Add RegexSetBuilder.

This API mirrors RegexBuilder, but for multiple patterns.

Also, modify regex-capi to use RegexSetBuilder internally.

Author: BurntSushi

regex-capi/ctest/test.c

@@ -200,8 +200,8 @@ bool test_iter_capture_name(char *expect, char *given) {
     if (strcmp(expect, given)) {
         if (DEBUG) {
             fprintf(stderr,
-                    "[test_iter_capture_name] expected first capture name '%s' "
-                    "got '%s'\n",
+                    "[test_iter_capture_name] expected first capture "
+                    "name '%s' got '%s'\n",
                     expect, given);
         }
         passed = false;
@@ -213,14 +213,16 @@ bool test_iter_capture_names() {
     bool passed = true;
 
     char *name;
-    rure *re = rure_compile_must("(?P<year>\\d{4})-(?P<month>\\d{2})-(?P<day>\\d{2})");
+    rure *re = rure_compile_must(
+        "(?P<year>\\d{4})-(?P<month>\\d{2})-(?P<day>\\d{2})");
     rure_iter_capture_names *it = rure_iter_capture_names_new(re);
 
     bool result = rure_iter_capture_names_next(it, &name);
     if (!result) {
         if (DEBUG) {
             fprintf(stderr,
-                    "[test_iter_capture_names] expected a second name, but got none\n");
+                    "[test_iter_capture_names] expected a second name, "
+                    "but got none\n");
         }
         passed = false;
         goto done;
@@ -426,14 +428,14 @@ bool test_regex_set_match_start() {
         goto done1;
     }
 
-    if (rure_set_is_match(re, (const uint8_t *) "foobiasdr", 7, 2)) {
+    if (rure_set_is_match(re, (const uint8_t *)"foobiasdr", 7, 2)) {
         passed = false;
         goto done1;
     }
 
     {
         bool matches[PAT_COUNT];
-        if (!rure_set_matches(re, (const uint8_t *) "fooobar", 8, 0, matches)) {
+        if (!rure_set_matches(re, (const uint8_t *)"fooobar", 8, 0, matches)) {
             passed = false;
             goto done1;
         }
@@ -453,7 +455,7 @@ bool test_regex_set_match_start() {
 
     {
         bool matches[PAT_COUNT];
-        if (!rure_set_matches(re, (const uint8_t *) "fooobar", 7, 1, matches)) {
+        if (!rure_set_matches(re, (const uint8_t *)"fooobar", 7, 1, matches)) {
             passed = false;
             goto done1;
         }
@@ -490,8 +492,8 @@ bool test_regex_set_options() {
     const char *patterns[] = { "\\w{100}" };
     const size_t patterns_lengths[] = { 8 };
 
-    rure_set *re = rure_compile_set((const uint8_t **) patterns, patterns_lengths,
-                                    1, 0, opts, err);
+    rure_set *re = rure_compile_set(
+        (const uint8_t **) patterns, patterns_lengths, 1, 0, opts, err);
     if (re != NULL) {
         if (DEBUG) {
             fprintf(stderr,
@@ -540,7 +542,8 @@ int main() {
              &passed);
     run_test(test_regex_set_matches, "test_regex_set_match", &passed);
     run_test(test_regex_set_options, "test_regex_set_options", &passed);
-    run_test(test_regex_set_match_start, "test_regex_set_match_start", &passed);
+    run_test(test_regex_set_match_start, "test_regex_set_match_start",
+             &passed);
 
     if (!passed) {
         exit(1);

regex-capi/src/rure.rs

@@ -1,17 +1,22 @@
-use ::error::{Error, ErrorKind};
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::ffi::{CStr, CString};
+use std::ptr;
+use std::str;
+use std::slice;
 
-use ::regex::bytes;
-use ::regex::internal::{Exec, ExecBuilder, RegexOptions};
-use ::regex::internal::RegularExpression;
-use ::libc::{c_char, size_t};
+use libc::{c_char, size_t};
+use regex::bytes;
 
-use ::std::collections::HashMap;
-use ::std::ops::Deref;
-use ::std::ffi::{CStr, CString};
-use ::std::ptr;
-use ::std::str;
-use ::std::slice;
+use error::{Error, ErrorKind};
 
+const RURE_FLAG_CASEI: u32 = 1 << 0;
+const RURE_FLAG_MULTI: u32 = 1 << 1;
+const RURE_FLAG_DOTNL: u32 = 1 << 2;
+const RURE_FLAG_SWAP_GREED: u32 = 1 << 3;
+const RURE_FLAG_SPACE: u32 = 1 << 4;
+const RURE_FLAG_UNICODE: u32 = 1 << 5;
+const RURE_DEFAULT_FLAGS: u32 = RURE_FLAG_UNICODE;
 
 pub struct Regex {
     re: bytes::Regex,
@@ -27,19 +32,9 @@ pub struct Options {
 // arbitrary position with a crate just yet. To circumvent this, we use
 // the `Exec` structure directly.
 pub struct RegexSet {
-    re: Exec,
-    pattern_count: usize
+    re: bytes::RegexSet,
 }
 
-const RURE_FLAG_CASEI: u32 = 1 << 0;
-const RURE_FLAG_MULTI: u32 = 1 << 1;
-const RURE_FLAG_DOTNL: u32 = 1 << 2;
-const RURE_FLAG_SWAP_GREED: u32 = 1 << 3;
-const RURE_FLAG_SPACE: u32 = 1 << 4;
-const RURE_FLAG_UNICODE: u32 = 1 << 5;
-const RURE_DEFAULT_FLAGS: u32 = RURE_FLAG_UNICODE;
-
-
 #[repr(C)]
 pub struct rure_match {
     pub start: size_t,
@@ -65,8 +60,8 @@ impl Deref for Regex {
 }
 
 impl Deref for RegexSet {
-    type Target = Exec;
-    fn deref(&self) -> &Exec { &self.re }
+    type Target = bytes::RegexSet;
+    fn deref(&self) -> &bytes::RegexSet { &self.re }
 }
 
 impl Default for Options {
@@ -501,37 +496,21 @@ ffi_fn! {
             });
         }
 
-        // Start with a default set and override values if present.
-        let mut opts = RegexOptions::default();
-        let pat_count = pats.len();
-        opts.pats = pats.into_iter().map(|s| s.to_owned()).collect();
-
+        let mut builder = bytes::RegexSetBuilder::new(pats);
         if !options.is_null() {
             let options = unsafe { &*options };
-            opts.size_limit = options.size_limit;
-            opts.dfa_size_limit = options.dfa_size_limit;
+            builder.size_limit(options.size_limit);
+            builder.dfa_size_limit(options.dfa_size_limit);
         }
-
-        opts.case_insensitive = flags & RURE_FLAG_CASEI > 0;
-        opts.multi_line = flags & RURE_FLAG_MULTI > 0;
-        opts.dot_matches_new_line = flags & RURE_FLAG_DOTNL > 0;
-        opts.swap_greed = flags & RURE_FLAG_SWAP_GREED > 0;
-        opts.ignore_whitespace = flags & RURE_FLAG_SPACE > 0;
-        opts.unicode = flags & RURE_FLAG_UNICODE > 0;
-
-        // `Exec` does not expose a `new` function with appropriate arguments
-        // so we construct directly.
-        let builder = ExecBuilder::new_options(opts)
-                                    .bytes(true)
-                                    .only_utf8(false);
-
+        builder.case_insensitive(flags & RURE_FLAG_CASEI > 0);
+        builder.multi_line(flags & RURE_FLAG_MULTI > 0);
+        builder.dot_matches_new_line(flags & RURE_FLAG_DOTNL > 0);
+        builder.swap_greed(flags & RURE_FLAG_SWAP_GREED > 0);
+        builder.ignore_whitespace(flags & RURE_FLAG_SPACE > 0);
+        builder.unicode(flags & RURE_FLAG_UNICODE > 0);
         match builder.build() {
-            Ok(ex) => {
-                let re = RegexSet {
-                    re: ex,
-                    pattern_count: pat_count
-                };
-                Box::into_raw(Box::new(re))
+            Ok(re) => {
+                Box::into_raw(Box::new(RegexSet { re: re }))
             }
             Err(err) => {
                 unsafe {
@@ -560,7 +539,7 @@ ffi_fn! {
     ) -> bool {
         let re = unsafe { &*re };
         let haystack = unsafe { slice::from_raw_parts(haystack, len) };
-        re.searcher().is_match_at(haystack, start)
+        re.is_match_at(haystack, start)
     }
 }
 
@@ -574,21 +553,20 @@ ffi_fn! {
     ) -> bool {
         let re = unsafe { &*re };
         let mut matches = unsafe {
-            slice::from_raw_parts_mut(matches, re.pattern_count)
+            slice::from_raw_parts_mut(matches, re.len())
         };
         let haystack = unsafe { slice::from_raw_parts(haystack, len) };
 
-        // many_matches_at isn't guaranteed to set non-matches to false
+        // read_matches_at isn't guaranteed to set non-matches to false
         for item in matches.iter_mut() {
             *item = false;
         }
-
-        re.searcher().many_matches_at(&mut matches, haystack, start)
+        re.read_matches_at(&mut matches, haystack, start)
     }
 }
 
 ffi_fn! {
     fn rure_set_len(re: *const RegexSet) -> size_t {
-        unsafe { (*re).pattern_count }
+        unsafe { (*re).len() }
     }
 }

src/lib.rs

@@ -459,6 +459,7 @@ extern crate utf8_ranges;
 
 pub use error::Error;
 pub use re_builder::unicode::*;
+pub use re_builder::set_unicode::*;
 pub use re_set::unicode::*;
 pub use re_trait::Locations;
 pub use re_unicode::{
@@ -556,6 +557,7 @@ performance on `&str`.
 */
 pub mod bytes {
     pub use re_builder::bytes::*;
+    pub use re_builder::set_bytes::*;
     pub use re_bytes::*;
     pub use re_set::bytes::*;
     pub use re_trait::Locations;
@@ -600,6 +602,4 @@ pub mod internal {
     pub use prog::{Program, Inst, EmptyLook, InstRanges};
     pub use re_plugin::Plugin;
     pub use re_unicode::_Regex;
-    pub use re_trait::RegularExpression;
-    pub use re_builder::RegexOptions;
 }

src/re_builder.rs

@@ -152,3 +152,116 @@ impl RegexBuilder {
 
 define_builder!(bytes, re_bytes, false);
 define_builder!(unicode, re_unicode, true);
+
+macro_rules! define_set_builder {
+    ($name:ident, $regex_mod:ident, $only_utf8:expr) => {
+        pub mod $name {
+            use error::Error;
+            use exec::ExecBuilder;
+            use super::RegexOptions;
+
+            use re_set::$regex_mod::RegexSet;
+
+/// A configurable builder for a set of regular expressions.
+///
+/// A builder can be used to configure how the regexes are built, for example,
+/// by setting the default flags (which can be overridden in the expression
+/// itself) or setting various limits.
+pub struct RegexSetBuilder(RegexOptions);
+
+impl RegexSetBuilder {
+    /// Create a new regular expression builder with the given pattern.
+    ///
+    /// If the pattern is invalid, then an error will be returned when
+    /// `compile` is called.
+    pub fn new<I, S>(patterns: I) -> RegexSetBuilder
+            where S: AsRef<str>, I: IntoIterator<Item=S> {
+        let mut builder = RegexSetBuilder(RegexOptions::default());
+        for pat in patterns {
+            builder.0.pats.push(pat.as_ref().to_owned());
+        }
+        builder
+    }
+
+    /// Consume the builder and compile the regular expressions into a set.
+    pub fn build(&self) -> Result<RegexSet, Error> {
+        ExecBuilder::new_options(self.0.clone())
+            .only_utf8($only_utf8)
+            .build()
+            .map(RegexSet::from)
+    }
+
+    /// Set the value for the case insensitive (`i`) flag.
+    pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.case_insensitive = yes;
+        self
+    }
+
+    /// Set the value for the multi-line matching (`m`) flag.
+    pub fn multi_line(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.multi_line = yes;
+        self
+    }
+
+    /// Set the value for the any character (`s`) flag, where in `.` matches
+    /// anything when `s` is set and matches anything except for new line when
+    /// it is not set (the default).
+    ///
+    /// N.B. "matches anything" means "any byte" for `regex::bytes::RegexSet`
+    /// expressions and means "any Unicode codepoint" for `regex::RegexSet`
+    /// expressions.
+    pub fn dot_matches_new_line(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.dot_matches_new_line = yes;
+        self
+    }
+
+    /// Set the value for the greedy swap (`U`) flag.
+    pub fn swap_greed(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.swap_greed = yes;
+        self
+    }
+
+    /// Set the value for the ignore whitespace (`x`) flag.
+    pub fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.ignore_whitespace = yes;
+        self
+    }
+
+    /// Set the value for the Unicode (`u`) flag.
+    ///
+    /// For byte based regular expressions, this is disabled by default.
+    pub fn unicode(&mut self, yes: bool) -> &mut RegexSetBuilder {
+        self.0.unicode = yes;
+        self
+    }
+
+    /// Set the approximate size limit of the compiled regular expression.
+    ///
+    /// This roughly corresponds to the number of bytes occupied by a single
+    /// compiled program. If the program exceeds this number, then a
+    /// compilation error is returned.
+    pub fn size_limit(&mut self, limit: usize) -> &mut RegexSetBuilder {
+        self.0.size_limit = limit;
+        self
+    }
+
+    /// Set the approximate size of the cache used by the DFA.
+    ///
+    /// This roughly corresponds to the number of bytes that the DFA will
+    /// use while searching.
+    ///
+    /// Note that this is a *per thread* limit. There is no way to set a global
+    /// limit. In particular, if a regex is used from multiple threads
+    /// simulanteously, then each thread may use up to the number of bytes
+    /// specified here.
+    pub fn dfa_size_limit(&mut self, limit: usize) -> &mut RegexSetBuilder {
+        self.0.dfa_size_limit = limit;
+        self
+    }
+}
+        }
+    }
+}
+
+define_set_builder!(set_bytes, bytes, false);
+define_set_builder!(set_unicode, unicode, true);