kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

check-ignore: add -n / --non-matching option 

If `-n` or `--non-matching` are specified, non-matching pathnames will
also be output, in which case all fields in each output record except
for <pathname> will be empty.  This can be useful when running
check-ignore as a background process, so that files can be
incrementally streamed to STDIN, and for each of these files, STDOUT
will indicate whether that file matched a pattern or not.  (Without
this option, it would be impossible to tell whether the absence of
output for a given file meant that it didn't match any pattern, or
that the result simply hadn't been flushed to STDOUT yet.)

Signed-off-by: Adam Spiers <git@adamspiers.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Adam Spiers 12 years ago committed by Junio C Hamano
parent
eef39f8124
commit
ae3caf4c91
3 changed files with 134 additions and 49 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      Documentation/git-check-ignore.txt
  2. 46
      builtin/check-ignore.c
  3. 122
      t/t0008-ignores.sh

15
Documentation/git-check-ignore.txt
Unescape View File

@ -39,6 +39,12 @@ OPTIONS
below). If `--stdin` is also given, input paths are separated below). If `--stdin` is also given, input paths are separated
with a NUL character instead of a linefeed character. with a NUL character instead of a linefeed character.


-n, --non-matching::
Show given paths which don't match any pattern. This only
makes sense when `--verbose` is enabled, otherwise it would
not be possible to distinguish between paths which match a
pattern and those which don't.

OUTPUT OUTPUT
------ ------


@ -65,6 +71,15 @@ are also used instead of colons and hard tabs:


<source> <NULL> <linenum> <NULL> <pattern> <NULL> <pathname> <NULL> <source> <NULL> <linenum> <NULL> <pattern> <NULL> <pathname> <NULL>


If `-n` or `--non-matching` are specified, non-matching pathnames will
also be output, in which case all fields in each output record except
for <pathname> will be empty. This can be useful when running
non-interactively, so that files can be incrementally streamed to
STDIN of a long-running check-ignore process, and for each of these
files, STDOUT will indicate whether that file matched a pattern or
not. (Without this option, it would be impossible to tell whether the
absence of output for a given file meant that it didn't match any
pattern, or that the output hadn't been generated yet.)


EXIT STATUS EXIT STATUS
----------- -----------

46
builtin/check-ignore.c
Unescape View File

@ -5,7 +5,7 @@
#include "pathspec.h" #include "pathspec.h"
#include "parse-options.h" #include "parse-options.h"


static int quiet, verbose, stdin_paths; static int quiet, verbose, stdin_paths, show_non_matching;
static const char * const check_ignore_usage[] = { static const char * const check_ignore_usage[] = {
"git check-ignore [options] pathname...", "git check-ignore [options] pathname...",
"git check-ignore [options] --stdin < <list-of-paths>", "git check-ignore [options] --stdin < <list-of-paths>",
@ -22,21 +22,28 @@ static const struct option check_ignore_options[] = {
N_("read file names from stdin")), N_("read file names from stdin")),
OPT_BOOLEAN('z', NULL, &null_term_line, OPT_BOOLEAN('z', NULL, &null_term_line,
N_("input paths are terminated by a null character")), N_("input paths are terminated by a null character")),
OPT_BOOLEAN('n', "non-matching", &show_non_matching,
N_("show non-matching input paths")),
OPT_END() OPT_END()
}; };


