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 # Copyright (c) 2009-2016 David Aguilar
   7 #
   8 # This file is licensed under the GPL v2, or a later version
   9 # at the discretion of Junio C Hamano.
  10 #
  11
  12 USAGE='[--tool=tool] [--tool-help] [-y|--no-prompt|--prompt] [-g|--gui|--no-gui] [-O<orderfile>] [file to merge] ...'
  13 SUBDIRECTORY_OK=Yes
  14 NONGIT_OK=Yes
  15 OPTIONS_SPEC=
  16 TOOL_MODE=merge
  17 . git-sh-setup
  18 . git-mergetool--lib
  19
  20 # Returns true if the mode reflects a symlink
  21 is_symlink () {
  22         test "$1" = 120000
  23 }
  24
  25 is_submodule () {
  26         test "$1" = 160000
  27 }
  28
  29 local_present () {
  30         test -n "$local_mode"
  31 }
  32
  33 remote_present () {
  34         test -n "$remote_mode"
  35 }
  36
  37 base_present () {
  38         test -n "$base_mode"
  39 }
  40
  41 mergetool_tmpdir_init () {
  42         if test "$(git config --bool mergetool.writeToTemp)" != true
  43         then
  44                 MERGETOOL_TMPDIR=.
  45                 return 0
  46         fi
  47         if MERGETOOL_TMPDIR=$(mktemp -d -t "git-mergetool-XXXXXX" 2>/dev/null)
  48         then
  49                 return 0
  50         fi
  51         die "error: mktemp is needed when 'mergetool.writeToTemp' is true"
  52 }
  53
  54 cleanup_temp_files () {
  55         if test "$1" = --save-backup
  56         then
  57                 rm -rf -- "$MERGED.orig"
  58                 test -e "$BACKUP" && mv -- "$BACKUP" "$MERGED.orig"
  59                 rm -f -- "$LOCAL" "$REMOTE" "$BASE"
  60         else
  61                 rm -f -- "$LOCAL" "$REMOTE" "$BASE" "$BACKUP"
  62         fi
  63         if test "$MERGETOOL_TMPDIR" != "."
  64         then
  65                 rmdir "$MERGETOOL_TMPDIR"
  66         fi
  67 }
  68
  69 describe_file () {
  70         mode="$1"
  71         branch="$2"
  72         file="$3"
  73
  74         printf "  {%s}: " "$branch"
  75         if test -z "$mode"
  76         then
  77                 echo "deleted"
  78         elif is_symlink "$mode"
  79         then
  80                 echo "a symbolic link -> '$(cat "$file")'"
  81         elif is_submodule "$mode"
  82         then
  83                 echo "submodule commit $file"
  84         elif base_present
  85         then
  86                 echo "modified file"
  87         else
  88                 echo "created file"
  89         fi
  90 }
  91
  92 resolve_symlink_merge () {
  93         while true
  94         do
  95                 printf "Use (l)ocal or (r)emote, or (a)bort? "
  96                 read ans || return 1
  97                 case "$ans" in
  98                 [lL]*)
  99                         git checkout-index -f --stage=2 -- "$MERGED"
 100                         git add -- "$MERGED"
 101                         cleanup_temp_files --save-backup
 102                         return 0
 103                         ;;
 104                 [rR]*)
 105                         git checkout-index -f --stage=3 -- "$MERGED"
 106                         git add -- "$MERGED"
 107                         cleanup_temp_files --save-backup
 108                         return 0
 109                         ;;
 110                 [aA]*)
 111                         return 1
 112                         ;;
 113                 esac
 114         done
 115 }
 116
 117 resolve_deleted_merge () {
 118         while true
 119         do
 120                 if base_present
 121                 then
 122                         printf "Use (m)odified or (d)eleted file, or (a)bort? "
 123                 else
 124                         printf "Use (c)reated or (d)eleted file, or (a)bort? "
 125                 fi
 126                 read ans || return 1
 127                 case "$ans" in
 128                 [mMcC]*)
 129                         git add -- "$MERGED"
 130                         if test "$merge_keep_backup" = "true"
 131                         then
 132                                 cleanup_temp_files --save-backup
 133                         else
 134                                 cleanup_temp_files
 135                         fi
 136                         return 0
 137                         ;;
 138                 [dD]*)
 139                         git rm -- "$MERGED" > /dev/null
 140                         cleanup_temp_files
 141                         return 0
 142                         ;;
 143                 [aA]*)
 144                         if test "$merge_keep_temporaries" = "false"
 145                         then
 146                                 cleanup_temp_files
 147                         fi
 148                         return 1
 149                         ;;
 150                 esac
 151         done
 152 }
 153
 154 resolve_submodule_merge () {
 155         while true
 156         do
 157                 printf "Use (l)ocal or (r)emote, or (a)bort? "
 158                 read ans || return 1
 159                 case "$ans" in
 160                 [lL]*)
 161                         if ! local_present
 162                         then
 163                                 if test -n "$(git ls-tree HEAD -- "$MERGED")"
 164                                 then
 165                                         # Local isn't present, but it's a subdirectory
 166                                         git ls-tree --full-name -r HEAD -- "$MERGED" |
 167                                         git update-index --index-info || exit $?
 168                                 else
 169                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 170                                         git update-index --force-remove "$MERGED"
 171                                         cleanup_temp_files --save-backup
 172                                 fi
 173                         elif is_submodule "$local_mode"
 174                         then
 175                                 stage_submodule "$MERGED" "$local_sha1"
 176                         else
 177                                 git checkout-index -f --stage=2 -- "$MERGED"
 178                                 git add -- "$MERGED"
 179                         fi
 180                         return 0
 181                         ;;
 182                 [rR]*)
 183                         if ! remote_present
 184                         then
 185                                 if test -n "$(git ls-tree MERGE_HEAD -- "$MERGED")"
 186                                 then
 187                                         # Remote isn't present, but it's a subdirectory
 188                                         git ls-tree --full-name -r MERGE_HEAD -- "$MERGED" |
 189                                         git update-index --index-info || exit $?
 190                                 else
 191                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 192                                         git update-index --force-remove "$MERGED"
 193                                 fi
 194                         elif is_submodule "$remote_mode"
 195                         then
 196                                 ! is_submodule "$local_mode" &&
 197                                 test -e "$MERGED" &&
 198                                 mv -- "$MERGED" "$BACKUP"
 199                                 stage_submodule "$MERGED" "$remote_sha1"
 200                         else
 201                                 test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
 202                                 git checkout-index -f --stage=3 -- "$MERGED"
 203                                 git add -- "$MERGED"
 204                         fi
 205                         cleanup_temp_files --save-backup
 206                         return 0
 207                         ;;
 208                 [aA]*)
 209                         return 1
 210                         ;;
 211                 esac
 212         done
 213 }
 214
 215 stage_submodule () {
 216         path="$1"
 217         submodule_sha1="$2"
 218         mkdir -p "$path" ||
 219         die "fatal: unable to create directory for module at $path"
 220         # Find $path relative to work tree
 221         work_tree_root=$(cd_to_toplevel && pwd)
 222         work_rel_path=$(cd "$path" &&
 223                 GIT_WORK_TREE="${work_tree_root}" git rev-parse --show-prefix
 224         )
 225         test -n "$work_rel_path" ||
 226         die "fatal: unable to get path of module $path relative to work tree"
 227         git update-index --add --replace --cacheinfo 160000 "$submodule_sha1" "${work_rel_path%/}" || die
 228 }
 229
 230 checkout_staged_file () {
 231         tmpfile="$(git checkout-index --temp --stage="$1" "$2" 2>/dev/null)" &&
 232         tmpfile=${tmpfile%%'    '*}
 233
 234         if test $? -eq 0 && test -n "$tmpfile"
 235         then
 236                 mv -- "$(git rev-parse --show-cdup)$tmpfile" "$3"
 237         else
 238                 >"$3"
 239         fi
 240 }
 241
 242 hide_resolved () {
 243         git merge-file --ours -q -p "$LOCAL" "$BASE" "$REMOTE" >"$LCONFL"
 244         git merge-file --theirs -q -p "$LOCAL" "$BASE" "$REMOTE" >"$RCONFL"
 245         mv -- "$LCONFL" "$LOCAL"
 246         mv -- "$RCONFL" "$REMOTE"
 247 }
 248
 249 merge_file () {
 250         MERGED="$1"
 251
 252         f=$(git ls-files -u -- "$MERGED")
 253         if test -z "$f"
 254         then
 255                 if test ! -f "$MERGED"
 256                 then
 257                         echo "$MERGED: file not found"
 258                 else
 259                         echo "$MERGED: file does not need merging"
 260                 fi
 261                 return 1
 262         fi
 263
 264         # extract file extension from the last path component
 265         case "${MERGED##*/}" in
 266         *.*)
 267                 ext=.${MERGED##*.}
 268                 BASE=${MERGED%"$ext"}
 269                 ;;
 270         *)
 271                 BASE=$MERGED
 272                 ext=
 273         esac
 274
 275         initialize_merge_tool "$merge_tool" || return
 276
 277         mergetool_tmpdir_init
 278
 279         if test "$MERGETOOL_TMPDIR" != "."
 280         then
 281                 # If we're using a temporary directory then write to the
 282                 # top-level of that directory.
 283                 BASE=${BASE##*/}
 284         fi
 285
 286         BACKUP="$MERGETOOL_TMPDIR/${BASE}_BACKUP_$$$ext"
 287         LOCAL="$MERGETOOL_TMPDIR/${BASE}_LOCAL_$$$ext"
 288         LCONFL="$MERGETOOL_TMPDIR/${BASE}_LOCAL_LCONFL_$$$ext"
 289         REMOTE="$MERGETOOL_TMPDIR/${BASE}_REMOTE_$$$ext"
 290         RCONFL="$MERGETOOL_TMPDIR/${BASE}_REMOTE_RCONFL_$$$ext"
 291         BASE="$MERGETOOL_TMPDIR/${BASE}_BASE_$$$ext"
 292
 293         base_mode= local_mode= remote_mode=
 294
 295         # here, $IFS is just a LF
 296         for line in $f
 297         do
 298                 mode=${line%% *}                # 1st word
 299                 sha1=${line#"$mode "}
 300                 sha1=${sha1%% *}                # 2nd word
 301                 case "${line#$mode $sha1 }" in  # remainder
 302                 '1      '*)
 303                         base_mode=$mode
 304                         ;;
 305                 '2      '*)
 306                         local_mode=$mode local_sha1=$sha1
 307                         ;;
 308                 '3      '*)
 309                         remote_mode=$mode remote_sha1=$sha1
 310                         ;;
 311                 esac
 312         done
 313
 314         if is_submodule "$local_mode" || is_submodule "$remote_mode"
 315         then
 316                 echo "Submodule merge conflict for '$MERGED':"
 317                 describe_file "$local_mode" "local" "$local_sha1"
 318                 describe_file "$remote_mode" "remote" "$remote_sha1"
 319                 resolve_submodule_merge
 320                 return
 321         fi
 322
 323         if test -f "$MERGED"
 324         then
 325                 mv -- "$MERGED" "$BACKUP"
 326                 cp -- "$BACKUP" "$MERGED"
 327         fi
 328         # Create a parent directory to handle delete/delete conflicts
 329         # where the base's directory no longer exists.
 330         mkdir -p "$(dirname "$MERGED")"
 331
 332         checkout_staged_file 1 "$MERGED" "$BASE"
 333         checkout_staged_file 2 "$MERGED" "$LOCAL"
 334         checkout_staged_file 3 "$MERGED" "$REMOTE"
 335
 336         # hideResolved preferences hierarchy.
 337         global_config="mergetool.hideResolved"
 338         tool_config="mergetool.${merge_tool}.hideResolved"
 339
 340         if enabled=$(git config --type=bool "$tool_config")
 341         then
 342                 # The user has a specific preference for a specific tool and no
 343                 # other preferences should override that.
 344                 : ;
 345         elif enabled=$(git config --type=bool "$global_config")
 346         then
 347                 # The user has a general preference for all tools.
 348                 #
 349                 # 'true' means the user likes the feature so we should use it
 350                 # where possible but tool authors can still override.
 351                 #
 352                 # 'false' means the user doesn't like the feature so we should
 353                 # not use it anywhere.
 354                 if test "$enabled" = true && hide_resolved_enabled
 355                 then
 356                     enabled=true
 357                 else
 358                     enabled=false
 359                 fi
 360         else
 361                 # The user does not have a preference. Ask the tool.
 362                 if hide_resolved_enabled
 363                 then
 364                     enabled=true
 365                 else
 366                     enabled=false
 367                 fi
 368         fi
 369
 370         if test "$enabled" = true
 371         then
 372                 hide_resolved
 373         fi
 374
 375         if test -z "$local_mode" || test -z "$remote_mode"
 376         then
 377                 echo "Deleted merge conflict for '$MERGED':"
 378                 describe_file "$local_mode" "local" "$LOCAL"
 379                 describe_file "$remote_mode" "remote" "$REMOTE"
 380                 resolve_deleted_merge
 381                 status=$?
 382                 rmdir -p "$(dirname "$MERGED")" 2>/dev/null
 383                 return $status
 384         fi
 385
 386         if is_symlink "$local_mode" || is_symlink "$remote_mode"
 387         then
 388                 echo "Symbolic link merge conflict for '$MERGED':"
 389                 describe_file "$local_mode" "local" "$LOCAL"
 390                 describe_file "$remote_mode" "remote" "$REMOTE"
 391                 resolve_symlink_merge
 392                 return
 393         fi
 394
 395         echo "Normal merge conflict for '$MERGED':"
 396         describe_file "$local_mode" "local" "$LOCAL"
 397         describe_file "$remote_mode" "remote" "$REMOTE"
 398         if test "$guessed_merge_tool" = true || test "$prompt" = true
 399         then
 400                 printf "Hit return to start merge resolution tool (%s): " "$merge_tool"
 401                 read ans || return 1
 402         fi
 403
 404         if base_present
 405         then
 406                 present=true
 407         else
 408                 present=false
 409         fi
 410
 411         if ! run_merge_tool "$merge_tool" "$present"
 412         then
 413                 echo "merge of $MERGED failed" 1>&2
 414                 mv -- "$BACKUP" "$MERGED"
 415
 416                 if test "$merge_keep_temporaries" = "false"
 417                 then
 418                         cleanup_temp_files
 419                 fi
 420
 421                 return 1
 422         fi
 423
 424         if test "$merge_keep_backup" = "true"
 425         then
 426                 mv -- "$BACKUP" "$MERGED.orig"
 427         else
 428                 rm -- "$BACKUP"
 429         fi
 430
 431         git add -- "$MERGED"
 432         cleanup_temp_files
 433         return 0
 434 }
 435
 436 prompt_after_failed_merge () {
 437         while true
 438         do
 439                 printf "Continue merging other unresolved paths [y/n]? "
 440                 read ans || return 1
 441                 case "$ans" in
 442                 [yY]*)
 443                         return 0
 444                         ;;
 445                 [nN]*)
 446                         return 1
 447                         ;;
 448                 esac
 449         done
 450 }
 451
 452 print_noop_and_exit () {
 453         echo "No files need merging"
 454         exit 0
 455 }
 456
 457 main () {
 458         prompt=$(git config --bool mergetool.prompt)
 459         GIT_MERGETOOL_GUI=false
 460         guessed_merge_tool=false
 461         orderfile=
 462
 463         while test $# != 0
 464         do
 465                 case "$1" in
 466                 --tool-help=*)
 467                         TOOL_MODE=${1#--tool-help=}
 468                         show_tool_help
 469                         ;;
 470                 --tool-help)
 471                         show_tool_help
 472                         ;;
 473                 -t|--tool*)
 474                         case "$#,$1" in
 475                         *,*=*)
 476                                 merge_tool=${1#*=}
 477                                 ;;
 478                         1,*)
 479                                 usage ;;
 480                         *)
 481                                 merge_tool="$2"
 482                                 shift ;;
 483                         esac
 484                         ;;
 485                 --no-gui)
 486                         GIT_MERGETOOL_GUI=false
 487                         ;;
 488                 -g|--gui)
 489                         GIT_MERGETOOL_GUI=true
 490                         ;;
 491                 -y|--no-prompt)
 492                         prompt=false
 493                         ;;
 494                 --prompt)
 495                         prompt=true
 496                         ;;
 497                 -O*)
 498                         orderfile="${1#-O}"
 499                         ;;
 500                 --)
 501                         shift
 502                         break
 503                         ;;
 504                 -*)
 505                         usage
 506                         ;;
 507                 *)
 508                         break
 509                         ;;
 510                 esac
 511                 shift
 512         done
 513
 514         git_dir_init
 515         require_work_tree
 516
 517         if test -z "$merge_tool"
 518         then
 519                 if ! merge_tool=$(get_merge_tool)
 520                 then
 521                         guessed_merge_tool=true
 522                 fi
 523         fi
 524         merge_keep_backup="$(git config --bool mergetool.keepBackup || echo true)"
 525         merge_keep_temporaries="$(git config --bool mergetool.keepTemporaries || echo false)"
 526
 527         prefix=$(git rev-parse --show-prefix) || exit 1
 528         cd_to_toplevel
 529
 530         if test -n "$orderfile"
 531         then
 532                 orderfile=$(
 533                         git rev-parse --prefix "$prefix" -- "$orderfile" |
 534                         sed -e 1d
 535                 )
 536         fi
 537
 538         if test $# -eq 0 && test -e "$GIT_DIR/MERGE_RR"
 539         then
 540                 set -- $(git rerere remaining)
 541                 if test $# -eq 0
 542                 then
 543                         print_noop_and_exit
 544                 fi
 545         elif test $# -ge 0
 546         then
 547                 # rev-parse provides the -- needed for 'set'
 548                 eval "set $(git rev-parse --sq --prefix "$prefix" -- "$@")"
 549         fi
 550
 551         files=$(git -c core.quotePath=false \
 552                 diff --name-only --diff-filter=U \
 553                 ${orderfile:+"-O$orderfile"} -- "$@")
 554
 555         if test -z "$files"
 556         then
 557                 print_noop_and_exit
 558         fi
 559
 560         printf "Merging:\n"
 561         printf "%s\n" "$files"
 562
 563         rc=0
 564         set -- $files
 565         while test $# -ne 0
 566         do
 567                 printf "\n"
 568                 if ! merge_file "$1"
 569                 then
 570                         rc=1
 571                         test $# -ne 1 && prompt_after_failed_merge || exit 1
 572                 fi
 573                 shift
 574         done
 575
 576         exit $rc
 577 }
 578
 579 main "$@"