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