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                         if $base_present; then
 263                                 "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" "$MERGED"
 264                         else
 265                                 "$merge_tool_path" "$LOCAL" "$LOCAL" "$REMOTE" "$MERGED"
 266                         fi
 267                         check_unchanged
 268                 else
 269                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 270                 fi
 271                 ;;
 272         tkdiff)
 273                 if merge_mode; then
 274                         if $base_present; then
 275                                 "$merge_tool_path" -a "$BASE" \
 276                                         -o "$MERGED" "$LOCAL" "$REMOTE"
 277                         else
 278                                 "$merge_tool_path" \
 279                                         -o "$MERGED" "$LOCAL" "$REMOTE"
 280                         fi
 281                         status=$?
 282                 else
 283                         "$merge_tool_path" "$LOCAL" "$REMOTE"
 284                 fi
 285                 ;;
 286         tortoisemerge)
 287                 if $base_present; then
 288                         touch "$BACKUP"
 289                         "$merge_tool_path" \
 290                                 -base:"$BASE" -mine:"$LOCAL" \
 291                                 -theirs:"$REMOTE" -merged:"$MERGED"
 292                         check_unchanged
 293                 else
 294                         echo "TortoiseMerge cannot be used without a base" 1>&2
 295                         status=1
 296                 fi
 297                 ;;
 298         xxdiff)
 299                 if merge_mode; then
 300                         touch "$BACKUP"
 301                         if $base_present; then
 302                                 "$merge_tool_path" -X --show-merged-pane \
 303                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
 304                                         -R 'Accel.Search: "Ctrl+F"' \
 305                                         -R 'Accel.SearchForward: "Ctrl-G"' \
 306                                         --merged-file "$MERGED" \
 307                                         "$LOCAL" "$BASE" "$REMOTE"
 308                         else
 309                                 "$merge_tool_path" -X $extra \
 310                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
 311                                         -R 'Accel.Search: "Ctrl+F"' \
 312                                         -R 'Accel.SearchForward: "Ctrl-G"' \
 313                                         --merged-file "$MERGED" \
 314                                         "$LOCAL" "$REMOTE"
 315                         fi
 316                         check_unchanged
 317                 else
 318                         "$merge_tool_path" \
 319                                 -R 'Accel.Search: "Ctrl+F"' \
 320                                 -R 'Accel.SearchForward: "Ctrl-G"' \
 321                                 "$LOCAL" "$REMOTE"
 322                 fi
 323                 ;;
 324         *)
 325                 merge_tool_cmd="$(get_merge_tool_cmd "$1")"
 326                 if test -z "$merge_tool_cmd"; then
 327                         if merge_mode; then
 328                                 status=1
 329                         fi
 330                         break
 331                 fi
 332                 if merge_mode; then
 333                         trust_exit_code="$(git config --bool \
 334                                 mergetool."$1".trustExitCode || echo false)"
 335                         if test "$trust_exit_code" = "false"; then
 336                                 touch "$BACKUP"
 337                                 ( eval $merge_tool_cmd )
 338                                 check_unchanged
 339                         else
 340                                 ( eval $merge_tool_cmd )
 341                                 status=$?
 342                         fi
 343                 else
 344                         ( eval $merge_tool_cmd )
 345                 fi
 346                 ;;
 347         esac
 348         return $status
 349 }
 350
 351 guess_merge_tool () {
 352         if merge_mode; then
 353                 tools="tortoisemerge"
 354         else
 355                 tools="kompare"
 356         fi
 357         if test -n "$DISPLAY"; then
 358                 if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
 359                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
 360                 else
 361                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
 362                 fi
 363                 tools="$tools gvimdiff diffuse ecmerge p4merge araxis bc3"
 364         fi
 365         case "${VISUAL:-$EDITOR}" in
 366         *vim*)
 367                 tools="$tools vimdiff emerge"
 368                 ;;
 369         *)
 370                 tools="$tools emerge vimdiff"
 371                 ;;
 372         esac
 373         echo >&2 "merge tool candidates: $tools"
 374
 375         # Loop over each candidate and stop when a valid merge tool is found.
 376         for i in $tools
 377         do
 378                 merge_tool_path="$(translate_merge_tool_path "$i")"
 379                 if type "$merge_tool_path" > /dev/null 2>&1; then
 380                         echo "$i"
 381                         return 0
 382                 fi
 383         done
 384
 385         echo >&2 "No known merge resolution program available."
 386         return 1
 387 }
 388
 389 get_configured_merge_tool () {
 390         # Diff mode first tries diff.tool and falls back to merge.tool.
 391         # Merge mode only checks merge.tool
 392         if diff_mode; then
 393                 merge_tool=$(git config diff.tool || git config merge.tool)
 394         else
 395                 merge_tool=$(git config merge.tool)
 396         fi
 397         if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
 398                 echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
 399                 echo >&2 "Resetting to default..."
 400                 return 1
 401         fi
 402         echo "$merge_tool"
 403 }
 404
 405 get_merge_tool_path () {
 406         # A merge tool has been set, so verify that it's valid.
 407         if test -n "$1"; then
 408                 merge_tool="$1"
 409         else
 410                 merge_tool="$(get_merge_tool)"
 411         fi
 412         if ! valid_tool "$merge_tool"; then
 413                 echo >&2 "Unknown merge tool $merge_tool"
 414                 exit 1
 415         fi
 416         if diff_mode; then
 417                 merge_tool_path=$(git config difftool."$merge_tool".path ||
 418                                   git config mergetool."$merge_tool".path)
 419         else
 420                 merge_tool_path=$(git config mergetool."$merge_tool".path)
 421         fi
 422         if test -z "$merge_tool_path"; then
 423                 merge_tool_path="$(translate_merge_tool_path "$merge_tool")"
 424         fi
 425         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
 426         ! type "$merge_tool_path" > /dev/null 2>&1; then
 427                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
 428                          "'$merge_tool_path'"
 429                 exit 1
 430         fi
 431         echo "$merge_tool_path"
 432 }
 433
 434 get_merge_tool () {
 435         # Check if a merge tool has been configured
 436         merge_tool=$(get_configured_merge_tool)
 437         # Try to guess an appropriate merge tool if no tool has been set.
 438         if test -z "$merge_tool"; then
 439                 merge_tool="$(guess_merge_tool)" || exit
 440         fi
 441         echo "$merge_tool"
 442 }