[thirdparty/git.git] / git-merge.sh

#!/bin/sh
#
# Copyright (c) 2005 Junio C Hamano
#

. git-sh-setup || die "Not a git archive"

LF='
'

usage () {
    die "git-merge [-n] [--no-commit] [-s <strategy>]... <merge-message> <head> <remote>+"
}

all_strategies='recursive octopus resolve stupid ours'
default_strategies='recursive'
use_strategies=

dropsave() {
	rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
		 "$GIT_DIR/MERGE_SAVE" || exit 1
}

savestate() {
	# Stash away any local modifications.
	git-diff-index -z --name-only $head |
	cpio -0 -o >"$GIT_DIR/MERGE_SAVE"
}

restorestate() {
        if test -f "$GIT_DIR/MERGE_SAVE"
	then
		git reset --hard $head
		cpio -iuv <"$GIT_DIR/MERGE_SAVE"
		git-update-index --refresh >/dev/null
	fi
}

finish () {
	test '' = "$2" || echo "$2"
	case "$merge_msg" in
	'')
		echo "No merge message -- not updating HEAD"
		;;
	*)
		git-update-ref HEAD "$1" "$head" || exit 1
		;;
	esac

	case "$no_summary" in
	'')
		git-diff-tree -p -M "$head" "$1" |
		git-apply --stat --summary
		;;
	esac
}

