Switch to more idiomatic builder definition.

Specifically, use mutable references instead of passing ownership.

Author: BurntSushi

regex-capi/src/rure.rs

@@ -118,16 +118,16 @@ ffi_fn! {
         let mut builder = bytes::RegexBuilder::new(pat);
         if !options.is_null() {
             let options = unsafe { &*options };
-            builder = builder.size_limit(options.size_limit);
-            builder = builder.dfa_size_limit(options.dfa_size_limit);
+            builder.size_limit(options.size_limit);
+            builder.dfa_size_limit(options.dfa_size_limit);
         }
-        builder = builder.case_insensitive(flags & RURE_FLAG_CASEI > 0);
-        builder = builder.multi_line(flags & RURE_FLAG_MULTI > 0);
-        builder = builder.dot_matches_new_line(flags & RURE_FLAG_DOTNL > 0);
-        builder = builder.swap_greed(flags & RURE_FLAG_SWAP_GREED > 0);
-        builder = builder.ignore_whitespace(flags & RURE_FLAG_SPACE > 0);
-        builder = builder.unicode(flags & RURE_FLAG_UNICODE > 0);
-        match builder.compile() {
+        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(re) => {
                 let mut capture_names = HashMap::new();
                 for (i, name) in re.capture_names().enumerate() {

src/re_builder.rs

@@ -71,21 +71,21 @@ impl RegexBuilder {
     /// Note that calling `as_str` on the resulting `Regex` will produce the
     /// pattern given to `new` verbatim. Notably, it will not incorporate any
     /// of the flags set on this builder.
-    pub fn compile(self) -> Result<Regex, Error> {
-        ExecBuilder::new_options(self.0)
+    pub fn build(&self) -> Result<Regex, Error> {
+        ExecBuilder::new_options(self.0.clone())
             .only_utf8($only_utf8)
             .build()
             .map(Regex::from)
     }
 
     /// Set the value for the case insensitive (`i`) flag.
-    pub fn case_insensitive(mut self, yes: bool) -> RegexBuilder {
+    pub fn case_insensitive(&mut self, yes: bool) -> &mut RegexBuilder {
         self.0.case_insensitive = yes;
         self
     }
 
     /// Set the value for the multi-line matching (`m`) flag.
-    pub fn multi_line(mut self, yes: bool) -> RegexBuilder {
+    pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
         self.0.multi_line = yes;
         self
     }
@@ -97,27 +97,27 @@ impl RegexBuilder {
     /// N.B. "matches anything" means "any byte" for `regex::bytes::Regex`
     /// expressions and means "any Unicode codepoint" for `regex::Regex`
     /// expressions.
-    pub fn dot_matches_new_line(mut self, yes: bool) -> RegexBuilder {
+    pub fn dot_matches_new_line(&mut self, yes: bool) -> &mut RegexBuilder {
         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) -> RegexBuilder {
+    pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
         self.0.swap_greed = yes;
         self
     }
 
     /// Set the value for the ignore whitespace (`x`) flag.
-    pub fn ignore_whitespace(mut self, yes: bool) -> RegexBuilder {
+    pub fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexBuilder {
         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) -> RegexBuilder {
+    pub fn unicode(&mut self, yes: bool) -> &mut RegexBuilder {
         self.0.unicode = yes;
         self
     }
@@ -127,7 +127,7 @@ impl RegexBuilder {
     /// 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) -> RegexBuilder {
+    pub fn size_limit(&mut self, limit: usize) -> &mut RegexBuilder {
         self.0.size_limit = limit;
         self
     }
@@ -141,7 +141,7 @@ impl RegexBuilder {
     /// 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) -> RegexBuilder {
+    pub fn dfa_size_limit(&mut self, limit: usize) -> &mut RegexBuilder {
         self.0.dfa_size_limit = limit;
         self
     }

src/re_bytes.rs

@@ -117,7 +117,7 @@ impl Regex {
     ///
     /// If an invalid expression is given, then an error is returned.
     pub fn new(re: &str) -> Result<Regex, Error> {
-        RegexBuilder::new(re).compile()
+        RegexBuilder::new(re).build()
     }
 
     /// Returns true if and only if the regex matches the string given.

src/re_unicode.rs

@@ -182,7 +182,7 @@ impl Regex {
     ///
     /// If an invalid expression is given, then an error is returned.
     pub fn new(re: &str) -> Result<Regex, Error> {
-        RegexBuilder::new(re).compile()
+        RegexBuilder::new(re).build()
     }
 
     /// Returns true if and only if the regex matches the string given.