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