Merge branch 'pr/remotes-in-hashmap'
[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] [--tool-help] [-y|--no-prompt|--prompt] [file to merge] ...'
12 SUBDIRECTORY_OK=Yes
13 OPTIONS_SPEC=
14 TOOL_MODE=merge
15 . git-sh-setup
16 . git-mergetool--lib
17 require_work_tree
18
19 # Returns true if the mode reflects a symlink
20 is_symlink () {
21         test "$1" = 120000
22 }
23
24 is_submodule () {
25         test "$1" = 160000
26 }
27
28 local_present () {
29         test -n "$local_mode"
30 }
31
32 remote_present () {
33         test -n "$remote_mode"
34 }
35
36 base_present () {
37         test -n "$base_mode"
38 }
39
40 cleanup_temp_files () {
41         if test "$1" = --save-backup
42         then
43                 rm -rf -- "$MERGED.orig"
44                 test -e "$BACKUP" && mv -- "$BACKUP" "$MERGED.orig"
45                 rm -f -- "$LOCAL" "$REMOTE" "$BASE"
46         else
47                 rm -f -- "$LOCAL" "$REMOTE" "$BASE" "$BACKUP"
48         fi
49 }
50
51 describe_file () {
52         mode="$1"
53         branch="$2"
54         file="$3"
55
56         printf "  {%s}: " "$branch"
57         if test -z "$mode"
58         then
59                 echo "deleted"
60         elif is_symlink "$mode"
61         then
62                 echo "a symbolic link -> '$(cat "$file")'"
63         elif is_submodule "$mode"
64         then
65                 echo "submodule commit $file"
66         elif base_present
67         then
68                 echo "modified file"
69         else
70                 echo "created file"
71         fi
72 }
73
74 resolve_symlink_merge () {
75         while true
76         do
77                 printf "Use (l)ocal or (r)emote, or (a)bort? "
78                 read ans || return 1
79                 case "$ans" in
80                 [lL]*)
81                         git checkout-index -f --stage=2 -- "$MERGED"
82                         git add -- "$MERGED"
83                         cleanup_temp_files --save-backup
84                         return 0
85                         ;;
86                 [rR]*)
87                         git checkout-index -f --stage=3 -- "$MERGED"
88                         git add -- "$MERGED"
89                         cleanup_temp_files --save-backup
90                         return 0
91                         ;;
92                 [aA]*)
93                         return 1
94                         ;;
95                 esac
96         done
97 }
98
99 resolve_deleted_merge () {
100         while true
101         do
102                 if base_present
103                 then
104                         printf "Use (m)odified or (d)eleted file, or (a)bort? "
105                 else
106                         printf "Use (c)reated or (d)eleted file, or (a)bort? "
107                 fi
108                 read ans || return 1
109                 case "$ans" in
110                 [mMcC]*)
111                         git add -- "$MERGED"
112                         cleanup_temp_files --save-backup
113                         return 0
114                         ;;
115                 [dD]*)
116                         git rm -- "$MERGED" > /dev/null
117                         cleanup_temp_files
118                         return 0
119                         ;;
120                 [aA]*)
121                         return 1
122                         ;;
123                 esac
124         done
125 }
126
127 resolve_submodule_merge () {
128         while true
129         do
130                 printf "Use (l)ocal or (r)emote, or (a)bort? "
131                 read ans || return 1
132                 case "$ans" in
133                 [lL]*)
134                         if ! local_present
135                         then
136                                 if test -n "$(git ls-tree HEAD -- "$MERGED")"
137                                 then
138                                         # Local isn't present, but it's a subdirectory
139                                         git ls-tree --full-name -r HEAD -- "$MERGED" |
140                                         git update-index --index-info || exit $?
141                                 else
142                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
143                                         git update-index --force-remove "$MERGED"
144                                         cleanup_temp_files --save-backup
145                                 fi
146                         elif is_submodule "$local_mode"
147                         then
148                                 stage_submodule "$MERGED" "$local_sha1"
149                         else
150                                 git checkout-index -f --stage=2 -- "$MERGED"
151                                 git add -- "$MERGED"
152                         fi
153                         return 0
154                         ;;
155                 [rR]*)
156                         if ! remote_present
157                         then
158                                 if test -n "$(git ls-tree MERGE_HEAD -- "$MERGED")"
159                                 then
160                                         # Remote isn't present, but it's a subdirectory
161                                         git ls-tree --full-name -r MERGE_HEAD -- "$MERGED" |
162                                         git update-index --index-info || exit $?
163                                 else
164                                         test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
165                                         git update-index --force-remove "$MERGED"
166                                 fi
167                         elif is_submodule "$remote_mode"
168                         then
169                                 ! is_submodule "$local_mode" &&
170                                 test -e "$MERGED" &&
171                                 mv -- "$MERGED" "$BACKUP"
172                                 stage_submodule "$MERGED" "$remote_sha1"
173                         else
174                                 test -e "$MERGED" && mv -- "$MERGED" "$BACKUP"
175                                 git checkout-index -f --stage=3 -- "$MERGED"
176                                 git add -- "$MERGED"
177                         fi
178                         cleanup_temp_files --save-backup
179                         return 0
180                         ;;
181                 [aA]*)
182                         return 1
183                         ;;
184                 esac
185         done
186 }
187
188 stage_submodule () {
189         path="$1"
190         submodule_sha1="$2"
191         mkdir -p "$path" ||
192         die "fatal: unable to create directory for module at $path"
193         # Find $path relative to work tree
194         work_tree_root=$(cd_to_toplevel && pwd)
195         work_rel_path=$(cd "$path" &&
196                 GIT_WORK_TREE="${work_tree_root}" git rev-parse --show-prefix
197         )
198         test -n "$work_rel_path" ||
199         die "fatal: unable to get path of module $path relative to work tree"
200         git update-index --add --replace --cacheinfo 160000 "$submodule_sha1" "${work_rel_path%/}" || die
201 }
202
203 checkout_staged_file () {
204         tmpfile=$(expr \
205                 "$(git checkout-index --temp --stage="$1" "$2" 2>/dev/null)" \
206                 : '\([^ ]*\)    ')
207
208         if test $? -eq 0 && test -n "$tmpfile"
209         then
210                 mv -- "$(git rev-parse --show-cdup)$tmpfile" "$3"
211         else
212                 >"$3"
213         fi
214 }
215
216 merge_file () {
217         MERGED="$1"
218
219         f=$(git ls-files -u -- "$MERGED")
220         if test -z "$f"
221         then
222                 if test ! -f "$MERGED"
223                 then
224                         echo "$MERGED: file not found"
225                 else
226                         echo "$MERGED: file does not need merging"
227                 fi
228                 return 1
229         fi
230
231         ext="$$$(expr "$MERGED" : '.*\(\.[^/]*\)$')"
232         BACKUP="./$MERGED.BACKUP.$ext"
233         LOCAL="./$MERGED.LOCAL.$ext"
234         REMOTE="./$MERGED.REMOTE.$ext"
235         BASE="./$MERGED.BASE.$ext"
236
237         base_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==1) print $1;}')
238         local_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==2) print $1;}')
239         remote_mode=$(git ls-files -u -- "$MERGED" | awk '{if ($3==3) print $1;}')
240
241         if is_submodule "$local_mode" || is_submodule "$remote_mode"
242         then
243                 echo "Submodule merge conflict for '$MERGED':"
244                 local_sha1=$(git ls-files -u -- "$MERGED" | awk '{if ($3==2) print $2;}')
245                 remote_sha1=$(git ls-files -u -- "$MERGED" | awk '{if ($3==3) print $2;}')
246                 describe_file "$local_mode" "local" "$local_sha1"
247                 describe_file "$remote_mode" "remote" "$remote_sha1"
248                 resolve_submodule_merge
249                 return
250         fi
251
252         mv -- "$MERGED" "$BACKUP"
253         cp -- "$BACKUP" "$MERGED"
254
255         checkout_staged_file 1 "$MERGED" "$BASE"
256         checkout_staged_file 2 "$MERGED" "$LOCAL"
257         checkout_staged_file 3 "$MERGED" "$REMOTE"
258
259         if test -z "$local_mode" || test -z "$remote_mode"
260         then
261                 echo "Deleted merge conflict for '$MERGED':"
262                 describe_file "$local_mode" "local" "$LOCAL"
263                 describe_file "$remote_mode" "remote" "$REMOTE"
264                 resolve_deleted_merge
265                 return
266         fi
267
268         if is_symlink "$local_mode" || is_symlink "$remote_mode"
269         then
270                 echo "Symbolic link merge conflict for '$MERGED':"
271                 describe_file "$local_mode" "local" "$LOCAL"
272                 describe_file "$remote_mode" "remote" "$REMOTE"
273                 resolve_symlink_merge
274                 return
275         fi
276
277         echo "Normal merge conflict for '$MERGED':"
278         describe_file "$local_mode" "local" "$LOCAL"
279         describe_file "$remote_mode" "remote" "$REMOTE"
280         if test "$guessed_merge_tool" = true || test "$prompt" = true
281         then
282                 printf "Hit return to start merge resolution tool (%s): " "$merge_tool"
283                 read ans || return 1
284         fi
285
286         if base_present
287         then
288                 present=true
289         else
290                 present=false
291         fi
292
293         if ! run_merge_tool "$merge_tool" "$present"
294         then
295                 echo "merge of $MERGED failed" 1>&2
296                 mv -- "$BACKUP" "$MERGED"
297
298                 if test "$merge_keep_temporaries" = "false"
299                 then
300                         cleanup_temp_files
301                 fi
302
303                 return 1
304         fi
305
306         if test "$merge_keep_backup" = "true"
307         then
308                 mv -- "$BACKUP" "$MERGED.orig"
309         else
310                 rm -- "$BACKUP"
311         fi
312
313         git add -- "$MERGED"
314         cleanup_temp_files
315         return 0
316 }
317
318 prompt=$(git config --bool mergetool.prompt)
319 guessed_merge_tool=false
320
321 while test $# != 0
322 do
323         case "$1" in
324         --tool-help)
325                 show_tool_help
326                 ;;
327         -t|--tool*)
328                 case "$#,$1" in
329                 *,*=*)
330                         merge_tool=$(expr "z$1" : 'z-[^=]*=\(.*\)')
331                         ;;
332                 1,*)
333                         usage ;;
334                 *)
335                         merge_tool="$2"
336                         shift ;;
337                 esac
338                 ;;
339         -y|--no-prompt)
340                 prompt=false
341                 ;;
342         --prompt)
343                 prompt=true
344                 ;;
345         --)
346                 shift
347                 break
348                 ;;
349         -*)
350                 usage
351                 ;;
352         *)
353                 break
354                 ;;
355         esac
356         shift
357 done
358
359 prompt_after_failed_merge () {
360         while true
361         do
362                 printf "Continue merging other unresolved paths (y/n) ? "
363                 read ans || return 1
364                 case "$ans" in
365                 [yY]*)
366                         return 0
367                         ;;
368                 [nN]*)
369                         return 1
370                         ;;
371                 esac
372         done
373 }
374
375 if test -z "$merge_tool"
376 then
377         # Check if a merge tool has been configured
378         merge_tool=$(get_configured_merge_tool)
379         # Try to guess an appropriate merge tool if no tool has been set.
380         if test -z "$merge_tool"
381         then
382                 merge_tool=$(guess_merge_tool) || exit
383                 guessed_merge_tool=true
384         fi
385 fi
386 merge_keep_backup="$(git config --bool mergetool.keepBackup || echo true)"
387 merge_keep_temporaries="$(git config --bool mergetool.keepTemporaries || echo false)"
388
389 last_status=0
390 rollup_status=0
391 files=
392
393 if test $# -eq 0
394 then
395         cd_to_toplevel
396
397         if test -e "$GIT_DIR/MERGE_RR"
398         then
399                 files=$(git rerere remaining)
400         else
401                 files=$(git ls-files -u | sed -e 's/^[^ ]*      //' | sort -u)
402         fi
403 else
404         files=$(git ls-files -u -- "$@" | sed -e 's/^[^ ]*      //' | sort -u)
405 fi
406
407 if test -z "$files"
408 then
409         echo "No files need merging"
410         exit 0
411 fi
412
413 printf "Merging:\n"
414 printf "%s\n" "$files"
415
416 IFS='
417 '
418 for i in $files
419 do
420         if test $last_status -ne 0
421         then
422                 prompt_after_failed_merge || exit 1
423         fi
424         printf "\n"
425         merge_file "$i"
426         last_status=$?
427         if test $last_status -ne 0
428         then
429                 rollup_status=1
430         fi
431 done
432
433 exit $rollup_status