[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_strategies='recursive'
use_strategies=
if test "@@NO_PYTHON@@"; then
	all_strategies='resolve octopus stupid ours'
	default_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 -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
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 "$#" 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 -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

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