Merge branch 'dl/difftool-mergetool'
[git] / 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 gui_mode () {
92         test "$GIT_MERGETOOL_GUI" = true
93 }
94
95 translate_merge_tool_path () {
96         echo "$1"
97 }
98
99 check_unchanged () {
100         if test "$MERGED" -nt "$BACKUP"
101         then
102                 return 0
103         else
104                 while true
105                 do
106                         echo "$MERGED seems unchanged."
107                         printf "Was the merge successful [y/n]? "
108                         read answer || return 1
109                         case "$answer" in
110                         y*|Y*) return 0 ;;
111                         n*|N*) return 1 ;;
112                         esac
113                 done
114         fi
115 }
116
117 valid_tool () {
118         setup_tool "$1" && return 0
119         cmd=$(get_merge_tool_cmd "$1")
120         test -n "$cmd"
121 }
122
123 setup_user_tool () {
124         merge_tool_cmd=$(get_merge_tool_cmd "$tool")
125         test -n "$merge_tool_cmd" || return 1
126
127         diff_cmd () {
128                 ( eval $merge_tool_cmd )
129         }
130
131         merge_cmd () {
132                 ( eval $merge_tool_cmd )
133         }
134 }
135
136 setup_tool () {
137         tool="$1"
138
139         # Fallback definitions, to be overridden by tools.
140         can_merge () {
141                 return 0
142         }
143
144         can_diff () {
145                 return 0
146         }
147
148         diff_cmd () {
149                 return 1
150         }
151
152         merge_cmd () {
153                 return 1
154         }
155
156         translate_merge_tool_path () {
157                 echo "$1"
158         }
159
160         # Most tools' exit codes cannot be trusted, so By default we ignore
161         # their exit code and check the merged file's modification time in
162         # check_unchanged() to determine whether or not the merge was
163         # successful.  The return value from run_merge_cmd, by default, is
164         # determined by check_unchanged().
165         #
166         # When a tool's exit code can be trusted then the return value from
167         # run_merge_cmd is simply the tool's exit code, and check_unchanged()
168         # is not called.
169         #
170         # The return value of exit_code_trustable() tells us whether or not we
171         # can trust the tool's exit code.
172         #
173         # User-defined and built-in tools default to false.
174         # Built-in tools advertise that their exit code is trustable by
175         # redefining exit_code_trustable() to true.
176
177         exit_code_trustable () {
178                 false
179         }
180
181
182         if ! test -f "$MERGE_TOOLS_DIR/$tool"
183         then
184                 setup_user_tool
185                 return $?
186         fi
187
188         # Load the redefined functions
189         . "$MERGE_TOOLS_DIR/$tool"
190         # Now let the user override the default command for the tool.  If
191         # they have not done so then this will return 1 which we ignore.
192         setup_user_tool
193
194         if merge_mode && ! can_merge
195         then
196                 echo "error: '$tool' can not be used to resolve merges" >&2
197                 return 1
198         elif diff_mode && ! can_diff
199         then
200                 echo "error: '$tool' can only be used to resolve merges" >&2
201                 return 1
202         fi
203         return 0
204 }
205
206 get_merge_tool_cmd () {
207         merge_tool="$1"
208         if diff_mode
209         then
210                 git config "difftool.$merge_tool.cmd" ||
211                 git config "mergetool.$merge_tool.cmd"
212         else
213                 git config "mergetool.$merge_tool.cmd"
214         fi
215 }
216
217 trust_exit_code () {
218         if git config --bool "mergetool.$1.trustExitCode"
219         then
220                 :; # OK
221         elif exit_code_trustable
222         then
223                 echo true
224         else
225                 echo false
226         fi
227 }
228
229
230 # Entry point for running tools
231 run_merge_tool () {
232         # If GIT_PREFIX is empty then we cannot use it in tools
233         # that expect to be able to chdir() to its value.
234         GIT_PREFIX=${GIT_PREFIX:-.}
235         export GIT_PREFIX
236
237         merge_tool_path=$(get_merge_tool_path "$1") || exit
238         base_present="$2"
239
240         # Bring tool-specific functions into scope
241         setup_tool "$1" || return 1
242
243         if merge_mode
244         then
245                 run_merge_cmd "$1"
246         else
247                 run_diff_cmd "$1"
248         fi
249 }
250
251 # Run a either a configured or built-in diff tool
252 run_diff_cmd () {
253         diff_cmd "$1"
254 }
255
256 # Run a either a configured or built-in merge tool
257 run_merge_cmd () {
258         mergetool_trust_exit_code=$(trust_exit_code "$1")
259         if test "$mergetool_trust_exit_code" = "true"
260         then
261                 merge_cmd "$1"
262         else
263                 touch "$BACKUP"
264                 merge_cmd "$1"
265                 check_unchanged
266         fi
267 }
268
269 list_merge_tool_candidates () {
270         if merge_mode
271         then
272                 tools="tortoisemerge"
273         else
274                 tools="kompare"
275         fi
276         if test -n "$DISPLAY"
277         then
278                 if test -n "$GNOME_DESKTOP_SESSION_ID"
279                 then
280                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
281                 else
282                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
283                 fi
284                 tools="$tools gvimdiff diffuse diffmerge ecmerge"
285                 tools="$tools p4merge araxis bc codecompare"
286                 tools="$tools smerge"
287         fi
288         case "${VISUAL:-$EDITOR}" in
289         *vim*)
290                 tools="$tools vimdiff emerge"
291                 ;;
292         *)
293                 tools="$tools emerge vimdiff"
294                 ;;
295         esac
296 }
297
298 show_tool_help () {
299         tool_opt="'git ${TOOL_MODE}tool --tool=<tool>'"
300
301         tab='   '
302         LF='
303 '
304         any_shown=no
305
306         cmd_name=${TOOL_MODE}tool
307         config_tools=$({
308                 diff_mode && list_config_tools difftool "$tab$tab"
309                 list_config_tools mergetool "$tab$tab"
310         } | sort)
311         extra_content=
312         if test -n "$config_tools"
313         then
314                 extra_content="${tab}user-defined:${LF}$config_tools"
315         fi
316
317         show_tool_names 'mode_ok && is_available' "$tab$tab" \
318                 "$tool_opt may be set to one of the following:" \
319                 "No suitable tool for 'git $cmd_name --tool=<tool>' found." \
320                 "$extra_content" &&
321                 any_shown=yes
322
323         show_tool_names 'mode_ok && ! is_available' "$tab$tab" \
324                 "${LF}The following tools are valid, but not currently available:" &&
325                 any_shown=yes
326
327         if test "$any_shown" = yes
328         then
329                 echo
330                 echo "Some of the tools listed above only work in a windowed"
331                 echo "environment. If run in a terminal-only session, they will fail."
332         fi
333         exit 0
334 }
335
336 guess_merge_tool () {
337         list_merge_tool_candidates
338         cat >&2 <<-EOF
339
340         This message is displayed because '$TOOL_MODE.tool' is not configured.
341         See 'git ${TOOL_MODE}tool --tool-help' or 'git help config' for more details.
342         'git ${TOOL_MODE}tool' will now attempt to use one of the following tools:
343         $tools
344         EOF
345
346         # Loop over each candidate and stop when a valid merge tool is found.
347         IFS=' '
348         for tool in $tools
349         do
350                 is_available "$tool" && echo "$tool" && return 0
351         done
352
353         echo >&2 "No known ${TOOL_MODE} tool is available."
354         return 1
355 }
356
357 get_configured_merge_tool () {
358         keys=
359         if diff_mode
360         then
361                 if gui_mode
362                 then
363                         keys="diff.guitool merge.guitool diff.tool merge.tool"
364                 else
365                         keys="diff.tool merge.tool"
366                 fi
367         else
368                 if gui_mode
369                 then
370                         keys="merge.guitool merge.tool"
371                 else
372                         keys="merge.tool"
373                 fi
374         fi
375
376         merge_tool=$(
377                 IFS=' '
378                 for key in $keys
379                 do
380                         selected=$(git config $key)
381                         if test -n "$selected"
382                         then
383                                 echo "$selected"
384                                 return
385                         fi
386                 done)
387
388         if test -n "$merge_tool" && ! valid_tool "$merge_tool"
389         then
390                 echo >&2 "git config option $TOOL_MODE.${gui_prefix}tool set to unknown tool: $merge_tool"
391                 echo >&2 "Resetting to default..."
392                 return 1
393         fi
394         echo "$merge_tool"
395 }
396
397 get_merge_tool_path () {
398         # A merge tool has been set, so verify that it's valid.
399         merge_tool="$1"
400         if ! valid_tool "$merge_tool"
401         then
402                 echo >&2 "Unknown merge tool $merge_tool"
403                 exit 1
404         fi
405         if diff_mode
406         then
407                 merge_tool_path=$(git config difftool."$merge_tool".path ||
408                                   git config mergetool."$merge_tool".path)
409         else
410                 merge_tool_path=$(git config mergetool."$merge_tool".path)
411         fi
412         if test -z "$merge_tool_path"
413         then
414                 merge_tool_path=$(translate_merge_tool_path "$merge_tool")
415         fi
416         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
417                 ! type "$merge_tool_path" >/dev/null 2>&1
418         then
419                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
420                          "'$merge_tool_path'"
421                 exit 1
422         fi
423         echo "$merge_tool_path"
424 }
425
426 get_merge_tool () {
427         is_guessed=false
428         # Check if a merge tool has been configured
429         merge_tool=$(get_configured_merge_tool)
430         # Try to guess an appropriate merge tool if no tool has been set.
431         if test -z "$merge_tool"
432         then
433                 merge_tool=$(guess_merge_tool) || exit
434                 is_guessed=true
435         fi
436         echo "$merge_tool"
437         test "$is_guessed" = false
438 }
439
440 mergetool_find_win32_cmd () {
441         executable=$1
442         sub_directory=$2
443
444         # Use $executable if it exists in $PATH
445         if type -p "$executable" >/dev/null 2>&1
446         then
447                 printf '%s' "$executable"
448                 return
449         fi
450
451         # Look for executable in the typical locations
452         for directory in $(env | grep -Ei '^PROGRAM(FILES(\(X86\))?|W6432)=' |
453                 cut -d '=' -f 2- | sort -u)
454         do
455                 if test -n "$directory" && test -x "$directory/$sub_directory/$executable"
456                 then
457                         printf '%s' "$directory/$sub_directory/$executable"
458                         return
459                 fi
460         done
461
462         printf '%s' "$executable"
463 }