[thirdparty/git.git] / t / t7814-grep-recurse-submodules.sh

#!/bin/sh

test_description='Test grep recurse-submodules feature

This test verifies the recurse-submodules feature correctly greps across
submodules.
'

. ./test-lib.sh

GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1
export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB

test_expect_success 'setup directory structure and submodule' '
	echo "(1|2)d(3|4)" >a &&
	mkdir b &&
	echo "(3|4)" >b/b &&
	git add a b &&
	git commit -m "add a and b" &&
	test_tick &&
	git init submodule &&
	echo "(1|2)d(3|4)" >submodule/a &&
	git -C submodule add a &&
	git -C submodule commit -m "add a" &&
	git submodule add ./submodule &&
	git commit -m "added submodule" &&
	test_tick
'

test_expect_success 'grep correctly finds patterns in a submodule' '
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	b/b:(3|4)
	submodule/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules >actual &&
	test_cmp expect actual
'

test_expect_success 'grep finds patterns in a submodule via config' '
	test_config submodule.recurse true &&
	# expect from previous test
	git grep -e "(3|4)" >actual &&
	test_cmp expect actual
'

test_expect_success 'grep --no-recurse-submodules overrides config' '
	test_config submodule.recurse true &&
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	b/b:(3|4)
	EOF

	git grep -e "(3|4)" --no-recurse-submodules >actual &&
	test_cmp expect actual
'

test_expect_success 'grep and basic pathspecs' '
	cat >expect <<-\EOF &&
	submodule/a:(1|2)d(3|4)
	EOF

	git grep -e. --recurse-submodules -- submodule >actual &&
	test_cmp expect actual
'

test_expect_success 'grep and nested submodules' '
	git init submodule/sub &&
	echo "(1|2)d(3|4)" >submodule/sub/a &&
	git -C submodule/sub add a &&
	git -C submodule/sub commit -m "add a" &&
	test_tick &&
	git -C submodule submodule add ./sub &&
	git -C submodule add sub &&
	git -C submodule commit -m "added sub" &&
	test_tick &&
	git add submodule &&
	git commit -m "updated submodule" &&
	test_tick &&

	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	b/b:(3|4)
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules >actual &&
	test_cmp expect actual
'

test_expect_success 'grep and multiple patterns' '
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --and -e "(1|2)" --recurse-submodules >actual &&
	test_cmp expect actual
'

test_expect_success 'grep and multiple patterns' '
	cat >expect <<-\EOF &&
	b/b:(3|4)
	EOF

	git grep -e "(3|4)" --and --not -e "(1|2)" --recurse-submodules >actual &&
	test_cmp expect actual
'

