api: generalize Replacer impls

This causes the `Replacer` impls for closures to accept functions
that return any AsRef<str>/AsRef<[u8]> instead of String/Vec<u8>
specifically.

PR #509

Author: elidupree

src/re_bytes.rs

@@ -1065,7 +1065,8 @@ impl<'c, 't> Iterator for SubCaptureMatches<'c, 't> {
 ///
 /// In general, users of this crate shouldn't need to implement this trait,
 /// since implementations are already provided for `&[u8]` and
-/// `FnMut(&Captures) -> Vec<u8>`, which covers most use cases.
+/// `FnMut(&Captures) -> Vec<u8>` (or any `FnMut(&Captures) -> T`
+/// where `T: AsRef<[u8]>`), which covers most use cases.
 pub trait Replacer {
     /// Appends text to `dst` to replace the current match.
     ///
@@ -1141,9 +1142,9 @@ impl<'a> Replacer for &'a [u8] {
     }
 }
 
-impl<F> Replacer for F where F: FnMut(&Captures) -> Vec<u8> {
+impl<F, T> Replacer for F where F: FnMut(&Captures) -> T, T: AsRef<[u8]> {
     fn replace_append(&mut self, caps: &Captures, dst: &mut Vec<u8>) {
-        dst.extend_from_slice(&(*self)(caps));
+        dst.extend_from_slice((*self)(caps).as_ref());
     }
 }
 

src/re_unicode.rs

@@ -1107,7 +1107,8 @@ impl<'r, 't> Iterator for Matches<'r, 't> {
 ///
 /// In general, users of this crate shouldn't need to implement this trait,
 /// since implementations are already provided for `&str` and
-/// `FnMut(&Captures) -> String`, which covers most use cases.
+/// `FnMut(&Captures) -> String` (or any `FnMut(&Captures) -> T`
+/// where `T: AsRef<str>`), which covers most use cases.
 pub trait Replacer {
     /// Appends text to `dst` to replace the current match.
     ///
@@ -1183,9 +1184,9 @@ impl<'a> Replacer for &'a str {
     }
 }
 
-impl<F> Replacer for F where F: FnMut(&Captures) -> String {
+impl<F, T> Replacer for F where F: FnMut(&Captures) -> T, T: AsRef<str> {
     fn replace_append(&mut self, caps: &Captures, dst: &mut String) {
-        dst.push_str(&(*self)(caps));
+        dst.push_str((*self)(caps).as_ref());
     }
 }
 

tests/macros_bytes.rs

@@ -2,6 +2,7 @@
 macro_rules! text { ($text:expr) => { $text.as_bytes() } }
 macro_rules! t { ($re:expr) => { text!($re) } }
 macro_rules! match_text { ($text:expr) => { $text.as_bytes() } }
+macro_rules! use_ { ($($path: tt)*) => { use regex::bytes::$($path)*; } }
 
 macro_rules! bytes { ($text:expr) => { $text } }
 

tests/macros_str.rs

@@ -2,6 +2,7 @@
 macro_rules! text { ($text:expr) => { $text } }
 macro_rules! t { ($text:expr) => { text!($text) } }
 macro_rules! match_text { ($text:expr) => { $text.as_str() } }
+macro_rules! use_ { ($($path: tt)*) => { use regex::$($path)*; } }
 
 macro_rules! no_expand {
     ($text:expr) => {{

tests/replace.rs

@@ -33,6 +33,12 @@ replace!(no_expand1, replace,
          r"(\S+)\s+(\S+)", "w1 w2", no_expand!("$2 $1"), "$2 $1");
 replace!(no_expand2, replace,
          r"(\S+)\s+(\S+)", "w1 w2", no_expand!("$$1"), "$$1");
+use_!(Captures);
+replace!(closure_returning_reference, replace, r"(\d+)", "age: 26",
+         | captures: &Captures | &match_text!(captures.get(1).unwrap())[0..1], "age: 2");
+replace!(closure_returning_value, replace, r"\d+", "age: 26",
+         | _captures: &Captures | t!("Z").to_owned(), "age: Z");
+
 
 // See https://github.com/rust-lang/regex/issues/314
 replace!(match_at_start_replace_with_empty, replace_all, r"foo", "foobar", t!(""), "bar");