[thirdparty/git.git] / git-mergetool--lib.sh

# git-mergetool--lib is a library for common merge tool functions
diff_mode() {
	test "$TOOL_MODE" = diff
}

merge_mode() {
	test "$TOOL_MODE" = merge
}

translate_merge_tool_path () {
	if test -n "$2"; then
		echo "$2"
	else
		case "$1" in
		vimdiff)
			path=vim
			;;
		gvimdiff)
			path=gvim
			;;
		emerge)
			path=emacs
			;;
		*)
			path="$1"
			;;
		esac
		echo "$path"
	fi
}

check_unchanged () {
	if test "$MERGED" -nt "$BACKUP"; then
		status=0
	else
		while true; do
			echo "$MERGED seems unchanged."
			printf "Was the merge successful? [y/n] "
			read answer < /dev/tty
			case "$answer" in
			y*|Y*) status=0; break ;;
			n*|N*) status=1; break ;;
			esac
		done
	fi
}

valid_tool () {
	case "$1" in
	kdiff3 | tkdiff | xxdiff | meld | opendiff | \
	emerge | vimdiff | gvimdiff | ecmerge | diffuse)
		;; # happy
	tortoisemerge)
		if ! merge_mode; then
			return 1
		fi
		;;
	kompare)
		if ! diff_mode; then
			return 1
		fi
		;;
	*)
		if test -z "$(get_merge_tool_cmd "$1")"; then
			return 1
		fi
		;;
	esac
}

get_merge_tool_cmd () {
	diff_mode &&
	custom_cmd="$(git config difftool.$1.cmd)"
	test -z "$custom_cmd" &&
	custom_cmd="$(git config mergetool.$1.cmd)"
	test -n "$custom_cmd" &&
	echo "$custom_cmd"
}