while case "$#" in 0) break ;; esac
do
	case "$1" in
	-n|--n|--no|--no-|--no-s|--no-su|--no-sum|--no-summ|\
		--no-summa|--no-summar|--no-summary)
		no_summary=t ;;
	--no-c|--no-co|--no-com|--no-comm|--no-commi|--no-commit)
		no_commit=t ;;
	-s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
		--strateg=*|--strategy=*|\
	-s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
		case "$#,$1" in
		*,*=*)
			strategy=`expr "$1" : '-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			strategy="$2"
			shift ;;
		esac
		case " $all_strategies " in
		*" $strategy "*)
			use_strategies="$use_strategies$strategy " ;;
		*)
			die "available strategies are: $all_strategies" ;;
		esac
		;;
	-*)	usage ;;
	*)	break ;;
	esac
	shift
done

test "$#" -le 2 && usage ;# we need at least two heads.

merge_msg="$1"
shift
head_arg="$1"
head=$(git-rev-parse --verify "$1"^0) || usage
shift

# All the rest are remote heads
for remote
do
	git-rev-parse --verify "$remote"^0 >/dev/null ||
	    die "$remote - not something we can merge"
done

case "$#" in
1)
	common=$(git-merge-base --all $head "$@")
	;;
*)
	common=$(git-show-branch --merge-base $head "$@")
	;;
esac
echo "$head" >"$GIT_DIR/ORIG_HEAD"

case "$#,$common,$no_commit" in
*,'',*)
	# No common ancestors found. We need a real merge.
	;;
1,"$1",*)
	# If head can reach all the merge then we are up to date.
	# but first the most common case of merging one remote
	echo "Already up-to-date."
	dropsave
	exit 0
	;;
1,"$head",*)
	# Again the most common case of merging one remote.
	echo "Updating from $head to $1."
	git-update-index --refresh 2>/dev/null
	new_head=$(git-rev-parse --verify "$1^0") &&
	git-read-tree -u -m $head "$new_head" &&
	finish "$new_head" "Fast forward"
	dropsave
	exit 0
	;;
1,?*"$LF"?*,*)
	# We are not doing octopus and not fast forward.  Need a
	# real merge.
	;;
1,*,)
	# We are not doing octopus, not fast forward, and have only
	# one common.  See if it is really trivial.
	echo "Trying really trivial in-index merge..."
	git-update-index --refresh 2>/dev/null
	if git-read-tree --trivial -m -u $common $head "$1" &&
	   result_tree=$(git-write-tree)
	then
	    echo "Wonderful."
	    result_commit=$(
	        echo "$merge_msg" |
	        git-commit-tree $result_tree -p HEAD -p "$1"
	    ) || exit
	    finish "$result_commit" "In-index merge"
	    dropsave
	    exit 0
	fi
	echo "Nope."
	;;
*)
	# An octopus.  If we can reach all the remote we are up to date.
	up_to_date=t
	for remote
	do
		common_one=$(git-merge-base --all $head $remote)
		if test "$common_one" != "$remote"
		then
			up_to_date=f
			break
		fi
	done
	if test "$up_to_date" = t
	then
		echo "Already up-to-date. Yeeah!"
		dropsave
		exit 0
	fi
	;;
esac

case "$use_strategies" in
'')
	case "$#" in
	1)
		use_strategies="$default_strategies" ;;
	*)
		use_strategies=octopus ;;
	esac		
	;;
esac

# At this point, we need a real merge.  No matter what strategy
# we use, it would operate on the index, possibly affecting the
# working tree, and when resolved cleanly, have the desired tree
# in the index -- this means that the index must be in sync with
# the $head commit.  The strategies are responsible to ensure this.

case "$use_strategies" in
?*' '?*)
    # Stash away the local changes so that we can try more than one.
    savestate
    single_strategy=no
    ;;
*)
    rm -f "$GIT_DIR/MERGE_SAVE"
    single_strategy=yes
    ;;
esac

result_tree= best_cnt=-1 best_strategy= wt_strategy=
for strategy in $use_strategies
do
    test "$wt_strategy" = '' || {
	echo "Rewinding the tree to pristine..."
	restorestate
    }
    case "$single_strategy" in
    no)
	echo "Trying merge strategy $strategy..."
	;;
    esac

    # Remember which strategy left the state in the working tree
    wt_strategy=$strategy

    git-merge-$strategy $common -- "$head_arg" "$@"
    exit=$?
    if test "$no_commit" = t && test "$exit" = 0
    then
	exit=1 ;# pretend it left conflicts.
    fi

    test "$exit" = 0 || {

	# The backend exits with 1 when conflicts are left to be resolved,
	# with 2 when it does not handle the given merge at all.

	if test "$exit" -eq 1
	then
	    cnt=`{
		git-diff-files --name-only
		git-ls-files --unmerged
	    } | wc -l`
	    if test $best_cnt -le 0 -o $cnt -le $best_cnt
	    then
		best_strategy=$strategy
		best_cnt=$cnt
	    fi
	fi
	continue
    }

    # Automerge succeeded.
    result_tree=$(git-write-tree) && break
done

# If we have a resulting tree, that means the strategy module
# auto resolved the merge cleanly.
if test '' != "$result_tree"
then
    parents="-p $head"
    for remote
    do
        parents="$parents -p $remote"
    done
    result_commit=$(echo "$merge_msg" | git-commit-tree $result_tree $parents) || exit
    finish "$result_commit" "Merge $result_commit, made by $wt_strategy."
    dropsave
    exit 0
fi

# Pick the result from the best strategy and have the user fix it up.
case "$best_strategy" in
'')
	restorestate
	die "No merge strategy handled the merge."
	;;
"$wt_strategy")
	# We already have its result in the working tree.
	;;
*)
	echo "Rewinding the tree to pristine..."
	restorestate
	echo "Using the $best_strategy to prepare resolving by hand."
	git-merge-$best_strategy $common -- "$head_arg" "$@"
	;;
esac
for remote
do
	echo $remote
done >"$GIT_DIR/MERGE_HEAD"
echo $merge_msg >"$GIT_DIR/MERGE_MSG"

die "Automatic merge failed/prevented; fix up by hand"
Commit	Line	Data
91063bbc JH	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2005 Junio C Hamano
	4	#
	5
	6	. git-sh-setup \|\| die "Not a git archive"
	7
	8	LF='
	9	'
	10
	11	usage () {
123ee3ca	12	die "git-merge [-n] [--no-commit] [-s <strategy>]... <merge-message> <head> <remote>+"
91063bbc JH	13	}
91063bbc JH	14
64da9e60	15	all_strategies='recursive octopus resolve stupid ours'
fbf8ac21	16	default_strategies='recursive'
91063bbc JH	17	use_strategies=
91063bbc JH	18
a9358240	19	dropsave() {
deca7e8c	20	rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
a9358240 JH	21	"$GIT_DIR/MERGE_SAVE" \|\| exit 1
	22	}
	23
	24	savestate() {
60fa0560	25	# Stash away any local modifications.
50b8e355	26	git-diff-index -z --name-only $head \|
88f8f0a5	27	cpio -0 -o >"$GIT_DIR/MERGE_SAVE"
a9358240 JH	28	}
	29
	30	restorestate() {
deca7e8c JH	31	if test -f "$GIT_DIR/MERGE_SAVE"
	32	then
	33	git reset --hard $head
	34	cpio -iuv <"$GIT_DIR/MERGE_SAVE"
	35	git-update-index --refresh >/dev/null
	36	fi
91063bbc JH	37	}
91063bbc JH	38
4f692b19 JH	39	finish () {
	40	test '' = "$2" \|\| echo "$2"
	41	case "$merge_msg" in
	42	'')
	43	echo "No merge message -- not updating HEAD"
	44	;;
	45	*)
	46	git-update-ref HEAD "$1" "$head" \|\| exit 1
	47	;;
	48	esac
	49
91063bbc JH	50	case "$no_summary" in
91063bbc JH	51	'')
4f692b19	52	git-diff-tree -p -M "$head" "$1" \|
91063bbc JH	53	git-apply --stat --summary
	54	;;
	55	esac
	56	}
	57
	58	while case "$#" in 0) break ;; esac
	59	do
	60	case "$1" in
	61	-n\|--n\|--no\|--no-\|--no-s\|--no-su\|--no-sum\|--no-summ\|\
	62	--no-summa\|--no-summar\|--no-summary)
	63	no_summary=t ;;
123ee3ca JH	64	--no-c\|--no-co\|--no-com\|--no-comm\|--no-commi\|--no-commit)
123ee3ca JH	65	no_commit=t ;;
91063bbc JH	66	-s=\|--s=\|--st=\|--str=\|--stra=\|--strat=\|--strate=*\|\
	67	--strateg=\|--strategy=\|\
	68	-s\|--s\|--st\|--str\|--stra\|--strat\|--strate\|--strateg\|--strategy)
	69	case "$#,$1" in
	70	,=*)
	71	strategy=`expr "$1" : '-[^=]=\(.\)'` ;;
f88ed172	72	1,*)
91063bbc JH	73	usage ;;
	74	*)
	75	strategy="$2"
	76	shift ;;
	77	esac
	78	case " $all_strategies " in
	79	" $strategy ")
	80	use_strategies="$use_strategies$strategy " ;;
	81	*)
	82	die "available strategies are: $all_strategies" ;;
	83	esac
	84	;;
	85	-*) usage ;;
	86	*) break ;;
	87	esac
	88	shift
	89	done
	90
91063bbc JH	91	test "$#" -le 2 && usage ;# we need at least two heads.
	92
	93	merge_msg="$1"
	94	shift
8cc01e50	95	head_arg="$1"
91063bbc JH	96	head=$(git-rev-parse --verify "$1"^0) \|\| usage
	97	shift
	98
	99	# All the rest are remote heads
	100	for remote
	101	do
	102	git-rev-parse --verify "$remote"^0 >/dev/null \|\|
	103	die "$remote - not something we can merge"
	104	done
	105
13956670 JH	106	case "$#" in
	107	1)
	108	common=$(git-merge-base --all $head "$@")
	109	;;
	110	*)
	111	common=$(git-show-branch --merge-base $head "$@")
	112	;;
	113	esac
91063bbc JH	114	echo "$head" >"$GIT_DIR/ORIG_HEAD"
91063bbc JH	115
123ee3ca JH	116	case "$#,$common,$no_commit" in
123ee3ca JH	117	,'',)
88f8f0a5	118	# No common ancestors found. We need a real merge.
91063bbc	119	;;
123ee3ca	120	1,"$1",*)
91063bbc JH	121	# If head can reach all the merge then we are up to date.
91063bbc JH	122	# but first the most common case of merging one remote
4f692b19	123	echo "Already up-to-date."
a9358240	124	dropsave
91063bbc JH	125	exit 0
91063bbc JH	126	;;
123ee3ca	127	1,"$head",*)
91063bbc JH	128	# Again the most common case of merging one remote.
	129	echo "Updating from $head to $1."
	130	git-update-index --refresh 2>/dev/null
bf7960eb	131	new_head=$(git-rev-parse --verify "$1^0") &&
4f692b19 JH	132	git-read-tree -u -m $head "$new_head" &&
4f692b19 JH	133	finish "$new_head" "Fast forward"
a9358240	134	dropsave
91063bbc JH	135	exit 0
91063bbc JH	136	;;
123ee3ca	137	1,?"$LF"?,*)
91063bbc JH	138	# We are not doing octopus and not fast forward. Need a
	139	# real merge.
	140	;;
123ee3ca	141	1,*,)
f9d72413 JH	142	# We are not doing octopus, not fast forward, and have only
	143	# one common. See if it is really trivial.
	144	echo "Trying really trivial in-index merge..."
	145	git-update-index --refresh 2>/dev/null
	146	if git-read-tree --trivial -m -u $common $head "$1" &&
	147	result_tree=$(git-write-tree)
	148	then
	149	echo "Wonderful."
	150	result_commit=$(
	151	echo "$merge_msg" \|
	152	git-commit-tree $result_tree -p HEAD -p "$1"
	153	) \|\| exit
4f692b19	154	finish "$result_commit" "In-index merge"
f9d72413 JH	155	dropsave
	156	exit 0
	157	fi
	158	echo "Nope."
	159	;;
91063bbc JH	160	*)
	161	# An octopus. If we can reach all the remote we are up to date.
	162	up_to_date=t
	163	for remote
	164	do
13956670	165	common_one=$(git-merge-base --all $head $remote)
91063bbc JH	166	if test "$common_one" != "$remote"
	167	then
	168	up_to_date=f
	169	break
	170	fi
	171	done
	172	if test "$up_to_date" = t
	173	then
	174	echo "Already up-to-date. Yeeah!"
a9358240	175	dropsave
91063bbc JH	176	exit 0
	177	fi
	178	;;
	179	esac
	180
fbf8ac21 JH	181	case "$use_strategies" in
	182	'')
	183	case "$#" in
	184	1)
	185	use_strategies="$default_strategies" ;;
	186	*)
	187	use_strategies=octopus ;;
	188	esac
	189	;;
	190	esac
	191
a9358240 JH	192	# At this point, we need a real merge. No matter what strategy
	193	# we use, it would operate on the index, possibly affecting the
	194	# working tree, and when resolved cleanly, have the desired tree
	195	# in the index -- this means that the index must be in sync with
60fa0560	196	# the $head commit. The strategies are responsible to ensure this.
91063bbc	197
a9358240 JH	198	case "$use_strategies" in
	199	?' '?)
	200	# Stash away the local changes so that we can try more than one.
	201	savestate
	202	single_strategy=no
	203	;;
	204	*)
deca7e8c	205	rm -f "$GIT_DIR/MERGE_SAVE"
a9358240 JH	206	single_strategy=yes
	207	;;
	208	esac
91063bbc JH	209
	210	result_tree= best_cnt=-1 best_strategy= wt_strategy=
	211	for strategy in $use_strategies
	212	do
	213	test "$wt_strategy" = '' \|\| {
	214	echo "Rewinding the tree to pristine..."
a9358240	215	restorestate
91063bbc	216	}
a9358240 JH	217	case "$single_strategy" in
	218	no)
	219	echo "Trying merge strategy $strategy..."
	220	;;
	221	esac
	222
	223	# Remember which strategy left the state in the working tree
91063bbc	224	wt_strategy=$strategy
a9358240	225
123ee3ca JH	226	git-merge-$strategy $common -- "$head_arg" "$@"
	227	exit=$?
	228	if test "$no_commit" = t && test "$exit" = 0
	229	then
	230	exit=1 ;# pretend it left conflicts.
	231	fi
	232
	233	test "$exit" = 0 \|\| {
91063bbc JH	234
	235	# The backend exits with 1 when conflicts are left to be resolved,
	236	# with 2 when it does not handle the given merge at all.
	237
91063bbc JH	238	if test "$exit" -eq 1
	239	then
	240	cnt=`{
	241	git-diff-files --name-only
	242	git-ls-files --unmerged
	243	} \| wc -l`
	244	if test $best_cnt -le 0 -o $cnt -le $best_cnt
	245	then
	246	best_strategy=$strategy
	247	best_cnt=$cnt
	248	fi
	249	fi
	250	continue
	251	}
	252
	253	# Automerge succeeded.
	254	result_tree=$(git-write-tree) && break
	255	done
	256
	257	# If we have a resulting tree, that means the strategy module
	258	# auto resolved the merge cleanly.
	259	if test '' != "$result_tree"
	260	then
	261	parents="-p $head"
	262	for remote
	263	do
	264	parents="$parents -p $remote"
	265	done
bf7960eb	266	result_commit=$(echo "$merge_msg" \| git-commit-tree $result_tree $parents) \|\| exit
4f692b19	267	finish "$result_commit" "Merge $result_commit, made by $wt_strategy."
a9358240	268	dropsave
91063bbc JH	269	exit 0
	270	fi
	271
	272	# Pick the result from the best strategy and have the user fix it up.
	273	case "$best_strategy" in
	274	'')
a9358240	275	restorestate
91063bbc JH	276	die "No merge strategy handled the merge."
	277	;;
	278	"$wt_strategy")
	279	# We already have its result in the working tree.
	280	;;
	281	*)
	282	echo "Rewinding the tree to pristine..."
a9358240	283	restorestate
91063bbc	284	echo "Using the $best_strategy to prepare resolving by hand."
a9358240	285	git-merge-$best_strategy $common -- "$head_arg" "$@"
91063bbc JH	286	;;
	287	esac
	288	for remote
	289	do
	290	echo $remote
	291	done >"$GIT_DIR/MERGE_HEAD"
deca7e8c JH	292	echo $merge_msg >"$GIT_DIR/MERGE_MSG"
deca7e8c JH	293
123ee3ca	294	die "Automatic merge failed/prevented; fix up by hand"