Merge branch 'aw/rebase-i-p'
[git] / 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         # If GIT_PREFIX is empty then we cannot use it in tools
90         # that expect to be able to chdir() to its value.
91         GIT_PREFIX=${GIT_PREFIX:-.}
92         export GIT_PREFIX
93
94         merge_tool_path="$(get_merge_tool_path "$1")" || exit
95         base_present="$2"
96         status=0
97
98         case "$1" in
99         araxis)
100                 if merge_mode; then
101                         touch "$BACKUP"
102                         if $base_present; then
103                                 "$merge_tool_path" -wait -merge -3 -a1 \
104                                         "$BASE" "$LOCAL" "$REMOTE" "$MERGED" \
105                                         >/dev/null 2>&1
106                         else
107                                 "$merge_tool_path" -wait -2 \
108                                         "$LOCAL" "$REMOTE" "$MERGED" \
109                                         >/dev/null 2>&1
110                         fi
111                         check_unchanged
112                 else
113                         "$merge_tool_path" -wait -2 "$LOCAL" "$REMOTE" \
114                                 >/dev/null 2>&1
115                 fi
116                 ;;
117         bc3)
118                 if merge_mode; then
119                         touch "$BACKUP"
120                         if $base_present; then
121                                 "$merge_tool_path" "$LOCAL" "$REMOTE" "$BASE" \
122                                         -mergeoutput="$MERGED"
123                         else
124                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
125                                         -mergeoutput="$MERGED"
126                         fi
127                         check_unchanged
128                 else
129                         "$merge_tool_path" "$LOCAL" "$REMOTE"
130                 fi
131                 ;;
132         diffuse)
133                 if merge_mode; then
134                         touch "$BACKUP"
135                         if $base_present; then
136                                 "$merge_tool_path" \
137                                         "$LOCAL" "$MERGED" "$REMOTE" \
138                                         "$BASE" | cat
139                         else
140                                 "$merge_tool_path" \
141                                         "$LOCAL" "$MERGED" "$REMOTE" | cat
142                         fi
143                         check_unchanged
144                 else
145                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
146                 fi
147                 ;;
148         ecmerge)
149                 if merge_mode; then
150                         touch "$BACKUP"
151                         if $base_present; then
152                                 "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" \
153                                         --default --mode=merge3 --to="$MERGED"
154                         else
155                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
156                                         --default --mode=merge2 --to="$MERGED"
157                         fi
158                         check_unchanged
159                 else
160                         "$merge_tool_path" --default --mode=diff2 \
161                                 "$LOCAL" "$REMOTE"
162                 fi
163                 ;;
164         emerge)
165                 if merge_mode; then
166                         if $base_present; then
167                                 "$merge_tool_path" \
168                                         -f emerge-files-with-ancestor-command \
169                                         "$LOCAL" "$REMOTE" "$BASE" \
170                                         "$(basename "$MERGED")"
171                         else
172                                 "$merge_tool_path" \
173                                         -f emerge-files-command \
174                                         "$LOCAL" "$REMOTE" \
175                                         "$(basename "$MERGED")"
176                         fi
177                         status=$?
178                 else
179                         "$merge_tool_path" -f emerge-files-command \
180                                 "$LOCAL" "$REMOTE"
181                 fi
182                 ;;
183         gvimdiff|vimdiff)
184                 if merge_mode; then
185                         touch "$BACKUP"
186                         if $base_present; then
187                                 "$merge_tool_path" -f -d -c "wincmd J" \
188                                         "$MERGED" "$LOCAL" "$BASE" "$REMOTE"
189                         else
190                                 "$merge_tool_path" -f -d -c "wincmd l" \
191                                         "$LOCAL" "$MERGED" "$REMOTE"
192                         fi
193                         check_unchanged
194                 else
195                         "$merge_tool_path" -R -f -d -c "wincmd l" \
196                                 -c 'cd $GIT_PREFIX' \
197                                 "$LOCAL" "$REMOTE"
198                 fi
199                 ;;
200         gvimdiff2|vimdiff2)
201                 if merge_mode; then
202                         touch "$BACKUP"
203                         "$merge_tool_path" -f -d -c "wincmd l" \
204                                 "$LOCAL" "$MERGED" "$REMOTE"
205                         check_unchanged
206                 else
207                         "$merge_tool_path" -R -f -d -c "wincmd l" \
208                                 -c 'cd $GIT_PREFIX' \
209                                 "$LOCAL" "$REMOTE"
210                 fi
211                 ;;
212         kdiff3)
213                 if merge_mode; then
214                         if $base_present; then
215                                 ("$merge_tool_path" --auto \
216                                         --L1 "$MERGED (Base)" \
217                                         --L2 "$MERGED (Local)" \
218                                         --L3 "$MERGED (Remote)" \
219                                         -o "$MERGED" \
220                                         "$BASE" "$LOCAL" "$REMOTE" \
221                                 > /dev/null 2>&1)
222                         else
223                                 ("$merge_tool_path" --auto \
224                                         --L1 "$MERGED (Local)" \
225                                         --L2 "$MERGED (Remote)" \
226                                         -o "$MERGED" \
227                                         "$LOCAL" "$REMOTE" \
228                                 > /dev/null 2>&1)
229                         fi
230                         status=$?
231                 else
232                         ("$merge_tool_path" --auto \
233                                 --L1 "$MERGED (A)" \
234                                 --L2 "$MERGED (B)" "$LOCAL" "$REMOTE" \
235                         > /dev/null 2>&1)
236                 fi
237                 ;;
238         kompare)
239                 "$merge_tool_path" "$LOCAL" "$REMOTE"
240                 ;;
241         meld)
242                 if merge_mode; then
243                         touch "$BACKUP"
244                         "$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
245                         check_unchanged
246                 else
247                         "$merge_tool_path" "$LOCAL" "$REMOTE"
248                 fi
249                 ;;
250         opendiff)
251                 if merge_mode; then
252                         touch "$BACKUP"
253                         if $base_present; then
254                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
255                                         -ancestor "$BASE" \
256                                         -merge "$MERGED" | cat
257                         else
258                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
259                                         -merge "$MERGED" | cat
260                         fi
261                         check_unchanged
262                 else
263                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
264                 fi
265                 ;;
266         p4merge)
267                 if merge_mode; then
268                         touch "$BACKUP"
269                         $base_present || >"$BASE"
270                         "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" "$MERGED"
271                         check_unchanged
272                 else
273                         "$merge_tool_path" "$LOCAL" "$REMOTE"
274                 fi
275                 ;;
276         tkdiff)
277                 if merge_mode; then
278                         if $base_present; then
279                                 "$merge_tool_path" -a "$BASE" \
280                                         -o "$MERGED" "$LOCAL" "$REMOTE"
281                         else
282                                 "$merge_tool_path" \
283                                         -o "$MERGED" "$LOCAL" "$REMOTE"
284                         fi
285                         status=$?
286                 else
287                         "$merge_tool_path" "$LOCAL" "$REMOTE"
288                 fi
289                 ;;
290         tortoisemerge)
291                 if $base_present; then
292                         touch "$BACKUP"
293                         "$merge_tool_path" \
294                                 -base:"$BASE" -mine:"$LOCAL" \
295                                 -theirs:"$REMOTE" -merged:"$MERGED"
296                         check_unchanged
297                 else
298                         echo "TortoiseMerge cannot be used without a base" 1>&2
299                         status=1
300                 fi
301                 ;;
302         xxdiff)
303                 if merge_mode; then
304                         touch "$BACKUP"
305                         if $base_present; then
306                                 "$merge_tool_path" -X --show-merged-pane \
307                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
308                                         -R 'Accel.Search: "Ctrl+F"' \
309                                         -R 'Accel.SearchForward: "Ctrl-G"' \
310                                         --merged-file "$MERGED" \
311                                         "$LOCAL" "$BASE" "$REMOTE"
312                         else
313                                 "$merge_tool_path" -X $extra \
314                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
315                                         -R 'Accel.Search: "Ctrl+F"' \
316                                         -R 'Accel.SearchForward: "Ctrl-G"' \
317                                         --merged-file "$MERGED" \
318                                         "$LOCAL" "$REMOTE"
319                         fi
320                         check_unchanged
321                 else
322                         "$merge_tool_path" \
323                                 -R 'Accel.Search: "Ctrl+F"' \
324                                 -R 'Accel.SearchForward: "Ctrl-G"' \
325                                 "$LOCAL" "$REMOTE"
326                 fi
327                 ;;
328         *)
329                 merge_tool_cmd="$(get_merge_tool_cmd "$1")"
330                 if test -z "$merge_tool_cmd"; then
331                         if merge_mode; then
332                                 status=1
333                         fi
334                         break
335                 fi
336                 if merge_mode; then
337                         trust_exit_code="$(git config --bool \
338                                 mergetool."$1".trustExitCode || echo false)"
339                         if test "$trust_exit_code" = "false"; then
340                                 touch "$BACKUP"
341                                 ( eval $merge_tool_cmd )
342                                 check_unchanged
343                         else
344                                 ( eval $merge_tool_cmd )
345                                 status=$?
346                         fi
347                 else
348                         ( eval $merge_tool_cmd )
349                 fi
350                 ;;
351         esac
352         return $status
353 }
354
355 guess_merge_tool () {
356         if merge_mode; then
357                 tools="tortoisemerge"
358         else
359                 tools="kompare"
360         fi
361         if test -n "$DISPLAY"; then
362                 if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
363                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
364                 else
365                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
366                 fi
367                 tools="$tools gvimdiff diffuse ecmerge p4merge araxis bc3"
368         fi
369         case "${VISUAL:-$EDITOR}" in
370         *vim*)
371                 tools="$tools vimdiff emerge"
372                 ;;
373         *)
374                 tools="$tools emerge vimdiff"
375                 ;;
376         esac
377         echo >&2 "merge tool candidates: $tools"
378
379         # Loop over each candidate and stop when a valid merge tool is found.
380         for i in $tools
381         do
382                 merge_tool_path="$(translate_merge_tool_path "$i")"
383                 if type "$merge_tool_path" > /dev/null 2>&1; then
384                         echo "$i"
385                         return 0
386                 fi
387         done
388
389         echo >&2 "No known merge resolution program available."
390         return 1
391 }
392
393 get_configured_merge_tool () {
394         # Diff mode first tries diff.tool and falls back to merge.tool.
395         # Merge mode only checks merge.tool
396         if diff_mode; then
397                 merge_tool=$(git config diff.tool || git config merge.tool)
398         else
399                 merge_tool=$(git config merge.tool)
400         fi
401         if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
402                 echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
403                 echo >&2 "Resetting to default..."
404                 return 1
405         fi
406         echo "$merge_tool"
407 }
408
409 get_merge_tool_path () {
410         # A merge tool has been set, so verify that it's valid.
411         if test -n "$1"; then
412                 merge_tool="$1"
413         else
414                 merge_tool="$(get_merge_tool)"
415         fi
416         if ! valid_tool "$merge_tool"; then
417                 echo >&2 "Unknown merge tool $merge_tool"
418                 exit 1
419         fi
420         if diff_mode; then
421                 merge_tool_path=$(git config difftool."$merge_tool".path ||
422                                   git config mergetool."$merge_tool".path)
423         else
424                 merge_tool_path=$(git config mergetool."$merge_tool".path)
425         fi
426         if test -z "$merge_tool_path"; then
427                 merge_tool_path="$(translate_merge_tool_path "$merge_tool")"
428         fi
429         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
430         ! type "$merge_tool_path" > /dev/null 2>&1; then
431                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
432                          "'$merge_tool_path'"
433                 exit 1
434         fi
435         echo "$merge_tool_path"
436 }
437
438 get_merge_tool () {
439         # Check if a merge tool has been configured
440         merge_tool=$(get_configured_merge_tool)
441         # Try to guess an appropriate merge tool if no tool has been set.
442         if test -z "$merge_tool"; then
443                 merge_tool="$(guess_merge_tool)" || exit
444         fi
445         echo "$merge_tool"
446 }