Merge branch 'as/check-ignore'

Enhance "check-ignore" (1.8.2 update) to work more like "check-attr"
over bidi-pipes.

* as/check-ignore:
t0008: use named pipe (FIFO) to test check-ignore streaming
Documentation: add caveats about I/O buffering for check-{attr,ignore}
check-ignore: allow incremental streaming of queries via --stdin
check-ignore: move setup into cmd_check_ignore()
check-ignore: add -n / --non-matching option
t0008: remove duplicated test fixture data

diff --cc Documentation/git.txt
index 9e302b0a60552c4297cb94018dad49169505bd35,122b33f0663a1fbd0b267102fa618d9e818a5c87..65de534e43ab4e83b2ba1c8cfc4df7c52ee2cb84
--- 1/Documentation/git.txt
--- 2/Documentation/git.txt
+++ b/Documentation/git.txt
@@@ -811,11 -771,12 +811,12 @@@ for further details
  'GIT_FLUSH'::
        If this environment variable is set to "1", then commands such
        as 'git blame' (in incremental mode), 'git rev-list', 'git log',
-       and 'git whatchanged' will force a flush of the output stream
-       after each commit-oriented record have been flushed.   If this
+       'git check-attr', 'git check-ignore', and 'git whatchanged' will
+       force a flush of the output stream after each record have been
+       flushed. If this
        variable is set to "0", the output of these commands will be done
        using completely buffered I/O.   If this environment variable is
 -      not set, git will choose buffered or record-oriented flushing
 +      not set, Git will choose buffered or record-oriented flushing
        based on whether stdout appears to be redirected to a file or not.
  
  'GIT_TRACE'::

diff --cc builtin/check-ignore.c
index 854a88a0568e2f0226d26a2d9ebc99d24765053b,c00a7d6bb9d239e2b0fef97c8157d109c6073bfd..4a8fc707c747596e31dcc6f57abf5f965cdf612f
--- 1/builtin/check-ignore.c
--- 2/builtin/check-ignore.c
+++ b/builtin/check-ignore.c
@@@ -53,9 -63,9 +63,9 @@@ static void output_exclude(const char *
        }
  }
  
- static int check_ignore(const char *prefix, const char **pathspec)
 -static int check_ignore(struct path_exclude_check *check,
++static int check_ignore(struct dir_struct *dir,
+                       const char *prefix, const char **pathspec)
  {
-       struct dir_struct dir;
        const char *path, *full_path;
        char *seen;
        int num_ignored = 0, dtype = DT_UNKNOWN, i;
@@@ -86,28 -89,27 +89,26 @@@
                                        ? strlen(prefix) : 0, path);
                full_path = check_path_for_gitlink(full_path);
                die_if_path_beyond_symlink(full_path, prefix);
+               exclude = NULL;
                if (!seen[i]) {
-                       exclude = last_exclude_matching(&dir, full_path, &dtype);
-                       if (exclude) {
-                               if (!quiet)
-                                       output_exclude(path, exclude);
-                               num_ignored++;
-                       }
 -                      exclude = last_exclude_matching_path(check, full_path,
 -                                                           -1, &dtype);
++                      exclude = last_exclude_matching(dir, full_path, &dtype);
                }
+               if (!quiet && (exclude || show_non_matching))
+                       output_exclude(path, exclude);
+               if (exclude)
+                       num_ignored++;
        }
        free(seen);
-       clear_directory(&dir);
  
        return num_ignored;
  }
  
- static int check_ignore_stdin_paths(const char *prefix)
 -static int check_ignore_stdin_paths(struct path_exclude_check *check, const char *prefix)
++static int check_ignore_stdin_paths(struct dir_struct *dir, const char *prefix)
  {
        struct strbuf buf, nbuf;
-       char **pathspec = NULL;
-       size_t nr = 0, alloc = 0;
+       char *pathspec[2] = { NULL, NULL };
        int line_termination = null_term_line ? 0 : '\n';
-       int num_ignored;
+       int num_ignored = 0;
  
        strbuf_init(&buf, 0);
        strbuf_init(&nbuf, 0);
@@@ -118,23 -120,20 +119,19 @@@
                                die("line is badly quoted");
                        strbuf_swap(&buf, &nbuf);
                }
-               ALLOC_GROW(pathspec, nr + 1, alloc);
-               pathspec[nr] = xcalloc(strlen(buf.buf) + 1, sizeof(*buf.buf));
-               strcpy(pathspec[nr++], buf.buf);
+               pathspec[0] = buf.buf;
 -              num_ignored += check_ignore(check, prefix, (const char **)pathspec);
++              num_ignored += check_ignore(dir, prefix, (const char **)pathspec);
+               maybe_flush_or_die(stdout, "check-ignore to stdout");
        }
-       ALLOC_GROW(pathspec, nr + 1, alloc);
-       pathspec[nr] = NULL;
-       num_ignored = check_ignore(prefix, (const char **)pathspec);
-       maybe_flush_or_die(stdout, "attribute to stdout");
        strbuf_release(&buf);
        strbuf_release(&nbuf);
-       free(pathspec);
        return num_ignored;
  }
  
  int cmd_check_ignore(int argc, const char **argv, const char *prefix)
  {
        int num_ignored;
 -      struct path_exclude_check check;
+       struct dir_struct dir;
  
        git_config(git_default_config, NULL);
  
@@@ -156,13 -155,27 +153,24 @@@
                if (verbose)
                        die(_("cannot have both --quiet and --verbose"));
        }
 -      dir.flags |= DIR_COLLECT_IGNORED;
+       if (show_non_matching && !verbose)
+               die(_("--non-matching is only valid with --verbose"));
+ 
+       /* read_cache() is only necessary so we can watch out for submodules. */
+       if (read_cache() < 0)
+               die(_("index file corrupt"));
+ 
+       memset(&dir, 0, sizeof(dir));
+       setup_standard_excludes(&dir);
  
 -      path_exclude_check_init(&check, &dir);
        if (stdin_paths) {
-               num_ignored = check_ignore_stdin_paths(prefix);
 -              num_ignored = check_ignore_stdin_paths(&check, prefix);
++              num_ignored = check_ignore_stdin_paths(&dir, prefix);
        } else {
-               num_ignored = check_ignore(prefix, argv);
 -              num_ignored = check_ignore(&check, prefix, argv);
++              num_ignored = check_ignore(&dir, prefix, argv);
                maybe_flush_or_die(stdout, "ignore to stdout");
        }
  
 -      path_exclude_check_clear(&check);
+       clear_directory(&dir);
+ 
        return !num_ignored;
  }