test_expect_success 'basic grep tree' '
	cat >expect <<-\EOF &&
	HEAD:a:(1|2)d(3|4)
	HEAD:b/b:(3|4)
	HEAD:submodule/a:(1|2)d(3|4)
	HEAD:submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree HEAD^' '
	cat >expect <<-\EOF &&
	HEAD^:a:(1|2)d(3|4)
	HEAD^:b/b:(3|4)
	HEAD^:submodule/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD^ >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree HEAD^^' '
	cat >expect <<-\EOF &&
	HEAD^^:a:(1|2)d(3|4)
	HEAD^^:b/b:(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD^^ >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree and pathspecs' '
	cat >expect <<-\EOF &&
	HEAD:submodule/a:(1|2)d(3|4)
	HEAD:submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD -- submodule >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree and pathspecs' '
	cat >expect <<-\EOF &&
	HEAD:submodule/a:(1|2)d(3|4)
	HEAD:submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD -- "submodule*a" >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree and more pathspecs' '
	cat >expect <<-\EOF &&
	HEAD:submodule/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD -- "submodul?/a" >actual &&
	test_cmp expect actual
'

test_expect_success 'grep tree and more pathspecs' '
	cat >expect <<-\EOF &&
	HEAD:submodule/sub/a:(1|2)d(3|4)
	EOF

	git grep -e "(3|4)" --recurse-submodules HEAD -- "submodul*/sub/a" >actual &&
	test_cmp expect actual
'

test_expect_success !MINGW 'grep recurse submodule colon in name' '
	git init parent &&
	test_when_finished "rm -rf parent" &&
	echo "(1|2)d(3|4)" >"parent/fi:le" &&
	git -C parent add "fi:le" &&
	git -C parent commit -m "add fi:le" &&
	test_tick &&

	git init "su:b" &&
	test_when_finished "rm -rf su:b" &&
	echo "(1|2)d(3|4)" >"su:b/fi:le" &&
	git -C "su:b" add "fi:le" &&
	git -C "su:b" commit -m "add fi:le" &&
	test_tick &&

	git -C parent submodule add "../su:b" "su:b" &&
	git -C parent commit -m "add submodule" &&
	test_tick &&

	cat >expect <<-\EOF &&
	fi:le:(1|2)d(3|4)
	su:b/fi:le:(1|2)d(3|4)
	EOF
	git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
	test_cmp expect actual &&

	cat >expect <<-\EOF &&
	HEAD:fi:le:(1|2)d(3|4)
	HEAD:su:b/fi:le:(1|2)d(3|4)
	EOF
	git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules HEAD >actual &&
	test_cmp expect actual
'

test_expect_success 'grep history with moved submoules' '
	git init parent &&
	test_when_finished "rm -rf parent" &&
	echo "(1|2)d(3|4)" >parent/file &&
	git -C parent add file &&
	git -C parent commit -m "add file" &&
	test_tick &&

	git init sub &&
	test_when_finished "rm -rf sub" &&
	echo "(1|2)d(3|4)" >sub/file &&
	git -C sub add file &&
	git -C sub commit -m "add file" &&
	test_tick &&

	git -C parent submodule add ../sub dir/sub &&
	git -C parent commit -m "add submodule" &&
	test_tick &&

	cat >expect <<-\EOF &&
	dir/sub/file:(1|2)d(3|4)
	file:(1|2)d(3|4)
	EOF
	git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
	test_cmp expect actual &&

	git -C parent mv dir/sub sub-moved &&
	git -C parent commit -m "moved submodule" &&
	test_tick &&

	cat >expect <<-\EOF &&
	file:(1|2)d(3|4)
	sub-moved/file:(1|2)d(3|4)
	EOF
	git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
	test_cmp expect actual &&

	cat >expect <<-\EOF &&
	HEAD^:dir/sub/file:(1|2)d(3|4)
	HEAD^:file:(1|2)d(3|4)
	EOF
	git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules HEAD^ >actual &&
	test_cmp expect actual
'

test_expect_success 'grep using relative path' '
	test_when_finished "rm -rf parent sub" &&
	git init sub &&
	echo "(1|2)d(3|4)" >sub/file &&
	git -C sub add file &&
	git -C sub commit -m "add file" &&
	test_tick &&

	git init parent &&
	echo "(1|2)d(3|4)" >parent/file &&
	git -C parent add file &&
	mkdir parent/src &&
	echo "(1|2)d(3|4)" >parent/src/file2 &&
	git -C parent add src/file2 &&
	git -C parent submodule add ../sub &&
	git -C parent commit -m "add files and submodule" &&
	test_tick &&

	# From top works
	cat >expect <<-\EOF &&
	file:(1|2)d(3|4)
	src/file2:(1|2)d(3|4)
	sub/file:(1|2)d(3|4)
	EOF
	git -C parent grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
	test_cmp expect actual &&

	# Relative path to top
	cat >expect <<-\EOF &&
	../file:(1|2)d(3|4)
	file2:(1|2)d(3|4)
	../sub/file:(1|2)d(3|4)
	EOF
	git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" -- .. >actual &&
	test_cmp expect actual &&

	# Relative path to submodule
	cat >expect <<-\EOF &&
	../sub/file:(1|2)d(3|4)
	EOF
	git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" -- ../sub >actual &&
	test_cmp expect actual
'

test_expect_success 'grep from a subdir' '
	test_when_finished "rm -rf parent sub" &&
	git init sub &&
	echo "(1|2)d(3|4)" >sub/file &&
	git -C sub add file &&
	git -C sub commit -m "add file" &&
	test_tick &&

	git init parent &&
	mkdir parent/src &&
	echo "(1|2)d(3|4)" >parent/src/file &&
	git -C parent add src/file &&
	git -C parent submodule add ../sub src/sub &&
	git -C parent submodule add ../sub sub &&
	git -C parent commit -m "add files and submodules" &&
	test_tick &&

	# Verify grep from root works
	cat >expect <<-\EOF &&
	src/file:(1|2)d(3|4)
	src/sub/file:(1|2)d(3|4)
	sub/file:(1|2)d(3|4)
	EOF
	git -C parent grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
	test_cmp expect actual &&

	# Verify grep from a subdir works
	cat >expect <<-\EOF &&
	file:(1|2)d(3|4)
	sub/file:(1|2)d(3|4)
	EOF
	git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
	test_cmp expect actual
'

test_incompatible_with_recurse_submodules ()
{
	test_expect_success "--recurse-submodules and $1 are incompatible" "
		test_must_fail git grep -e. --recurse-submodules $1 2>actual &&
		test_i18ngrep 'not supported with --recurse-submodules' actual
	"
}

test_incompatible_with_recurse_submodules --untracked

test_expect_success 'grep --recurse-submodules --no-index ignores --recurse-submodules' '
	git grep --recurse-submodules --no-index -e "^(.|.)[\d]" >actual &&
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF
	test_cmp expect actual
'

test_expect_success 'grep --recurse-submodules should pass the pattern type along' '
	# Fixed
	test_must_fail git grep -F --recurse-submodules -e "(.|.)[\d]" &&
	test_must_fail git -c grep.patternType=fixed grep --recurse-submodules -e "(.|.)[\d]" &&

	# Basic
	git grep -G --recurse-submodules -e "(.|.)[\d]" >actual &&
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF
	test_cmp expect actual &&
	git -c grep.patternType=basic grep --recurse-submodules -e "(.|.)[\d]" >actual &&
	test_cmp expect actual &&

	# Extended
	git grep -E --recurse-submodules -e "(.|.)[\d]" >actual &&
	cat >expect <<-\EOF &&
	.gitmodules:[submodule "submodule"]
	.gitmodules:	path = submodule
	.gitmodules:	url = ./submodule
	a:(1|2)d(3|4)
	submodule/.gitmodules:[submodule "sub"]
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF
	test_cmp expect actual &&
	git -c grep.patternType=extended grep --recurse-submodules -e "(.|.)[\d]" >actual &&
	test_cmp expect actual &&
	git -c grep.extendedRegexp=true grep --recurse-submodules -e "(.|.)[\d]" >actual &&
	test_cmp expect actual &&

	# Perl
	if test_have_prereq PCRE
	then
		git grep -P --recurse-submodules -e "(.|.)[\d]" >actual &&
		cat >expect <<-\EOF &&
		a:(1|2)d(3|4)
		b/b:(3|4)
		submodule/a:(1|2)d(3|4)
		submodule/sub/a:(1|2)d(3|4)
		EOF
		test_cmp expect actual &&
		git -c grep.patternType=perl grep --recurse-submodules -e "(.|.)[\d]" >actual &&
		test_cmp expect actual
	fi
'

test_expect_success 'grep --recurse-submodules with submodules without .gitmodules in the working tree' '
	test_when_finished "git -C submodule checkout .gitmodules" &&
	rm submodule/.gitmodules &&
	git grep --recurse-submodules -e "(.|.)[\d]" >actual &&
	cat >expect <<-\EOF &&
	a:(1|2)d(3|4)
	submodule/a:(1|2)d(3|4)
	submodule/sub/a:(1|2)d(3|4)
	EOF
	test_cmp expect actual
'

reset_and_clean () {
	git reset --hard &&
	git clean -fd &&
	git submodule foreach --recursive 'git reset --hard' &&
	git submodule foreach --recursive 'git clean -fd'
}

test_expect_success 'grep --recurse-submodules without --cached considers worktree modifications' '
	reset_and_clean &&
	echo "A modified line in submodule" >>submodule/a &&
	echo "submodule/a:A modified line in submodule" >expect &&
	git grep --recurse-submodules "A modified line in submodule" >actual &&
	test_cmp expect actual
'

test_expect_success 'grep --recurse-submodules with --cached ignores worktree modifications' '
	reset_and_clean &&
	echo "A modified line in submodule" >>submodule/a &&
	test_must_fail git grep --recurse-submodules --cached "A modified line in submodule" >actual 2>&1 &&
	test_must_be_empty actual
'
test_done
Commit	Line	Data
0281e487 BW	1	#!/bin/sh
	2
	3	test_description='Test grep recurse-submodules feature
	4
	5	This test verifies the recurse-submodules feature correctly greps across
	6	submodules.
	7	'
	8
	9	. ./test-lib.sh
	10
18a2f66d JT	11	GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB=1
	12	export GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB
	13
0281e487	14	test_expect_success 'setup directory structure and submodule' '
5d52a30e	15	echo "(1\|2)d(3\|4)" >a &&
0281e487	16	mkdir b &&
5d52a30e	17	echo "(3\|4)" >b/b &&
0281e487 BW	18	git add a b &&
0281e487 BW	19	git commit -m "add a and b" &&
663d2501	20	test_tick &&
0281e487	21	git init submodule &&
5d52a30e	22	echo "(1\|2)d(3\|4)" >submodule/a &&
0281e487 BW	23	git -C submodule add a &&
	24	git -C submodule commit -m "add a" &&
	25	git submodule add ./submodule &&
663d2501 NTND	26	git commit -m "added submodule" &&
663d2501 NTND	27	test_tick
0281e487 BW	28	'
	29
	30	test_expect_success 'grep correctly finds patterns in a submodule' '
	31	cat >expect <<-\EOF &&
5d52a30e ÆAB	32	a:(1\|2)d(3\|4)
	33	b/b:(3\|4)
	34	submodule/a:(1\|2)d(3\|4)
0281e487 BW	35	EOF
0281e487 BW	36
5d52a30e	37	git grep -e "(3\|4)" --recurse-submodules >actual &&
0281e487 BW	38	test_cmp expect actual
	39	'
	40
9071c078 SB	41	test_expect_success 'grep finds patterns in a submodule via config' '
	42	test_config submodule.recurse true &&
	43	# expect from previous test
	44	git grep -e "(3\|4)" >actual &&
	45	test_cmp expect actual
	46	'
	47
	48	test_expect_success 'grep --no-recurse-submodules overrides config' '
	49	test_config submodule.recurse true &&
	50	cat >expect <<-\EOF &&
	51	a:(1\|2)d(3\|4)
	52	b/b:(3\|4)
	53	EOF
	54
	55	git grep -e "(3\|4)" --no-recurse-submodules >actual &&
	56	test_cmp expect actual
	57	'
	58
0281e487 BW	59	test_expect_success 'grep and basic pathspecs' '
0281e487 BW	60	cat >expect <<-\EOF &&
5d52a30e	61	submodule/a:(1\|2)d(3\|4)
0281e487 BW	62	EOF
	63
	64	git grep -e. --recurse-submodules -- submodule >actual &&
	65	test_cmp expect actual
	66	'
	67
	68	test_expect_success 'grep and nested submodules' '
	69	git init submodule/sub &&
5d52a30e	70	echo "(1\|2)d(3\|4)" >submodule/sub/a &&
0281e487 BW	71	git -C submodule/sub add a &&
0281e487 BW	72	git -C submodule/sub commit -m "add a" &&
663d2501	73	test_tick &&
0281e487 BW	74	git -C submodule submodule add ./sub &&
	75	git -C submodule add sub &&
	76	git -C submodule commit -m "added sub" &&
663d2501	77	test_tick &&
0281e487 BW	78	git add submodule &&
0281e487 BW	79	git commit -m "updated submodule" &&
663d2501	80	test_tick &&
0281e487 BW	81
0281e487 BW	82	cat >expect <<-\EOF &&
5d52a30e ÆAB	83	a:(1\|2)d(3\|4)
	84	b/b:(3\|4)
	85	submodule/a:(1\|2)d(3\|4)
	86	submodule/sub/a:(1\|2)d(3\|4)
0281e487 BW	87	EOF
0281e487 BW	88
5d52a30e	89	git grep -e "(3\|4)" --recurse-submodules >actual &&
0281e487 BW	90	test_cmp expect actual
	91	'
	92
	93	test_expect_success 'grep and multiple patterns' '
	94	cat >expect <<-\EOF &&
5d52a30e ÆAB	95	a:(1\|2)d(3\|4)
	96	submodule/a:(1\|2)d(3\|4)
	97	submodule/sub/a:(1\|2)d(3\|4)
0281e487 BW	98	EOF
0281e487 BW	99
5d52a30e	100	git grep -e "(3\|4)" --and -e "(1\|2)" --recurse-submodules >actual &&
0281e487 BW	101	test_cmp expect actual
	102	'
	103
	104	test_expect_success 'grep and multiple patterns' '
	105	cat >expect <<-\EOF &&
5d52a30e	106	b/b:(3\|4)
0281e487 BW	107	EOF
0281e487 BW	108
5d52a30e	109	git grep -e "(3\|4)" --and --not -e "(1\|2)" --recurse-submodules >actual &&
0281e487 BW	110	test_cmp expect actual
	111	'
	112
74ed4371 BW	113	test_expect_success 'basic grep tree' '
74ed4371 BW	114	cat >expect <<-\EOF &&
5d52a30e ÆAB	115	HEAD:a:(1\|2)d(3\|4)
	116	HEAD:b/b:(3\|4)
	117	HEAD:submodule/a:(1\|2)d(3\|4)
	118	HEAD:submodule/sub/a:(1\|2)d(3\|4)
74ed4371 BW	119	EOF
74ed4371 BW	120
5d52a30e	121	git grep -e "(3\|4)" --recurse-submodules HEAD >actual &&
74ed4371 BW	122	test_cmp expect actual
	123	'
	124
	125	test_expect_success 'grep tree HEAD^' '
	126	cat >expect <<-\EOF &&
5d52a30e ÆAB	127	HEAD^:a:(1\|2)d(3\|4)
	128	HEAD^:b/b:(3\|4)
	129	HEAD^:submodule/a:(1\|2)d(3\|4)
74ed4371 BW	130	EOF
74ed4371 BW	131
5d52a30e	132	git grep -e "(3\|4)" --recurse-submodules HEAD^ >actual &&
74ed4371 BW	133	test_cmp expect actual
	134	'
	135
	136	test_expect_success 'grep tree HEAD^^' '
	137	cat >expect <<-\EOF &&
5d52a30e ÆAB	138	HEAD^^:a:(1\|2)d(3\|4)
5d52a30e ÆAB	139	HEAD^^:b/b:(3\|4)
74ed4371 BW	140	EOF
74ed4371 BW	141
5d52a30e	142	git grep -e "(3\|4)" --recurse-submodules HEAD^^ >actual &&
74ed4371 BW	143	test_cmp expect actual
	144	'
	145
	146	test_expect_success 'grep tree and pathspecs' '
	147	cat >expect <<-\EOF &&
5d52a30e ÆAB	148	HEAD:submodule/a:(1\|2)d(3\|4)
5d52a30e ÆAB	149	HEAD:submodule/sub/a:(1\|2)d(3\|4)
74ed4371 BW	150	EOF
74ed4371 BW	151
5d52a30e	152	git grep -e "(3\|4)" --recurse-submodules HEAD -- submodule >actual &&
74ed4371 BW	153	test_cmp expect actual
	154	'
	155
	156	test_expect_success 'grep tree and pathspecs' '
	157	cat >expect <<-\EOF &&
5d52a30e ÆAB	158	HEAD:submodule/a:(1\|2)d(3\|4)
5d52a30e ÆAB	159	HEAD:submodule/sub/a:(1\|2)d(3\|4)
74ed4371 BW	160	EOF
74ed4371 BW	161
5d52a30e	162	git grep -e "(3\|4)" --recurse-submodules HEAD -- "submodule*a" >actual &&
74ed4371 BW	163	test_cmp expect actual
	164	'
	165
	166	test_expect_success 'grep tree and more pathspecs' '
	167	cat >expect <<-\EOF &&
5d52a30e	168	HEAD:submodule/a:(1\|2)d(3\|4)
74ed4371 BW	169	EOF
74ed4371 BW	170
5d52a30e	171	git grep -e "(3\|4)" --recurse-submodules HEAD -- "submodul?/a" >actual &&
74ed4371 BW	172	test_cmp expect actual
	173	'
	174
	175	test_expect_success 'grep tree and more pathspecs' '
	176	cat >expect <<-\EOF &&
5d52a30e	177	HEAD:submodule/sub/a:(1\|2)d(3\|4)
74ed4371 BW	178	EOF
74ed4371 BW	179
5d52a30e	180	git grep -e "(3\|4)" --recurse-submodules HEAD -- "submodul*/sub/a" >actual &&
74ed4371 BW	181	test_cmp expect actual
	182	'
	183
	184	test_expect_success !MINGW 'grep recurse submodule colon in name' '
	185	git init parent &&
	186	test_when_finished "rm -rf parent" &&
5d52a30e	187	echo "(1\|2)d(3\|4)" >"parent/fi:le" &&
74ed4371 BW	188	git -C parent add "fi:le" &&
74ed4371 BW	189	git -C parent commit -m "add fi:le" &&
663d2501	190	test_tick &&
74ed4371 BW	191
	192	git init "su:b" &&
	193	test_when_finished "rm -rf su:b" &&
5d52a30e	194	echo "(1\|2)d(3\|4)" >"su:b/fi:le" &&
74ed4371 BW	195	git -C "su:b" add "fi:le" &&
74ed4371 BW	196	git -C "su:b" commit -m "add fi:le" &&
663d2501	197	test_tick &&
74ed4371 BW	198
	199	git -C parent submodule add "../su:b" "su:b" &&
	200	git -C parent commit -m "add submodule" &&
663d2501	201	test_tick &&
74ed4371 BW	202
74ed4371 BW	203	cat >expect <<-\EOF &&
5d52a30e ÆAB	204	fi:le:(1\|2)d(3\|4)
5d52a30e ÆAB	205	su:b/fi:le:(1\|2)d(3\|4)
74ed4371	206	EOF
5d52a30e	207	git -C parent grep -e "(1\|2)d(3\|4)" --recurse-submodules >actual &&
74ed4371 BW	208	test_cmp expect actual &&
	209
	210	cat >expect <<-\EOF &&
5d52a30e ÆAB	211	HEAD:fi:le:(1\|2)d(3\|4)
5d52a30e ÆAB	212	HEAD:su:b/fi:le:(1\|2)d(3\|4)
74ed4371	213	EOF
5d52a30e	214	git -C parent grep -e "(1\|2)d(3\|4)" --recurse-submodules HEAD >actual &&
74ed4371 BW	215	test_cmp expect actual
	216	'
	217
e6fac7f3 BW	218	test_expect_success 'grep history with moved submoules' '
	219	git init parent &&
	220	test_when_finished "rm -rf parent" &&
5d52a30e	221	echo "(1\|2)d(3\|4)" >parent/file &&
e6fac7f3 BW	222	git -C parent add file &&
e6fac7f3 BW	223	git -C parent commit -m "add file" &&
663d2501	224	test_tick &&
e6fac7f3 BW	225
	226	git init sub &&
	227	test_when_finished "rm -rf sub" &&
5d52a30e	228	echo "(1\|2)d(3\|4)" >sub/file &&
e6fac7f3 BW	229	git -C sub add file &&
e6fac7f3 BW	230	git -C sub commit -m "add file" &&
663d2501	231	test_tick &&
e6fac7f3 BW	232
	233	git -C parent submodule add ../sub dir/sub &&
	234	git -C parent commit -m "add submodule" &&
663d2501	235	test_tick &&
e6fac7f3 BW	236
e6fac7f3 BW	237	cat >expect <<-\EOF &&
5d52a30e ÆAB	238	dir/sub/file:(1\|2)d(3\|4)
5d52a30e ÆAB	239	file:(1\|2)d(3\|4)
e6fac7f3	240	EOF
5d52a30e	241	git -C parent grep -e "(1\|2)d(3\|4)" --recurse-submodules >actual &&
e6fac7f3 BW	242	test_cmp expect actual &&
	243
	244	git -C parent mv dir/sub sub-moved &&
	245	git -C parent commit -m "moved submodule" &&
663d2501	246	test_tick &&
e6fac7f3 BW	247
e6fac7f3 BW	248	cat >expect <<-\EOF &&
5d52a30e ÆAB	249	file:(1\|2)d(3\|4)
5d52a30e ÆAB	250	sub-moved/file:(1\|2)d(3\|4)
e6fac7f3	251	EOF
5d52a30e	252	git -C parent grep -e "(1\|2)d(3\|4)" --recurse-submodules >actual &&
e6fac7f3 BW	253	test_cmp expect actual &&
	254
	255	cat >expect <<-\EOF &&
5d52a30e ÆAB	256	HEAD^:dir/sub/file:(1\|2)d(3\|4)
5d52a30e ÆAB	257	HEAD^:file:(1\|2)d(3\|4)
e6fac7f3	258	EOF
5d52a30e	259	git -C parent grep -e "(1\|2)d(3\|4)" --recurse-submodules HEAD^ >actual &&
e6fac7f3 BW	260	test_cmp expect actual
	261	'
	262
be80a239 BW	263	test_expect_success 'grep using relative path' '
	264	test_when_finished "rm -rf parent sub" &&
	265	git init sub &&
5d52a30e	266	echo "(1\|2)d(3\|4)" >sub/file &&
be80a239 BW	267	git -C sub add file &&
be80a239 BW	268	git -C sub commit -m "add file" &&
663d2501	269	test_tick &&
be80a239 BW	270
be80a239 BW	271	git init parent &&
5d52a30e	272	echo "(1\|2)d(3\|4)" >parent/file &&
be80a239 BW	273	git -C parent add file &&
be80a239 BW	274	mkdir parent/src &&
5d52a30e	275	echo "(1\|2)d(3\|4)" >parent/src/file2 &&
be80a239 BW	276	git -C parent add src/file2 &&
	277	git -C parent submodule add ../sub &&
	278	git -C parent commit -m "add files and submodule" &&
663d2501	279	test_tick &&
be80a239 BW	280
	281	# From top works
	282	cat >expect <<-\EOF &&
5d52a30e ÆAB	283	file:(1\|2)d(3\|4)
	284	src/file2:(1\|2)d(3\|4)
	285	sub/file:(1\|2)d(3\|4)
be80a239	286	EOF
5d52a30e	287	git -C parent grep --recurse-submodules -e "(1\|2)d(3\|4)" >actual &&
be80a239 BW	288	test_cmp expect actual &&
	289
	290	# Relative path to top
	291	cat >expect <<-\EOF &&
5d52a30e ÆAB	292	../file:(1\|2)d(3\|4)
	293	file2:(1\|2)d(3\|4)
	294	../sub/file:(1\|2)d(3\|4)
be80a239	295	EOF
5d52a30e	296	git -C parent/src grep --recurse-submodules -e "(1\|2)d(3\|4)" -- .. >actual &&
be80a239 BW	297	test_cmp expect actual &&
	298
	299	# Relative path to submodule
	300	cat >expect <<-\EOF &&
5d52a30e	301	../sub/file:(1\|2)d(3\|4)
be80a239	302	EOF
5d52a30e	303	git -C parent/src grep --recurse-submodules -e "(1\|2)d(3\|4)" -- ../sub >actual &&
be80a239 BW	304	test_cmp expect actual
	305	'
	306
	307	test_expect_success 'grep from a subdir' '
	308	test_when_finished "rm -rf parent sub" &&
	309	git init sub &&
5d52a30e	310	echo "(1\|2)d(3\|4)" >sub/file &&
be80a239 BW	311	git -C sub add file &&
be80a239 BW	312	git -C sub commit -m "add file" &&
663d2501	313	test_tick &&
be80a239 BW	314
	315	git init parent &&
	316	mkdir parent/src &&
5d52a30e	317	echo "(1\|2)d(3\|4)" >parent/src/file &&
be80a239 BW	318	git -C parent add src/file &&
	319	git -C parent submodule add ../sub src/sub &&
	320	git -C parent submodule add ../sub sub &&
	321	git -C parent commit -m "add files and submodules" &&
663d2501	322	test_tick &&
be80a239 BW	323
	324	# Verify grep from root works
	325	cat >expect <<-\EOF &&
5d52a30e ÆAB	326	src/file:(1\|2)d(3\|4)
	327	src/sub/file:(1\|2)d(3\|4)
	328	sub/file:(1\|2)d(3\|4)
be80a239	329	EOF
5d52a30e	330	git -C parent grep --recurse-submodules -e "(1\|2)d(3\|4)" >actual &&
be80a239 BW	331	test_cmp expect actual &&
	332
	333	# Verify grep from a subdir works
	334	cat >expect <<-\EOF &&
5d52a30e ÆAB	335	file:(1\|2)d(3\|4)
5d52a30e ÆAB	336	sub/file:(1\|2)d(3\|4)
be80a239	337	EOF
5d52a30e	338	git -C parent/src grep --recurse-submodules -e "(1\|2)d(3\|4)" >actual &&
be80a239 BW	339	test_cmp expect actual
	340	'
	341
0281e487 BW	342	test_incompatible_with_recurse_submodules ()
	343	{
	344	test_expect_success "--recurse-submodules and $1 are incompatible" "
	345	test_must_fail git grep -e. --recurse-submodules $1 2>actual &&
	346	test_i18ngrep 'not supported with --recurse-submodules' actual
	347	"
	348	}
	349
	350	test_incompatible_with_recurse_submodules --untracked
c56c48dd PB	351
	352	test_expect_success 'grep --recurse-submodules --no-index ignores --recurse-submodules' '
	353	git grep --recurse-submodules --no-index -e "^(.\|.)[\d]" >actual &&
	354	cat >expect <<-\EOF &&
	355	a:(1\|2)d(3\|4)
	356	submodule/a:(1\|2)d(3\|4)
	357	submodule/sub/a:(1\|2)d(3\|4)
	358	EOF
	359	test_cmp expect actual
	360	'
0281e487	361
5ee6f1a2 ÆAB	362	test_expect_success 'grep --recurse-submodules should pass the pattern type along' '
	363	# Fixed
	364	test_must_fail git grep -F --recurse-submodules -e "(.\|.)[\d]" &&
	365	test_must_fail git -c grep.patternType=fixed grep --recurse-submodules -e "(.\|.)[\d]" &&
	366
	367	# Basic
	368	git grep -G --recurse-submodules -e "(.\|.)[\d]" >actual &&
	369	cat >expect <<-\EOF &&
	370	a:(1\|2)d(3\|4)
	371	submodule/a:(1\|2)d(3\|4)
	372	submodule/sub/a:(1\|2)d(3\|4)
	373	EOF
	374	test_cmp expect actual &&
	375	git -c grep.patternType=basic grep --recurse-submodules -e "(.\|.)[\d]" >actual &&
	376	test_cmp expect actual &&
	377
	378	# Extended
	379	git grep -E --recurse-submodules -e "(.\|.)[\d]" >actual &&
	380	cat >expect <<-\EOF &&
	381	.gitmodules:[submodule "submodule"]
	382	.gitmodules: path = submodule
	383	.gitmodules: url = ./submodule
	384	a:(1\|2)d(3\|4)
	385	submodule/.gitmodules:[submodule "sub"]
	386	submodule/a:(1\|2)d(3\|4)
	387	submodule/sub/a:(1\|2)d(3\|4)
	388	EOF
	389	test_cmp expect actual &&
	390	git -c grep.patternType=extended grep --recurse-submodules -e "(.\|.)[\d]" >actual &&
	391	test_cmp expect actual &&
	392	git -c grep.extendedRegexp=true grep --recurse-submodules -e "(.\|.)[\d]" >actual &&
	393	test_cmp expect actual &&
	394
	395	# Perl
	396	if test_have_prereq PCRE
	397	then
	398	git grep -P --recurse-submodules -e "(.\|.)[\d]" >actual &&
	399	cat >expect <<-\EOF &&
	400	a:(1\|2)d(3\|4)
	401	b/b:(3\|4)
	402	submodule/a:(1\|2)d(3\|4)
	403	submodule/sub/a:(1\|2)d(3\|4)
	404	EOF
	405	test_cmp expect actual &&
	406	git -c grep.patternType=perl grep --recurse-submodules -e "(.\|.)[\d]" >actual &&
	407	test_cmp expect actual
	408	fi
	409	'
	410
d9b8b8f8	411	test_expect_success 'grep --recurse-submodules with submodules without .gitmodules in the working tree' '
76e9bdc4 AO	412	test_when_finished "git -C submodule checkout .gitmodules" &&
	413	rm submodule/.gitmodules &&
	414	git grep --recurse-submodules -e "(.\|.)[\d]" >actual &&
	415	cat >expect <<-\EOF &&
	416	a:(1\|2)d(3\|4)
	417	submodule/a:(1\|2)d(3\|4)
	418	submodule/sub/a:(1\|2)d(3\|4)
	419	EOF
	420	test_cmp expect actual
	421	'
	422
6a289d45 MT	423	reset_and_clean () {
	424	git reset --hard &&
	425	git clean -fd &&
	426	git submodule foreach --recursive 'git reset --hard' &&
	427	git submodule foreach --recursive 'git clean -fd'
	428	}
	429
	430	test_expect_success 'grep --recurse-submodules without --cached considers worktree modifications' '
	431	reset_and_clean &&
	432	echo "A modified line in submodule" >>submodule/a &&
	433	echo "submodule/a:A modified line in submodule" >expect &&
	434	git grep --recurse-submodules "A modified line in submodule" >actual &&
	435	test_cmp expect actual
	436	'
	437
	438	test_expect_success 'grep --recurse-submodules with --cached ignores worktree modifications' '
	439	reset_and_clean &&
	440	echo "A modified line in submodule" >>submodule/a &&
	441	test_must_fail git grep --recurse-submodules --cached "A modified line in submodule" >actual 2>&1 &&
	442	test_must_be_empty actual
	443	'
0281e487	444	test_done