Add bare repository indicator for __git_ps1
[git] / git-mergetool.sh
1 #!/bin/sh
2 #
3 # This program resolves merge conflicts in git
4 #
5 # Copyright (c) 2006 Theodore Y. Ts'o
6 #
7 # This file is licensed under the GPL v2, or a later version
8 # at the discretion of Junio C Hamano.
9 #
10
11 USAGE='[--tool=tool] [-y|--no-prompt|--prompt] [file to merge] ...'
12 SUBDIRECTORY_OK=Yes
13 OPTIONS_SPEC=
14 . git-sh-setup
15 require_work_tree
16
17 # Returns true if the mode reflects a symlink
18 is_symlink () {
19     test "$1" = 120000
20 }
21
22 local_present () {
23     test -n "$local_mode"
24 }
25
26 remote_present () {
27     test -n "$remote_mode"
28 }
29
30 base_present () {
31     test -n "$base_mode"
32 }
33
34 cleanup_temp_files () {
35     if test "$1" = --save-backup ; then
36         mv -- "$BACKUP" "$MERGED.orig"
37         rm -f -- "$LOCAL" "$REMOTE" "$BASE"
38     else
39         rm -f -- "$LOCAL" "$REMOTE" "$BASE" "$BACKUP"
40     fi
41 }
42
43 describe_file () {
44     mode="$1"
45     branch="$2"
46     file="$3"
47
48     printf "  {%s}: " "$branch"
49     if test -z "$mode"; then
50         echo "deleted"
51     elif is_symlink "$mode" ; then
52         echo "a symbolic link -> '$(cat "$file")'"
53     else
54         if base_present; then
55             echo "modified"
56         else
57             echo "created"
58         fi
59     fi
60 }
61
62
63 resolve_symlink_merge () {
64     while true; do
65         printf "Use (l)ocal or (r)emote, or (a)bort? "
66         read ans
67         case "$ans" in
68             [lL]*)
69                 git checkout-index -f --stage=2 -- "$MERGED"
70                 git add -- "$MERGED"
71                 cleanup_temp_files --save-backup
72                 return 0
73                 ;;
74             [rR]*)
75                 git checkout-index -f --stage=3 -- "$MERGED"
76                 git add -- "$MERGED"
77                 cleanup_temp_files --save-backup
78                 return 0
79                 ;;
80             [aA]*)
81                 return 1
82                 ;;
83             esac
84         done
85 }
86
87 resolve_deleted_merge () {
88     while true; do
89         if base_present; then
90             printf "Use (m)odified or (d)eleted file, or (a)bort? "
91         else
92             printf "Use (c)reated or (d)eleted file, or (a)bort? "
93         fi
94         read ans
95         case "$ans" in
96             [mMcC]*)
97                 git add -- "$MERGED"
98                 cleanup_temp_files --save-backup
99                 return 0
100                 ;;
101             [dD]*)
102                 git rm -- "$MERGED" > /dev/null
103                 cleanup_temp_files
104                 return 0
105                 ;;
106             [aA]*)
107                 return 1
108                 ;;
109             esac
110         done
111 }
112
113 check_unchanged () {
114     if test "$MERGED" -nt "$BACKUP" ; then
115         status=0;
116     else
117         while true; do
118             echo "$MERGED seems unchanged."
119             printf "Was the merge successful? [y/n] "
120             read answer < /dev/tty
121             case "$answer" in
122                 y*|Y*) status=0; break ;;
123                 n*|N*) status=1; break ;;
124             esac
125         done
126     fi
127 }
128
129 checkout_staged_file () {
130     tmpfile=$(expr "$(git checkout-index --temp --stage="$1" "$2")" : '\([^     ]*\)    ')
131
132     if test $? -eq 0 -a -n "$tmpfile" ; then
133         mv -- "$(git rev-parse --show-cdup)$tmpfile" "$3"
134     fi
135 }
136
137 merge_file () {
138     MERGED="$1"
139
140     f=`git ls-files -u -- "$MERGED"`
141     if test -z "$f" ; then
142         if test ! -f "$MERGED" ; then
143             echo "$MERGED: file not found"
144         else
145             echo "$MERGED: file does not need merging"
146         fi
147         return 1
148     fi
149
150     ext="$$$(expr "$MERGED" : '.*\(\.[^/]*\)$')"
151     BACKUP="./$MERGED.BACKUP.$ext"
152     LOCAL="./$MERGED.LOCAL.$ext"
153     REMOTE="./$MERGED.REMOTE.$ext"
154     BASE="./$MERGED.BASE.$ext"
155
156     mv -- "$MERGED" "$BACKUP"
157     cp -- "$BACKUP" "$MERGED"
158
159     base_mode=`git ls-files -u -- "$MERGED" | awk '{if ($3==1) print $1;}'`
160     local_mode=`git ls-files -u -- "$MERGED" | awk '{if ($3==2) print $1;}'`
161     remote_mode=`git ls-files -u -- "$MERGED" | awk '{if ($3==3) print $1;}'`
162
163     base_present   && checkout_staged_file 1 "$MERGED" "$BASE"
164     local_present  && checkout_staged_file 2 "$MERGED" "$LOCAL"
165     remote_present && checkout_staged_file 3 "$MERGED" "$REMOTE"
166
167     if test -z "$local_mode" -o -z "$remote_mode"; then
168         echo "Deleted merge conflict for '$MERGED':"
169         describe_file "$local_mode" "local" "$LOCAL"
170         describe_file "$remote_mode" "remote" "$REMOTE"
171         resolve_deleted_merge
172         return
173     fi
174
175     if is_symlink "$local_mode" || is_symlink "$remote_mode"; then
176         echo "Symbolic link merge conflict for '$MERGED':"
177         describe_file "$local_mode" "local" "$LOCAL"
178         describe_file "$remote_mode" "remote" "$REMOTE"
179         resolve_symlink_merge
180         return
181     fi
182
183     echo "Normal merge conflict for '$MERGED':"
184     describe_file "$local_mode" "local" "$LOCAL"
185     describe_file "$remote_mode" "remote" "$REMOTE"
186     if "$prompt" = true; then
187         printf "Hit return to start merge resolution tool (%s): " "$merge_tool"
188         read ans
189     fi
190
191     case "$merge_tool" in
192         kdiff3)
193             if base_present ; then
194                 ("$merge_tool_path" --auto --L1 "$MERGED (Base)" --L2 "$MERGED (Local)" --L3 "$MERGED (Remote)" \
195                     -o "$MERGED" "$BASE" "$LOCAL" "$REMOTE" > /dev/null 2>&1)
196             else
197                 ("$merge_tool_path" --auto --L1 "$MERGED (Local)" --L2 "$MERGED (Remote)" \
198                     -o "$MERGED" "$LOCAL" "$REMOTE" > /dev/null 2>&1)
199             fi
200             status=$?
201             ;;
202         tkdiff)
203             if base_present ; then
204                 "$merge_tool_path" -a "$BASE" -o "$MERGED" "$LOCAL" "$REMOTE"
205             else
206                 "$merge_tool_path" -o "$MERGED" "$LOCAL" "$REMOTE"
207             fi
208             status=$?
209             ;;
210         meld)
211             touch "$BACKUP"
212             "$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
213             check_unchanged
214             ;;
215         vimdiff)
216             touch "$BACKUP"
217             "$merge_tool_path" -c "wincmd l" "$LOCAL" "$MERGED" "$REMOTE"
218             check_unchanged
219             ;;
220         gvimdiff)
221             touch "$BACKUP"
222             "$merge_tool_path" -c "wincmd l" -f "$LOCAL" "$MERGED" "$REMOTE"
223             check_unchanged
224             ;;
225         xxdiff)
226             touch "$BACKUP"
227             if base_present ; then
228                 "$merge_tool_path" -X --show-merged-pane \
229                     -R 'Accel.SaveAsMerged: "Ctrl-S"' \
230                     -R 'Accel.Search: "Ctrl+F"' \
231                     -R 'Accel.SearchForward: "Ctrl-G"' \
232                     --merged-file "$MERGED" "$LOCAL" "$BASE" "$REMOTE"
233             else
234                 "$merge_tool_path" -X --show-merged-pane \
235                     -R 'Accel.SaveAsMerged: "Ctrl-S"' \
236                     -R 'Accel.Search: "Ctrl+F"' \
237                     -R 'Accel.SearchForward: "Ctrl-G"' \
238                     --merged-file "$MERGED" "$LOCAL" "$REMOTE"
239             fi
240             check_unchanged
241             ;;
242         opendiff)
243             touch "$BACKUP"
244             if base_present; then
245                 "$merge_tool_path" "$LOCAL" "$REMOTE" -ancestor "$BASE" -merge "$MERGED" | cat
246             else
247                 "$merge_tool_path" "$LOCAL" "$REMOTE" -merge "$MERGED" | cat
248             fi
249             check_unchanged
250             ;;
251         ecmerge)
252             touch "$BACKUP"
253             if base_present; then
254                 "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" --default --mode=merge3 --to="$MERGED"
255             else
256                 "$merge_tool_path" "$LOCAL" "$REMOTE" --default --mode=merge2 --to="$MERGED"
257             fi
258             check_unchanged
259             ;;
260         emerge)
261             if base_present ; then
262                 "$merge_tool_path" -f emerge-files-with-ancestor-command "$LOCAL" "$REMOTE" "$BASE" "$(basename "$MERGED")"
263             else
264                 "$merge_tool_path" -f emerge-files-command "$LOCAL" "$REMOTE" "$(basename "$MERGED")"
265             fi
266             status=$?
267             ;;
268         *)
269             if test -n "$merge_tool_cmd"; then
270                 if test "$merge_tool_trust_exit_code" = "false"; then
271                     touch "$BACKUP"
272                     ( eval $merge_tool_cmd )
273                     check_unchanged
274                 else
275                     ( eval $merge_tool_cmd )
276                     status=$?
277                 fi
278             fi
279             ;;
280     esac
281     if test "$status" -ne 0; then
282         echo "merge of $MERGED failed" 1>&2
283         mv -- "$BACKUP" "$MERGED"
284
285         if test "$merge_keep_temporaries" = "false"; then
286             cleanup_temp_files
287         fi
288
289         return 1
290     fi
291
292     if test "$merge_keep_backup" = "true"; then
293         mv -- "$BACKUP" "$MERGED.orig"
294     else
295         rm -- "$BACKUP"
296     fi
297
298     git add -- "$MERGED"
299     cleanup_temp_files
300     return 0
301 }
302
303 prompt=$(git config --bool mergetool.prompt || echo true)
304
305 while test $# != 0
306 do
307     case "$1" in
308         -t|--tool*)
309             case "$#,$1" in
310                 *,*=*)
311                     merge_tool=`expr "z$1" : 'z-[^=]*=\(.*\)'`
312                     ;;
313                 1,*)
314                     usage ;;
315                 *)
316                     merge_tool="$2"
317                     shift ;;
318             esac
319             ;;
320         -y|--no-prompt)
321             prompt=false
322             ;;
323         --prompt)
324             prompt=true
325             ;;
326         --)
327             shift
328             break
329             ;;
330         -*)
331             usage
332             ;;
333         *)
334             break
335             ;;
336     esac
337     shift
338 done
339
340 valid_custom_tool()
341 {
342     merge_tool_cmd="$(git config mergetool.$1.cmd)"
343     test -n "$merge_tool_cmd"
344 }
345
346 valid_tool() {
347         case "$1" in
348                 kdiff3 | tkdiff | xxdiff | meld | opendiff | emerge | vimdiff | gvimdiff | ecmerge)
349                         ;; # happy
350                 *)
351                         if ! valid_custom_tool "$1"; then
352                                 return 1
353                         fi
354                         ;;
355         esac
356 }
357
358 init_merge_tool_path() {
359         merge_tool_path=`git config mergetool.$1.path`
360         if test -z "$merge_tool_path" ; then
361                 case "$1" in
362                         emerge)
363                                 merge_tool_path=emacs
364                                 ;;
365                         *)
366                                 merge_tool_path=$1
367                                 ;;
368                 esac
369         fi
370 }
371
372 prompt_after_failed_merge() {
373     while true; do
374         printf "Continue merging other unresolved paths (y/n) ? "
375         read ans
376         case "$ans" in
377
378             [yY]*)
379                 return 0
380                 ;;
381
382             [nN]*)
383                 return 1
384                 ;;
385         esac
386     done
387 }
388
389 if test -z "$merge_tool"; then
390     merge_tool=`git config merge.tool`
391     if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
392             echo >&2 "git config option merge.tool set to unknown tool: $merge_tool"
393             echo >&2 "Resetting to default..."
394             unset merge_tool
395     fi
396 fi
397
398 if test -z "$merge_tool" ; then
399     if test -n "$DISPLAY"; then
400         if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
401             merge_tool_candidates="meld kdiff3 tkdiff xxdiff gvimdiff"
402         else
403             merge_tool_candidates="kdiff3 tkdiff xxdiff meld gvimdiff"
404         fi
405     fi
406     if echo "${VISUAL:-$EDITOR}" | grep 'emacs' > /dev/null 2>&1; then
407         merge_tool_candidates="$merge_tool_candidates emerge opendiff vimdiff"
408     elif echo "${VISUAL:-$EDITOR}" | grep 'vim' > /dev/null 2>&1; then
409         merge_tool_candidates="$merge_tool_candidates vimdiff opendiff emerge"
410     else
411         merge_tool_candidates="$merge_tool_candidates opendiff emerge vimdiff"
412     fi
413     echo "merge tool candidates: $merge_tool_candidates"
414     for i in $merge_tool_candidates; do
415         init_merge_tool_path $i
416         if type "$merge_tool_path" > /dev/null 2>&1; then
417             merge_tool=$i
418             break
419         fi
420     done
421     if test -z "$merge_tool" ; then
422         echo "No known merge resolution program available."
423         exit 1
424     fi
425 else
426     if ! valid_tool "$merge_tool"; then
427         echo >&2 "Unknown merge_tool $merge_tool"
428         exit 1
429     fi
430
431     init_merge_tool_path "$merge_tool"
432
433     merge_keep_backup="$(git config --bool merge.keepBackup || echo true)"
434     merge_keep_temporaries="$(git config --bool mergetool.keepTemporaries || echo false)"
435
436     if test -z "$merge_tool_cmd" && ! type "$merge_tool_path" > /dev/null 2>&1; then
437         echo "The merge tool $merge_tool is not available as '$merge_tool_path'"
438         exit 1
439     fi
440
441     if ! test -z "$merge_tool_cmd"; then
442         merge_tool_trust_exit_code="$(git config --bool mergetool.$merge_tool.trustExitCode || echo false)"
443     fi
444 fi
445
446 last_status=0
447 rollup_status=0
448
449 if test $# -eq 0 ; then
450     files=`git ls-files -u | sed -e 's/^[^      ]*      //' | sort -u`
451     if test -z "$files" ; then
452         echo "No files need merging"
453         exit 0
454     fi
455     echo Merging the files: "$files"
456     git ls-files -u |
457     sed -e 's/^[^       ]*      //' |
458     sort -u |
459     while IFS= read i
460     do
461         if test $last_status -ne 0; then
462             prompt_after_failed_merge < /dev/tty || exit 1
463         fi
464         printf "\n"
465         merge_file "$i" < /dev/tty > /dev/tty
466         last_status=$?
467         if test $last_status -ne 0; then
468             rollup_status=1
469         fi
470     done
471 else
472     while test $# -gt 0; do
473         if test $last_status -ne 0; then
474             prompt_after_failed_merge || exit 1
475         fi
476         printf "\n"
477         merge_file "$1"
478         last_status=$?
479         if test $last_status -ne 0; then
480             rollup_status=1
481         fi
482         shift
483     done
484 fi
485
486 exit $rollup_status