config: add persistent configuration

This commit adds support for reading configuration files that change
ripgrep's default behavior. The format of the configuration file is an
"rc" style and is very simple. It is defined by two rules:

  1. Every line is a shell argument, after trimming ASCII whitespace.
  2. Lines starting with '#' (optionally preceded by any amount of
     ASCII whitespace) are ignored.

ripgrep will look for a single configuration file if and only if the
RIPGREP_CONFIG_PATH environment variable is set and is non-empty.
ripgrep will parse shell arguments from this file on startup and will
behave as if the arguments in this file were prepended to any explicit
arguments given to ripgrep on the command line.

For example, if your ripgreprc file contained a single line:

    --smart-case

then the following command

    RIPGREP_CONFIG_PATH=wherever/.ripgreprc rg foo

would behave identically to the following command

    rg --smart-case foo

This commit also adds a new flag, --no-config, that when present will
suppress any and all support for configuration. This includes any future
support for auto-loading configuration files from pre-determined paths
(which this commit does not add).

Conflicts between configuration files and explicit arguments are handled
exactly like conflicts in the same command line invocation. That is,
this command:

    RIPGREP_CONFIG_PATH=wherever/.ripgreprc rg foo --case-sensitive

is exactly equivalent to

    rg --smart-case foo --case-sensitive

in which case, the --case-sensitive flag would override the --smart-case
flag.

Closes #196

src/config.rs

@@ -0,0 +1,195 @@
+// This module provides routines for reading ripgrep config "rc" files. The
+// primary output of these routines is a sequence of arguments, where each
+// argument corresponds precisely to one shell argument.
+
+use std::env;
+use std::error::Error;
+use std::fs::File;
+use std::io::{self, BufRead};
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+
+use Result;
+
+/// Return a sequence of arguments derived from ripgrep rc configuration files.
+///
+/// If no_messages is false and there was a problem reading a config file,
+/// then errors are printed to stderr.
+pub fn args(no_messages: bool) -> Vec<OsString> {
+    let config_path = match env::var_os("RIPGREP_CONFIG_PATH") {
+        None => return vec![],
+        Some(config_path) => {
+            if config_path.is_empty() {
+                return vec![];
+            }
+            PathBuf::from(config_path)
+        }
+    };
+    let (args, errs) = match parse(&config_path) {
+        Ok((args, errs)) => (args, errs),
+        Err(err) => {
+            if !no_messages {
+                eprintln!("{}", err);
+            }
+            return vec![];
+        }
+    };
+    if !no_messages && !errs.is_empty() {
+        for err in errs {
+            eprintln!("{}:{}", config_path.display(), err);
+        }
+    }
+    debug!(
+        "{}: arguments loaded from config file: {:?}",
+        config_path.display(), args);
+    args
+}
+
+/// Parse a single ripgrep rc file from the given path.
+///
+/// On success, this returns a set of shell arguments, in order, that should
+/// be pre-pended to the arguments given to ripgrep at the command line.
+///
+/// If the file could not be read, then an error is returned. If there was
+/// a problem parsing one or more lines in the file, then errors are returned
+/// for each line in addition to successfully parsed arguments.
+fn parse<P: AsRef<Path>>(
+    path: P,
+) -> Result<(Vec<OsString>, Vec<Box<Error>>)> {
+    let path = path.as_ref();
+    match File::open(&path) {
+        Ok(file) => parse_reader(file),
+        Err(err) => errored!("{}: {}", path.display(), err),
+    }
+}
+
+/// Parse a single ripgrep rc file from the given reader.
+///
+/// Callers should not provided a buffered reader, as this routine will use its
+/// own buffer internally.
+///
+/// On success, this returns a set of shell arguments, in order, that should
+/// be pre-pended to the arguments given to ripgrep at the command line.
+///
+/// If the reader could not be read, then an error is returned. If there was a
+/// problem parsing one or more lines, then errors are returned for each line
+/// in addition to successfully parsed arguments.
+fn parse_reader<R: io::Read>(
+    rdr: R,
+) -> Result<(Vec<OsString>, Vec<Box<Error>>)> {
+    let mut bufrdr = io::BufReader::new(rdr);
+    let (mut args, mut errs) = (vec![], vec![]);
+    let mut line = vec![];
+    let mut line_number = 0;
+    while {
+        line.clear();
+        line_number += 1;
+        bufrdr.read_until(b'\n', &mut line)? > 0
+    } {
+        trim(&mut line);
+        if line.is_empty() || line[0] == b'#' {
+            continue;
+        }
+        match bytes_to_os_string(&line) {
+            Ok(osstr) => {
+                args.push(osstr);
+            }
+            Err(err) => {
+                errs.push(format!("{}: {}", line_number, err).into());
+            }
+        }
+    }
+    Ok((args, errs))
+}
+
+/// Trim the given bytes of whitespace according to the ASCII definition.
+fn trim(x: &mut Vec<u8>) {
+    let upto = x.iter().take_while(|b| is_space(**b)).count();
+    x.drain(..upto);
+    let revto = x.len() - x.iter().rev().take_while(|b| is_space(**b)).count();
+    x.drain(revto..);
+}
+
+/// Returns true if and only if the given byte is an ASCII space character.
+fn is_space(b: u8) -> bool {
+    b == b'\t'
+    || b == b'\n'
+    || b == b'\x0B'
+    || b == b'\x0C'
+    || b == b'\r'
+    || b == b' '
+}
+
+/// On Unix, get an OsString from raw bytes.
+#[cfg(unix)]
+fn bytes_to_os_string(bytes: &[u8]) -> Result<OsString> {
+    use std::os::unix::ffi::OsStringExt;
+    Ok(OsString::from_vec(bytes.to_vec()))
+}
+
+/// On non-Unix (like Windows), require UTF-8.
+#[cfg(not(unix))]
+fn bytes_to_os_string(bytes: &[u8]) -> Result<OsString> {
+    String::from_utf8(bytes.to_vec()).map(OsString::from).map_err(From::from)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ffi::OsString;
+    use super::parse_reader;
+
+    #[test]
+    fn basic() {
+        let (args, errs) = parse_reader(&b"\
+# Test
+--context=0
+   --smart-case
+-u
+
+
+   # --bar
+--foo
+"[..]).unwrap();
+        assert!(errs.is_empty());
+        let args: Vec<String> =
+            args.into_iter().map(|s| s.into_string().unwrap()).collect();
+        assert_eq!(args, vec![
+            "--context=0", "--smart-case", "-u", "--foo",
+        ]);
+    }
+
+    // We test that we can handle invalid UTF-8 on Unix-like systems.
+    #[test]
+    #[cfg(unix)]
+    fn error() {
+        use std::os::unix::ffi::OsStringExt;
+
+        let (args, errs) = parse_reader(&b"\
+quux
+foo\xFFbar
+baz
+"[..]).unwrap();
+        assert!(errs.is_empty());
+        assert_eq!(args, vec![
+            OsString::from("quux"),
+            OsString::from_vec(b"foo\xFFbar".to_vec()),
+            OsString::from("baz"),
+        ]);
+    }
+
+    // ... but test that invalid UTF-8 fails on Windows.
+    #[test]
+    #[cfg(not(unix))]
+    fn error() {
+        let (args, errs) = parse_reader(&b"\
+quux
+foo\xFFbar
+baz
+"[..]).unwrap();
+        assert_eq!(errs.len(), 1);
+        assert_eq!(args, vec![
+            OsString::from("quux"),
+            OsString::from("baz"),
+        ]);
+    }
+}