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
|
|
|
|
#include <stdio.h>
|
|
|
|
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 &&
|
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 &&
|
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
|
|
|
|
'
|
|
|
|
|
|
|
|
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)" '
|
|
|
|
: >expected &&
|
2014-03-11 21:07:58 +00:00
|
|
|
test_must_fail git grep -n -w -e "^w" $H >actual &&
|
2009-05-23 11:45:26 +00:00
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
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)" '
|
|
|
|
: >expected &&
|
|
|
|
if git grep -n -w -e "^y y" $H >actual
|
|
|
|
then
|
|
|
|
echo should not have matched
|
|
|
|
cat actual
|
|
|
|
false
|
|
|
|
else
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-05 05:16:42 +00:00
|
|
|
fi
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success "grep -w $L (z)" '
|
|
|
|
: >expected &&
|
|
|
|
if git grep -n -w -e "^z" $H >actual
|
|
|
|
then
|
|
|
|
echo should not have matched
|
|
|
|
cat actual
|
|
|
|
false
|
|
|
|
else
|
2010-05-14 09:31:37 +00:00
|
|
|
test_cmp expected actual
|
2006-08-05 05:16:42 +00:00
|
|
|
fi
|
|
|
|
'
|
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
|
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
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE "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
|
|
|
|
'
|
|
|
|
|
|
|
|
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
|
|
|
|
test_expect_success 'grep -l -C' '
|
|
|
|
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
|
|
|
|
'
|
|
|
|
|
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' '
|
|
|
|
>empty &&
|
|
|
|
git grep -q mmap >actual &&
|
|
|
|
test_cmp empty actual &&
|
|
|
|
test_must_fail git grep -q qfwfq >actual &&
|
|
|
|
test_cmp empty actual
|
|
|
|
'
|
|
|
|
|
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 &&
|
|
|
|
>expect &&
|
|
|
|
test_cmp expect 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)' '
|
|
|
|
git log -g --grep-reflog="commit: third" --author="non-existant" --pretty=tformat:%s >actual &&
|
|
|
|
: >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
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' '
|
|
|
|
: >expect &&
|
|
|
|
git log --author="$GIT_AUTHOR_DATE" >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'log --committer does not search in timestamp' '
|
|
|
|
: >expect &&
|
|
|
|
git log --committer="$GIT_COMMITTER_DATE" >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
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>
|
|
|
|
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
|
|
|
'
|
|
|
|
|
|
|
|
cat >expected <<EOF
|
|
|
|
hello.c= printf("Hello world.\n");
|
|
|
|
hello.c: return 0;
|
|
|
|
hello.c- /* char ?? */
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'grep -W with userdiff' '
|
|
|
|
test_when_finished "rm -f .gitattributes" &&
|
|
|
|
git config diff.custom.xfuncname "(printf.*|})$" &&
|
|
|
|
echo "hello.c diff=custom" >.gitattributes &&
|
|
|
|
git grep -W return >actual &&
|
|
|
|
test_cmp expected actual
|
2011-08-01 17:20:53 +00:00
|
|
|
'
|
|
|
|
|
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 &&
|
|
|
|
(
|
|
|
|
cd s || exit 1
|
|
|
|
( git grep xxyyzz .. >out ; echo $? >status )
|
|
|
|
! test -s out &&
|
|
|
|
test 1 = $(cat status)
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
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
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non/git" &&
|
|
|
|
export GIT_CEILING_DIRECTORIES &&
|
|
|
|
cd non/git &&
|
|
|
|
test_must_fail git grep o &&
|
|
|
|
git grep --no-index o >../actual.full &&
|
|
|
|
test_cmp ../expect.full ../actual.full
|
|
|
|
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 &&
|
|
|
|
(
|
|
|
|
GIT_CEILING_DIRECTORIES="$(pwd)/non/git" &&
|
|
|
|
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 &&
|
|
|
|
|
|
|
|
{
|
|
|
|
echo ".gitignore:.*o*"
|
|
|
|
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
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
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 &&
|
|
|
|
: >is/expect.empty &&
|
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 &&
|
|
|
|
test_cmp ../expect.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 &&
|
|
|
|
test_cmp ../../expect.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
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
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
|
|
|
|
'
|
|
|
|
|
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
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep --perl-regexp pattern' '
|
|
|
|
git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P pattern' '
|
|
|
|
git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success 'grep pattern with grep.extendedRegexp=true' '
|
2011-05-26 22:43:59 +00:00
|
|
|
>empty &&
|
2011-05-22 11:37:28 +00:00
|
|
|
test_must_fail git -c grep.extendedregexp=true \
|
|
|
|
grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp empty actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P pattern with grep.extendedRegexp=true' '
|
|
|
|
git -c grep.extendedregexp=true \
|
|
|
|
grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P -v pattern' '
|
|
|
|
{
|
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
|
|
|
|
'
|
|
|
|
|
2011-05-09 21:52:07 +00:00
|
|
|
test_expect_success LIBPCRE '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
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P -w pattern' '
|
|
|
|
{
|
|
|
|
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
|
|
|
|
'
|
|
|
|
|
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["
|
|
|
|
'
|
|
|
|
|
2011-05-22 11:37:28 +00:00
|
|
|
test_expect_success LIBPCRE 'grep -P invalidpattern properly dies ' '
|
|
|
|
test_must_fail git grep -P "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 LIBPCRE 'grep invalidpattern properly dies with grep.patternType=perl' '
|
|
|
|
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' '
|
|
|
|
>empty &&
|
|
|
|
test_must_fail git grep -G -F -P -E "a\x{2b}b\x{2a}c" ab >actual &&
|
|
|
|
test_cmp empty 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' '
|
|
|
|
>empty &&
|
|
|
|
test_must_fail git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=perl \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
grep "a\x{2b}b\x{2a}c" ab >actual &&
|
|
|
|
test_cmp empty actual
|
|
|
|
'
|
|
|
|
|
2011-05-26 22:43:59 +00:00
|
|
|
test_expect_success LIBPCRE 'grep -G -F -E -P pattern' '
|
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git grep -G -F -E -P "a\x{2b}b\x{2a}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 LIBPCRE 'grep pattern with grep.patternType=fixed, =basic, =extended, =perl' '
|
|
|
|
echo "ab:a+b*c" >expected &&
|
|
|
|
git \
|
|
|
|
-c grep.patterntype=fixed \
|
|
|
|
-c grep.patterntype=basic \
|
|
|
|
-c grep.patterntype=extended \
|
|
|
|
-c grep.patterntype=perl \
|
|
|
|
grep "a\x{2b}b\x{2a}c" ab >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P pattern with grep.patternType=fixed' '
|
|
|
|
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>
|
|
|
|
2:int main(int argc, const <BLACK;BYELLOW>char<RESET> **argv)
|
|
|
|
6: /* <BLACK;BYELLOW>char<RESET> ?? */
|
|
|
|
|
|
|
|
<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
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -E "^ "' '
|
|
|
|
git grep -E "^ " space >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success LIBPCRE 'grep -P "^ "' '
|
|
|
|
git grep -P "^ " space >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2006-08-05 05:16:42 +00:00
|
|
|
test_done
|