Merge branch 'maint'
[git] / git-merge.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano
4 #
5
6 OPTIONS_KEEPDASHDASH=
7 OPTIONS_SPEC="\
8 git-merge [options] <remote>...
9 git-merge [options] <msg> HEAD <remote>
10 --
11 stat                 show a diffstat at the end of the merge
12 n                    don't show a diffstat at the end of the merge
13 summary              (synonym to --stat)
14 log                  add list of one-line log to merge commit message
15 squash               create a single commit instead of doing a merge
16 commit               perform a commit if the merge sucesses (default)
17 ff                   allow fast forward (default)
18 s,strategy=          merge strategy to use
19 m,message=           message to be used for the merge commit (if any)
20 "
21
22 SUBDIRECTORY_OK=Yes
23 . git-sh-setup
24 require_work_tree
25 cd_to_toplevel
26
27 test -z "$(git ls-files -u)" ||
28         die "You are in the middle of a conflicted merge."
29
30 LF='
31 '
32
33 all_strategies='recur recursive octopus resolve stupid ours subtree'
34 default_twohead_strategies='recursive'
35 default_octopus_strategies='octopus'
36 no_fast_forward_strategies='subtree ours'
37 no_trivial_strategies='recursive recur subtree ours'
38 use_strategies=
39
40 allow_fast_forward=t
41 allow_trivial_merge=t
42 squash= no_commit= log_arg=
43
44 dropsave() {
45         rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
46                  "$GIT_DIR/MERGE_STASH" || exit 1
47 }
48
49 savestate() {
50         # Stash away any local modifications.
51         git stash create >"$GIT_DIR/MERGE_STASH"
52 }
53
54 restorestate() {
55         if test -f "$GIT_DIR/MERGE_STASH"
56         then
57                 git reset --hard $head >/dev/null
58                 git stash apply $(cat "$GIT_DIR/MERGE_STASH")
59                 git update-index --refresh >/dev/null
60         fi
61 }
62
63 finish_up_to_date () {
64         case "$squash" in
65         t)
66                 echo "$1 (nothing to squash)" ;;
67         '')
68                 echo "$1" ;;
69         esac
70         dropsave
71 }
72
73 squash_message () {
74         echo Squashed commit of the following:
75         echo
76         git log --no-merges --pretty=medium ^"$head" $remoteheads
77 }
78
79 finish () {
80         if test '' = "$2"
81         then
82                 rlogm="$GIT_REFLOG_ACTION"
83         else
84                 echo "$2"
85                 rlogm="$GIT_REFLOG_ACTION: $2"
86         fi
87         case "$squash" in
88         t)
89                 echo "Squash commit -- not updating HEAD"
90                 squash_message >"$GIT_DIR/SQUASH_MSG"
91                 ;;
92         '')
93                 case "$merge_msg" in
94                 '')
95                         echo "No merge message -- not updating HEAD"
96                         ;;
97                 *)
98                         git update-ref -m "$rlogm" HEAD "$1" "$head" || exit 1
99                         git gc --auto
100                         ;;
101                 esac
102                 ;;
103         esac
104         case "$1" in
105         '')
106                 ;;
107         ?*)
108                 if test "$show_diffstat" = t
109                 then
110                         # We want color (if set), but no pager
111                         GIT_PAGER='' git diff --stat --summary -M "$head" "$1"
112                 fi
113                 ;;
114         esac
115
116         # Run a post-merge hook
117         if test -x "$GIT_DIR"/hooks/post-merge
118         then
119             case "$squash" in
120             t)
121                 "$GIT_DIR"/hooks/post-merge 1
122                 ;;
123             '')
124                 "$GIT_DIR"/hooks/post-merge 0
125                 ;;
126             esac
127         fi
128 }
129
130 merge_name () {
131         remote="$1"
132         rh=$(git rev-parse --verify "$remote^0" 2>/dev/null) || return
133         bh=$(git show-ref -s --verify "refs/heads/$remote" 2>/dev/null)
134         if test "$rh" = "$bh"
135         then
136                 echo "$rh               branch '$remote' of ."
137         elif truname=$(expr "$remote" : '\(.*\)~[1-9][0-9]*$') &&
138                 git show-ref -q --verify "refs/heads/$truname" 2>/dev/null
139         then
140                 echo "$rh               branch '$truname' (early part) of ."
141         elif test "$remote" = "FETCH_HEAD" -a -r "$GIT_DIR/FETCH_HEAD"
142         then
143                 sed -e 's/      not-for-merge   /               /' -e 1q \
144                         "$GIT_DIR/FETCH_HEAD"
145         else
146                 echo "$rh               commit '$remote'"
147         fi
148 }
149
150 parse_config () {
151         while test $# != 0; do
152                 case "$1" in
153                 -n|--no-stat|--no-summary)
154                         show_diffstat=false ;;
155                 --stat|--summary)
156                         show_diffstat=t ;;
157                 --log|--no-log)
158                         log_arg=$1 ;;
159                 --squash)
160                         test "$allow_fast_forward" = t ||
161                                 die "You cannot combine --squash with --no-ff."
162                         squash=t no_commit=t ;;
163                 --no-squash)
164                         squash= no_commit= ;;
165                 --commit)
166                         no_commit= ;;
167                 --no-commit)
168                         no_commit=t ;;
169                 --ff)
170                         allow_fast_forward=t ;;
171                 --no-ff)
172                         test "$squash" != t ||
173                                 die "You cannot combine --squash with --no-ff."
174                         allow_fast_forward=f ;;
175                 -s|--strategy)
176                         shift
177                         case " $all_strategies " in
178                         *" $1 "*)
179                                 use_strategies="$use_strategies$1 " ;;
180                         *)
181                                 die "available strategies are: $all_strategies" ;;
182                         esac
183                         ;;
184                 -m|--message)
185                         shift
186                         merge_msg="$1"
187                         have_message=t
188                         ;;
189                 --)
190                         shift
191                         break ;;
192                 *)      usage ;;
193                 esac
194                 shift
195         done
196         args_left=$#
197 }
198
199 test $# != 0 || usage
200
201 have_message=
202
203 if branch=$(git-symbolic-ref -q HEAD)
204 then
205         mergeopts=$(git config "branch.${branch#refs/heads/}.mergeoptions")
206         if test -n "$mergeopts"
207         then
208                 parse_config $mergeopts --
209         fi
210 fi
211
212 parse_config "$@"
213 while test $args_left -lt $#; do shift; done
214
215 if test -z "$show_diffstat"; then
216     test "$(git config --bool merge.diffstat)" = false && show_diffstat=false
217     test "$(git config --bool merge.stat)" = false && show_diffstat=false
218     test -z "$show_diffstat" && show_diffstat=t
219 fi
220
221 # This could be traditional "merge <msg> HEAD <commit>..."  and the
222 # way we can tell it is to see if the second token is HEAD, but some
223 # people might have misused the interface and used a committish that
224 # is the same as HEAD there instead.  Traditional format never would
225 # have "-m" so it is an additional safety measure to check for it.
226
227 if test -z "$have_message" &&
228         second_token=$(git rev-parse --verify "$2^0" 2>/dev/null) &&
229         head_commit=$(git rev-parse --verify "HEAD" 2>/dev/null) &&
230         test "$second_token" = "$head_commit"
231 then
232         merge_msg="$1"
233         shift
234         head_arg="$1"
235         shift
236 elif ! git rev-parse --verify HEAD >/dev/null 2>&1
237 then
238         # If the merged head is a valid one there is no reason to
239         # forbid "git merge" into a branch yet to be born.  We do
240         # the same for "git pull".
241         if test 1 -ne $#
242         then
243                 echo >&2 "Can merge only exactly one commit into empty head"
244                 exit 1
245         fi
246
247         rh=$(git rev-parse --verify "$1^0") ||
248                 die "$1 - not something we can merge"
249
250         git update-ref -m "initial pull" HEAD "$rh" "" &&
251         git read-tree --reset -u HEAD
252         exit
253
254 else
255         # We are invoked directly as the first-class UI.
256         head_arg=HEAD
257
258         # All the rest are the commits being merged; prepare
259         # the standard merge summary message to be appended to
260         # the given message.  If remote is invalid we will die
261         # later in the common codepath so we discard the error
262         # in this loop.
263         merge_name=$(for remote
264                 do
265                         merge_name "$remote"
266                 done | git fmt-merge-msg $log_arg
267         )
268         merge_msg="${merge_msg:+$merge_msg$LF$LF}$merge_name"
269 fi
270 head=$(git rev-parse --verify "$head_arg"^0) || usage
271
272 # All the rest are remote heads
273 test "$#" = 0 && usage ;# we need at least one remote head.
274 set_reflog_action "merge $*"
275
276 remoteheads=
277 for remote
278 do
279         remotehead=$(git rev-parse --verify "$remote"^0 2>/dev/null) ||
280             die "$remote - not something we can merge"
281         remoteheads="${remoteheads}$remotehead "
282         eval GITHEAD_$remotehead='"$remote"'
283         export GITHEAD_$remotehead
284 done
285 set x $remoteheads ; shift
286
287 case "$use_strategies" in
288 '')
289         case "$#" in
290         1)
291                 var="`git config --get pull.twohead`"
292                 if test -n "$var"
293                 then
294                         use_strategies="$var"
295                 else
296                         use_strategies="$default_twohead_strategies"
297                 fi ;;
298         *)
299                 var="`git config --get pull.octopus`"
300                 if test -n "$var"
301                 then
302                         use_strategies="$var"
303                 else
304                         use_strategies="$default_octopus_strategies"
305                 fi ;;
306         esac
307         ;;
308 esac
309
310 for s in $use_strategies
311 do
312         for ss in $no_fast_forward_strategies
313         do
314                 case " $s " in
315                 *" $ss "*)
316                         allow_fast_forward=f
317                         break
318                         ;;
319                 esac
320         done
321         for ss in $no_trivial_strategies
322         do
323                 case " $s " in
324                 *" $ss "*)
325                         allow_trivial_merge=f
326                         break
327                         ;;
328                 esac
329         done
330 done
331
332 case "$#" in
333 1)
334         common=$(git merge-base --all $head "$@")
335         ;;
336 *)
337         common=$(git show-branch --merge-base $head "$@")
338         ;;
339 esac
340 echo "$head" >"$GIT_DIR/ORIG_HEAD"
341
342 case "$allow_fast_forward,$#,$common,$no_commit" in
343 ?,*,'',*)
344         # No common ancestors found. We need a real merge.
345         ;;
346 ?,1,"$1",*)
347         # If head can reach all the merge then we are up to date.
348         # but first the most common case of merging one remote.
349         finish_up_to_date "Already up-to-date."
350         exit 0
351         ;;
352 t,1,"$head",*)
353         # Again the most common case of merging one remote.
354         echo "Updating $(git rev-parse --short $head)..$(git rev-parse --short $1)"
355         git update-index --refresh 2>/dev/null
356         msg="Fast forward"
357         if test -n "$have_message"
358         then
359                 msg="$msg (no commit created; -m option ignored)"
360         fi
361         new_head=$(git rev-parse --verify "$1^0") &&
362         git read-tree -v -m -u --exclude-per-directory=.gitignore $head "$new_head" &&
363         finish "$new_head" "$msg" || exit
364         dropsave
365         exit 0
366         ;;
367 ?,1,?*"$LF"?*,*)
368         # We are not doing octopus and not fast forward.  Need a
369         # real merge.
370         ;;
371 ?,1,*,)
372         # We are not doing octopus, not fast forward, and have only
373         # one common.
374         git update-index --refresh 2>/dev/null
375         case "$allow_trivial_merge" in
376         t)
377                 # See if it is really trivial.
378                 git var GIT_COMMITTER_IDENT >/dev/null || exit
379                 echo "Trying really trivial in-index merge..."
380                 if git read-tree --trivial -m -u -v $common $head "$1" &&
381                    result_tree=$(git write-tree)
382                 then
383                         echo "Wonderful."
384                         result_commit=$(
385                                 printf '%s\n' "$merge_msg" |
386                                 git commit-tree $result_tree -p HEAD -p "$1"
387                         ) || exit
388                         finish "$result_commit" "In-index merge"
389                         dropsave
390                         exit 0
391                 fi
392                 echo "Nope."
393         esac
394         ;;
395 *)
396         # An octopus.  If we can reach all the remote we are up to date.
397         up_to_date=t
398         for remote
399         do
400                 common_one=$(git merge-base --all $head $remote)
401                 if test "$common_one" != "$remote"
402                 then
403                         up_to_date=f
404                         break
405                 fi
406         done
407         if test "$up_to_date" = t
408         then
409                 finish_up_to_date "Already up-to-date. Yeeah!"
410                 exit 0
411         fi
412         ;;
413 esac
414
415 # We are going to make a new commit.
416 git var GIT_COMMITTER_IDENT >/dev/null || exit
417
418 # At this point, we need a real merge.  No matter what strategy
419 # we use, it would operate on the index, possibly affecting the
420 # working tree, and when resolved cleanly, have the desired tree
421 # in the index -- this means that the index must be in sync with
422 # the $head commit.  The strategies are responsible to ensure this.
423
424 case "$use_strategies" in
425 ?*' '?*)
426     # Stash away the local changes so that we can try more than one.
427     savestate
428     single_strategy=no
429     ;;
430 *)
431     rm -f "$GIT_DIR/MERGE_STASH"
432     single_strategy=yes
433     ;;
434 esac
435
436 result_tree= best_cnt=-1 best_strategy= wt_strategy=
437 merge_was_ok=
438 for strategy in $use_strategies
439 do
440     test "$wt_strategy" = '' || {
441         echo "Rewinding the tree to pristine..."
442         restorestate
443     }
444     case "$single_strategy" in
445     no)
446         echo "Trying merge strategy $strategy..."
447         ;;
448     esac
449
450     # Remember which strategy left the state in the working tree
451     wt_strategy=$strategy
452
453     git-merge-$strategy $common -- "$head_arg" "$@"
454     exit=$?
455     if test "$no_commit" = t && test "$exit" = 0
456     then
457         merge_was_ok=t
458         exit=1 ;# pretend it left conflicts.
459     fi
460
461     test "$exit" = 0 || {
462
463         # The backend exits with 1 when conflicts are left to be resolved,
464         # with 2 when it does not handle the given merge at all.
465
466         if test "$exit" -eq 1
467         then
468             cnt=`{
469                 git diff-files --name-only
470                 git ls-files --unmerged
471             } | wc -l`
472             if test $best_cnt -le 0 -o $cnt -le $best_cnt
473             then
474                 best_strategy=$strategy
475                 best_cnt=$cnt
476             fi
477         fi
478         continue
479     }
480
481     # Automerge succeeded.
482     result_tree=$(git write-tree) && break
483 done
484
485 # If we have a resulting tree, that means the strategy module
486 # auto resolved the merge cleanly.
487 if test '' != "$result_tree"
488 then
489     if test "$allow_fast_forward" = "t"
490     then
491         parents=$(git show-branch --independent "$head" "$@")
492     else
493         parents=$(git rev-parse "$head" "$@")
494     fi
495     parents=$(echo "$parents" | sed -e 's/^/-p /')
496     result_commit=$(printf '%s\n' "$merge_msg" | git commit-tree $result_tree $parents) || exit
497     finish "$result_commit" "Merge made by $wt_strategy."
498     dropsave
499     exit 0
500 fi
501
502 # Pick the result from the best strategy and have the user fix it up.
503 case "$best_strategy" in
504 '')
505         restorestate
506         case "$use_strategies" in
507         ?*' '?*)
508                 echo >&2 "No merge strategy handled the merge."
509                 ;;
510         *)
511                 echo >&2 "Merge with strategy $use_strategies failed."
512                 ;;
513         esac
514         exit 2
515         ;;
516 "$wt_strategy")
517         # We already have its result in the working tree.
518         ;;
519 *)
520         echo "Rewinding the tree to pristine..."
521         restorestate
522         echo "Using the $best_strategy to prepare resolving by hand."
523         git-merge-$best_strategy $common -- "$head_arg" "$@"
524         ;;
525 esac
526
527 if test "$squash" = t
528 then
529         finish
530 else
531         for remote
532         do
533                 echo $remote
534         done >"$GIT_DIR/MERGE_HEAD"
535         printf '%s\n' "$merge_msg" >"$GIT_DIR/MERGE_MSG"
536 fi
537
538 if test "$merge_was_ok" = t
539 then
540         echo >&2 \
541         "Automatic merge went well; stopped before committing as requested"
542         exit 0
543 else
544         {
545             echo '
546 Conflicts:
547 '
548                 git ls-files --unmerged |
549                 sed -e 's/^[^   ]*      /       /' |
550                 uniq
551         } >>"$GIT_DIR/MERGE_MSG"
552         git rerere
553         die "Automatic merge failed; fix conflicts and then commit the result."
554 fi