git add --patch with difftool

Here's my script for this, which opens kdiff3 for you to perform a 2-file merge. If you don't like kdiff3, provide your own values for MERGETOOL and MERGECMD (but you'd be crazy not to like kdiff3).

To avoid surprises, this script tries to mimic git add -p as far as arguments and error codes. (It handles both lists of files and directories.)

Plus, it properly handles various corner cases, including:

• The user tries to run the script in a non-git directory (abort with an error)
• The user hits Ctrl+C before finishing (quit early)
• The user declines to save the merge result within the difftool (then don't use it, but move on to the next file)
• The difftool has an unexpected error (stop early)

Example usage:

$ ## With kdiff3 (default): $ add-with-mergetool myfile1.txt $ add-with-mergetool some-directory $ ## ...or with custom mergetool: $ export MERGETOOL='opendiff' $ export MERGECMD='$MERGETOOL $LOCAL $REMOTE -merge $MERGED' $ add-with-mergetool some-directory/*.py 

#!/bin/bash # # add-with-mergetool # Author: Stuart Berg (http://github.com/stuarteberg) # # This little script is like 'git add --patch', except that # it launches a merge-tool to perform the merge. # TODO: For now, this script hard-codes MERGETOOL and MERGECMD for kdiff3. # Modify those variables for your own tool if you wish. # In the future, it would be nice if we could somehow read # MERGETOOL and MERGECMD from the user's git-config. # Configure for kdiff3 # (and hide warnings on about modalSession, from kdiff3 on OSX) MERGETOOL=${MERGETOOL-kdiff3} MERGECMD=${MERGECMD-'"${MERGETOOL}" "${LOCAL}" "${REMOTE}" -o "${MERGED}"'\ 2>&1 | grep -iv modalSession} main() { check_for_errors "$@" process_all "$@" } check_for_errors() { which "${MERGETOOL}" > /dev/null if [[ $? == 1 ]]; then echo "Error: Can't find mergetool: '${MERGETOOL}'" 1>&2 exit 1 fi if [[ "$1" == "-h" ]]; then echo "Usage: $(basename $0) [<pathspec>...]" 1>&2 exit 0 fi # Exit early if we're not in a git repo git status > /dev/null || exit $? } process_all() { repo_toplevel=$(git rev-parse --show-toplevel) # If no args given, add everything (like 'git add -p') if [[ $# == 0 ]]; then set -- "$repo_toplevel" fi # For each given file/directory... args=( "$@" ) for arg in "${args[@]}" do # Find the modified file(s) changed_files=( $(git diff --name-only -- "$arg") ) ( # Switch to toplevel, to easily handle 'git diff' output cd "$repo_toplevel" # For each modified file... for f in "${changed_files[@]}" do if [[ $startmsg_shown != "yes" ]]; then echo "Starting $(basename $0). Use Ctrl+C to stop early." echo "To skip a file, quit ${MERGETOOL} without saving." echo startmsg_shown="yes" fi # This is where the magic happens. patch_file_and_add "$f" done ) || exit $? # exit early if loop body failed done } # This helper function launches the mergetool for a single file, # and then adds it to the git index (if the user saved the new file). patch_file_and_add() { f="$1" git show :"$f" > "$f.from_index" # Copy from the index ( set -e trap "echo && exit 130" INT # Ctrl+C should trigger abnormal exit # Execute 2-file merge echo "Launching ${MERGETOOL} for '$f'." LOCAL="$f.from_index" REMOTE="$f" MERGED="$f.to_add" eval "${MERGECMD}" if [[ -e "$f.to_add" ]]; then mv "$f" "$f.from_working" # Backup original from working-tree mv "$f.to_add" "$f" # Replace with patched version git add "$f" # Add to the index mv "$f.from_working" "$f" # Restore the working-tree version fi ) status=$? rm "$f.from_index" # Discard the old index version if [ $status == 130 ]; then echo "User interrupted." 1>&2 exit $status elif [ $status != 0 ]; then echo "Error: Interactive add-patch stopped early!" 1>&2 exit $status fi } main "$@" 

I like the answers from Cascabel and Stuart because they show how to script a cover that accomplishes the desired task. They use git add instead of git add --patch as the question stated, but are still in the spirit of the question. Another alternative is to use git add --edit which has the advantage that it does not need to modify the working tree at all. My answer is logically a small change to Stuart's script.

The issue I see with git add --patch is that it is inherently interactive, making it hard to cover with a script. Stuart's approach is to use a diff tool to determine the desired full content of the index and then use git add to make it so. My approach differs in that instead of modifying the working tree before and after calling git add I take the desired full content and turn it into a patch that can be applied to the index to make it so. Then EDITOR="mv \"$PATCH\"" git add --edit can be used to make it so. This avoids modifications to the working tree.

To use this approach, start with Stuart's script and replace the definition of patch_file_and_add with this:

patch_file_and_add() { f="$1" base=$(basename "$f") dir=$(mktemp -d) mkdir "$dir/working" mkdir "$dir/index" mkdir "$dir/merged" LOCAL="$dir/working/$base" REMOTE="$dir/index/$base" MERGED="$dir/merged/$base" PATCH1="$dir/head.patch" PATCH="$dir/full.patch" git show :"$f" > "$REMOTE" # Copy from the index ( set -e trap "echo && exit 130" INT # Ctrl+C should trigger abnormal exit # Execute 2-file merge echo "Launching ${MERGETOOL} for '$f'." cp "$f" "$LOCAL" eval "${MERGECMD}" if [[ -e "$MERGED" ]]; then git diff -- "$f" > "$PATCH1" 2> /dev/null git diff --staged -- "$f" >> "$PATCH1" 2> /dev/null # We need both of the above in case one is empty. head -4 "$PATCH1" > "$PATCH" diff --unified=7 "$REMOTE" "$MERGED" | tail -n +3 >> "$PATCH" # Now we have the patch we want to apply to the index. EDITOR="mv \"$PATCH\"" git add -e -- "$f" fi rm -rf "$dir" ) status=$? if [ $status == 130 ]; then echo "User interrupted." 1>&2 exit $status elif [ $status != 0 ]; then echo "Error: Interactive add-patch stopped early!" 1>&2 exit $status fi } 

Strictly speaking LOCAL could be set to $f instead of using mv to put it next to the others. But I seem to remember that some 3rd party diff programs allow hiding the common initial part of the path, so this approach can take advantage of that feature.

Thanks Cascabel and Stuart, for excellent answers, and HaxElit for an excellent question.

If vimdiff is your difftool in .gitconfig:

[diff] tool = vimdiff 

you could also execute the command below while standing in the file screen:

:!git add % 

Unfortunately not.

The only UI I know of at the moment is part of git-gui when invoked as

git gui citool 

The other UI is the interactive console UI when invoked as

git add -i 

git difftool allows some different tool options, but not the add interface.