2006-08-05 05:16:42 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2006 Junio C Hamano
|
|
|
|
#
|
|
|
|
|
2006-08-11 07:44:42 +00:00
|
|
|
test_description='git grep various.
|
2006-08-05 05:16:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
2009-07-01 22:06:34 +00:00
|
|
|
cat >hello.c <<EOF
|
2016-05-28 15:05:41 +00:00
|
|
|
#include <assert.h>
|
2009-07-01 22:06:34 +00:00
|
|
|
#include <stdio.h>
|
2016-05-28 15:05:41 +00:00
|
|
|
|
2009-07-01 22:06:34 +00:00
|
|
|
int main(int argc, const char **argv)
|
|
|
|
{
|
|
|
|
printf("Hello world.\n");
|
|
|
|
return 0;
|
2009-11-06 09:22:35 +00:00
|
|
|
/* char ?? */
|
2009-07-01 22:06:34 +00:00
|
|
|
}
|
|
|
|
EOF
|
|
|
|
|
2006-08-05 05:16:42 +00:00
|
|
|
test_expect_success setup '
|
|
|
|
{
|
|
|
|
echo foo mmap bar
|
|
|
|
echo foo_mmap bar
|
|
|
|
echo foo_mmap bar mmap
|
|
|
|
echo foo mmap bar_mmap
|
|
|
|
echo foo_mmap bar mmap baz
|
|
|
|
} >file &&
|
2011-05-09 21:52:07 +00:00
|
|
|
{
|
|
|
|
echo Hello world
|
|
|
|
echo HeLLo world
|
|
|
|
echo Hello_world
|
|
|
|
echo HeLLo_world
|
|
|
|
} >hello_world &&
|
2011-05-22 11:37:28 +00:00
|
|
|
{
|
2011-05-26 22:43:59 +00:00
|
|
|
echo "a+b*c"
|
|
|
|
echo "a+bc"
|
|
|
|
echo "abc"
|
2011-05-22 11:37:28 +00:00
|
|
|
} >ab &&
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
{
|
|
|
|
echo d &&
|
|
|
|
echo 0
|
|
|
|
} >d0 &&
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 17:52:15 +00:00
|
|
|
echo vvv >v &&
|
2009-05-23 11:45:26 +00:00
|
|
|
echo ww w >w &&
|
2006-08-05 05:16:42 +00:00
|
|
|
echo x x xx x >x &&
|
|
|
|
echo y yy >y &&
|
|
|
|
echo zzz > z &&
|
2006-08-11 07:44:42 +00:00
|
|
|
mkdir t &&
|
|
|
|
echo test >t/t &&
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 17:52:15 +00:00
|
|
|
echo vvv >t/v &&
|
|
|
|
mkdir t/a &&
|
|
|
|
echo vvv >t/a/v &&
|
2012-02-27 16:45:49 +00:00
|
|
|
{
|
|
|
|
echo "line without leading space1"
|
|
|
|
echo " line with leading space1"
|
|
|
|
echo " line with leading space2"
|
|
|
|
echo " line with leading space3"
|
|
|
|
echo "line without leading space2"
|
|
|
|
} >space &&
|
2017-11-18 18:06:16 +00:00
|
|
|
cat >hello.ps1 <<-\EOF &&
|
|
|
|
# No-op.
|
|
|
|
function dummy() {}
|
|
|
|
|
|
|
|
# Say hello.
|
|
|
|
function hello() {
|
|
|
|
echo "Hello world."
|
|
|
|
} # hello
|
|
|
|
|
|
|
|
# Still a no-op.
|
|
|
|
function dummy() {}
|
|
|
|
EOF
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 17:52:15 +00:00
|
|
|
git add . &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_tick &&
|
2006-08-05 05:16:42 +00:00
|
|
|
git commit -m initial
|
|
|
|
'
|
|
|
|
|
2009-04-27 18:10:24 +00:00
|
|
|
test_expect_success 'grep should not segfault with a bad input' '
|
|
|
|
test_must_fail git grep "("
|
|
|
|
'
|
|
|
|
|
2006-08-05 05:16:42 +00:00
|
|
|
for H in HEAD ''
|
|
|
|
do
|
|
|
|
case "$H" in
|
|
|
|
HEAD) HC='HEAD:' L='HEAD' ;;
|
|
|
|
'') HC= L='in working tree' ;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:foo mmap bar
|
|
|
|
echo ${HC}file:3:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:4:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:5:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
2011-03-30 19:31:05 +00:00
|
|
|
git -c grep.linenumber=false grep -n -w -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2018-06-22 15:49:45 +00:00
|
|
|
test_expect_success "grep -w $L (with --column)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:5:foo mmap bar
|
|
|
|
echo ${HC}file:14:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:5:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:14:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep --column -w -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (with --column, extended OR)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:14:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:19:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep --column -w -e mmap$ --or -e baz $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (with --column, --invert)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:foo mmap bar
|
|
|
|
echo ${HC}file:1:foo_mmap bar
|
|
|
|
echo ${HC}file:1:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:1:foo mmap bar_mmap
|
|
|
|
} >expected &&
|
|
|
|
git grep --column --invert -w -e baz $H -- file >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L (with --column, --invert, extended OR)" '
|
|
|
|
{
|
|
|
|
echo ${HC}hello_world:6:HeLLo_world
|
|
|
|
} >expected &&
|
|
|
|
git grep --column --invert -e ll --or --not -e _ $H -- hello_world \
|
|
|
|
>actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L (with --column, --invert, extended AND)" '
|
|
|
|
{
|
|
|
|
echo ${HC}hello_world:3:Hello world
|
|
|
|
echo ${HC}hello_world:3:Hello_world
|
|
|
|
echo ${HC}hello_world:6:HeLLo_world
|
|
|
|
} >expected &&
|
|
|
|
git grep --column --invert --not -e _ --and --not -e ll $H -- hello_world \
|
|
|
|
>actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L (with --column, double-negation)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep --column --not \( --not -e foo --or --not -e baz \) $H -- file \
|
|
|
|
>actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (with --column, -C)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:5:foo mmap bar
|
|
|
|
echo ${HC}file-foo_mmap bar
|
|
|
|
echo ${HC}file:14:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:5:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:14:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep --column -w -C1 -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (with --line-number, --column)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:5:foo mmap bar
|
|
|
|
echo ${HC}file:3:14:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:4:5:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:5:14:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep -n --column -w -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (with non-extended patterns, --column)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:5:foo mmap bar
|
|
|
|
echo ${HC}file:10:foo_mmap bar
|
|
|
|
echo ${HC}file:10:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:5:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:10:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git grep --column -w -e bar -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-03-30 19:31:05 +00:00
|
|
|
test_expect_success "grep -w $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:foo mmap bar
|
|
|
|
echo ${HC}file:3:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:4:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:5:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git -c grep.linenumber=true grep -w -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:foo mmap bar
|
|
|
|
echo ${HC}file:foo_mmap bar mmap
|
|
|
|
echo ${HC}file:foo mmap bar_mmap
|
|
|
|
echo ${HC}file:foo_mmap bar mmap baz
|
|
|
|
} >expected &&
|
|
|
|
git -c grep.linenumber=true grep --no-line-number -w -e mmap $H >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-05 05:16:42 +00:00
|
|
|
'
|
|
|
|
|
2009-05-23 11:45:26 +00:00
|
|
|
test_expect_success "grep -w $L (w)" '
|
2014-03-11 21:07:58 +00:00
|
|
|
test_must_fail git grep -n -w -e "^w" $H >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2009-05-23 11:45:26 +00:00
|
|
|
'
|
|
|
|
|
2006-08-05 05:16:42 +00:00
|
|
|
test_expect_success "grep -w $L (x)" '
|
|
|
|
{
|
|
|
|
echo ${HC}x:1:x x xx x
|
|
|
|
} >expected &&
|
|
|
|
git grep -n -w -e "x xx* x" $H >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-05 05:16:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (y-1)" '
|
|
|
|
{
|
|
|
|
echo ${HC}y:1:y yy
|
|
|
|
} >expected &&
|
|
|
|
git grep -n -w -e "^y" $H >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-05 05:16:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (y-2)" '
|
|
|
|
if git grep -n -w -e "^y y" $H >actual
|
|
|
|
then
|
|
|
|
echo should not have matched
|
|
|
|
cat actual
|
|
|
|
false
|
|
|
|
else
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2006-08-05 05:16:42 +00:00
|
|
|
fi
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (z)" '
|
|
|
|
if git grep -n -w -e "^z" $H >actual
|
|
|
|
then
|
|
|
|
echo should not have matched
|
|
|
|
cat actual
|
|
|
|
false
|
|
|
|
else
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2006-08-05 05:16:42 +00:00
|
|
|
fi
|
|
|
|
'
|
2006-08-11 07:44:42 +00:00
|
|
|
|
2018-07-09 20:33:47 +00:00
|
|
|
test_expect_success "grep $L (with --column, --only-matching)" '
|
|
|
|
{
|
|
|
|
echo ${HC}file:1:5:mmap
|
|
|
|
echo ${HC}file:2:5:mmap
|
|
|
|
echo ${HC}file:3:5:mmap
|
|
|
|
echo ${HC}file:3:13:mmap
|
|
|
|
echo ${HC}file:4:5:mmap
|
|
|
|
echo ${HC}file:4:13:mmap
|
|
|
|
echo ${HC}file:5:5:mmap
|
|
|
|
echo ${HC}file:5:13:mmap
|
|
|
|
} >expected &&
|
|
|
|
git grep --column -n -o -e mmap $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2006-08-11 07:44:42 +00:00
|
|
|
test_expect_success "grep $L (t-1)" '
|
|
|
|
echo "${HC}t/t:1:test" >expected &&
|
|
|
|
git grep -n -e test $H >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-11 07:44:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L (t-2)" '
|
|
|
|
echo "${HC}t:1:test" >expected &&
|
|
|
|
(
|
|
|
|
cd t &&
|
|
|
|
git grep -n -e test $H
|
|
|
|
) >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-11 07:44:42 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L (t-3)" '
|
|
|
|
echo "${HC}t/t:1:test" >expected &&
|
|
|
|
(
|
|
|
|
cd t &&
|
|
|
|
git grep --full-name -n -e test $H
|
|
|
|
) >actual &&
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-11 07:44:42 +00:00
|
|
|
'
|
|
|
|
|
2008-02-01 09:50:53 +00:00
|
|
|
test_expect_success "grep -c $L (no /dev/null)" '
|
2008-09-30 08:03:55 +00:00
|
|
|
! git grep -c test $H | grep /dev/null
|
2016-06-30 10:13:47 +00:00
|
|
|
'
|
2007-09-14 07:31:00 +00:00
|
|
|
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 17:52:15 +00:00
|
|
|
test_expect_success "grep --max-depth -1 $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/a/v:1:vvv
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth -1 -n -e vvv $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --max-depth 0 $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 0 -n -e vvv $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --max-depth 0 -- '*' $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/a/v:1:vvv
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 0 -n -e vvv $H -- "*" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --max-depth 1 $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 1 -n -e vvv $H >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --max-depth 0 -- t $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 0 -n -e vvv $H -- t >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2010-12-15 15:02:56 +00:00
|
|
|
test_expect_success "grep --max-depth 0 -- . t $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 0 -n -e vvv $H -- . t >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --max-depth 0 -- t . $L" '
|
|
|
|
{
|
|
|
|
echo ${HC}t/v:1:vvv
|
|
|
|
echo ${HC}v:1:vvv
|
|
|
|
} >expected &&
|
|
|
|
git grep --max-depth 0 -n -e vvv $H -- t . >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success "grep $L with grep.extendedRegexp=false" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:a+bc" >expected &&
|
|
|
|
git -c grep.extendedRegexp=false grep "a+b*c" $H ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
2010-12-15 15:02:56 +00:00
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success "grep $L with grep.extendedRegexp=true" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:abc" >expected &&
|
|
|
|
git -c grep.extendedRegexp=true grep "a+b*c" $H ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
|
|
|
|
test_expect_success "grep $L with grep.patterntype=basic" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:a+bc" >expected &&
|
|
|
|
git -c grep.patterntype=basic grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L with grep.patterntype=extended" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:abc" >expected &&
|
|
|
|
git -c grep.patterntype=extended grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L with grep.patterntype=fixed" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:a+b*c" >expected &&
|
|
|
|
git -c grep.patterntype=fixed grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE "grep $L with grep.patterntype=perl" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:a+b*c" >expected &&
|
|
|
|
git -c grep.patterntype=perl grep "a\x{2b}b\x{2a}c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:09 +00:00
|
|
|
test_expect_success !PCRE "grep $L with grep.patterntype=perl errors without PCRE" '
|
|
|
|
test_must_fail git -c grep.patterntype=perl grep "foo.*bar"
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success "grep $L with grep.patternType=default and grep.extendedRegexp=true" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:abc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.patternType=default \
|
|
|
|
-c grep.extendedRegexp=true \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep $L with grep.extendedRegexp=true and grep.patternType=default" '
|
2014-03-11 21:07:58 +00:00
|
|
|
echo "${HC}ab:abc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.extendedRegexp=true \
|
|
|
|
-c grep.patternType=default \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2014-03-11 21:07:58 +00:00
|
|
|
test_expect_success "grep $L with grep.patternType=extended and grep.extendedRegexp=false" '
|
|
|
|
echo "${HC}ab:abc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.patternType=extended \
|
|
|
|
-c grep.extendedRegexp=false \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2014-03-11 21:07:58 +00:00
|
|
|
test_expect_success "grep $L with grep.patternType=basic and grep.extendedRegexp=true" '
|
|
|
|
echo "${HC}ab:a+bc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.patternType=basic \
|
|
|
|
-c grep.extendedRegexp=true \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2014-03-11 21:07:58 +00:00
|
|
|
test_expect_success "grep $L with grep.extendedRegexp=false and grep.patternType=extended" '
|
|
|
|
echo "${HC}ab:abc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.extendedRegexp=false \
|
|
|
|
-c grep.patternType=extended \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2014-03-11 21:07:58 +00:00
|
|
|
test_expect_success "grep $L with grep.extendedRegexp=true and grep.patternType=basic" '
|
|
|
|
echo "${HC}ab:a+bc" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.extendedRegexp=true \
|
|
|
|
-c grep.patternType=basic \
|
2014-03-11 21:07:58 +00:00
|
|
|
grep "a+b*c" $H ab >actual &&
|
2014-03-11 21:15:49 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --count $L" '
|
|
|
|
echo ${HC}ab:3 >expected &&
|
|
|
|
git grep --count -e b $H -- ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep --count -h $L" '
|
|
|
|
echo 3 >expected &&
|
|
|
|
git grep --count -h -e b $H -- ab >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
2006-08-05 05:16:42 +00:00
|
|
|
done
|
|
|
|
|
2012-01-23 17:52:44 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
file
|
|
|
|
EOF
|
|
|
|
test_expect_success 'grep -l -C' '
|
|
|
|
git grep -l -C1 foo >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
file:5
|
|
|
|
EOF
|
2016-06-21 21:14:11 +00:00
|
|
|
test_expect_success 'grep -c -C' '
|
2012-01-23 17:52:44 +00:00
|
|
|
git grep -c -C1 foo >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep -L -C' '
|
|
|
|
git ls-files >expected &&
|
|
|
|
git grep -L -C1 nonexistent_string >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-08-18 01:38:51 +00:00
|
|
|
test_expect_success 'grep --files-without-match --quiet' '
|
|
|
|
git grep --files-without-match --quiet nonexistent_string >actual &&
|
2018-08-19 21:57:24 +00:00
|
|
|
test_must_be_empty actual
|
2017-08-18 01:38:51 +00:00
|
|
|
'
|
|
|
|
|
2009-06-27 18:47:44 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo mmap bar_mmap
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -e A --and -e B' '
|
|
|
|
git grep -e "foo mmap" --and -e bar_mmap >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo_mmap bar mmap
|
|
|
|
file:foo_mmap bar mmap baz
|
|
|
|
EOF
|
|
|
|
|
|
|
|
|
|
|
|
test_expect_success 'grep ( -e A --or -e B ) --and -e B' '
|
|
|
|
git grep \( -e foo_ --or -e baz \) \
|
|
|
|
--and -e " mmap" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo mmap bar
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -e A --and --not -e B' '
|
|
|
|
git grep -e "foo mmap" --and --not -e bar_mmap >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2009-11-22 15:58:09 +00:00
|
|
|
test_expect_success 'grep should ignore GREP_OPTIONS' '
|
|
|
|
GREP_OPTIONS=-v git grep " mmap bar\$" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2009-10-16 14:13:25 +00:00
|
|
|
test_expect_success 'grep -f, non-existent file' '
|
|
|
|
test_must_fail git grep -f patterns
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo mmap bar
|
|
|
|
file:foo_mmap bar
|
|
|
|
file:foo_mmap bar mmap
|
|
|
|
file:foo mmap bar_mmap
|
|
|
|
file:foo_mmap bar mmap baz
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >pattern <<EOF
|
|
|
|
mmap
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -f, one pattern' '
|
|
|
|
git grep -f pattern >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo mmap bar
|
|
|
|
file:foo_mmap bar
|
|
|
|
file:foo_mmap bar mmap
|
|
|
|
file:foo mmap bar_mmap
|
|
|
|
file:foo_mmap bar mmap baz
|
|
|
|
t/a/v:vvv
|
|
|
|
t/v:vvv
|
|
|
|
v:vvv
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >patterns <<EOF
|
|
|
|
mmap
|
|
|
|
vvv
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -f, multiple patterns' '
|
|
|
|
git grep -f patterns >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2012-05-20 14:33:07 +00:00
|
|
|
test_expect_success 'grep, multiple patterns' '
|
|
|
|
git grep "$(cat patterns)" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2009-10-16 14:13:25 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
file:foo mmap bar
|
|
|
|
file:foo_mmap bar
|
|
|
|
file:foo_mmap bar mmap
|
|
|
|
file:foo mmap bar_mmap
|
|
|
|
file:foo_mmap bar mmap baz
|
|
|
|
t/a/v:vvv
|
|
|
|
t/v:vvv
|
|
|
|
v:vvv
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >patterns <<EOF
|
|
|
|
|
|
|
|
mmap
|
|
|
|
|
|
|
|
vvv
|
|
|
|
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -f, ignore empty lines' '
|
|
|
|
git grep -f patterns >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-03-19 18:33:15 +00:00
|
|
|
test_expect_success 'grep -f, ignore empty lines, read patterns from stdin' '
|
|
|
|
git grep -f - <patterns >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2009-07-01 22:03:44 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
y:y yy
|
|
|
|
--
|
|
|
|
z:zzz
|
|
|
|
EOF
|
|
|
|
|
2010-01-28 20:33:42 +00:00
|
|
|
test_expect_success 'grep -q, silently report matches' '
|
|
|
|
git grep -q mmap >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual &&
|
2010-01-28 20:33:42 +00:00
|
|
|
test_must_fail git grep -q qfwfq >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2010-01-28 20:33:42 +00:00
|
|
|
'
|
|
|
|
|
2010-01-13 03:06:41 +00:00
|
|
|
test_expect_success 'grep -C1 hunk mark between files' '
|
|
|
|
git grep -C1 "^[yz]" >actual &&
|
2009-07-01 22:03:44 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_expect_success 'log grep setup' '
|
|
|
|
echo a >>file &&
|
|
|
|
test_tick &&
|
|
|
|
GIT_AUTHOR_NAME="With * Asterisk" \
|
|
|
|
GIT_AUTHOR_EMAIL="xyzzy@frotz.com" \
|
|
|
|
git commit -a -m "second" &&
|
|
|
|
|
|
|
|
echo a >>file &&
|
|
|
|
test_tick &&
|
2010-09-13 05:15:35 +00:00
|
|
|
git commit -a -m "third" &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
|
2010-09-13 05:15:35 +00:00
|
|
|
echo a >>file &&
|
|
|
|
test_tick &&
|
|
|
|
GIT_AUTHOR_NAME="Night Fall" \
|
|
|
|
GIT_AUTHOR_EMAIL="nitfol@frobozz.com" \
|
|
|
|
git commit -a -m "fourth"
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (1)' '
|
|
|
|
git log --author=author --pretty=tformat:%s >actual &&
|
2012-09-14 09:46:39 +00:00
|
|
|
{
|
|
|
|
echo third && echo initial
|
|
|
|
} >expect &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (2)' '
|
|
|
|
git log --author=" * " -F --pretty=tformat:%s >actual &&
|
2012-09-14 09:46:39 +00:00
|
|
|
{
|
|
|
|
echo second
|
|
|
|
} >expect &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (3)' '
|
|
|
|
git log --author="^A U" --pretty=tformat:%s >actual &&
|
2012-09-14 09:46:39 +00:00
|
|
|
{
|
|
|
|
echo third && echo initial
|
|
|
|
} >expect &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (4)' '
|
|
|
|
git log --author="frotz\.com>$" --pretty=tformat:%s >actual &&
|
2012-09-14 09:46:39 +00:00
|
|
|
{
|
|
|
|
echo second
|
|
|
|
} >expect &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (5)' '
|
"log --author=me --grep=it" should find intersection, not union
Historically, any grep filter in "git log" family of commands were taken
as restricting to commits with any of the words in the commit log message.
However, the user almost always want to find commits "done by this person
on that topic". With "--all-match" option, a series of grep patterns can
be turned into a requirement that all of them must produce a match, but
that makes it impossible to ask for "done by me, on either this or that"
with:
log --author=me --committer=him --grep=this --grep=that
because it will require both "this" and "that" to appear.
Change the "header" parser of grep library to treat the headers specially,
and parse it as:
(all-match-OR (HEADER-AUTHOR me)
(HEADER-COMMITTER him)
(OR
(PATTERN this)
(PATTERN that) ) )
Even though the "log" command line parser doesn't give direct access to
the extended grep syntax to group terms with parentheses, this change will
cover the majority of the case the users would want.
This incidentally revealed that one test in t7002 was bogus. It ran:
log --author=Thor --grep=Thu --format='%s'
and expected (wrongly) "Thu" to match "Thursday" in the author/committer
date, but that would never match, as the timestamp in raw commit buffer
does not have the name of the day-of-the-week.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-18 04:09:06 +00:00
|
|
|
git log --author=Thor -F --pretty=tformat:%s >actual &&
|
2012-09-14 09:46:39 +00:00
|
|
|
{
|
|
|
|
echo third && echo initial
|
|
|
|
} >expect &&
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (6)' '
|
|
|
|
git log --author=-0700 --pretty=tformat:%s >actual &&
|
2018-07-27 17:48:11 +00:00
|
|
|
test_must_be_empty actual
|
2008-12-27 08:21:03 +00:00
|
|
|
'
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
|
2012-09-29 04:41:28 +00:00
|
|
|
test_expect_success 'log grep (7)' '
|
|
|
|
git log -g --grep-reflog="commit: third" --pretty=tformat:%s >actual &&
|
|
|
|
echo third >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (8)' '
|
|
|
|
git log -g --grep-reflog="commit: third" --grep-reflog="commit: second" --pretty=tformat:%s >actual &&
|
|
|
|
{
|
|
|
|
echo third && echo second
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (9)' '
|
|
|
|
git log -g --grep-reflog="commit: third" --author="Thor" --pretty=tformat:%s >actual &&
|
|
|
|
echo third >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log grep (9)' '
|
2016-08-09 08:53:38 +00:00
|
|
|
git log -g --grep-reflog="commit: third" --author="non-existent" --pretty=tformat:%s >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2012-09-29 04:41:28 +00:00
|
|
|
'
|
|
|
|
|
2012-09-29 18:59:52 +00:00
|
|
|
test_expect_success 'log --grep-reflog can only be used under -g' '
|
|
|
|
test_must_fail git log --grep-reflog="commit: third"
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:40 +00:00
|
|
|
test_expect_success 'log with multiple --grep uses union' '
|
|
|
|
git log --grep=i --grep=r --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo fourth && echo third && echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log --all-match with multiple --grep uses intersection' '
|
|
|
|
git log --all-match --grep=i --grep=r --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third
|
|
|
|
} >expect &&
|
"log --author=me --grep=it" should find intersection, not union
Historically, any grep filter in "git log" family of commands were taken
as restricting to commits with any of the words in the commit log message.
However, the user almost always want to find commits "done by this person
on that topic". With "--all-match" option, a series of grep patterns can
be turned into a requirement that all of them must produce a match, but
that makes it impossible to ask for "done by me, on either this or that"
with:
log --author=me --committer=him --grep=this --grep=that
because it will require both "this" and "that" to appear.
Change the "header" parser of grep library to treat the headers specially,
and parse it as:
(all-match-OR (HEADER-AUTHOR me)
(HEADER-COMMITTER him)
(OR
(PATTERN this)
(PATTERN that) ) )
Even though the "log" command line parser doesn't give direct access to
the extended grep syntax to group terms with parentheses, this change will
cover the majority of the case the users would want.
This incidentally revealed that one test in t7002 was bogus. It ran:
log --author=Thor --grep=Thu --format='%s'
and expected (wrongly) "Thu" to match "Thursday" in the author/committer
date, but that would never match, as the timestamp in raw commit buffer
does not have the name of the day-of-the-week.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-18 04:09:06 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2010-09-13 05:15:35 +00:00
|
|
|
test_expect_success 'log with multiple --author uses union' '
|
|
|
|
git log --author="Thor" --author="Aster" --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third && echo second && echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:41 +00:00
|
|
|
test_expect_success 'log --all-match with multiple --author still uses union' '
|
|
|
|
git log --all-match --author="Thor" --author="Aster" --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third && echo second && echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:42 +00:00
|
|
|
test_expect_success 'log --grep --author uses intersection' '
|
|
|
|
# grep matches only third and fourth
|
|
|
|
# author matches only initial and third
|
|
|
|
git log --author="A U Thor" --grep=r --format=%s >actual &&
|
2010-09-13 05:15:35 +00:00
|
|
|
{
|
2012-09-14 09:46:42 +00:00
|
|
|
echo third
|
2010-09-13 05:15:35 +00:00
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:42 +00:00
|
|
|
test_expect_success 'log --grep --grep --author takes union of greps and intersects with author' '
|
|
|
|
# grep matches initial and second but not third
|
|
|
|
# author matches only initial and third
|
|
|
|
git log --author="A U Thor" --grep=s --grep=l --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:43 +00:00
|
|
|
test_expect_success 'log ---all-match -grep --author --author still takes union of authors and intersects with grep' '
|
|
|
|
# grep matches only initial and third
|
|
|
|
# author matches all but second
|
|
|
|
git log --all-match --author="Thor" --author="Night" --grep=i --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third && echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:42 +00:00
|
|
|
test_expect_success 'log --grep --author --author takes union of authors and intersects with grep' '
|
|
|
|
# grep matches only initial and third
|
|
|
|
# author matches all but second
|
2010-09-13 05:15:35 +00:00
|
|
|
git log --author="Thor" --author="Night" --grep=i --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third && echo initial
|
|
|
|
} >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-14 09:46:43 +00:00
|
|
|
test_expect_success 'log --all-match --grep --grep --author takes intersection' '
|
|
|
|
# grep matches only third
|
|
|
|
# author matches only initial and third
|
|
|
|
git log --all-match --author="A U Thor" --grep=i --grep=r --format=%s >actual &&
|
|
|
|
{
|
|
|
|
echo third
|
|
|
|
} >expect &&
|
2010-09-13 05:15:35 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-09-29 04:41:27 +00:00
|
|
|
test_expect_success 'log --author does not search in timestamp' '
|
|
|
|
git log --author="$GIT_AUTHOR_DATE" >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2012-09-29 04:41:27 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log --committer does not search in timestamp' '
|
|
|
|
git log --committer="$GIT_COMMITTER_DATE" >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2012-09-29 04:41:27 +00:00
|
|
|
'
|
|
|
|
|
2008-12-27 08:21:03 +00:00
|
|
|
test_expect_success 'grep with CE_VALID file' '
|
|
|
|
git update-index --assume-unchanged t/t &&
|
|
|
|
rm t/t &&
|
2010-01-13 03:06:41 +00:00
|
|
|
test "$(git grep test)" = "t/t:test" &&
|
2008-12-27 08:21:03 +00:00
|
|
|
git update-index --no-assume-unchanged t/t &&
|
|
|
|
git checkout t/t
|
log --author/--committer: really match only with name part
When we tried to find commits done by AUTHOR, the first implementation
tried to pattern match a line with "^author .*AUTHOR", which later was
enhanced to strip leading caret and look for "^author AUTHOR" when the
search pattern was anchored at the left end (i.e. --author="^AUTHOR").
This had a few problems:
* When looking for fixed strings (e.g. "git log -F --author=x --grep=y"),
the regexp internally used "^author .*x" would never match anything;
* To match at the end (e.g. "git log --author='google.com>$'"), the
generated regexp has to also match the trailing timestamp part the
commit header lines have. Also, in order to determine if the '$' at
the end means "match at the end of the line" or just a literal dollar
sign (probably backslash-quoted), we would need to parse the regexp
ourselves.
An earlier alternative tried to make sure that a line matches "^author "
(to limit by field name) and the user supplied pattern at the same time.
While it solved the -F problem by introducing a special override for
matching the "^author ", it did not solve the trailing timestamp nor tail
match problem. It also would have matched every commit if --author=author
was asked for, not because the author's email part had this string, but
because every commit header line that talks about the author begins with
that field name, regardleses of who wrote it.
Instead of piling more hacks on top of hacks, this rethinks the grep
machinery that is used to look for strings in the commit header, and makes
sure that (1) field name matches literally at the beginning of the line,
followed by a SP, and (2) the user supplied pattern is matched against the
remainder of the line, excluding the trailing timestamp data.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-09-05 05:15:02 +00:00
|
|
|
'
|
|
|
|
|
2009-07-01 22:07:24 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c=#include <stdio.h>
|
|
|
|
hello.c: return 0;
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -p with userdiff' '
|
|
|
|
git config diff.custom.funcname "^#" &&
|
|
|
|
echo "hello.c diff=custom" >.gitattributes &&
|
|
|
|
git grep -p return >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2009-07-01 22:06:34 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c=int main(int argc, const char **argv)
|
|
|
|
hello.c: return 0;
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -p' '
|
2009-07-01 22:07:24 +00:00
|
|
|
rm -f .gitattributes &&
|
2009-07-01 22:06:34 +00:00
|
|
|
git grep -p return >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c-#include <stdio.h>
|
2016-05-28 15:05:41 +00:00
|
|
|
hello.c-
|
2009-07-01 22:06:34 +00:00
|
|
|
hello.c=int main(int argc, const char **argv)
|
|
|
|
hello.c-{
|
|
|
|
hello.c- printf("Hello world.\n");
|
|
|
|
hello.c: return 0;
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -p -B5' '
|
|
|
|
git grep -p -B5 return >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-08-01 17:20:53 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c=int main(int argc, const char **argv)
|
|
|
|
hello.c-{
|
|
|
|
hello.c- printf("Hello world.\n");
|
|
|
|
hello.c: return 0;
|
|
|
|
hello.c- /* char ?? */
|
|
|
|
hello.c-}
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -W' '
|
|
|
|
git grep -W return >actual &&
|
|
|
|
test_cmp expected actual
|
2011-12-12 21:16:06 +00:00
|
|
|
'
|
|
|
|
|
2016-05-28 15:05:41 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c-#include <assert.h>
|
|
|
|
hello.c:#include <stdio.h>
|
|
|
|
EOF
|
|
|
|
|
2016-05-28 15:06:19 +00:00
|
|
|
test_expect_success 'grep -W shows no trailing empty lines' '
|
2016-05-28 15:05:41 +00:00
|
|
|
git grep -W stdio >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-12-12 21:16:06 +00:00
|
|
|
test_expect_success 'grep -W with userdiff' '
|
|
|
|
test_when_finished "rm -f .gitattributes" &&
|
2017-11-18 18:06:16 +00:00
|
|
|
git config diff.custom.xfuncname "^function .*$" &&
|
|
|
|
echo "hello.ps1 diff=custom" >.gitattributes &&
|
|
|
|
git grep -W echo >function-context-userdiff-actual
|
|
|
|
'
|
|
|
|
|
2017-11-18 18:08:08 +00:00
|
|
|
test_expect_success ' includes preceding comment' '
|
2017-11-18 18:06:16 +00:00
|
|
|
grep "# Say hello" function-context-userdiff-actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success ' includes function line' '
|
|
|
|
grep "=function hello" function-context-userdiff-actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success ' includes matching line' '
|
|
|
|
grep ": echo" function-context-userdiff-actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success ' includes last line of the function' '
|
|
|
|
grep "} # hello" function-context-userdiff-actual
|
2011-08-01 17:20:53 +00:00
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:12 +00:00
|
|
|
for threads in $(test_seq 0 10)
|
|
|
|
do
|
|
|
|
test_expect_success "grep --threads=$threads & -c grep.threads=$threads" "
|
|
|
|
git grep --threads=$threads . >actual.$threads &&
|
|
|
|
if test $threads -ge 1
|
|
|
|
then
|
|
|
|
test_cmp actual.\$(($threads - 1)) actual.$threads
|
|
|
|
fi &&
|
|
|
|
git -c grep.threads=$threads grep . >actual.$threads &&
|
|
|
|
if test $threads -ge 1
|
|
|
|
then
|
|
|
|
test_cmp actual.\$(($threads - 1)) actual.$threads
|
|
|
|
fi
|
|
|
|
"
|
|
|
|
done
|
|
|
|
|
2017-05-25 19:45:34 +00:00
|
|
|
test_expect_success !PTHREADS,C_LOCALE_OUTPUT 'grep --threads=N or pack.threads=N warns when no pthreads' '
|
|
|
|
git grep --threads=2 Hello hello_world 2>err &&
|
|
|
|
grep ^warning: err >warnings &&
|
|
|
|
test_line_count = 1 warnings &&
|
|
|
|
grep -F "no threads support, ignoring --threads" err &&
|
|
|
|
git -c grep.threads=2 grep Hello hello_world 2>err &&
|
|
|
|
grep ^warning: err >warnings &&
|
|
|
|
test_line_count = 1 warnings &&
|
|
|
|
grep -F "no threads support, ignoring grep.threads" err &&
|
|
|
|
git -c grep.threads=2 grep --threads=4 Hello hello_world 2>err &&
|
|
|
|
grep ^warning: err >warnings &&
|
|
|
|
test_line_count = 2 warnings &&
|
|
|
|
grep -F "no threads support, ignoring --threads" err &&
|
|
|
|
grep -F "no threads support, ignoring grep.threads" err &&
|
|
|
|
git -c grep.threads=0 grep --threads=0 Hello hello_world 2>err &&
|
|
|
|
test_line_count = 0 err
|
|
|
|
'
|
|
|
|
|
2009-09-05 12:31:17 +00:00
|
|
|
test_expect_success 'grep from a subdirectory to search wider area (1)' '
|
|
|
|
mkdir -p s &&
|
|
|
|
(
|
|
|
|
cd s && git grep "x x x" ..
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep from a subdirectory to search wider area (2)' '
|
|
|
|
mkdir -p s &&
|
|
|
|
(
|
2018-07-02 00:23:52 +00:00
|
|
|
cd s &&
|
|
|
|
test_expect_code 1 git grep xxyyzz .. >out &&
|
2018-08-27 21:33:43 +00:00
|
|
|
test_must_be_empty out
|
2009-09-05 12:31:17 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2009-11-06 09:22:35 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c:int main(int argc, const char **argv)
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -Fi' '
|
|
|
|
git grep -Fi "CHAR *" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2010-02-06 18:40:08 +00:00
|
|
|
test_expect_success 'outside of git repository' '
|
|
|
|
rm -fr non &&
|
|
|
|
mkdir -p non/git/sub &&
|
|
|
|
echo hello >non/git/file1 &&
|
|
|
|
echo world >non/git/sub/file2 &&
|
|
|
|
{
|
|
|
|
echo file1:hello &&
|
|
|
|
echo sub/file2:world
|
|
|
|
} >non/expect.full &&
|
2010-10-31 01:46:54 +00:00
|
|
|
echo file2:world >non/expect.sub &&
|
2010-02-06 18:40:08 +00:00
|
|
|
(
|
2016-01-11 21:26:19 +00:00
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
2010-02-06 18:40:08 +00:00
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
test_must_fail git grep o &&
|
|
|
|
git grep --no-index o >../actual.full &&
|
2016-01-11 21:26:19 +00:00
|
|
|
test_cmp ../expect.full ../actual.full &&
|
2010-02-06 18:40:08 +00:00
|
|
|
cd sub &&
|
|
|
|
test_must_fail git grep o &&
|
|
|
|
git grep --no-index o >../../actual.sub &&
|
|
|
|
test_cmp ../../expect.sub ../../actual.sub
|
2011-09-27 20:43:12 +00:00
|
|
|
) &&
|
|
|
|
|
|
|
|
echo ".*o*" >non/git/.gitignore &&
|
|
|
|
(
|
2016-01-11 21:26:19 +00:00
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
2011-09-27 20:43:12 +00:00
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
test_must_fail git grep o &&
|
|
|
|
git grep --no-index --exclude-standard o >../actual.full &&
|
|
|
|
test_cmp ../expect.full ../actual.full &&
|
|
|
|
|
|
|
|
{
|
2016-01-11 21:26:19 +00:00
|
|
|
echo ".gitignore:.*o*" &&
|
2011-09-27 20:43:12 +00:00
|
|
|
cat ../expect.full
|
|
|
|
} >../expect.with.ignored &&
|
|
|
|
git grep --no-index --no-exclude o >../actual.full &&
|
|
|
|
test_cmp ../expect.with.ignored ../actual.full
|
2010-02-06 18:40:08 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-01-12 10:40:26 +00:00
|
|
|
test_expect_success 'outside of git repository with fallbackToNoIndex' '
|
|
|
|
rm -fr non &&
|
|
|
|
mkdir -p non/git/sub &&
|
|
|
|
echo hello >non/git/file1 &&
|
|
|
|
echo world >non/git/sub/file2 &&
|
|
|
|
cat <<-\EOF >non/expect.full &&
|
|
|
|
file1:hello
|
|
|
|
sub/file2:world
|
|
|
|
EOF
|
|
|
|
echo file2:world >non/expect.sub &&
|
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
|
|
|
|
git -c grep.fallbackToNoIndex=true grep o >../actual.full &&
|
|
|
|
test_cmp ../expect.full ../actual.full &&
|
|
|
|
cd sub &&
|
|
|
|
test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
|
|
|
|
git -c grep.fallbackToNoIndex=true grep o >../../actual.sub &&
|
|
|
|
test_cmp ../../expect.sub ../../actual.sub
|
|
|
|
) &&
|
|
|
|
|
|
|
|
echo ".*o*" >non/git/.gitignore &&
|
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
|
|
|
|
git -c grep.fallbackToNoIndex=true grep --exclude-standard o >../actual.full &&
|
|
|
|
test_cmp ../expect.full ../actual.full &&
|
|
|
|
|
|
|
|
{
|
|
|
|
echo ".gitignore:.*o*" &&
|
|
|
|
cat ../expect.full
|
|
|
|
} >../expect.with.ignored &&
|
|
|
|
git -c grep.fallbackToNoIndex grep --no-exclude o >../actual.full &&
|
|
|
|
test_cmp ../expect.with.ignored ../actual.full
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2010-02-06 18:40:08 +00:00
|
|
|
test_expect_success 'inside git repository but with --no-index' '
|
|
|
|
rm -fr is &&
|
|
|
|
mkdir -p is/git/sub &&
|
|
|
|
echo hello >is/git/file1 &&
|
|
|
|
echo world >is/git/sub/file2 &&
|
|
|
|
echo ".*o*" >is/git/.gitignore &&
|
|
|
|
{
|
|
|
|
echo file1:hello &&
|
|
|
|
echo sub/file2:world
|
2011-09-27 20:43:12 +00:00
|
|
|
} >is/expect.unignored &&
|
|
|
|
{
|
|
|
|
echo ".gitignore:.*o*" &&
|
|
|
|
cat is/expect.unignored
|
2010-02-06 18:40:08 +00:00
|
|
|
} >is/expect.full &&
|
2010-10-31 01:46:54 +00:00
|
|
|
echo file2:world >is/expect.sub &&
|
2010-02-06 18:40:08 +00:00
|
|
|
(
|
|
|
|
cd is/git &&
|
|
|
|
git init &&
|
|
|
|
test_must_fail git grep o >../actual.full &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty ../actual.full &&
|
2011-09-27 20:43:12 +00:00
|
|
|
|
|
|
|
git grep --untracked o >../actual.unignored &&
|
|
|
|
test_cmp ../expect.unignored ../actual.unignored &&
|
|
|
|
|
2010-02-06 18:40:08 +00:00
|
|
|
git grep --no-index o >../actual.full &&
|
|
|
|
test_cmp ../expect.full ../actual.full &&
|
2011-09-27 20:43:12 +00:00
|
|
|
|
|
|
|
git grep --no-index --exclude-standard o >../actual.unignored &&
|
|
|
|
test_cmp ../expect.unignored ../actual.unignored &&
|
|
|
|
|
2010-02-06 18:40:08 +00:00
|
|
|
cd sub &&
|
|
|
|
test_must_fail git grep o >../../actual.sub &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty ../../actual.sub &&
|
2011-09-27 20:43:12 +00:00
|
|
|
|
2010-02-06 18:40:08 +00:00
|
|
|
git grep --no-index o >../../actual.sub &&
|
2011-09-27 20:43:12 +00:00
|
|
|
test_cmp ../../expect.sub ../../actual.sub &&
|
|
|
|
|
|
|
|
git grep --untracked o >../../actual.sub &&
|
2010-02-06 18:40:08 +00:00
|
|
|
test_cmp ../../expect.sub ../../actual.sub
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
grep: turn off gitlink detection for --no-index
If we are running "git grep --no-index" outside of a git
repository, we behave roughly like "grep -r", examining all
files in the current directory and its subdirectories.
However, because we use fill_directory() to do the
recursion, it will skip over any directories which look like
sub-repositories.
For a normal git operation (like "git grep" in a repository)
this makes sense; we do not want to cross the boundary out
of our current repository into a submodule. But for
"--no-index" without a repository, we should look at all
files, including embedded repositories.
There is one exception, though: we probably should _not_
descend into ".git" directories. Doing so is inefficient and
unlikely to turn up useful hits.
This patch drops our use of dir.c's gitlink-detection, but
we do still avoid ".git". That makes us more like tools such
as "ack" or "ag", which also know to avoid cruft in .git.
As a bonus, this also drops our usage of the ref code
when we are outside of a repository, making the transition
to pluggable ref backends cleaner.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-07 15:51:21 +00:00
|
|
|
test_expect_success 'grep --no-index descends into repos, but not .git' '
|
|
|
|
rm -fr non &&
|
|
|
|
mkdir -p non/git &&
|
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
|
|
|
|
echo magic >file &&
|
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
echo magic >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m foo &&
|
|
|
|
echo magic >.git/file
|
|
|
|
) &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
file
|
|
|
|
repo/file
|
|
|
|
EOF
|
|
|
|
git grep -l --no-index magic >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2010-02-07 04:44:15 +00:00
|
|
|
test_expect_success 'setup double-dash tests' '
|
|
|
|
cat >double-dash <<EOF &&
|
|
|
|
--
|
|
|
|
->
|
|
|
|
other
|
|
|
|
EOF
|
|
|
|
git add double-dash
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
double-dash:->
|
|
|
|
EOF
|
|
|
|
test_expect_success 'grep -- pattern' '
|
|
|
|
git grep -- "->" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
test_expect_success 'grep -- pattern -- pathspec' '
|
|
|
|
git grep -- "->" -- double-dash >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
test_expect_success 'grep -e pattern -- path' '
|
|
|
|
git grep -e "->" -- double-dash >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
double-dash:--
|
|
|
|
EOF
|
|
|
|
test_expect_success 'grep -e -- -- path' '
|
|
|
|
git grep -e -- -- double-dash >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
grep: fix "--" rev/pathspec disambiguation
If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.
But there are two bugs here:
1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".
So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.
We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.
2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.
But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.
This patch fixes both bugs, and tries to comment the parsing
flow a bit better.
It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:05:55 +00:00
|
|
|
test_expect_success 'dashdash disambiguates rev as rev' '
|
|
|
|
test_when_finished "rm -f master" &&
|
|
|
|
echo content >master &&
|
|
|
|
echo master:hello.c >expect &&
|
|
|
|
git grep -l o master -- hello.c >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'dashdash disambiguates pathspec as pathspec' '
|
|
|
|
test_when_finished "git rm -f master" &&
|
|
|
|
echo content >master &&
|
|
|
|
git add master &&
|
|
|
|
echo master:content >expect &&
|
|
|
|
git grep o -- master >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'report bogus arg without dashdash' '
|
|
|
|
test_must_fail git grep o does-not-exist
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'report bogus rev with dashdash' '
|
|
|
|
test_must_fail git grep o hello.c --
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'allow non-existent path with dashdash' '
|
|
|
|
# We need a real match so grep exits with success.
|
|
|
|
tree=$(git ls-tree HEAD |
|
|
|
|
sed s/hello.c/not-in-working-tree/ |
|
|
|
|
git mktree) &&
|
|
|
|
git grep o "$tree" -- not-in-working-tree
|
|
|
|
'
|
|
|
|
|
2017-02-14 06:03:03 +00:00
|
|
|
test_expect_success 'grep --no-index pattern -- path' '
|
|
|
|
rm -fr non &&
|
|
|
|
mkdir -p non/git &&
|
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
|
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
echo hello >hello &&
|
|
|
|
echo goodbye >goodbye &&
|
|
|
|
echo hello:hello >expect &&
|
|
|
|
git grep --no-index o -- hello >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
grep: avoid resolving revision names in --no-index case
We disallow the use of revisions with --no-index, but we
don't actually check and complain until well after we've
parsed the revisions.
This is the cause of a few problems:
1. We shouldn't be calling get_sha1() at all when we aren't
in a repository, as it might access the ref or object
databases. For now, this should generally just return
failure, but eventually it will become a BUG().
2. When there's a "--" disambiguator and you're outside a
repository, we'll complain early with "unable to resolve
revision". But we can give a much more specific error.
3. When there isn't a "--" disambiguator, we still do the
normal rev/path checks. This is silly, as we know we
cannot have any revs with --no-index. Everything we see
must be a path.
Outside of a repository this doesn't matter (since we
know it won't resolve), but inside one, we may complain
unnecessarily if a filename happens to also match a
refname.
This patch skips the get_sha1() call entirely in the
no-index case, and behaves as if it failed (with the
exception of giving a better error message).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:07:29 +00:00
|
|
|
test_expect_success 'grep --no-index complains of revs' '
|
|
|
|
test_must_fail git grep --no-index o master -- 2>err &&
|
2017-02-14 21:54:36 +00:00
|
|
|
test_i18ngrep "cannot be used with revs" err
|
grep: avoid resolving revision names in --no-index case
We disallow the use of revisions with --no-index, but we
don't actually check and complain until well after we've
parsed the revisions.
This is the cause of a few problems:
1. We shouldn't be calling get_sha1() at all when we aren't
in a repository, as it might access the ref or object
databases. For now, this should generally just return
failure, but eventually it will become a BUG().
2. When there's a "--" disambiguator and you're outside a
repository, we'll complain early with "unable to resolve
revision". But we can give a much more specific error.
3. When there isn't a "--" disambiguator, we still do the
normal rev/path checks. This is silly, as we know we
cannot have any revs with --no-index. Everything we see
must be a path.
Outside of a repository this doesn't matter (since we
know it won't resolve), but inside one, we may complain
unnecessarily if a filename happens to also match a
refname.
This patch skips the get_sha1() call entirely in the
no-index case, and behaves as if it failed (with the
exception of giving a better error message).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:07:29 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep --no-index prefers paths to revs' '
|
|
|
|
test_when_finished "rm -f master" &&
|
|
|
|
echo content >master &&
|
|
|
|
echo master:content >expect &&
|
|
|
|
git grep --no-index o master >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2017-02-14 06:08:09 +00:00
|
|
|
test_expect_success 'grep --no-index does not "diagnose" revs' '
|
|
|
|
test_must_fail git grep --no-index o :1:hello.c 2>err &&
|
|
|
|
test_i18ngrep ! -i "did you mean" err
|
|
|
|
'
|
|
|
|
|
2011-05-09 21:52:07 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c:int main(int argc, const char **argv)
|
|
|
|
hello.c: printf("Hello world.\n");
|
|
|
|
EOF
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep --perl-regexp pattern' '
|
2011-05-09 21:52:07 +00:00
|
|
|
git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:09 +00:00
|
|
|
test_expect_success !PCRE 'grep --perl-regexp pattern errors without PCRE' '
|
|
|
|
test_must_fail git grep --perl-regexp "foo.*bar"
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P pattern' '
|
2011-05-09 21:52:07 +00:00
|
|
|
git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-11-23 14:16:58 +00:00
|
|
|
test_expect_success LIBPCRE2 "grep -P with (*NO_JIT) doesn't error out" '
|
|
|
|
git grep -P "(*NO_JIT)\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:09 +00:00
|
|
|
test_expect_success !PCRE 'grep -P pattern errors without PCRE' '
|
|
|
|
test_must_fail git grep -P "foo.*bar"
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success 'grep pattern with grep.extendedRegexp=true' '
|
|
|
|
test_must_fail git -c grep.extendedregexp=true \
|
|
|
|
grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty actual
|
2011-05-22 11:37:28 +00:00
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P pattern with grep.extendedRegexp=true' '
|
2011-05-22 11:37:28 +00:00
|
|
|
git -c grep.extendedregexp=true \
|
|
|
|
grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P -v pattern' '
|
2011-05-22 11:37:28 +00:00
|
|
|
{
|
2011-05-26 22:43:59 +00:00
|
|
|
echo "ab:a+b*c"
|
|
|
|
echo "ab:a+bc"
|
2011-05-22 11:37:28 +00:00
|
|
|
} >expected &&
|
2011-05-26 22:43:59 +00:00
|
|
|
git grep -P -v "abc" ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P -i pattern' '
|
2011-06-20 21:49:34 +00:00
|
|
|
cat >expected <<-EOF &&
|
|
|
|
hello.c: printf("Hello world.\n");
|
|
|
|
EOF
|
2011-05-09 21:52:07 +00:00
|
|
|
git grep -P -i "PRINTF\([^\d]+\)" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P -w pattern' '
|
2011-05-09 21:52:07 +00:00
|
|
|
{
|
|
|
|
echo "hello_world:Hello world"
|
|
|
|
echo "hello_world:HeLLo world"
|
|
|
|
} >expected &&
|
|
|
|
git grep -P -w "He((?i)ll)o" hello_world >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:10 +00:00
|
|
|
test_expect_success PCRE 'grep -P backreferences work (the PCRE NO_AUTO_CAPTURE flag is not set)' '
|
|
|
|
git grep -P -h "(?P<one>.)(?P=one)" hello_world >actual &&
|
|
|
|
test_cmp hello_world actual &&
|
|
|
|
git grep -P -h "(.)\1" hello_world >actual &&
|
|
|
|
test_cmp hello_world actual
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success 'grep -G invalidpattern properly dies ' '
|
|
|
|
test_must_fail git grep -G "a["
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep invalidpattern properly dies with grep.patternType=basic' '
|
|
|
|
test_must_fail git -c grep.patterntype=basic grep "a["
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success 'grep -E invalidpattern properly dies ' '
|
|
|
|
test_must_fail git grep -E "a["
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep invalidpattern properly dies with grep.patternType=extended' '
|
|
|
|
test_must_fail git -c grep.patterntype=extended grep "a["
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P invalidpattern properly dies ' '
|
2011-05-22 11:37:28 +00:00
|
|
|
test_must_fail git grep -P "a["
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep invalidpattern properly dies with grep.patternType=perl' '
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_must_fail git -c grep.patterntype=perl grep "a["
|
|
|
|
'
|
|
|
|
|
2011-05-26 22:43:59 +00:00
|
|
|
test_expect_success 'grep -G -E -F pattern' '
|
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git grep -G -E -F "a+b*c" ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep pattern with grep.patternType=basic, =extended, =fixed' '
|
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
grep "a+b*c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success 'grep -E -F -G pattern' '
|
2011-05-26 22:43:59 +00:00
|
|
|
echo "ab:a+bc" >expected &&
|
|
|
|
git grep -E -F -G "a+b*c" ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep pattern with grep.patternType=extended, =fixed, =basic' '
|
|
|
|
echo "ab:a+bc" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
grep "a+b*c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-05-26 22:43:59 +00:00
|
|
|
test_expect_success 'grep -F -G -E pattern' '
|
|
|
|
echo "ab:abc" >expected &&
|
|
|
|
git grep -F -G -E "a+b*c" ab >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =extended' '
|
|
|
|
echo "ab:abc" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
grep "a+b*c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-05-26 22:43:59 +00:00
|
|
|
test_expect_success 'grep -G -F -P -E pattern' '
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
echo "d0:d" >expected &&
|
|
|
|
git grep -G -F -P -E "[\d]" d0 >actual &&
|
|
|
|
test_cmp expected actual
|
2011-05-22 11:37:28 +00:00
|
|
|
'
|
|
|
|
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =perl, =extended' '
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
echo "d0:d" >expected &&
|
|
|
|
git \
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=perl \
|
|
|
|
-c grep.patterntype=extended \
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
grep "[\d]" d0 >actual &&
|
|
|
|
test_cmp expected actual
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -G -F -E -P pattern' '
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
echo "d0:0" >expected &&
|
|
|
|
git grep -G -F -E -P "[\d]" d0 >actual &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep pattern with grep.patternType=fixed, =basic, =extended, =perl' '
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
echo "d0:0" >expected &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
-c grep.patterntype=perl \
|
t7810: avoid assumption about invalid regex syntax
A few of the tests want to check that "git grep -P -E" will
override -P with -E, and vice versa. To do so, we use a
regex with "\x{..}", which is valid in PCRE but not defined
by POSIX (for basic or extended regular expressions).
However, POSIX declares quite a lot of syntax, including
"\x", as "undefined". That leaves implementations free to
extend the standard if they choose. At least one, musl libc,
implements "\x" in the same way as PCRE. Our tests check
that "-E" complains about "\x", which fails with musl.
We can fix this by finding some construct which behaves
reliably on both PCRE and POSIX, but differently in each
system.
One such construct is the use of backslash inside brackets.
In PCRE, "[\d]" interprets "\d" as it would outside the
brackets, matching a digit. Whereas in POSIX, the backslash
must be treated literally, and we match either it or a
literal "d". Moreover, implementations are not free to
change this according to POSIX, so we should be able to rely
on it.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-01-11 11:10:55 +00:00
|
|
|
grep "[\d]" d0 >actual &&
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P pattern with grep.patternType=fixed' '
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
grep -P "a\x{2b}b\x{2a}c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep -F pattern with grep.patternType=basic' '
|
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
grep -F "*c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep -G pattern with grep.patternType=fixed' '
|
|
|
|
{
|
|
|
|
echo "ab:a+b*c"
|
|
|
|
echo "ab:a+bc"
|
|
|
|
} >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
grep -G "a+b" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep -E pattern with grep.patternType=fixed' '
|
|
|
|
{
|
|
|
|
echo "ab:a+b*c"
|
|
|
|
echo "ab:a+bc"
|
|
|
|
echo "ab:abc"
|
|
|
|
} >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
grep -E "a+" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-06-05 15:24:15 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c<RED>:<RESET>int main(int argc, const char **argv)
|
|
|
|
hello.c<RED>-<RESET>{
|
|
|
|
<RED>--<RESET>
|
|
|
|
hello.c<RED>:<RESET> /* char ?? */
|
|
|
|
hello.c<RED>-<RESET>}
|
|
|
|
<RED>--<RESET>
|
|
|
|
hello_world<RED>:<RESET>Hello_world
|
|
|
|
hello_world<RED>-<RESET>HeLLo_world
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --color, separator' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename normal &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.match normal &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator red &&
|
|
|
|
|
|
|
|
git grep --color=always -A1 -e char -e lo_w hello.c hello_world |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-06-05 15:24:25 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c:int main(int argc, const char **argv)
|
|
|
|
hello.c: /* char ?? */
|
|
|
|
|
|
|
|
hello_world:Hello_world
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --break' '
|
|
|
|
git grep --break -e char -e lo_w hello.c hello_world >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c:int main(int argc, const char **argv)
|
|
|
|
hello.c-{
|
|
|
|
--
|
|
|
|
hello.c: /* char ?? */
|
|
|
|
hello.c-}
|
|
|
|
|
|
|
|
hello_world:Hello_world
|
|
|
|
hello_world-HeLLo_world
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --break with context' '
|
|
|
|
git grep --break -A1 -e char -e lo_w hello.c hello_world >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-06-05 15:24:36 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c
|
|
|
|
int main(int argc, const char **argv)
|
|
|
|
/* char ?? */
|
|
|
|
hello_world
|
|
|
|
Hello_world
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --heading' '
|
|
|
|
git grep --heading -e char -e lo_w hello.c hello_world >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
<BOLD;GREEN>hello.c<RESET>
|
2016-05-28 15:05:41 +00:00
|
|
|
4:int main(int argc, const <BLACK;BYELLOW>char<RESET> **argv)
|
|
|
|
8: /* <BLACK;BYELLOW>char<RESET> ?? */
|
2011-06-05 15:24:36 +00:00
|
|
|
|
|
|
|
<BOLD;GREEN>hello_world<RESET>
|
|
|
|
3:Hel<BLACK;BYELLOW>lo_w<RESET>orld
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'mimic ack-grep --group' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename "bold green" &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.match "black yellow" &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator normal &&
|
|
|
|
|
|
|
|
git grep --break --heading -n --color \
|
|
|
|
-e char -e lo_w hello.c hello_world |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2012-02-27 16:45:49 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
space: line with leading space1
|
|
|
|
space: line with leading space2
|
|
|
|
space: line with leading space3
|
|
|
|
EOF
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -E "^ "' '
|
2012-02-27 16:45:49 +00:00
|
|
|
git grep -E "^ " space >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-20 21:42:06 +00:00
|
|
|
test_expect_success PCRE 'grep -P "^ "' '
|
2012-02-27 16:45:49 +00:00
|
|
|
git grep -P "^ " space >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2014-10-27 18:23:05 +00:00
|
|
|
cat >expected <<EOF
|
|
|
|
space-line without leading space1
|
|
|
|
space: line <RED>with <RESET>leading space1
|
|
|
|
space: line <RED>with <RESET>leading <RED>space2<RESET>
|
|
|
|
space: line <RED>with <RESET>leading space3
|
|
|
|
space:line without leading <RED>space2<RESET>
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --color -e A -e B with context' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename normal &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.matchContext normal &&
|
|
|
|
test_config color.grep.matchSelected red &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator normal &&
|
|
|
|
|
|
|
|
git grep --color=always -C2 -e "with " -e space2 space |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
space-line without leading space1
|
|
|
|
space- line with leading space1
|
|
|
|
space: line <RED>with <RESET>leading <RED>space2<RESET>
|
|
|
|
space- line with leading space3
|
|
|
|
space-line without leading space2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --color -e A --and -e B with context' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename normal &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.matchContext normal &&
|
|
|
|
test_config color.grep.matchSelected red &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator normal &&
|
|
|
|
|
|
|
|
git grep --color=always -C2 -e "with " --and -e space2 space |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
space-line without leading space1
|
|
|
|
space: line <RED>with <RESET>leading space1
|
|
|
|
space- line with leading space2
|
|
|
|
space: line <RED>with <RESET>leading space3
|
|
|
|
space-line without leading space2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --color -e A --and --not -e B with context' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename normal &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.matchContext normal &&
|
|
|
|
test_config color.grep.matchSelected red &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator normal &&
|
|
|
|
|
|
|
|
git grep --color=always -C2 -e "with " --and --not -e space2 space |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
2016-05-28 15:05:41 +00:00
|
|
|
hello.c-
|
2014-10-27 18:23:05 +00:00
|
|
|
hello.c=int main(int argc, const char **argv)
|
|
|
|
hello.c-{
|
|
|
|
hello.c: pr<RED>int<RESET>f("<RED>Hello<RESET> world.\n");
|
|
|
|
hello.c- return 0;
|
|
|
|
hello.c- /* char ?? */
|
|
|
|
hello.c-}
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep --color -e A --and -e B -p with context' '
|
|
|
|
test_config color.grep.context normal &&
|
|
|
|
test_config color.grep.filename normal &&
|
|
|
|
test_config color.grep.function normal &&
|
|
|
|
test_config color.grep.linenumber normal &&
|
|
|
|
test_config color.grep.matchContext normal &&
|
|
|
|
test_config color.grep.matchSelected red &&
|
|
|
|
test_config color.grep.selected normal &&
|
|
|
|
test_config color.grep.separator normal &&
|
|
|
|
|
|
|
|
git grep --color=always -p -C3 -e int --and -e Hello --no-index hello.c |
|
|
|
|
test_decode_color >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2016-06-30 10:13:48 +00:00
|
|
|
test_expect_success 'grep can find things only in the work tree' '
|
|
|
|
: >work-tree-only &&
|
|
|
|
git add work-tree-only &&
|
|
|
|
test_when_finished "git rm -f work-tree-only" &&
|
|
|
|
echo "find in work tree" >work-tree-only &&
|
|
|
|
git grep --quiet "find in work tree" &&
|
|
|
|
test_must_fail git grep --quiet --cached "find in work tree" &&
|
|
|
|
test_must_fail git grep --quiet "find in work tree" HEAD
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep can find things only in the work tree (i-t-a)' '
|
|
|
|
echo "intend to add this" >intend-to-add &&
|
|
|
|
git add -N intend-to-add &&
|
|
|
|
test_when_finished "git rm -f intend-to-add" &&
|
|
|
|
git grep --quiet "intend to add this" &&
|
|
|
|
test_must_fail git grep --quiet --cached "intend to add this" &&
|
|
|
|
test_must_fail git grep --quiet "intend to add this" HEAD
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep does not search work tree with assume unchanged' '
|
|
|
|
echo "intend to add this" >intend-to-add &&
|
|
|
|
git add -N intend-to-add &&
|
|
|
|
git update-index --assume-unchanged intend-to-add &&
|
|
|
|
test_when_finished "git rm -f intend-to-add" &&
|
|
|
|
test_must_fail git grep --quiet "intend to add this" &&
|
|
|
|
test_must_fail git grep --quiet --cached "intend to add this" &&
|
|
|
|
test_must_fail git grep --quiet "intend to add this" HEAD
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep can find things only in the index' '
|
|
|
|
echo "only in the index" >cache-this &&
|
|
|
|
git add cache-this &&
|
|
|
|
rm cache-this &&
|
|
|
|
test_when_finished "git rm --cached cache-this" &&
|
|
|
|
test_must_fail git grep --quiet "only in the index" &&
|
|
|
|
git grep --quiet --cached "only in the index" &&
|
|
|
|
test_must_fail git grep --quiet "only in the index" HEAD
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep does not report i-t-a with -L --cached' '
|
|
|
|
echo "intend to add this" >intend-to-add &&
|
|
|
|
git add -N intend-to-add &&
|
|
|
|
test_when_finished "git rm -f intend-to-add" &&
|
|
|
|
git ls-files | grep -v "^intend-to-add\$" >expected &&
|
|
|
|
git grep -L --cached "nonexistent_string" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'grep does not report i-t-a and assume unchanged with -L' '
|
|
|
|
echo "intend to add this" >intend-to-add-assume-unchanged &&
|
|
|
|
git add -N intend-to-add-assume-unchanged &&
|
|
|
|
test_when_finished "git rm -f intend-to-add-assume-unchanged" &&
|
|
|
|
git update-index --assume-unchanged intend-to-add-assume-unchanged &&
|
|
|
|
git ls-files | grep -v "^intend-to-add-assume-unchanged\$" >expected &&
|
|
|
|
git grep -L "nonexistent_string" >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2006-08-05 05:16:42 +00:00
|
|
|
test_done
|