git-mergetool--lib.sh

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