0.1.5

Also, change -Q/--literal to -F/--fixed-strings because compatibility
with grep is probably better.

Cargo.lock

@@ -1,11 +1,11 @@
 [root]
 name = "ripgrep"
-version = "0.1.3"
+version = "0.1.5"
 dependencies = [
  "deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "docopt 0.6.83 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "fnv 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "grep 0.1.1",
  "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "fnv"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -236,7 +236,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1614659040e711785ed8ea24219140654da1729f3ec8a47a9719d041112fe7bf"
 "checksum docopt 0.6.83 (registry+https://github.com/rust-lang/crates.io-index)" = "fc42c6077823a361410c37d47c2535b73a190cbe10838dc4f400fe87c10c8c3b"
 "checksum env_logger 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "15abd780e45b3ea4f76b4e9a26ff4843258dd8a3eed2775a0e7368c2e7936c2f"
-"checksum fnv 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8e8af7b5408ab0c4910cad114c8f9eb454bf75df7afe8964307eeafb68a13a5e"
+"checksum fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6cc484842f1e2884faf56f529f960cc12ad8c71ce96cc7abba0a067c98fee344"
 "checksum fs2 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "bcd414e5a1a979b931bb92f41b7a54106d3f6d2e6c253e9ce943b7cd468251ef"
 "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ripgrep"
-version = "0.1.3"  #:version
+version = "0.1.5"  #:version
 authors = ["Andrew Gallant <jamslam@gmail.com>"]
 description = """
 Line oriented search tool using Rust's regex library. Combines the raw

README-NEW.md

@@ -0,0 +1,234 @@
+ripgrep (rg)
+------------
+`ripgrep` is a command line search tool that combines the usability of The
+Silver Searcher (an `ack` clone) with the raw speed of GNU grep. `ripgrep` has
+first class support on Windows, Mac and Linux, with binary downloads available
+for [every release](https://github.com/BurntSushi/ripgrep/releases).
+
+[![Linux build status](https://api.travis-ci.org/BurntSushi/ripgrep.png)](https://travis-ci.org/BurntSushi/ripgrep)
+[![Windows build status](https://ci.appveyor.com/api/projects/status/github/BurntSushi/ripgrep?svg=true)](https://ci.appveyor.com/project/BurntSushi/ripgrep)
+[![](https://img.shields.io/crates/v/ripgrep.svg)](https://crates.io/crates/ripgrep)
+
+Dual-licensed under MIT or the [UNLICENSE](http://unlicense.org).
+
+### Screenshot of search results
+
+[![A screenshot of a sample search with ripgrep](http://burntsushi.net/stuff/ripgrep1.png)](http://burntsushi.net/stuff/ripgrep1.png)
+
+### Quick example comparing tools
+
+This example searches the entire Linux kernel source tree (after running
+`make`) for `[A-Z]+_SUSPEND`, where all matches must be words. Timings were
+collected on a system with an Intel i7-6900K 3.2 GHz.
+
+Please remember that a single benchmark is never enough! See my
+[blog post on `ripgrep`](http://blog.burntsushi.net/ripgrep/)
+for a very detailed comparison with more benchmarks and analysis.
+
+| Tool | Command | Line count | Time |
+| ---- | ------- | ---------- | ---- |
+| ripgrep | `rg -n -w '[A-Z]+_SUSPEND'` | 450 | **0.245s** |
+| [The Silver Searcher](https://github.com/ggreer/the_silver_searcher) | `ag -w '[A-Z]+_SUSPEND'` | 450 | 0.753s |
+| [git grep](https://www.kernel.org/pub/software/scm/git/docs/git-grep.html) | `LC_ALL=C git grep -E -n -w '[A-Z]+_SUSPEND'` | 450 | 0.823s |
+| [git grep](https://www.kernel.org/pub/software/scm/git/docs/git-grep.html) | `LC_ALL=en_US.UTF-8 git grep -E -n -w '[A-Z]+_SUSPEND'` | 450 | 2.880s |
+| [sift](https://github.com/svent/sift) | `sift --git -n -w '[A-Z]+_SUSPEND'` | 450 | 3.656s |
+| [The Platinum Searcher](https://github.com/monochromegane/the_platinum_searcher) | `pt -w -e '[A-Z]+_SUSPEND'` | 450 | 12.369s |
+| [ack](http://beyondgrep.com/) | `ack -w '[A-Z]+_SUSPEND'` | 1878 | 16.952s |
+
+(Yes, `ack` [has](https://github.com/petdance/ack2/issues/445) a
+[bug](https://github.com/petdance/ack2/issues/14).)
+
+### Why should I use `ripgrep`?
+
+* It can replace both The Silver Searcher and GNU grep because it is faster
+  than both. (N.B. It is not, strictly speaking, a "drop-in" replacement for
+  both, but the feature sets are far more similar than different.)
+* Like The Silver Searcher, `ripgrep` defaults to recursive directory search
+  and won't search files ignored by your `.gitignore` files. It also ignores
+  hidden and binary files by default. `ripgrep` also implements full support
+  for `.gitignore`, where as there are many bugs related to that functionality
+  in The Silver Searcher.
+* `ripgrep` can search specific types of files. For example, `rg -tpy foo`
+  limits your search to Python files and `rg -Tjs foo` excludes Javascript
+  files from your search. `ripgrep` can be taught about new file types with
+  custom matching rules.
+* `ripgrep` supports many features found in `grep`, such as showing the context
+  of search results, searching multiple patterns, highlighting matches with
+  color and full Unicode support. Unlike GNU grep, `ripgrep` stays fast while
+  supporting Unicode (which is always on).
+
+### Is it really faster than everything else?
+
+Yes. A large number of benchmarks with detailed analysis for each is
+[available on my blog](http://blog.burntsushi.net/ripgrep/).
+
+Summarizing, `ripgrep` is fast because:
+
+* It is built on top of
+  [Rust's regex engine](https://github.com/rust-lang-nursery/regex).
+  Rust's regex engine uses finite automata, SIMD and aggressive literal
+  optimizations to make searching very fast.
+* Rust's regex library maintains performance with full Unicode support by
+  building UTF-8 decoding directly into its deterministic finite automaton
+  engine.
+* It supports searching with either memory maps or by searching incrementally
+  with an intermediate buffer. The former is better for single files and the
+  latter is better for large directories. `ripgrep` chooses the best searching
+  strategy for you automatically.
+* Applies your ignore patterns in `.gitignore` files using a
+  [`RegexSet`](https://doc.rust-lang.org/regex/regex/struct.RegexSet.html).
+  That means a single file path can be matched against multiple glob patterns
+  simultaneously.
+* Uses a Chase-Lev work-stealing queue for quickly distributing work to
+  multiple threads.
+
+### Installation
+
+N.B. `ripgrep` is not yet available in any package repositories. I'd like to
+fix that in the future.
+
+[Binaries for `ripgrep` are available for Windows, Mac and
+Linux.](https://github.com/BurntSushi/ripgrep/releases) Linux binaries are
+static executables. Windows binaries are available either as built with MinGW
+(GNU) or with Microsoft Visual C++ (MSVC). When possible, prefer MSVC over GNU,
+but you'll need to have the
+[Microsoft Visual C++ Build
+Tools](http://landinghub.visualstudio.com/visual-cpp-build-tools)
+installed.
+
+If you're a Rust programmer, `ripgrep` can be installed with `cargo`:
+
+```
+$ cargo install ripgrep
+```
+
+### Whirlwind tour
+
+The command line usage of `ripgrep` doesn't differ much from other tools that
+perform a similar function, so you probably already know how to use `ripgrep`.
+The full details can be found in `rg --help`, but let's go on a whirlwind tour.
+
+`ripgrep` detects when its printing to a terminal, and will automatically
+colorize your output and show line numbers, just like The Silver Searcher.
+Coloring works on Windows too! Colors can be controlled more granularly with
+the `--color` flag.
+
+One last thing before we get started: `ripgrep` assumes UTF-8 *everywhere*. It
+can still search files that are invalid UTF-8 (like, say, latin-1), but it will
+simply not work on UTF-16 encoded files or other more exotic encodings.
+[Support for other encodings may
+happen.](https://github.com/BurntSushi/ripgrep/issues/1)
+
+To recursively search the current directory, while respecting all `.gitignore`
+files:
+
+```
+$ rg foobar
+```
+
+The above command also respects all `.rgignore` files, including in parent
+directories. `.rgignore` files can be used when `.gitignore` files are
+insufficient. In all cases, `.rgignore` patterns take precedence over
+`.gitignore`.
+
+To ignore all ignore files, use `--no-ignore`:
+
+```
+$ rg --no-ignore foobar
+```
+
+(Tip: If your ignore files aren't being adhered to like you expect, run your
+search with the `--debug` flag.)
+
+Make the search case insensitive with `-i`, invert the search with `-v` or
+show the 2 lines before and after every search result with `-C2`.
+
+Force all matches to be surrounded by word boundaries with `-w`.
+
+Search and replace (find first and last names and swap them):
+
+```
+$ rg '([A-Z][a-z]+)\s+([A-Z][a-z]+)' --replace '$2, $1'
+```
+
+Named groups are supported:
+
+```
+$ rg '(?P<first>[A-Z][a-z]+)\s+(?P<last>[A-Z][a-z]+)' --replace '$last, $first'
+```
+
+Up the ante with full Unicode support, by matching any uppercase Unicode letter
+followed by any sequence of lowercase Unicode letters (good luck doing this
+with other search tools!):
+
+```
+$ rg '(\p{Lu}\p{Ll}+)\s+(\p{Lu}\p{Ll}+)' --replace '$2, $1'
+```
+
+Search only files matching a particular glob:
+
+```
+$ rg foo -g 'README.*'
+```
+
+<!--*-->
+
+Or exclude files matching a particular glob:
+
+```
+$ rg foo -g '!*.min.js'
+```
+
+Search only HTML and CSS files:
+
+```
+$ rg -thtml -tcss foobar
+```
+
+Search everything except for Javascript files:
+
+```
+$ rg -Tjs foobar
+```
+
+To see a list of types supported, run `rg --type-list`. To add a new type, use
+`--type-add`:
+
+```
+$ rg --type-add 'foo:*.foo,*.foobar'
+```
+
+The type `foo` will now match any file ending with the `.foo` or `.foobar`
+extensions.
+
+### Building
+
+`ripgrep` is written in Rust, so you'll need to grab a
+[Rust installation](https://www.rust-lang.org/) in order to compile it.
+`ripgrep` compiles with Rust 1.9 (stable) or newer. Building is easy:
+
+```
+$ git clone git://github.com/BurntSushi/ripgrep
+$ cd ripgrep
+$ cargo build --release
+$ ./target/release/rg --version
+0.1.3
+```
+
+If you have a Rust nightly compiler, then you can enable optional SIMD
+acceleration like so:
+
+```
+RUSTFLAGS="-C target-cpu=native" cargo build --release --features simd-accel
+```
+
+### Running tests
+
+`ripgrep` is relatively well tested, including both unit tests and integration
+tests. To run the full test suite, use:
+
+```
+$ cargo test
+```
+
+from the repository root.

benchsuite/benchsuite

@@ -1157,6 +1157,7 @@ def collect_benchmarks(suite_dir, filter_pat=None,
                     name,
                     ' '.join(['--download %s' % n for n in e.missing_names]),
                 ))
+            continue
         except MissingCommands as e:
             fmt = 'missing commands: %s, skipping benchmark %s ' \
                   '(run with --allow-missing to run incomplete benchmarks)'

src/args.rs

@@ -35,13 +35,14 @@ use Result;
 /// If you've never heard of Docopt before, see: http://docopt.org
 /// (TL;DR: The CLI parser is generated from the usage string below.)
 const USAGE: &'static str = "
-Usage: rg [options] <pattern> [<path> ...]
+Usage: rg [options] -e PATTERN ... [<path> ...]
+       rg [options] <pattern> [<path> ...]
        rg [options] --files [<path> ...]
        rg [options] --type-list
        rg --help
        rg --version
 
-rg combines the usability of the silver search with the raw speed of grep.
+rg combines the usability of The Silver Searcher with the raw speed of grep.
 
 Common options:
     -a, --text                 Search binary files as if they were text.
@@ -49,6 +50,11 @@ Common options:
     --color WHEN               Whether to use coloring in match.
                                Valid values are never, always or auto.
                                [default: auto]
+    -e, --regexp PATTERN ...   Use PATTERN to search. This option can be
+                               provided multiple times, where all patterns
+                               given are searched.
+    -F, --fixed-strings        Treat the pattern as a literal string instead of
+                               a regular expression.
     -g, --glob GLOB ...        Include or exclude files for searching that
                                match the given glob. This always overrides any
                                other ignore logic. Multiple glob flags may be
@@ -134,9 +140,6 @@ Less common options:
     -p, --pretty
         Alias for --color=always --heading -n.
 
-    -Q, --literal
-        Treat the pattern as a literal string instead of a regular expression.
-
     -j, --threads ARG
         The number of threads to use. Defaults to the number of logical CPUs
         (capped at 6). [default: 0]
@@ -178,7 +181,7 @@ pub struct RawArgs {
     flag_ignore_case: bool,
     flag_invert_match: bool,
     flag_line_number: bool,
-    flag_literal: bool,
+    flag_fixed_strings: bool,
     flag_mmap: bool,
     flag_no_heading: bool,
     flag_no_ignore: bool,
@@ -187,6 +190,7 @@ pub struct RawArgs {
     flag_no_mmap: bool,
     flag_pretty: bool,
     flag_quiet: bool,
+    flag_regexp: Vec<String>,
     flag_replace: Option<String>,
     flag_text: bool,
     flag_threads: usize,
@@ -236,19 +240,7 @@ pub struct Args {
 impl RawArgs {
     /// Convert arguments parsed into a configuration used by ripgrep.
     fn to_args(&self) -> Result<Args> {
-        let pattern = {
-            let pattern =
-                if self.flag_literal {
-                    regex::quote(&self.arg_pattern)
-                } else {
-                    self.arg_pattern.clone()
-                };
-            if self.flag_word_regexp {
-                format!(r"\b{}\b", pattern)
-            } else {
-                pattern
-            }
-        };
+        let pattern = self.pattern();
         let paths =
             if self.arg_path.is_empty() {
                 if atty::on_stdin()
@@ -380,6 +372,34 @@ impl RawArgs {
         }
         Ok(())
     }
+
+    fn pattern(&self) -> String {
+        if !self.flag_regexp.is_empty() {
+            if self.flag_fixed_strings {
+                self.flag_regexp.iter().cloned().map(|lit| {
+                    self.word_pattern(regex::quote(&lit))
+                }).collect::<Vec<String>>().join("|")
+            } else {
+                self.flag_regexp.iter().cloned().map(|pat| {
+                    self.word_pattern(pat)
+                }).collect::<Vec<String>>().join("|")
+            }
+        } else {
+            if self.flag_fixed_strings {
+                self.word_pattern(regex::quote(&self.arg_pattern))
+            } else {
+                self.word_pattern(self.arg_pattern.clone())
+            }
+        }
+    }
+
+    fn word_pattern(&self, s: String) -> String {
+        if self.flag_word_regexp {
+            format!(r"\b{}\b", s)
+        } else {
+            s
+        }
+    }
 }
 
 impl Args {

tests/tests.rs

@@ -166,7 +166,7 @@ For the Doctor Watsons of this world, as opposed to the Sherlock
 
 sherlock!(literal, "()", "file", |wd: WorkDir, mut cmd: Command| {
     wd.create("file", "blib\n()\nblab\n");
-    cmd.arg("-Q");
+    cmd.arg("-F");
     let lines: String = wd.stdout(&mut cmd);
     assert_eq!(lines, "()\n");
 });