git-mergetool.sh

   1 #!/bin/sh
   2 #
   3 # This program resolves merge conflicts in git
   4 #
   5 # Copyright (c) 2006 Theodore Y. Ts'o
   6 #
   7 # This file is licensed under the GPL v2, or a later version
   8 # at the discretion of Junio C Hamano.
   9 #
  10
  11 USAGE='[--tool=tool] [--tool-help] [-y|--no-prompt|--prompt] [file to merge] ...'
  12 SUBDIRECTORY_OK=Yes
  13 NONGIT_OK=Yes
  14 OPTIONS_SPEC=
  15 TOOL_MODE=merge
  16 . git-sh-setup
  17 . git-mergetool--lib
  18
  19 # Returns true if the mode reflects a symlink
  20 is_symlink () {
  21         test "$1" = 120000
  22 }
  23
  24 is_submodule () {
  25         test "$1" = 160000
  26 }
  27
  28 local_present () {
  29         test -n "$local_mode"
  30 }
  31
  32 remote_present () {
  33         test -n "$remote_mode"
  34 }
  35
  36 base_present () {
  37         test -n "$base_mode"
  38 }
  39
  40 mergetool_tmpdir_init () {
  41         if test "$(git config --bool mergetool.writeToTemp)" != true
  42         then
  43                 MERGETOOL_TMPDIR=.
  44                 return 0
  45         fi
  46         if MERGETOOL_TMPDIR=$(mktemp -d -t "git-mergetool-XXXXXX" 2>/dev/null)
  47         then
  48                 return 0
  49         fi
  50         die "error: mktemp is needed when 'mergetool.writeToTemp' is true"
  51 }
  52
  53 cleanup_temp_files () {
  54         if test "$1" = --save-backup
  55         then
  56                 rm -rf -- "$MERGED.orig"
  57                 test -e "$BACKUP" && mv -- "$BACKUP" "$MERGED.orig"
  58                 rm -f -- "$LOCAL" "$REMOTE" "$BASE"
  59         else
  60                 rm -f -- "$LOCAL" "$REMOTE" "$BASE" "$BACKUP"
  61         fi
  62         if test "$MERGETOOL_TMPDIR" != "."
  63         then
  64                 rmdir "$MERGETOOL_TMPDIR"
  65         fi
  66 }
  67
  68 describe_file () {
  69         mode="$1"
  70         branch="$2"
  71         file="$3"
  72
  73         printf "  {%s}: " "$branch"
  74         if test -z "$mode"
  75         then
  76                 echo "deleted"
  77         elif is_symlink "$mode"
  78         then
  79                 echo "a symbolic link -> '$(cat "$file")'"
  80         elif is_submodule "$mode"
  81         then
  82                 echo "submodule commit $file"
  83         elif base_present
  84         then
  85                 echo "modified file"
  86         else
  87                 echo "created file"
  88         fi
  89 }
  90
  91 resolve_symlink_merge () {
  92         while true
  93         do
  94                 printf "Use (l)ocal or (r)emote, or (a)bort? "
  95                 read ans || return 1
  96                 case "$ans" in
  97                 [lL]*)
  98                         git checkout-index -f --stage=2 -- "$MERGED"
  99                         git add -- "$MERGED"
 100                         cleanup_temp_files --save-backup
 101                         return 0
 102                         ;;
 103                 [rR]*)
 104                         git checkout-index -f --stage=3 -- "$MERGED"
 105                         git add -- "$MERGED"
 106                         cleanup_temp_files --save-backup
 107                         return 0
 108                         ;;
 109                 [aA]*)
 110                         return 1
 111                         ;;
 112                 esac
 113         done
 114 }
 115
 116 resolve_deleted_merge () {
 117         while true
 118         do
 119                 if base_present
 120                 then
 121                         printf "Use (m)odified or (d)eleted file, or (a)bort? "
 122                 else
 123                         printf "Use (c)reated or (d)eleted file, or (a)bort? "
 124                 fi
 125                 read ans || return 1
 126                 case "$ans" in
 127                 [mMcC]*)
 128                         git add -- "$MERGED"
 129                         cleanup_temp_files --save-backup
 130                         return 0
 131                         ;;
 132                 [dD]*)
 133                         git rm -- "$MERGED" > /dev/null
 134                         cleanup_temp_files
 135                         return 0
 136                         ;;
 137                 [aA]*)
 138                         return 1
 139                         ;;
 140                 esac
 141         done
 142 }
 143
 144 resolve_submodule_merge () {
 145         while true
 146         do
 147                 printf "Use (l)ocal or (r)emote, or (a)bort? "
 148                 read ans || return 1
 149                 case "$ans" in
 150                 [lL]*)
 151                         if ! local_present
 152                         then
 153                                 if test -n "$(git ls-tree HEAD -- "$MERGED")"
 154                                 then
 155                                         # Local isn't present, but it's a subdirectory
 156                                         git ls-tree --full-name -r HEAD -- "$MERGED" |
 157                                         git update-index --index-info || exit $?
 158                                 else
 159                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 160                                         git update-index --force-remove "$MERGED"
 161                                         cleanup_temp_files --save-backup
 162                                 fi
 163                         elif is_submodule "$local_mode"
 164                         then
 165                                 stage_submodule "$MERGED" "$local_sha1"
 166                         else
 167                                 git checkout-index -f --stage=2 -- "$MERGED"
 168                                 git add -- "$MERGED"
 169                         fi
 170                         return 0
 171                         ;;
 172                 [rR]*)
 173                         if ! remote_present
 174                         then
 175                                 if test -n "$(git ls-tree MERGE_HEAD -- "$MERGED")"
 176                                 then
 177                                         # Remote isn't present, but it's a subdirectory
 178                                         git ls-tree --full-name -r MERGE_HEAD -- "$MERGED" |
 179                                         git update-index --index-info || exit $?
 180                                 else
 181                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 182                                         git update-index --force-remove "$MERGED"
 183                                 fi
 184                         elif is_submodule "$remote_mode"
 185                         then
 186                                 ! is_submodule "$local_mode" &&
 187                                 test -e "$MERGED" &&
 188                                 mv -- "$MERGED" "$BACKUP"
 189                                 stage_submodule "$MERGED" "$remote_sha1"
 190                         else
 191                                 test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 192                                 git checkout-index -f --stage=3 -- "$MERGED"
 193                                 git add -- "$MERGED"
 194                         fi
 195                         cleanup_temp_files --save-backup
 196                         return 0
 197                         ;;
 198                 [aA]*)
 199                         return 1
 200                         ;;
 201                 esac
 202         done
 203 }
 204
 205 stage_submodule () {
 206         path="$1"
 207         submodule_sha1="$2"
 208         mkdir -p "$path" ||
 209         die "fatal: unable to create directory for module at $path"
 210         # Find $path relative to work tree
 211         work_tree_root=$(cd_to_toplevel && pwd)
 212         work_rel_path=$(cd "$path" &&
 213                 GIT_WORK_TREE="${work_tree_root}" git rev-parse --show-prefix
 214         )
 215         test -n "$work_rel_path" ||
 216         die "fatal: unable to get path of module $path relative to work tree"
 217         git update-index --add --replace --cacheinfo 160000 "$submodule_sha1" "${work_rel_path%/}" || die
 218 }
 219
 220 checkout_staged_file () {
 221         tmpfile=$(expr \
 222                 "$(git checkout-index --temp --stage="$1" "$2" 2>/dev/null)" \
 223                 : '\([^ ]*\)    ')
 224
 225         if test $? -eq 0 && test -n "$tmpfile"
 226         then
 227                 mv -- "$(git rev-parse --show-cdup)$tmpfile" "$3"
 228         else
 229                 >"$3"
 230         fi
 231 }
 232
 233 merge_file () {
 234         MERGED="$1"
 235
 236         f=$(git ls-files -u -- "$MERGED")
 237         if test -z "$f"
 238         then
 239                 if test ! -f "$MERGED"
 240                 then
 241                         echo "$MERGED: file not found"
 242                 else
 243                         echo "$MERGED: file does not need merging"
 244                 fi
 245                 return 1
 246         fi
 247
 248         if BASE=$(expr "$MERGED" : '\(.*\)\.[^/]*$')
 249         then
 250                 ext=$(expr "$MERGED" : '.*\(\.[^/]*\)$')
 251         else
 252                 BASE=$MERGED
 253                 ext=
 254         fi
 255
 256         mergetool_tmpdir_init
 257
 258         if test "$MERGETOOL_TMPDIR" != "."
 259         then
 260                 # If we're using a temporary directory then write to the
 261                 # top-level of that directory.
 262                 BASE=${BASE##*/}
 263         fi
 264
 265         BACKUP="$MERGETOOL_TMPDIR/${BASE}_BACKUP_$$$ext"
 266         LOCAL="$MERGETOOL_TMPDIR/${BASE}_LOCAL_$$$ext"
 267         REMOTE="$MERGETOOL_TMPDIR/${BASE}_REMOTE_$$$ext"
 268         BASE="$MERGETOOL_TMPDIR/${BASE}_BASE_$$$ext"
 269
 270         base_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==1) print $1;}')
 271         local_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==2) print $1;}')
 272         remote_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==3) print $1;}')
 273
 274         if is_submodule "$local_mode" || is_submodule "$remote_mode"
 275         then
 276                 echo "Submodule merge conflict for '$MERGED':"
 277                 local_sha1=$(git ls-files -u -- "$MERGED" | awk '{if ($3==2) print $2;}')
 278                 remote_sha1=$(git ls-files -u -- "$MERGED" | awk '{if ($3==3) print $2;}')
 279                 describe_file "$local_mode" "local" "$local_sha1"
 280                 describe_file "$remote_mode" "remote" "$remote_sha1"
 281                 resolve_submodule_merge
 282                 return
 283         fi
 284
 285         mv -- "$MERGED" "$BACKUP"
 286         cp -- "$BACKUP" "$MERGED"
 287
 288         checkout_staged_file 1 "$MERGED" "$BASE"
 289         checkout_staged_file 2 "$MERGED" "$LOCAL"
 290         checkout_staged_file 3 "$MERGED" "$REMOTE"
 291
 292         if test -z "$local_mode" || test -z "$remote_mode"
 293         then
 294                 echo "Deleted merge conflict for '$MERGED':"
 295                 describe_file "$local_mode" "local" "$LOCAL"
 296                 describe_file "$remote_mode" "remote" "$REMOTE"
 297                 resolve_deleted_merge
 298                 return
 299         fi
 300
 301         if is_symlink "$local_mode" || is_symlink "$remote_mode"
 302         then
 303                 echo "Symbolic link merge conflict for '$MERGED':"
 304                 describe_file "$local_mode" "local" "$LOCAL"
 305                 describe_file "$remote_mode" "remote" "$REMOTE"
 306                 resolve_symlink_merge
 307                 return
 308         fi
 309
 310         echo "Normal merge conflict for '$MERGED':"
 311         describe_file "$local_mode" "local" "$LOCAL"
 312         describe_file "$remote_mode" "remote" "$REMOTE"
 313         if test "$guessed_merge_tool" = true || test "$prompt" = true
 314         then
 315                 printf "Hit return to start merge resolution tool (%s): " "$merge_tool"
 316                 read ans || return 1
 317         fi
 318
 319         if base_present
 320         then
 321                 present=true
 322         else
 323                 present=false
 324         fi
 325
 326         if ! run_merge_tool "$merge_tool" "$present"
 327         then
 328                 echo "merge of $MERGED failed" 1>&2
 329                 mv -- "$BACKUP" "$MERGED"
 330
 331                 if test "$merge_keep_temporaries" = "false"
 332                 then
 333                         cleanup_temp_files
 334                 fi
 335
 336                 return 1
 337         fi
 338
 339         if test "$merge_keep_backup" = "true"
 340         then
 341                 mv -- "$BACKUP" "$MERGED.orig"
 342         else
 343                 rm -- "$BACKUP"
 344         fi
 345
 346         git add -- "$MERGED"
 347         cleanup_temp_files
 348         return 0
 349 }
 350
 351 prompt=$(git config --bool mergetool.prompt)
 352 guessed_merge_tool=false
 353
 354 while test $# != 0
 355 do
 356         case "$1" in
 357         --tool-help=*)
 358                 TOOL_MODE=${1#--tool-help=}
 359                 show_tool_help
 360                 ;;
 361         --tool-help)
 362                 show_tool_help
 363                 ;;
 364         -t|--tool*)
 365                 case "$#,$1" in
 366                 *,*=*)
 367                         merge_tool=$(expr "z$1" : 'z-[^=]*=\(.*\)')
 368                         ;;
 369                 1,*)
 370                         usage ;;
 371                 *)
 372                         merge_tool="$2"
 373                         shift ;;
 374                 esac
 375                 ;;
 376         -y|--no-prompt)
 377                 prompt=false
 378                 ;;
 379         --prompt)
 380                 prompt=true
 381                 ;;
 382         --)
 383                 shift
 384                 break
 385                 ;;
 386         -*)
 387                 usage
 388                 ;;
 389         *)
 390                 break
 391                 ;;
 392         esac
 393         shift
 394 done
 395
 396 prompt_after_failed_merge () {
 397         while true
 398         do
 399                 printf "Continue merging other unresolved paths (y/n) ? "
 400                 read ans || return 1
 401                 case "$ans" in
 402                 [yY]*)
 403                         return 0
 404                         ;;
 405                 [nN]*)
 406                         return 1
 407                         ;;
 408                 esac
 409         done
 410 }
 411
 412 git_dir_init
 413 require_work_tree
 414
 415 if test -z "$merge_tool"
 416 then
 417         # Check if a merge tool has been configured
 418         merge_tool=$(get_configured_merge_tool)
 419         # Try to guess an appropriate merge tool if no tool has been set.
 420         if test -z "$merge_tool"
 421         then
 422                 merge_tool=$(guess_merge_tool) || exit
 423                 guessed_merge_tool=true
 424         fi
 425 fi
 426 merge_keep_backup="$(git config --bool mergetool.keepBackup || echo true)"
 427 merge_keep_temporaries="$(git config --bool mergetool.keepTemporaries || echo false)"
 428
 429 files=
 430
 431 if test $# -eq 0
 432 then
 433         cd_to_toplevel
 434
 435         if test -e "$GIT_DIR/MERGE_RR"
 436         then
 437                 files=$(git rerere remaining)
 438         else
 439                 files=$(git ls-files -u | sed -e 's/^[^ ]*      //' | sort -u)
 440         fi
 441 else
 442         files=$(git ls-files -u -- "$@" | sed -e 's/^[^ ]*      //' | sort -u)
 443 fi
 444
 445 if test -z "$files"
 446 then
 447         echo "No files need merging"
 448         exit 0
 449 fi
 450
 451 printf "Merging:\n"
 452 printf "%s\n" "$files"
 453
 454 IFS='
 455 '
 456 rc=0
 457 for i in $files
 458 do
 459         printf "\n"
 460         if ! merge_file "$i"
 461         then
 462                 rc=1
 463                 prompt_after_failed_merge || exit 1
 464         fi
 465 done
 466
 467 exit $rc