static void output_exclude(const char *path, struct exclude *exclude) static void output_exclude(const char *path, struct exclude *exclude)
{ {
char *bang = exclude->flags & EXC_FLAG_NEGATIVE ? "!" : ""; char *bang = (exclude && exclude->flags & EXC_FLAG_NEGATIVE) ? "!" : "";
char *slash = exclude->flags & EXC_FLAG_MUSTBEDIR ? "/" : ""; char *slash = (exclude && exclude->flags & EXC_FLAG_MUSTBEDIR) ? "/" : "";
if (!null_term_line) { if (!null_term_line) {
if (!verbose) { if (!verbose) {
write_name_quoted(path, stdout, '\n'); write_name_quoted(path, stdout, '\n');
} else { } else {
quote_c_style(exclude->el->src, NULL, stdout, 0); if (exclude) {
printf(":%d:%s%s%s\t", quote_c_style(exclude->el->src, NULL, stdout, 0);
exclude->srcpos, printf(":%d:%s%s%s\t",
bang, exclude->pattern, slash); exclude->srcpos,
bang, exclude->pattern, slash);
}
else {
printf("::\t");
}
quote_c_style(path, NULL, stdout, 0); quote_c_style(path, NULL, stdout, 0);
fputc('\n', stdout); fputc('\n', stdout);
} }
@ -44,11 +51,14 @@ static void output_exclude(const char *path, struct exclude *exclude)
if (!verbose) { if (!verbose) {
printf("%s%c", path, '\0'); printf("%s%c", path, '\0');
} else { } else {
printf("%s%c%d%c%s%s%s%c%s%c", if (exclude)
exclude->el->src, '\0', printf("%s%c%d%c%s%s%s%c%s%c",
exclude->srcpos, '\0', exclude->el->src, '\0',
bang, exclude->pattern, slash, '\0', exclude->srcpos, '\0',
path, '\0'); bang, exclude->pattern, slash, '\0',
path, '\0');
else
printf("%c%c%c%s%c", '\0', '\0', '\0', path, '\0');
} }
} }
} }
@ -89,15 +99,15 @@ static int check_ignore(const char *prefix, const char **pathspec)
? strlen(prefix) : 0, path); ? strlen(prefix) : 0, path);
full_path = check_path_for_gitlink(full_path); full_path = check_path_for_gitlink(full_path);
die_if_path_beyond_symlink(full_path, prefix); die_if_path_beyond_symlink(full_path, prefix);
exclude = NULL;
if (!seen[i]) { if (!seen[i]) {
exclude = last_exclude_matching_path(&check, full_path, exclude = last_exclude_matching_path(&check, full_path,
-1, &dtype); -1, &dtype);
if (exclude) {
if (!quiet)
output_exclude(path, exclude);
num_ignored++;
}
} }
if (!quiet && (exclude || show_non_matching))
output_exclude(path, exclude);
if (exclude)
num_ignored++;
} }
free(seen); free(seen);
clear_directory(&dir); clear_directory(&dir);
@ -161,6 +171,8 @@ int cmd_check_ignore(int argc, const char **argv, const char *prefix)
if (verbose) if (verbose)
die(_("cannot have both --quiet and --verbose")); die(_("cannot have both --quiet and --verbose"));
} }
if (show_non_matching && !verbose)
die(_("--non-matching is only valid with --verbose"));