run_merge_tool () {
	base_present="$2"
	status=0

	case "$1" in
	kdiff3)
		if merge_mode; then
			if $base_present; then
				("$merge_tool_path" --auto \
					--L1 "$MERGED (Base)" \
					--L2 "$MERGED (Local)" \
					--L3 "$MERGED (Remote)" \
					-o "$MERGED" \
					"$BASE" "$LOCAL" "$REMOTE" \
				> /dev/null 2>&1)
			else
				("$merge_tool_path" --auto \
					--L1 "$MERGED (Local)" \
					--L2 "$MERGED (Remote)" \
					-o "$MERGED" \
					"$LOCAL" "$REMOTE" \
				> /dev/null 2>&1)
			fi
			status=$?
		else
			("$merge_tool_path" --auto \
			 --L1 "$MERGED (A)" \
			 --L2 "$MERGED (B)" "$LOCAL" "$REMOTE" \
			 > /dev/null 2>&1)
		fi
		;;
	kompare)
		"$merge_tool_path" "$LOCAL" "$REMOTE"
		;;
	tkdiff)
		if merge_mode; then
			if $base_present; then
				"$merge_tool_path" -a "$BASE" \
					-o "$MERGED" "$LOCAL" "$REMOTE"
			else
				"$merge_tool_path" \
					-o "$MERGED" "$LOCAL" "$REMOTE"
			fi
			status=$?
		else
			"$merge_tool_path" "$LOCAL" "$REMOTE"
		fi
		;;
	meld)
		if merge_mode; then
			touch "$BACKUP"
			"$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
			check_unchanged
		else
			"$merge_tool_path" "$LOCAL" "$REMOTE"
		fi
		;;
	diffuse)
		if merge_mode; then
			touch "$BACKUP"
			if $base_present; then
				"$merge_tool_path" \
					"$LOCAL" "$MERGED" "$REMOTE" \
					"$BASE" | cat
			else
				"$merge_tool_path" \
					"$LOCAL" "$MERGED" "$REMOTE" | cat
			fi
			check_unchanged
		else
			"$merge_tool_path" "$LOCAL" "$REMOTE" | cat
		fi
		;;
	vimdiff)
		if merge_mode; then
			touch "$BACKUP"
			"$merge_tool_path" -d -c "wincmd l" \
				"$LOCAL" "$MERGED" "$REMOTE"
			check_unchanged
		else
			"$merge_tool_path" -d -c "wincmd l" \
				"$LOCAL" "$REMOTE"
		fi
		;;
	gvimdiff)
		if merge_mode; then
			touch "$BACKUP"
			"$merge_tool_path" -d -c "wincmd l" -f \
				"$LOCAL" "$MERGED" "$REMOTE"
			check_unchanged
		else
			"$merge_tool_path" -d -c "wincmd l" -f \
				"$LOCAL" "$REMOTE"
		fi
		;;
	xxdiff)
		if merge_mode; then
			touch "$BACKUP"
			if $base_present; then
				"$merge_tool_path" -X --show-merged-pane \
					-R 'Accel.SaveAsMerged: "Ctrl-S"' \
					-R 'Accel.Search: "Ctrl+F"' \
					-R 'Accel.SearchForward: "Ctrl-G"' \
					--merged-file "$MERGED" \
					"$LOCAL" "$BASE" "$REMOTE"
			else
				"$merge_tool_path" -X $extra \
					-R 'Accel.SaveAsMerged: "Ctrl-S"' \
					-R 'Accel.Search: "Ctrl+F"' \
					-R 'Accel.SearchForward: "Ctrl-G"' \
					--merged-file "$MERGED" \
					"$LOCAL" "$REMOTE"
			fi
			check_unchanged
		else
			"$merge_tool_path" \
				-R 'Accel.Search: "Ctrl+F"' \
				-R 'Accel.SearchForward: "Ctrl-G"' \
				"$LOCAL" "$REMOTE"
		fi
		;;
	opendiff)
		if merge_mode; then
			touch "$BACKUP"
			if $base_present; then
				"$merge_tool_path" "$LOCAL" "$REMOTE" \
					-ancestor "$BASE" \
					-merge "$MERGED" | cat
			else
				"$merge_tool_path" "$LOCAL" "$REMOTE" \
					-merge "$MERGED" | cat
			fi
			check_unchanged
		else
			"$merge_tool_path" "$LOCAL" "$REMOTE" | cat
		fi
		;;
	ecmerge)
		if merge_mode; then
			touch "$BACKUP"
			if $base_present; then
				"$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" \
					--default --mode=merge3 --to="$MERGED"
			else
				"$merge_tool_path" "$LOCAL" "$REMOTE" \
					--default --mode=merge2 --to="$MERGED"
			fi
			check_unchanged
		else
			"$merge_tool_path" "$LOCAL" "$REMOTE" \
				--default --mode=merge2 --to="$MERGED"
		fi
		;;
	emerge)
		if merge_mode; then
			if $base_present; then
				"$merge_tool_path" \
					-f emerge-files-with-ancestor-command \
					"$LOCAL" "$REMOTE" "$BASE" \
					"$(basename "$MERGED")"
			else
				"$merge_tool_path" \
					-f emerge-files-command \
					"$LOCAL" "$REMOTE" \
					"$(basename "$MERGED")"
			fi
			status=$?
		else
			"$merge_tool_path" -f emerge-files-command \
				"$LOCAL" "$REMOTE" "$(basename "$MERGED")"
		fi
		;;
	tortoisemerge)
		if $base_present; then
			touch "$BACKUP"
			"$merge_tool_path" \
				-base:"$BASE" -mine:"$LOCAL" \
				-theirs:"$REMOTE" -merged:"$MERGED"
			check_unchanged
		else
			echo "TortoiseMerge cannot be used without a base" 1>&2
			status=1
		fi
		;;
	*)
		if test -z "$merge_tool_cmd"; then
			if merge_mode; then
				status=1
			fi
			break
		fi
		if merge_mode; then
			if test "$merge_tool_trust_exit_code" = "false"; then
				touch "$BACKUP"
				( eval $merge_tool_cmd )
				check_unchanged
			else
				( eval $merge_tool_cmd )
				status=$?
			fi
		else
			( eval $merge_tool_cmd )
		fi
		;;
	esac
	return $status
}

