Update to regex 0.2.

4 files changed, 18 insertions, 12 deletions

diff --git a/grep/Cargo.toml b/grep/Cargo.toml
index 8f7f3aae..8ac92bf9 100644
--- a/grep/Cargo.toml
+++ b/grep/Cargo.toml
@@ -15,5 +15,5 @@ license = "Unlicense/MIT"
 [dependencies]
 log = "0.3"
 memchr = "1"
-regex = "0.1.77"
-regex-syntax = "0.3.9"
+regex = "0.2.0"
+regex-syntax = "0.4.0"
diff --git a/grep/src/lib.rs b/grep/src/lib.rs
index 1fd01269..3b2f0ebd 100644
--- a/grep/src/lib.rs
+++ b/grep/src/lib.rs
@@ -78,6 +78,6 @@ impl From<regex::Error> for Error {
 
 impl From<syntax::Error> for Error {
     fn from(err: syntax::Error) -> Error {
-        Error::Regex(regex::Error::Syntax(err))
+        Error::Regex(regex::Error::Syntax(err.to_string()))
     }
 }
diff --git a/grep/src/literals.rs b/grep/src/literals.rs
index 3e68d24e..eebeac4c 100644
--- a/grep/src/literals.rs
+++ b/grep/src/literals.rs
@@ -79,12 +79,16 @@ impl LiteralSets {
             debug!("required literals found: {:?}", req_lits);
             let alts: Vec<String> =
                 req_lits.into_iter().map(|x| bytes_to_regex(x)).collect();
-            Some(RegexBuilder::new(&alts.join("|")).unicode(false))
+            let mut builder = RegexBuilder::new(&alts.join("|"));
+            builder.unicode(false);
+            Some(builder)
         } else if lit.is_empty() {
             None
         } else {
             debug!("required literal found: {:?}", show(lit));
-            Some(RegexBuilder::new(&bytes_to_regex(&lit)).unicode(false))
+            let mut builder = RegexBuilder::new(&bytes_to_regex(&lit));
+            builder.unicode(false);
+            Some(builder)
         }
     }
 }
diff --git a/grep/src/search.rs b/grep/src/search.rs
index cf1a4c3f..498df0c1 100644
--- a/grep/src/search.rs
+++ b/grep/src/search.rs
@@ -167,16 +167,18 @@ impl GrepBuilder {
     /// Creates a new regex from the given expression with the current
     /// configuration.
     fn regex(&self, expr: &Expr) -> Result<Regex> {
-        self.regex_build(RegexBuilder::new(&expr.to_string()).unicode(true))
+        let mut builder = RegexBuilder::new(&expr.to_string());
+        builder.unicode(true);
+        self.regex_build(builder)
     }
 
     /// Builds a new regex from the given builder using the caller's settings.
-    fn regex_build(&self, builder: RegexBuilder) -> Result<Regex> {
+    fn regex_build(&self, mut builder: RegexBuilder) -> Result<Regex> {
         builder
             .multi_line(true)
             .size_limit(self.opts.size_limit)
             .dfa_size_limit(self.opts.dfa_size_limit)
-            .compile()
+            .build()
             .map_err(From::from)
     }
 
@@ -368,11 +370,11 @@ mod tests {
     fn find_lines(pat: &str, haystack: &[u8]) -> Vec<Match> {
         let re = Regex::new(pat).unwrap();
         let mut lines = vec![];
-        for (s, e) in re.find_iter(haystack) {
-            let start = memrchr(b'\n', &haystack[..s])
+        for m in re.find_iter(haystack) {
+            let start = memrchr(b'\n', &haystack[..m.start()])
                         .map_or(0, |i| i + 1);
-            let end = memchr(b'\n', &haystack[e..])
-                      .map_or(haystack.len(), |i| e + i + 1);
+            let end = memchr(b'\n', &haystack[m.end()..])
+                      .map_or(haystack.len(), |i| m.end() + i + 1);
             lines.push(Match {
                 start: start,
                 end: end,