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

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


USAGE='[-n] [--no-commit] [-s <strategy>]... <merge-message> <head> <remote>+'
. git-sh-setup

LF='
'

all_strategies='recursive octopus resolve stupid ours'
default_twohead_strategies='recursive'
default_octopus_strategies='octopus'
no_trivial_merge_strategies='ours'
use_strategies=

index_merge=t
if test "@@NO_PYTHON@@"; then
	all_strategies='resolve octopus stupid ours'
	default_twohead_strategies='resolve'
fi

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 --stat --summary -M "$head" "$1"
		;;
	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

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

# All the rest are remote heads
test "$#" = 0 && usage ;# we need at least one remote head.

remoteheads=
for remote
do
	remotehead=$(git-rev-parse --verify "$remote"^0) ||
	    die "$remote - not something we can merge"
	remoteheads="${remoteheads}$remotehead "
done
set x $remoteheads ; shift

case "$use_strategies" in
'')
	case "$#" in
	1)
		use_strategies="$default_twohead_strategies" ;;
	*)
		use_strategies="$default_octopus_strategies" ;;
	esac
	;;
esac

for s in $use_strategies
do
	case " $s " in
	*" $no_trivial_merge_strategies "*)
		index_merge=f
		break
		;;
	esac
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 "$index_merge,$#,$common,$no_commit" in
f,*)
	# We've been told not to try anything clever.  Skip to real merge.
	;;
?,*,'',*)
	# 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 -v -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.
	git var GIT_COMMITTER_IDENT >/dev/null || exit

	echo "Trying really trivial in-index merge..."
	git-update-index --refresh 2>/dev/null
	if git-read-tree --trivial -m -u -v $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

# We are going to make a new commit.
git var GIT_COMMITTER_IDENT >/dev/null || exit

# 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=
merge_was_ok=
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
        merge_was_ok=t
	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=$(git-show-branch --independent "$head" "$@" | sed -e 's/^/-p /')
    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
	echo >&2 "No merge strategy handled the merge."
	exit 2
	;;
"$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"

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