guess_merge_tool () {
	if merge_mode; then
		tools="tortoisemerge"
	else
		tools="kompare"
	fi
	if test -n "$DISPLAY"; then
		if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
			tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
		else
			tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
		fi
		tools="$tools gvimdiff diffuse ecmerge"
	fi
	if echo "${VISUAL:-$EDITOR}" | grep emacs > /dev/null 2>&1; then
		# $EDITOR is emacs so add emerge as a candidate
		tools="$tools emerge vimdiff"
	elif echo "${VISUAL:-$EDITOR}" | grep vim > /dev/null 2>&1; then
		# $EDITOR is vim so add vimdiff as a candidate
		tools="$tools vimdiff emerge"
	else
		tools="$tools emerge vimdiff"
	fi
	echo >&2 "merge tool candidates: $tools"

	# Loop over each candidate and stop when a valid merge tool is found.
	for i in $tools
	do
		merge_tool_path="$(translate_merge_tool_path "$i")"
		if type "$merge_tool_path" > /dev/null 2>&1; then
			merge_tool="$i"
			break
		fi
	done

	if test -z "$merge_tool" ; then
		echo >&2 "No known merge resolution program available."
		return 1
	fi
	echo "$merge_tool"
}

get_configured_merge_tool () {
	# Diff mode first tries diff.tool and falls back to merge.tool.
	# Merge mode only checks merge.tool
	if diff_mode; then
		tool=$(git config diff.tool)
	fi
	if test -z "$tool"; then
		tool=$(git config merge.tool)
	fi
	if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
		echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
		echo >&2 "Resetting to default..."
		return 1
	fi
	echo "$tool"
}

get_merge_tool_path () {
	# A merge tool has been set, so verify that it's valid.
	if ! valid_tool "$merge_tool"; then
		echo >&2 "Unknown merge tool $merge_tool"
		exit 1
	fi
	if diff_mode; then
		merge_tool_path=$(git config difftool."$merge_tool".path)
	fi
	if test -z "$merge_tool_path"; then
		merge_tool_path=$(git config mergetool."$merge_tool".path)
	fi
	merge_tool_path="$(translate_merge_tool_path "$merge_tool" "$merge_tool_path")"
	if test -z "$merge_tool_cmd" && ! type "$merge_tool_path" > /dev/null 2>&1; then
		echo >&2 "The $TOOL_MODE tool $merge_tool is not available as '$merge_tool_path'"
		exit 1
	fi
	echo "$merge_tool_path"
}

