git-mergetool--lib.sh

   1 #!/bin/sh
   2 # git-mergetool--lib is a library for common merge tool functions
   3 diff_mode() {
   4         test "$TOOL_MODE" = diff
   5 }
   6
   7 merge_mode() {
   8         test "$TOOL_MODE" = merge
   9 }
  10
  11 translate_merge_tool_path () {
  12         case "$1" in
  13         araxis)
  14                 echo compare
  15                 ;;
  16         bc3)
  17                 echo bcompare
  18                 ;;
  19         emerge)
  20                 echo emacs
  21                 ;;
  22         gvimdiff|gvimdiff2)
  23                 echo gvim
  24                 ;;
  25         vimdiff|vimdiff2)
  26                 echo vim
  27                 ;;
  28         *)
  29                 echo "$1"
  30                 ;;
  31         esac
  32 }
  33
  34 check_unchanged () {
  35         if test "$MERGED" -nt "$BACKUP"; then
  36                 status=0
  37         else
  38                 while true; do
  39                         echo "$MERGED seems unchanged."
  40                         printf "Was the merge successful? [y/n] "
  41                         read answer
  42                         case "$answer" in
  43                         y*|Y*) status=0; break ;;
  44                         n*|N*) status=1; break ;;
  45                         esac
  46                 done
  47         fi
  48 }
  49
  50 valid_tool () {
  51         case "$1" in
  52         araxis | bc3 | diffuse | ecmerge | emerge | gvimdiff | gvimdiff2 | \
  53         kdiff3 | meld | opendiff | p4merge | tkdiff | vimdiff | vimdiff2 | xxdiff)
  54                 ;; # happy
  55         kompare)
  56                 if ! diff_mode; then
  57                         return 1
  58                 fi
  59                 ;;
  60         tortoisemerge)
  61                 if ! merge_mode; then
  62                         return 1
  63                 fi
  64                 ;;
  65         *)
  66                 if test -z "$(get_merge_tool_cmd "$1")"; then
  67                         return 1
  68                 fi
  69                 ;;
  70         esac
  71 }
  72
  73 get_merge_tool_cmd () {
  74         # Prints the custom command for a merge tool
  75         if test -n "$1"; then
  76                 merge_tool="$1"
  77         else
  78                 merge_tool="$(get_merge_tool)"
  79         fi
  80         if diff_mode; then
  81                 echo "$(git config difftool.$merge_tool.cmd ||
  82                         git config mergetool.$merge_tool.cmd)"
  83         else
  84                 echo "$(git config mergetool.$merge_tool.cmd)"
  85         fi
  86 }
  87
  88 run_merge_tool () {
  89         merge_tool_path="$(get_merge_tool_path "$1")" || exit
  90         base_present="$2"
  91         status=0
  92
  93         case "$1" in
  94         araxis)
  95                 if merge_mode; then
  96                         touch "$BACKUP"
  97                         if $base_present; then
  98                                 "$merge_tool_path" -wait -merge -3 -a1 \
  99                                         "$BASE" "$LOCAL" "$REMOTE" "$MERGED" \
 100                                         >/dev/null 2>&1
 101                         else
 102                                 "$merge_tool_path" -wait -2 \
 103                                         "$LOCAL" "$REMOTE" "$MERGED" \
 104                                         >/dev/null 2>&1
 105                         fi
 106                         check_unchanged
 107                 else
 108                         "$merge_tool_path" -wait -2 "$LOCAL" "$REMOTE" \
 109                                 >/dev/null 2>&1
 110                 fi
 111                 ;;
 112         bc3)
 113                 if merge_mode; then
 114                         touch "$BACKUP"
 115                         if $base_present; then
 116                                 "$merge_tool_path" "$LOCAL" "$REMOTE" "$BASE" \
 117                                         -mergeoutput="$MERGED"
 118                         else
 119                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
 120                                         -mergeoutput="$MERGED"
 121                         fi
 122                         check_unchanged
 123                 else
 124                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 125                 fi
 126                 ;;
 127         diffuse)
 128                 if merge_mode; then
 129                         touch "$BACKUP"
 130                         if $base_present; then
 131                                 "$merge_tool_path" \
 132                                         "$LOCAL" "$MERGED" "$REMOTE" \
 133                                         "$BASE" | cat
 134                         else
 135                                 "$merge_tool_path" \
 136                                         "$LOCAL" "$MERGED" "$REMOTE" | cat
 137                         fi
 138                         check_unchanged
 139                 else
 140                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
 141                 fi
 142                 ;;
 143         ecmerge)
 144                 if merge_mode; then
 145                         touch "$BACKUP"
 146                         if $base_present; then
 147                                 "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" \
 148                                         --default --mode=merge3 --to="$MERGED"
 149                         else
 150                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
 151                                         --default --mode=merge2 --to="$MERGED"
 152                         fi
 153                         check_unchanged
 154                 else
 155                         "$merge_tool_path" --default --mode=diff2 \
 156                                 "$LOCAL" "$REMOTE"
 157                 fi
 158                 ;;
 159         emerge)
 160                 if merge_mode; then
 161                         if $base_present; then
 162                                 "$merge_tool_path" \
 163                                         -f emerge-files-with-ancestor-command \
 164                                         "$LOCAL" "$REMOTE" "$BASE" \
 165                                         "$(basename "$MERGED")"
 166                         else
 167                                 "$merge_tool_path" \
 168                                         -f emerge-files-command \
 169                                         "$LOCAL" "$REMOTE" \
 170                                         "$(basename "$MERGED")"
 171                         fi
 172                         status=$?
 173                 else
 174                         "$merge_tool_path" -f emerge-files-command \
 175                                 "$LOCAL" "$REMOTE"
 176                 fi
 177                 ;;
 178         gvimdiff|vimdiff)
 179                 if merge_mode; then
 180                         touch "$BACKUP"
 181                         if $base_present; then
 182                                 "$merge_tool_path" -f -d -c "wincmd J" \
 183                                         "$MERGED" "$LOCAL" "$BASE" "$REMOTE"
 184                         else
 185                                 "$merge_tool_path" -f -d -c "wincmd l" \
 186                                         "$LOCAL" "$MERGED" "$REMOTE"
 187                         fi
 188                         check_unchanged
 189                 else
 190                         "$merge_tool_path" -R -f -d -c "wincmd l" \
 191                                 "$LOCAL" "$REMOTE"
 192                 fi
 193                 ;;
 194         gvimdiff2|vimdiff2)
 195                 if merge_mode; then
 196                         touch "$BACKUP"
 197                         "$merge_tool_path" -f -d -c "wincmd l" \
 198                                 "$LOCAL" "$MERGED" "$REMOTE"
 199                         check_unchanged
 200                 else
 201                         "$merge_tool_path" -R -f -d -c "wincmd l" \
 202                                 "$LOCAL" "$REMOTE"
 203                 fi
 204                 ;;
 205         kdiff3)
 206                 if merge_mode; then
 207                         if $base_present; then
 208                                 ("$merge_tool_path" --auto \
 209                                         --L1 "$MERGED (Base)" \
 210                                         --L2 "$MERGED (Local)" \
 211                                         --L3 "$MERGED (Remote)" \
 212                                         -o "$MERGED" \
 213                                         "$BASE" "$LOCAL" "$REMOTE" \
 214                                 > /dev/null 2>&1)
 215                         else
 216                                 ("$merge_tool_path" --auto \
 217                                         --L1 "$MERGED (Local)" \
 218                                         --L2 "$MERGED (Remote)" \
 219                                         -o "$MERGED" \
 220                                         "$LOCAL" "$REMOTE" \
 221                                 > /dev/null 2>&1)
 222                         fi
 223                         status=$?
 224                 else
 225                         ("$merge_tool_path" --auto \
 226                                 --L1 "$MERGED (A)" \
 227                                 --L2 "$MERGED (B)" "$LOCAL" "$REMOTE" \
 228                         > /dev/null 2>&1)
 229                 fi
 230                 ;;
 231         kompare)
 232                 "$merge_tool_path" "$LOCAL" "$REMOTE"
 233                 ;;
 234         meld)
 235                 if merge_mode; then
 236                         touch "$BACKUP"
 237                         "$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
 238                         check_unchanged
 239                 else
 240                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 241                 fi
 242                 ;;
 243         opendiff)
 244                 if merge_mode; then
 245                         touch "$BACKUP"
 246                         if $base_present; then
 247                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
 248                                         -ancestor "$BASE" \
 249                                         -merge "$MERGED" | cat
 250                         else
 251                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
 252                                         -merge "$MERGED" | cat
 253                         fi
 254                         check_unchanged
 255                 else
 256                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
 257                 fi
 258                 ;;
 259         p4merge)
 260                 if merge_mode; then
 261                         touch "$BACKUP"
 262                         $base_present || >"$BASE"
 263                         "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" "$MERGED"
 264                         check_unchanged
 265                 else
 266                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 267                 fi
 268                 ;;
 269         tkdiff)
 270                 if merge_mode; then
 271                         if $base_present; then
 272                                 "$merge_tool_path" -a "$BASE" \
 273                                         -o "$MERGED" "$LOCAL" "$REMOTE"
 274                         else
 275                                 "$merge_tool_path" \
 276                                         -o "$MERGED" "$LOCAL" "$REMOTE"
 277                         fi
 278                         status=$?
 279                 else
 280                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 281                 fi
 282                 ;;
 283         tortoisemerge)
 284                 if $base_present; then
 285                         touch "$BACKUP"
 286                         "$merge_tool_path" \
 287                                 -base:"$BASE" -mine:"$LOCAL" \
 288                                 -theirs:"$REMOTE" -merged:"$MERGED"
 289                         check_unchanged
 290                 else
 291                         echo "TortoiseMerge cannot be used without a base" 1>&2
 292                         status=1
 293                 fi
 294                 ;;
 295         xxdiff)
 296                 if merge_mode; then
 297                         touch "$BACKUP"
 298                         if $base_present; then
 299                                 "$merge_tool_path" -X --show-merged-pane \
 300                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
 301                                         -R 'Accel.Search: "Ctrl+F"' \
 302                                         -R 'Accel.SearchForward: "Ctrl-G"' \
 303                                         --merged-file "$MERGED" \
 304                                         "$LOCAL" "$BASE" "$REMOTE"
 305                         else
 306                                 "$merge_tool_path" -X $extra \
 307                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
 308                                         -R 'Accel.Search: "Ctrl+F"' \
 309                                         -R 'Accel.SearchForward: "Ctrl-G"' \
 310                                         --merged-file "$MERGED" \
 311                                         "$LOCAL" "$REMOTE"
 312                         fi
 313                         check_unchanged
 314                 else
 315                         "$merge_tool_path" \
 316                                 -R 'Accel.Search: "Ctrl+F"' \
 317                                 -R 'Accel.SearchForward: "Ctrl-G"' \
 318                                 "$LOCAL" "$REMOTE"
 319                 fi
 320                 ;;
 321         *)
 322                 merge_tool_cmd="$(get_merge_tool_cmd "$1")"
 323                 if test -z "$merge_tool_cmd"; then
 324                         if merge_mode; then
 325                                 status=1
 326                         fi
 327                         break
 328                 fi
 329                 if merge_mode; then
 330                         trust_exit_code="$(git config --bool \
 331                                 mergetool."$1".trustExitCode || echo false)"
 332                         if test "$trust_exit_code" = "false"; then
 333                                 touch "$BACKUP"
 334                                 ( eval $merge_tool_cmd )
 335                                 check_unchanged
 336                         else
 337                                 ( eval $merge_tool_cmd )
 338                                 status=$?
 339                         fi
 340                 else
 341                         ( eval $merge_tool_cmd )
 342                 fi
 343                 ;;
 344         esac
 345         return $status
 346 }
 347
 348 guess_merge_tool () {
 349         if merge_mode; then
 350                 tools="tortoisemerge"
 351         else
 352                 tools="kompare"
 353         fi
 354         if test -n "$DISPLAY"; then
 355                 if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
 356                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
 357                 else
 358                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
 359                 fi
 360                 tools="$tools gvimdiff diffuse ecmerge p4merge araxis bc3"
 361         fi
 362         case "${VISUAL:-$EDITOR}" in
 363         *vim*)
 364                 tools="$tools vimdiff emerge"
 365                 ;;
 366         *)
 367                 tools="$tools emerge vimdiff"
 368                 ;;
 369         esac
 370         echo >&2 "merge tool candidates: $tools"
 371
 372         # Loop over each candidate and stop when a valid merge tool is found.
 373         for i in $tools
 374         do
 375                 merge_tool_path="$(translate_merge_tool_path "$i")"
 376                 if type "$merge_tool_path" > /dev/null 2>&1; then
 377                         echo "$i"
 378                         return 0
 379                 fi
 380         done
 381
 382         echo >&2 "No known merge resolution program available."
 383         return 1
 384 }
 385
 386 get_configured_merge_tool () {
 387         # Diff mode first tries diff.tool and falls back to merge.tool.
 388         # Merge mode only checks merge.tool
 389         if diff_mode; then
 390                 merge_tool=$(git config diff.tool || git config merge.tool)
 391         else
 392                 merge_tool=$(git config merge.tool)
 393         fi
 394         if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
 395                 echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
 396                 echo >&2 "Resetting to default..."
 397                 return 1
 398         fi
 399         echo "$merge_tool"
 400 }
 401
 402 get_merge_tool_path () {
 403         # A merge tool has been set, so verify that it's valid.
 404         if test -n "$1"; then
 405                 merge_tool="$1"
 406         else
 407                 merge_tool="$(get_merge_tool)"
 408         fi
 409         if ! valid_tool "$merge_tool"; then
 410                 echo >&2 "Unknown merge tool $merge_tool"
 411                 exit 1
 412         fi
 413         if diff_mode; then
 414                 merge_tool_path=$(git config difftool."$merge_tool".path ||
 415                                   git config mergetool."$merge_tool".path)
 416         else
 417                 merge_tool_path=$(git config mergetool."$merge_tool".path)
 418         fi
 419         if test -z "$merge_tool_path"; then
 420                 merge_tool_path="$(translate_merge_tool_path "$merge_tool")"
 421         fi
 422         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
 423         ! type "$merge_tool_path" > /dev/null 2>&1; then
 424                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
 425                          "'$merge_tool_path'"
 426                 exit 1
 427         fi
 428         echo "$merge_tool_path"
 429 }
 430
 431 get_merge_tool () {
 432         # Check if a merge tool has been configured
 433         merge_tool=$(get_configured_merge_tool)
 434         # Try to guess an appropriate merge tool if no tool has been set.
 435         if test -z "$merge_tool"; then
 436                 merge_tool="$(guess_merge_tool)" || exit
 437         fi
 438         echo "$merge_tool"
 439 }