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