full integration of rev-cache into git, completed test suite
[git] / git-mergetool--lib.sh
1 # git-mergetool--lib is a library for common merge tool functions
2 diff_mode() {
3         test "$TOOL_MODE" = diff
4 }
5
6 merge_mode() {
7         test "$TOOL_MODE" = merge
8 }
9
10 translate_merge_tool_path () {
11         case "$1" in
12         vimdiff)
13                 echo vim
14                 ;;
15         gvimdiff)
16                 echo gvim
17                 ;;
18         emerge)
19                 echo emacs
20                 ;;
21         araxis)
22                 echo compare
23                 ;;
24         *)
25                 echo "$1"
26                 ;;
27         esac
28 }
29
30 check_unchanged () {
31         if test "$MERGED" -nt "$BACKUP"; then
32                 status=0
33         else
34                 while true; do
35                         echo "$MERGED seems unchanged."
36                         printf "Was the merge successful? [y/n] "
37                         read answer < /dev/tty
38                         case "$answer" in
39                         y*|Y*) status=0; break ;;
40                         n*|N*) status=1; break ;;
41                         esac
42                 done
43         fi
44 }
45
46 valid_tool () {
47         case "$1" in
48         kdiff3 | tkdiff | xxdiff | meld | opendiff | \
49         emerge | vimdiff | gvimdiff | ecmerge | diffuse | araxis)
50                 ;; # happy
51         tortoisemerge)
52                 if ! merge_mode; then
53                         return 1
54                 fi
55                 ;;
56         kompare)
57                 if ! diff_mode; then
58                         return 1
59                 fi
60                 ;;
61         *)
62                 if test -z "$(get_merge_tool_cmd "$1")"; then
63                         return 1
64                 fi
65                 ;;
66         esac
67 }
68
69 get_merge_tool_cmd () {
70         # Prints the custom command for a merge tool
71         if test -n "$1"; then
72                 merge_tool="$1"
73         else
74                 merge_tool="$(get_merge_tool)"
75         fi
76         if diff_mode; then
77                 echo "$(git config difftool.$merge_tool.cmd ||
78                         git config mergetool.$merge_tool.cmd)"
79         else
80                 echo "$(git config mergetool.$merge_tool.cmd)"
81         fi
82 }
83
84 run_merge_tool () {
85         merge_tool_path="$(get_merge_tool_path "$1")" || exit
86         base_present="$2"
87         status=0
88
89         case "$1" in
90         kdiff3)
91                 if merge_mode; then
92                         if $base_present; then
93                                 ("$merge_tool_path" --auto \
94                                         --L1 "$MERGED (Base)" \
95                                         --L2 "$MERGED (Local)" \
96                                         --L3 "$MERGED (Remote)" \
97                                         -o "$MERGED" \
98                                         "$BASE" "$LOCAL" "$REMOTE" \
99                                 > /dev/null 2>&1)
100                         else
101                                 ("$merge_tool_path" --auto \
102                                         --L1 "$MERGED (Local)" \
103                                         --L2 "$MERGED (Remote)" \
104                                         -o "$MERGED" \
105                                         "$LOCAL" "$REMOTE" \
106                                 > /dev/null 2>&1)
107                         fi
108                         status=$?
109                 else
110                         ("$merge_tool_path" --auto \
111                                 --L1 "$MERGED (A)" \
112                                 --L2 "$MERGED (B)" "$LOCAL" "$REMOTE" \
113                         > /dev/null 2>&1)
114                 fi
115                 ;;
116         kompare)
117                 "$merge_tool_path" "$LOCAL" "$REMOTE"
118                 ;;
119         tkdiff)
120                 if merge_mode; then
121                         if $base_present; then
122                                 "$merge_tool_path" -a "$BASE" \
123                                         -o "$MERGED" "$LOCAL" "$REMOTE"
124                         else
125                                 "$merge_tool_path" \
126                                         -o "$MERGED" "$LOCAL" "$REMOTE"
127                         fi
128                         status=$?
129                 else
130                         "$merge_tool_path" "$LOCAL" "$REMOTE"
131                 fi
132                 ;;
133         meld)
134                 if merge_mode; then
135                         touch "$BACKUP"
136                         "$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
137                         check_unchanged
138                 else
139                         "$merge_tool_path" "$LOCAL" "$REMOTE"
140                 fi
141                 ;;
142         diffuse)
143                 if merge_mode; then
144                         touch "$BACKUP"
145                         if $base_present; then
146                                 "$merge_tool_path" \
147                                         "$LOCAL" "$MERGED" "$REMOTE" \
148                                         "$BASE" | cat
149                         else
150                                 "$merge_tool_path" \
151                                         "$LOCAL" "$MERGED" "$REMOTE" | cat
152                         fi
153                         check_unchanged
154                 else
155                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
156                 fi
157                 ;;
158         vimdiff)
159                 if merge_mode; then
160                         touch "$BACKUP"
161                         "$merge_tool_path" -d -c "wincmd l" \
162                                 "$LOCAL" "$MERGED" "$REMOTE"
163                         check_unchanged
164                 else
165                         "$merge_tool_path" -d -c "wincmd l" \
166                                 "$LOCAL" "$REMOTE"
167                 fi
168                 ;;
169         gvimdiff)
170                 if merge_mode; then
171                         touch "$BACKUP"
172                         "$merge_tool_path" -d -c "wincmd l" -f \
173                                 "$LOCAL" "$MERGED" "$REMOTE"
174                         check_unchanged
175                 else
176                         "$merge_tool_path" -d -c "wincmd l" -f \
177                                 "$LOCAL" "$REMOTE"
178                 fi
179                 ;;
180         xxdiff)
181                 if merge_mode; then
182                         touch "$BACKUP"
183                         if $base_present; then
184                                 "$merge_tool_path" -X --show-merged-pane \
185                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
186                                         -R 'Accel.Search: "Ctrl+F"' \
187                                         -R 'Accel.SearchForward: "Ctrl-G"' \
188                                         --merged-file "$MERGED" \
189                                         "$LOCAL" "$BASE" "$REMOTE"
190                         else
191                                 "$merge_tool_path" -X $extra \
192                                         -R 'Accel.SaveAsMerged: "Ctrl-S"' \
193                                         -R 'Accel.Search: "Ctrl+F"' \
194                                         -R 'Accel.SearchForward: "Ctrl-G"' \
195                                         --merged-file "$MERGED" \
196                                         "$LOCAL" "$REMOTE"
197                         fi
198                         check_unchanged
199                 else
200                         "$merge_tool_path" \
201                                 -R 'Accel.Search: "Ctrl+F"' \
202                                 -R 'Accel.SearchForward: "Ctrl-G"' \
203                                 "$LOCAL" "$REMOTE"
204                 fi
205                 ;;
206         opendiff)
207                 if merge_mode; then
208                         touch "$BACKUP"
209                         if $base_present; then
210                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
211                                         -ancestor "$BASE" \
212                                         -merge "$MERGED" | cat
213                         else
214                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
215                                         -merge "$MERGED" | cat
216                         fi
217                         check_unchanged
218                 else
219                         "$merge_tool_path" "$LOCAL" "$REMOTE" | cat
220                 fi
221                 ;;
222         ecmerge)
223                 if merge_mode; then
224                         touch "$BACKUP"
225                         if $base_present; then
226                                 "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" \
227                                         --default --mode=merge3 --to="$MERGED"
228                         else
229                                 "$merge_tool_path" "$LOCAL" "$REMOTE" \
230                                         --default --mode=merge2 --to="$MERGED"
231                         fi
232                         check_unchanged
233                 else
234                         "$merge_tool_path" --default --mode=diff2 \
235                                 "$LOCAL" "$REMOTE"
236                 fi
237                 ;;
238         emerge)
239                 if merge_mode; then
240                         if $base_present; then
241                                 "$merge_tool_path" \
242                                         -f emerge-files-with-ancestor-command \
243                                         "$LOCAL" "$REMOTE" "$BASE" \
244                                         "$(basename "$MERGED")"
245                         else
246                                 "$merge_tool_path" \
247                                         -f emerge-files-command \
248                                         "$LOCAL" "$REMOTE" \
249                                         "$(basename "$MERGED")"
250                         fi
251                         status=$?
252                 else
253                         "$merge_tool_path" -f emerge-files-command \
254                                 "$LOCAL" "$REMOTE"
255                 fi
256                 ;;
257         tortoisemerge)
258                 if $base_present; then
259                         touch "$BACKUP"
260                         "$merge_tool_path" \
261                                 -base:"$BASE" -mine:"$LOCAL" \
262                                 -theirs:"$REMOTE" -merged:"$MERGED"
263                         check_unchanged
264                 else
265                         echo "TortoiseMerge cannot be used without a base" 1>&2
266                         status=1
267                 fi
268                 ;;
269         araxis)
270                 if merge_mode; then
271                         touch "$BACKUP"
272                         if $base_present; then
273                                 "$merge_tool_path" -wait -merge -3 -a1 \
274                                         "$BASE" "$LOCAL" "$REMOTE" "$MERGED" \
275                                         >/dev/null 2>&1
276                         else
277                                 "$merge_tool_path" -wait -2 \
278                                         "$LOCAL" "$REMOTE" "$MERGED" \
279                                         >/dev/null 2>&1
280                         fi
281                         check_unchanged
282                 else
283                         "$merge_tool_path" -wait -2 "$LOCAL" "$REMOTE" \
284                                 >/dev/null 2>&1
285                 fi
286                 ;;
287         *)
288                 merge_tool_cmd="$(get_merge_tool_cmd "$1")"
289                 if test -z "$merge_tool_cmd"; then
290                         if merge_mode; then
291                                 status=1
292                         fi
293                         break
294                 fi
295                 if merge_mode; then
296                         trust_exit_code="$(git config --bool \
297                                 mergetool."$1".trustExitCode || echo false)"
298                         if test "$trust_exit_code" = "false"; then
299                                 touch "$BACKUP"
300                                 ( eval $merge_tool_cmd )
301                                 check_unchanged
302                         else
303                                 ( eval $merge_tool_cmd )
304                                 status=$?
305                         fi
306                 else
307                         ( eval $merge_tool_cmd )
308                 fi
309                 ;;
310         esac
311         return $status
312 }
313
314 guess_merge_tool () {
315         if merge_mode; then
316                 tools="tortoisemerge"
317         else
318                 tools="kompare"
319         fi
320         if test -n "$DISPLAY"; then
321                 if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
322                         tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
323                 else
324                         tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
325                 fi
326                 tools="$tools gvimdiff diffuse ecmerge araxis"
327         fi
328         if echo "${VISUAL:-$EDITOR}" | grep emacs > /dev/null 2>&1; then
329                 # $EDITOR is emacs so add emerge as a candidate
330                 tools="$tools emerge vimdiff"
331         elif echo "${VISUAL:-$EDITOR}" | grep vim > /dev/null 2>&1; then
332                 # $EDITOR is vim so add vimdiff as a candidate
333                 tools="$tools vimdiff emerge"
334         else
335                 tools="$tools emerge vimdiff"
336         fi
337         echo >&2 "merge tool candidates: $tools"
338
339         # Loop over each candidate and stop when a valid merge tool is found.
340         for i in $tools
341         do
342                 merge_tool_path="$(translate_merge_tool_path "$i")"
343                 if type "$merge_tool_path" > /dev/null 2>&1; then
344                         echo "$i"
345                         return 0
346                 fi
347         done
348
349         echo >&2 "No known merge resolution program available."
350         return 1
351 }
352
353 get_configured_merge_tool () {
354         # Diff mode first tries diff.tool and falls back to merge.tool.
355         # Merge mode only checks merge.tool
356         if diff_mode; then
357                 merge_tool=$(git config diff.tool || git config merge.tool)
358         else
359                 merge_tool=$(git config merge.tool)
360         fi
361         if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
362                 echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
363                 echo >&2 "Resetting to default..."
364                 return 1
365         fi
366         echo "$merge_tool"
367 }
368
369 get_merge_tool_path () {
370         # A merge tool has been set, so verify that it's valid.
371         if test -n "$1"; then
372                 merge_tool="$1"
373         else
374                 merge_tool="$(get_merge_tool)"
375         fi
376         if ! valid_tool "$merge_tool"; then
377                 echo >&2 "Unknown merge tool $merge_tool"
378                 exit 1
379         fi
380         if diff_mode; then
381                 merge_tool_path=$(git config difftool."$merge_tool".path ||
382                                   git config mergetool."$merge_tool".path)
383         else
384                 merge_tool_path=$(git config mergetool."$merge_tool".path)
385         fi
386         if test -z "$merge_tool_path"; then
387                 merge_tool_path="$(translate_merge_tool_path "$merge_tool")"
388         fi
389         if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
390         ! type "$merge_tool_path" > /dev/null 2>&1; then
391                 echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
392                          "'$merge_tool_path'"
393                 exit 1
394         fi
395         echo "$merge_tool_path"
396 }
397
398 get_merge_tool () {
399         # Check if a merge tool has been configured
400         merge_tool=$(get_configured_merge_tool)
401         # Try to guess an appropriate merge tool if no tool has been set.
402         if test -z "$merge_tool"; then
403                 merge_tool="$(guess_merge_tool)" || exit
404         fi
405         echo "$merge_tool"
406 }