get_merge_tool () {
	merge_tool="$1"
	# Check if a merge tool has been configured
	if test -z "$merge_tool"; then
		merge_tool=$(get_configured_merge_tool)
	fi
	# Try to guess an appropriate merge tool if no tool has been set.
	if test -z "$merge_tool"; then
		merge_tool=$(guess_merge_tool) || exit
	fi
	echo "$merge_tool"
}
Commit	Line	Data
21d0ba7e DA	1	# git-mergetool--lib is a library for common merge tool functions
	2	diff_mode() {
	3	test "$TOOL_MODE" = diff
	4	}
	5
	6	merge_mode() {
	7	test "$TOOL_MODE" = merge
	8	}
	9
	10	translate_merge_tool_path () {
	11	if test -n "$2"; then
	12	echo "$2"
	13	else
	14	case "$1" in
	15	vimdiff)
	16	path=vim
	17	;;
	18	gvimdiff)
	19	path=gvim
	20	;;
	21	emerge)
	22	path=emacs
	23	;;
	24	*)
	25	path="$1"
	26	;;
	27	esac
	28	echo "$path"
	29	fi
	30	}
	31
	32	check_unchanged () {
	33	if test "$MERGED" -nt "$BACKUP"; then
	34	status=0
	35	else
	36	while true; do
	37	echo "$MERGED seems unchanged."
	38	printf "Was the merge successful? [y/n] "
	39	read answer < /dev/tty
	40	case "$answer" in
	41	y\|Y) status=0; break ;;
	42	n\|N) status=1; break ;;
	43	esac
	44	done
	45	fi
	46	}
	47
	48	valid_tool () {
	49	case "$1" in
	50	kdiff3 \| tkdiff \| xxdiff \| meld \| opendiff \| \
	51	emerge \| vimdiff \| gvimdiff \| ecmerge \| diffuse)
	52	;; # happy
	53	tortoisemerge)
	54	if ! merge_mode; then
	55	return 1
	56	fi
	57	;;
	58	kompare)
	59	if ! diff_mode; then
	60	return 1
	61	fi
	62	;;
	63	*)
	64	if test -z "$(get_merge_tool_cmd "$1")"; then