if (stdin_paths) { if (stdin_paths) {
num_ignored = check_ignore_stdin_paths(prefix); num_ignored = check_ignore_stdin_paths(prefix);

122
t/t0008-ignores.sh
Unescape View File

@ -66,16 +66,23 @@ test_check_ignore () {


init_vars && init_vars &&
rm -f "$HOME/stdout" "$HOME/stderr" "$HOME/cmd" && rm -f "$HOME/stdout" "$HOME/stderr" "$HOME/cmd" &&
echo git $global_args check-ignore $quiet_opt $verbose_opt $args \ echo git $global_args check-ignore $quiet_opt $verbose_opt $non_matching_opt $args \
>"$HOME/cmd" && >"$HOME/cmd" &&
echo "$expect_code" >"$HOME/expected-exit-code" &&
test_expect_code "$expect_code" \ test_expect_code "$expect_code" \
git $global_args check-ignore $quiet_opt $verbose_opt $args \ git $global_args check-ignore $quiet_opt $verbose_opt $non_matching_opt $args \
>"$HOME/stdout" 2>"$HOME/stderr" && >"$HOME/stdout" 2>"$HOME/stderr" &&
test_cmp "$HOME/expected-stdout" "$HOME/stdout" && test_cmp "$HOME/expected-stdout" "$HOME/stdout" &&
stderr_empty_on_success "$expect_code" stderr_empty_on_success "$expect_code"
} }


# Runs the same code with 3 different levels of output verbosity, # Runs the same code with 4 different levels of output verbosity:
#
# 1. with -q / --quiet
# 2. with default verbosity
# 3. with -v / --verbose
# 4. with -v / --verbose, *and* -n / --non-matching
#
# expecting success each time. Takes advantage of the fact that # expecting success each time. Takes advantage of the fact that
# check-ignore --verbose output is the same as normal output except # check-ignore --verbose output is the same as normal output except
# for the extra first column. # for the extra first column.
@ -83,7 +90,9 @@ test_check_ignore () {
# Arguments: # Arguments:
# - (optional) prereqs for this test, e.g. 'SYMLINKS' # - (optional) prereqs for this test, e.g. 'SYMLINKS'
# - test name # - test name
# - output to expect from -v / --verbose mode # - output to expect from the fourth verbosity mode (the output
# from the other verbosity modes is automatically inferred
# from this value)
# - code to run (should invoke test_check_ignore) # - code to run (should invoke test_check_ignore)
test_expect_success_multi () { test_expect_success_multi () {
prereq= prereq=
@ -92,8 +101,9 @@ test_expect_success_multi () {
prereq=$1 prereq=$1
shift shift
fi fi
testname="$1" expect_verbose="$2" code="$3" testname="$1" expect_all="$2" code="$3"


expect_verbose=$( echo "$expect_all" | grep -v '^:: ' )
expect=$( echo "$expect_verbose" | sed -e 's/.* //' ) expect=$( echo "$expect_verbose" | sed -e 's/.* //' )


test_expect_success $prereq "$testname" ' test_expect_success $prereq "$testname" '
@ -101,23 +111,40 @@ test_expect_success_multi () {
eval "$code" eval "$code"
' '


for quiet_opt in '-q' '--quiet' # --quiet is only valid when a single pattern is passed
do if test $( echo "$expect_all" | wc -l ) = 1
test_expect_success $prereq "$testname${quiet_opt:+ with $quiet_opt}" " then
for quiet_opt in '-q' '--quiet'
do
test_expect_success $prereq "$testname${quiet_opt:+ with $quiet_opt}" "
expect '' && expect '' &&
$code $code
" "
done done
quiet_opt= quiet_opt=
fi


for verbose_opt in '-v' '--verbose' for verbose_opt in '-v' '--verbose'
do do
test_expect_success $prereq "$testname${verbose_opt:+ with $verbose_opt}" " for non_matching_opt in '' ' -n' ' --non-matching'
expect '$expect_verbose' && do
$code if test -n "$non_matching_opt"
" then
my_expect="$expect_all"
else
my_expect="$expect_verbose"
fi

test_code="
expect '$my_expect' &&
$code
"
opts="$verbose_opt$non_matching_opt"
test_expect_success $prereq "$testname${opts:+ with $opts}" "$test_code"
done
done done
verbose_opt= verbose_opt=
non_matching_opt=
} }


test_expect_success 'setup' ' test_expect_success 'setup' '
@ -178,7 +205,7 @@ test_expect_success 'setup' '
# #
# test invalid inputs # test invalid inputs


test_expect_success_multi '. corner-case' '' ' test_expect_success_multi '. corner-case' ':: .' '
test_check_ignore . 1 test_check_ignore . 1
' '


@ -276,27 +303,39 @@ do
where="in subdir $subdir" where="in subdir $subdir"
fi fi


test_expect_success_multi "non-existent file $where not ignored" '' " test_expect_success_multi "non-existent file $where not ignored" \
test_check_ignore '${subdir}non-existent' 1 ":: ${subdir}non-existent" \
" "test_check_ignore '${subdir}non-existent' 1"


test_expect_success_multi "non-existent file $where ignored" \ test_expect_success_multi "non-existent file $where ignored" \
".gitignore:1:one ${subdir}one" " ".gitignore:1:one ${subdir}one" \
test_check_ignore '${subdir}one' "test_check_ignore '${subdir}one'"
"


test_expect_success_multi "existing untracked file $where not ignored" '' " test_expect_success_multi "existing untracked file $where not ignored" \
test_check_ignore '${subdir}not-ignored' 1 ":: ${subdir}not-ignored" \
" "test_check_ignore '${subdir}not-ignored' 1"


test_expect_success_multi "existing tracked file $where not ignored" '' " test_expect_success_multi "existing tracked file $where not ignored" \
test_check_ignore '${subdir}ignored-but-in-index' 1 ":: ${subdir}ignored-but-in-index" \
" "test_check_ignore '${subdir}ignored-but-in-index' 1"


test_expect_success_multi "existing untracked file $where ignored" \ test_expect_success_multi "existing untracked file $where ignored" \
".gitignore:2:ignored-* ${subdir}ignored-and-untracked" " ".gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
test_check_ignore '${subdir}ignored-and-untracked' "test_check_ignore '${subdir}ignored-and-untracked'"
"
test_expect_success_multi "mix of file types $where" \
":: ${subdir}non-existent
.gitignore:1:one ${subdir}one
:: ${subdir}not-ignored
:: ${subdir}ignored-but-in-index
.gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
"test_check_ignore '
${subdir}non-existent
${subdir}one
${subdir}not-ignored
${subdir}ignored-but-in-index
${subdir}ignored-and-untracked'
"
done done


# Having established the above, from now on we mostly test against # Having established the above, from now on we mostly test against
@ -391,7 +430,7 @@ test_expect_success 'cd to ignored sub-directory with -v' '
# #
# test handling of symlinks # test handling of symlinks


test_expect_success_multi SYMLINKS 'symlink' '' ' test_expect_success_multi SYMLINKS 'symlink' ':: a/symlink' '
test_check_ignore "a/symlink" 1 test_check_ignore "a/symlink" 1
' '


@ -574,22 +613,33 @@ cat <<-\EOF >stdin
globaltwo globaltwo
b/globaltwo b/globaltwo
../b/globaltwo ../b/globaltwo
c/not-ignored
EOF EOF
cat <<-EOF >expected-verbose # N.B. we deliberately end STDIN with a non-matching pattern in order
# to test that the exit code indicates that one or more of the
# provided paths is ignored - in other words, that it represents an
# aggregation of all the results, not just the final result.

cat <<-EOF >expected-all
.gitignore:1:one ../one .gitignore:1:one ../one
:: ../not-ignored
.gitignore:1:one one .gitignore:1:one one
:: not-ignored
a/b/.gitignore:8:!on* b/on a/b/.gitignore:8:!on* b/on
a/b/.gitignore:8:!on* b/one a/b/.gitignore:8:!on* b/one
a/b/.gitignore:8:!on* b/one one a/b/.gitignore:8:!on* b/one one
a/b/.gitignore:8:!on* b/one two a/b/.gitignore:8:!on* b/one two
a/b/.gitignore:8:!on* "b/one\"three" a/b/.gitignore:8:!on* "b/one\"three"
a/b/.gitignore:9:!two b/two a/b/.gitignore:9:!two b/two
:: b/not-ignored
a/.gitignore:1:two* b/twooo a/.gitignore:1:two* b/twooo
$global_excludes:2:!globaltwo ../globaltwo $global_excludes:2:!globaltwo ../globaltwo
$global_excludes:2:!globaltwo globaltwo $global_excludes:2:!globaltwo globaltwo
$global_excludes:2:!globaltwo b/globaltwo $global_excludes:2:!globaltwo b/globaltwo
$global_excludes:2:!globaltwo ../b/globaltwo $global_excludes:2:!globaltwo ../b/globaltwo
:: c/not-ignored
EOF EOF
grep -v '^:: ' expected-all >expected-verbose
sed -e 's/.* //' expected-verbose >expected-default sed -e 's/.* //' expected-verbose >expected-default


sed -e 's/^"//' -e 's/\\//' -e 's/"$//' stdin | \ sed -e 's/^"//' -e 's/\\//' -e 's/"$//' stdin | \
@ -615,6 +665,14 @@ test_expect_success '--stdin from subdirectory with -v' '
) )
' '


test_expect_success '--stdin from subdirectory with -v -n' '
expect_from_stdin <expected-all &&
(
cd a &&
test_check_ignore "--stdin -v -n" <../stdin
)
'

for opts in '--stdin -z' '-z --stdin' for opts in '--stdin -z' '-z --stdin'
do do
test_expect_success "$opts from subdirectory" ' test_expect_success "$opts from subdirectory" '

Write Preview
Loading…
Cancel
Save