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