65	return 1
66	fi
67	;;
68	esac
69	}
70
71	get_merge_tool_cmd () {
72	diff_mode &&
73	custom_cmd="$(git config difftool.$1.cmd)"
74	test -z "$custom_cmd" &&
75	custom_cmd="$(git config mergetool.$1.cmd)"
76	test -n "$custom_cmd" &&
77	echo "$custom_cmd"
78	}
79
80	run_merge_tool () {
81	base_present="$2"
82	status=0
83
84	case "$1" in
85	kdiff3)
86	if merge_mode; then
87	if $base_present; then
88	("$merge_tool_path" --auto \
89	--L1 "$MERGED (Base)" \
90	--L2 "$MERGED (Local)" \
91	--L3 "$MERGED (Remote)" \
92	-o "$MERGED" \
93	"$BASE" "$LOCAL" "$REMOTE" \
94	> /dev/null 2>&1)
95	else
96	("$merge_tool_path" --auto \
97	--L1 "$MERGED (Local)" \
98	--L2 "$MERGED (Remote)" \
99	-o "$MERGED" \
100	"$LOCAL" "$REMOTE" \
101	> /dev/null 2>&1)
102	fi
103	status=$?
104	else
105	("$merge_tool_path" --auto \
106	--L1 "$MERGED (A)" \
107	--L2 "$MERGED (B)" "$LOCAL" "$REMOTE" \
108	> /dev/null 2>&1)
109	fi
110	;;
111	kompare)
112	"$merge_tool_path" "$LOCAL" "$REMOTE"
113	;;
114	tkdiff)
115	if merge_mode; then
116	if $base_present; then
117	"$merge_tool_path" -a "$BASE" \
118	-o "$MERGED" "$LOCAL" "$REMOTE"
119	else
120	"$merge_tool_path" \
121	-o "$MERGED" "$LOCAL" "$REMOTE"
122	fi
123	status=$?
124	else
125	"$merge_tool_path" "$LOCAL" "$REMOTE"
126	fi
127	;;
128	meld)
129	if merge_mode; then
130	touch "$BACKUP"
131	"$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"
132	check_unchanged
133	else
134	"$merge_tool_path" "$LOCAL" "$REMOTE"
135	fi
136	;;
137	diffuse)
138	if merge_mode; then
139	touch "$BACKUP"
140	if $base_present; then
141	"$merge_tool_path" \
142	"$LOCAL" "$MERGED" "$REMOTE" \
143	"$BASE" \| cat
144	else
145	"$merge_tool_path" \
146	"$LOCAL" "$MERGED" "$REMOTE" \| cat
147	fi
148	check_unchanged
149	else
150	"$merge_tool_path" "$LOCAL" "$REMOTE" \| cat
151	fi
152	;;
153	vimdiff)
154	if merge_mode; then
155	touch "$BACKUP"
156	"$merge_tool_path" -d -c "wincmd l" \
157	"$LOCAL" "$MERGED" "$REMOTE"
158	check_unchanged
159	else
160	"$merge_tool_path" -d -c "wincmd l" \
161	"$LOCAL" "$REMOTE"
162	fi
163	;;
164	gvimdiff)
165	if merge_mode; then
166	touch "$BACKUP"
167	"$merge_tool_path" -d -c "wincmd l" -f \
168	"$LOCAL" "$MERGED" "$REMOTE"
169	check_unchanged
170	else
171	"$merge_tool_path" -d -c "wincmd l" -f \
172	"$LOCAL" "$REMOTE"
173	fi
174	;;
175	xxdiff)
176	if merge_mode; then
177	touch "$BACKUP"
178	if $base_present; then
179	"$merge_tool_path" -X --show-merged-pane \
180	-R 'Accel.SaveAsMerged: "Ctrl-S"' \
181	-R 'Accel.Search: "Ctrl+F"' \
182	-R 'Accel.SearchForward: "Ctrl-G"' \
183	--merged-file "$MERGED" \
184	"$LOCAL" "$BASE" "$REMOTE"
185	else
186	"$merge_tool_path" -X $extra \
187	-R 'Accel.SaveAsMerged: "Ctrl-S"' \
188	-R 'Accel.Search: "Ctrl+F"' \
189	-R 'Accel.SearchForward: "Ctrl-G"' \
190	--merged-file "$MERGED" \
191	"$LOCAL" "$REMOTE"
192	fi
193	check_unchanged
194	else
195	"$merge_tool_path" \
196	-R 'Accel.Search: "Ctrl+F"' \
197	-R 'Accel.SearchForward: "Ctrl-G"' \
198	"$LOCAL" "$REMOTE"
199	fi
200	;;
201	opendiff)
202	if merge_mode; then
203	touch "$BACKUP"
204	if $base_present; then
205	"$merge_tool_path" "$LOCAL" "$REMOTE" \
206	-ancestor "$BASE" \
207	-merge "$MERGED" \| cat
208	else
209	"$merge_tool_path" "$LOCAL" "$REMOTE" \
210	-merge "$MERGED" \| cat
211	fi
212	check_unchanged
213	else
214	"$merge_tool_path" "$LOCAL" "$REMOTE" \| cat
215	fi
216	;;
217	ecmerge)
218	if merge_mode; then
219	touch "$BACKUP"
220	if $base_present; then
221	"$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" \
222	--default --mode=merge3 --to="$MERGED"
223	else
224	"$merge_tool_path" "$LOCAL" "$REMOTE" \
225	--default --mode=merge2 --to="$MERGED"
226	fi
227	check_unchanged
228	else
229	"$merge_tool_path" "$LOCAL" "$REMOTE" \
230	--default --mode=merge2 --to="$MERGED"
231	fi
232	;;
233	emerge)
234	if merge_mode; then
235	if $base_present; then
236	"$merge_tool_path" \
237	-f emerge-files-with-ancestor-command \
238	"$LOCAL" "$REMOTE" "$BASE" \
239	"$(basename "$MERGED")"
240	else
241	"$merge_tool_path" \
242	-f emerge-files-command \
243	"$LOCAL" "$REMOTE" \
244	"$(basename "$MERGED")"
245	fi
246	status=$?
247	else
248	"$merge_tool_path" -f emerge-files-command \
249	"$LOCAL" "$REMOTE" "$(basename "$MERGED")"
250	fi
251	;;
252	tortoisemerge)
253	if $base_present; then
254	touch "$BACKUP"
255	"$merge_tool_path" \
256	-base:"$BASE" -mine:"$LOCAL" \
257	-theirs:"$REMOTE" -merged:"$MERGED"
258	check_unchanged
259	else
260	echo "TortoiseMerge cannot be used without a base" 1>&2
261	status=1
262	fi
263	;;
264	*)
265	if test -z "$merge_tool_cmd"; then
266	if merge_mode; then
267	status=1
268	fi
269	break
270	fi
271	if merge_mode; then
272	if test "$merge_tool_trust_exit_code" = "false"; then
273	touch "$BACKUP"
274	( eval $merge_tool_cmd )
275	check_unchanged
276	else
277	( eval $merge_tool_cmd )
278	status=$?
279	fi
280	else
281	( eval $merge_tool_cmd )
282	fi
283	;;
284	esac
285	return $status
286	}
287
288	guess_merge_tool () {
289	if merge_mode; then
290	tools="tortoisemerge"
291	else
292	tools="kompare"
293	fi
294	if test -n "$DISPLAY"; then
295	if test -n "$GNOME_DESKTOP_SESSION_ID" ; then
296	tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
297	else
298	tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
299	fi
300	tools="$tools gvimdiff diffuse ecmerge"
301	fi
302	if echo "${VISUAL:-$EDITOR}" \| grep emacs > /dev/null 2>&1; then
303	# $EDITOR is emacs so add emerge as a candidate
304	tools="$tools emerge vimdiff"
305	elif echo "${VISUAL:-$EDITOR}" \| grep vim > /dev/null 2>&1; then
306	# $EDITOR is vim so add vimdiff as a candidate
307	tools="$tools vimdiff emerge"
308	else
309	tools="$tools emerge vimdiff"
310	fi
311	echo >&2 "merge tool candidates: $tools"
312
313	# Loop over each candidate and stop when a valid merge tool is found.
314	for i in $tools
315	do
316	merge_tool_path="$(translate_merge_tool_path "$i")"
317	if type "$merge_tool_path" > /dev/null 2>&1; then
318	merge_tool="$i"
319	break
320	fi
321	done
322
323	if test -z "$merge_tool" ; then
324	echo >&2 "No known merge resolution program available."
325	return 1
326	fi
327	echo "$merge_tool"
328	}
329
330	get_configured_merge_tool () {
331	# Diff mode first tries diff.tool and falls back to merge.tool.
332	# Merge mode only checks merge.tool
333	if diff_mode; then
334	tool=$(git config diff.tool)
335	fi
336	if test -z "$tool"; then
337	tool=$(git config merge.tool)
338	fi
339	if test -n "$merge_tool" && ! valid_tool "$merge_tool"; then
340	echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
341	echo >&2 "Resetting to default..."
342	return 1
343	fi
344	echo "$tool"
345	}
346
347	get_merge_tool_path () {
348	# A merge tool has been set, so verify that it's valid.
349	if ! valid_tool "$merge_tool"; then
350	echo >&2 "Unknown merge tool $merge_tool"
351	exit 1
352	fi
353	if diff_mode; then
354	merge_tool_path=$(git config difftool."$merge_tool".path)
355	fi
356	if test -z "$merge_tool_path"; then
357	merge_tool_path=$(git config mergetool."$merge_tool".path)
358	fi
359	merge_tool_path="$(translate_merge_tool_path "$merge_tool" "$merge_tool_path")"
360	if test -z "$merge_tool_cmd" && ! type "$merge_tool_path" > /dev/null 2>&1; then
361	echo >&2 "The $TOOL_MODE tool $merge_tool is not available as '$merge_tool_path'"
362	exit 1
363	fi
364	echo "$merge_tool_path"
365	}
366
367	get_merge_tool () {
368	merge_tool="$1"
369	# Check if a merge tool has been configured
370	if test -z "$merge_tool"; then
371	merge_tool=$(get_configured_merge_tool)
372	fi
373	# Try to guess an appropriate merge tool if no tool has been set.
374	if test -z "$merge_tool"; then
375	merge_tool=$(guess_merge_tool) \|\| exit
376	fi
377	echo "$merge_tool"
378	}