Stream results when feasible.

For example, when only a single file (or stdin) is being searched, then we
should be able to print directly to the terminal instead of intermediate
buffers. (The buffers are only necessary for parallelism.)

Closes BurntSushi#4.

src/args.rs

@@ -9,16 +9,20 @@ use grep::{Grep, GrepBuilder};
 use log;
 use num_cpus;
 use regex;
-use term::Terminal;
+use term::{self, Terminal};
+#[cfg(windows)]
+use term::WinConsole;
 use walkdir::WalkDir;
 
 use atty;
 use gitignore::{Gitignore, GitignoreBuilder};
 use ignore::Ignore;
-use out::{Out, OutBuffer};
+use out::{Out, ColoredTerminal};
 use printer::Printer;
 use search_buffer::BufferSearcher;
 use search_stream::{InputBuffer, Searcher};
+#[cfg(windows)]
+use terminal_win::WindowsBuffer;
 use types::{FileTypeDef, Types, TypesBuilder};
 use walk;
 
@@ -442,7 +446,7 @@ impl Args {
 
     /// Create a new printer of individual search results that writes to the
     /// writer given.
-    pub fn printer<W: Send + Terminal>(&self, wtr: W) -> Printer<W> {
+    pub fn printer<W: Terminal + Send>(&self, wtr: W) -> Printer<W> {
         let mut p = Printer::new(wtr)
             .column(self.column)
             .context_separator(self.context_separator.clone())
@@ -469,8 +473,29 @@ impl Args {
     }
 
     /// Create a new buffer for use with searching.
-    pub fn outbuf(&self) -> OutBuffer {
-        OutBuffer::new(self.color)
+    #[cfg(not(windows))]
+    pub fn outbuf(&self) -> ColoredTerminal<term::TerminfoTerminal<Vec<u8>>> {
+        ColoredTerminal::new(vec![], self.color)
+    }
+
+    /// Create a new buffer for use with searching.
+    #[cfg(windows)]
+    pub fn outbuf(&self) -> ColoredTerminal<WindowsBuffer> {
+        ColoredTerminal::new_buffer(self.color)
+    }
+
+    /// Create a new buffer for use with searching.
+    #[cfg(not(windows))]
+    pub fn stdout(
+        &self,
+    ) -> ColoredTerminal<term::TerminfoTerminal<io::BufWriter<io::Stdout>>> {
+        ColoredTerminal::new(io::BufWriter::new(io::stdout()), self.color)
+    }
+
+    /// Create a new buffer for use with searching.
+    #[cfg(windows)]
+    pub fn stdout(&self) -> ColoredTerminal<WinConsole<io::Stdout>> {
+        ColoredTerminal::new_stdout(self.color)
     }
 
     /// Return the paths that should be searched.

src/gitignore.rs

@@ -21,7 +21,6 @@ additional rules such as whitelists (prefix of `!`) or directory-only globs
 // TODO(burntsushi): Implement something similar, but for Mercurial. We can't
 // use this exact implementation because hgignore files are different.
 
-use std::env;
 use std::error::Error as StdError;
 use std::fmt;
 use std::fs::File;
@@ -89,21 +88,10 @@ pub struct Gitignore {
 }
 
 impl Gitignore {
-    /// Create a new gitignore glob matcher from the gitignore file at the
-    /// given path. The root of the gitignore file is the basename of path.
-    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Gitignore, Error> {
-        let root = match path.as_ref().parent() {
-            Some(parent) => parent.to_path_buf(),
-            None => env::current_dir().unwrap_or(Path::new("/").to_path_buf()),
-        };
-        let mut builder = GitignoreBuilder::new(root);
-        try!(builder.add_path(path));
-        builder.build()
-    }
-
     /// Create a new gitignore glob matcher from the given root directory and
     /// string containing the contents of a gitignore file.
-    pub fn from_str<P: AsRef<Path>>(
+    #[allow(dead_code)]
+    fn from_str<P: AsRef<Path>>(
         root: P,
         gitignore: &str,
     ) -> Result<Gitignore, Error> {
@@ -159,11 +147,6 @@ impl Gitignore {
     pub fn num_ignores(&self) -> u64 {
         self.num_ignores
     }
-
-    /// Returns the total number of whitelisted patterns.
-    pub fn num_whitelist(&self) -> u64 {
-        self.num_whitelist
-    }
 }
 
 /// The result of a glob match.
@@ -182,6 +165,7 @@ pub enum Match<'a> {
 
 impl<'a> Match<'a> {
     /// Returns true if the match result implies the path should be ignored.
+    #[allow(dead_code)]
     pub fn is_ignored(&self) -> bool {
         match *self {
             Match::Ignored(_) => true,

src/glob.rs

@@ -95,6 +95,7 @@ impl Set {
     }
 
     /// Returns the number of glob patterns in this set.
+    #[allow(dead_code)]
     pub fn len(&self) -> usize {
         self.set.len()
     }
@@ -137,6 +138,7 @@ impl SetBuilder {
     ///
     /// If the pattern could not be parsed as a glob, then an error is
     /// returned.
+    #[allow(dead_code)]
     pub fn add(&mut self, pat: &str) -> Result<(), Error> {
         self.add_with(pat, &MatchOptions::default())
     }
@@ -205,6 +207,7 @@ impl Pattern {
     /// Convert this pattern to a string that is guaranteed to be a valid
     /// regular expression and will represent the matching semantics of this
     /// glob pattern. This uses a default set of options.
+    #[allow(dead_code)]
     pub fn to_regex(&self) -> String {
         self.to_regex_with(&MatchOptions::default())
     }
@@ -315,7 +318,7 @@ impl<'a> Parser<'a> {
             }
             return Ok(());
         }
-        let last = self.p.tokens.pop().unwrap();
+        self.p.tokens.pop().unwrap();
         if prev != Some('/') {
             return Err(Error::InvalidRecursive);
         }