git-mergetool--lib.sh

   1 #!/bin/sh
   2 # git-mergetool--lib is a library for common merge tool functions
   3
   4 : ${MERGE_TOOLS_DIR=$(git --exec-path)/mergetools}
   5
   6 mode_ok () {
   7         if diff_mode
   8         then
   9                 can_diff
  10         elif merge_mode
  11         then
  12                 can_merge
  13         else
  14                 false
  15         fi
  16 }
  17
  18 is_available () {
  19         merge_tool_path=$(translate_merge_tool_path "$1") &&
  20         type "$merge_tool_path" >/dev/null 2>&1
  21 }
  22
  23 list_config_tools () {
  24         section=$1
  25         line_prefix=${2:-}
  26
  27         git config --get-regexp $section'\..*\.cmd' |
  28         while read -r key value
  29         do
  30                 toolname=${key#$section.}
  31                 toolname=${toolname%.cmd}
  32
  33                 printf "%s%s\n" "$line_prefix" "$toolname"
  34         done
  35 }
  36
  37 show_tool_names () {
  38         condition=${1:-true} per_line_prefix=${2:-} preamble=${3:-}
  39         not_found_msg=${4:-}
  40         extra_content=${5:-}
  41
  42         shown_any=
  43         ( cd "$MERGE_TOOLS_DIR" && ls ) | {
  44                 while read toolname
  45                 do
  46                         if setup_tool "$toolname" 2>/dev/null &&
  47                                 (eval "$condition" "$toolname")
  48                         then
  49                                 if test -n "$preamble"
  50                                 then
  51                                         printf "%s\n" "$preamble"
  52                                         preamble=
  53                                 fi
  54                                 shown_any=yes
  55                                 printf "%s%s\n" "$per_line_prefix" "$toolname"
  56                         fi
  57                 done
  58
  59                 if test -n "$extra_content"
  60                 then
  61                         if test -n "$preamble"
  62                         then
  63                                 # Note: no '\n' here since we don't want a
  64                                 # blank line if there is no initial content.
  65                                 printf "%s" "$preamble"
  66                                 preamble=
  67                         fi
  68                         shown_any=yes
  69                         printf "\n%s\n" "$extra_content"
  70                 fi
  71
  72                 if test -n "$preamble" && test -n "$not_found_msg"
  73                 then
  74                         printf "%s\n" "$not_found_msg"
  75                 fi
  76
  77                 test -n "$shown_any"
  78         }
  79 }
  80
  81 diff_mode() {
  82         test "$TOOL_MODE" = diff
  83 }
  84
  85 merge_mode() {
  86         test "$TOOL_MODE" = merge
  87 }
  88
  89 translate_merge_tool_path () {
  90         echo "$1"
  91 }
  92
  93 check_unchanged () {
  94         if test "$MERGED" -nt "$BACKUP"
  95         then
  96                 status=0
  97         else
  98                 while true
  99                 do
 100                         echo "$MERGED seems unchanged."
 101                         printf "Was the merge successful? [y/n] "
 102                         read answer || return 1
 103                         case "$answer" in
 104                         y*|Y*) status=0; break ;;
 105                         n*|N*) status=1; break ;;
 106                         esac
 107                 done
 108         fi
 109 }
 110
 111 valid_tool () {
 112         setup_tool "$1" && return 0
 113         cmd=$(get_merge_tool_cmd "$1")
 114         test -n "$cmd"
 115 }
 116
 117 setup_tool () {
 118         tool="$1"
 119
 120         # Fallback definitions, to be overriden by tools.
 121         can_merge () {
 122                 return 0
 123         }
 124
 125         can_diff () {
 126                 return 0
 127         }
 128
 129         diff_cmd () {
 130                 status=1
 131                 return $status
 132         }
 133
 134         merge_cmd () {
 135                 status=1
 136                 return $status
 137         }
 138
 139         translate_merge_tool_path () {
 140                 echo "$1"
 141         }
 142
 143         if ! test -f "$MERGE_TOOLS_DIR/$tool"
 144         then
 145                 # Use a special return code for this case since we want to
 146                 # source "defaults" even when an explicit tool path is
 147                 # configured since the user can use that to override the
 148                 # default path in the scriptlet.
 149                 return 2
 150         fi
 151
 152         # Load the redefined functions
 153         . "$MERGE_TOOLS_DIR/$tool"
 154
 155         if merge_mode && ! can_merge
 156         then
 157                 echo "error: '$tool' can not be used to resolve merges" >&2
 158                 return 1
 159         elif diff_mode && ! can_diff
 160         then
 161                 echo "error: '$tool' can only be used to resolve merges" >&2
 162                 return 1
 163         fi
 164         return 0
 165 }
 166
 167 get_merge_tool_cmd () {
 168         merge_tool="$1"
 169         if diff_mode
 170         then
 171                 git config "difftool.$merge_tool.cmd" ||
 172                 git config "mergetool.$merge_tool.cmd"
 173         else
 174                 git config "mergetool.$merge_tool.cmd"
 175         fi
 176 }
 177
 178 # Entry point for running tools
 179 run_merge_tool () {
 180         # If GIT_PREFIX is empty then we cannot use it in tools
 181         # that expect to be able to chdir() to its value.
 182         GIT_PREFIX=${GIT_PREFIX:-.}
 183         export GIT_PREFIX
 184
 185         merge_tool_path=$(get_merge_tool_path "$1") || exit
 186         base_present="$2"
 187         status=0
 188
 189         # Bring tool-specific functions into scope
 190         setup_tool "$1"
 191         exitcode=$?
 192         case $exitcode in
 193         0)
 194                 :
 195                 ;;
 196         2)
 197                 # The configured tool is not a built-in tool.
 198                 test -n "$merge_tool_path" || return 1
 199                 ;;
 200         *)
 201                 return $exitcode
 202                 ;;
 203         esac
 204
 205         if merge_mode
 206         then
 207                 run_merge_cmd "$1"
 208         else
 209                 run_diff_cmd "$1"
 210         fi
 211         return $status
 212 }
 213
 214 # Run a either a configured or built-in diff tool
 215 run_diff_cmd () {
 216         merge_tool_cmd=$(get_merge_tool_cmd "$1")
 217         if test -n "$merge_tool_cmd"
 218         then
 219                 ( eval $merge_tool_cmd )
 220                 status=$?
 221                 return $status
 222         else
 223                 diff_cmd "$1"
 224         fi
 225 }
 226
 227 # Run a either a configured or built-in merge tool
 228 run_merge_cmd () {
 229         merge_tool_cmd=$(get_merge_tool_cmd "$1")
 230         if test -n "$merge_tool_cmd"
 231         then
 232                 trust_exit_code=$(git config --bool \
 233                         "mergetool.$1.trustExitCode" || echo false)
 234                 if test "$trust_exit_code" = "false"
 235                 then
 236                         touch "$BACKUP"
 237                         ( eval $merge_tool_cmd )
 238                         status=$?
 239                         check_unchanged
 240                 else
 241                         ( eval $merge_tool_cmd )
 242                         status=$?
 243                 fi
 244                 return $status
 245         else
 246                 merge_cmd "$1"
 247         fi
 248 }
 249
 250 list_merge_tool_candidates () {
 251         if merge_mode
 252         then
 253                 tools="tortoisemerge"
 254         else
 255                 tools="kompare"
 256         fi
 257         if test -n "$DISPLAY"
 258         then
 259                 if test -n "$GNOME_DESKTOP_SESSION_ID"
 260                 then
 261                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
 262                 else
 263                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
 264                 fi
 265                 tools="$tools gvimdiff diffuse ecmerge p4merge araxis bc3 codecompare"
 266         fi
 267         case "${VISUAL:-$EDITOR}" in
 268         *vim*)
 269                 tools="$tools vimdiff emerge"
 270                 ;;
 271         *)
 272                 tools="$tools emerge vimdiff"
 273                 ;;
 274         esac
 275 }
 276
 277 show_tool_help () {
 278         tool_opt="'git ${TOOL_MODE}tool --tool-<tool>'"
 279
 280         tab='   '
 281         LF='
 282 '
 283         any_shown=no
 284
 285         cmd_name=${TOOL_MODE}tool
 286         config_tools=$({
 287                 diff_mode && list_config_tools difftool "$tab$tab"
 288                 list_config_tools mergetool "$tab$tab"
 289         } | sort)
 290         extra_content=
 291         if test -n "$config_tools"
 292         then
 293                 extra_content="${tab}user-defined:${LF}$config_tools"
 294         fi
 295
 296         show_tool_names 'mode_ok && is_available' "$tab$tab" \
 297                 "$tool_opt may be set to one of the following:" \
 298                 "No suitable tool for 'git $cmd_name --tool=<tool>' found." \
 299                 "$extra_content" &&
 300                 any_shown=yes
 301
 302         show_tool_names 'mode_ok && ! is_available' "$tab$tab" \
 303                 "${LF}The following tools are valid, but not currently available:" &&
 304                 any_shown=yes
 305
 306         if test "$any_shown" = yes
 307         then
 308                 echo
 309                 echo "Some of the tools listed above only work in a windowed"
 310                 echo "environment. If run in a terminal-only session, they will fail."
 311         fi
 312         exit 0
 313 }
 314
 315 guess_merge_tool () {
 316         list_merge_tool_candidates
 317         cat >&2 <<-EOF
 318
 319         This message is displayed because '$TOOL_MODE.tool' is not configured.
 320         See 'git ${TOOL_MODE}tool --tool-help' or 'git help config' for more details.
 321         'git ${TOOL_MODE}tool' will now attempt to use one of the following tools:
 322         $tools
 323         EOF
 324
 325         # Loop over each candidate and stop when a valid merge tool is found.
 326         for tool in $tools
 327         do
 328                 is_available "$tool" && echo "$tool" && return 0
 329         done
 330
 331         echo >&2 "No known ${TOOL_MODE} tool is available."
 332         return 1
 333 }
 334
 335 get_configured_merge_tool () {
 336         # Diff mode first tries diff.tool and falls back to merge.tool.
 337         # Merge mode only checks merge.tool
 338         if diff_mode
 339         then
 340                 merge_tool=$(git config diff.tool || git config merge.tool)
 341         else
 342                 merge_tool=$(git config merge.tool)
 343         fi
 344         if test -n "$merge_tool" && ! valid_tool "$merge_tool"
 345         then
 346                 echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
 347                 echo >&2 "Resetting to default..."
 348                 return 1
 349         fi
 350         echo "$merge_tool"
 351 }
 352
 353 get_merge_tool_path () {
 354         # A merge tool has been set, so verify that it's valid.
 355         merge_tool="$1"
 356         if ! valid_tool "$merge_tool"
 357         then
 358                 echo >&2 "Unknown merge tool $merge_tool"
 359                 exit 1
 360         fi
 361         if diff_mode
 362         then
 363                 merge_tool_path=$(git config difftool."$merge_tool".path ||
 364                                   git config mergetool."$merge_tool".path)
 365         else
 366                 merge_tool_path=$(git config mergetool."$merge_tool".path)
 367         fi
 368         if test -z "$merge_tool_path"
 369         then
 370                 merge_tool_path=$(translate_merge_tool_path "$merge_tool")
 371         fi
 372         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
 373                 ! type "$merge_tool_path" >/dev/null 2>&1
 374         then
 375                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
 376                          "'$merge_tool_path'"
 377                 exit 1
 378         fi
 379         echo "$merge_tool_path"
 380 }
 381
 382 get_merge_tool () {
 383         # Check if a merge tool has been configured
 384         merge_tool=$(get_configured_merge_tool)
 385         # Try to guess an appropriate merge tool if no tool has been set.
 386         if test -z "$merge_tool"
 387         then
 388                 merge_tool=$(guess_merge_tool) || exit
 389         fi
 390         echo "$merge_tool"
 391 }