feat(str): Regex predicate

This is a short term API.  Different issues we'll need to consider when
evolving this include:
- Easy to create predicate
- The ability to customize the regex (e.g. case sensitivity, multi-line,
  ignoring whityespace).
  - It looks like the flags can be enabled with `(?flag)` inside the
    regex. Good enough?
- How error handling should work. Re-export? A single error type for
  the whole crate?

This is a part of assert-rs#12

Author: epage

Cargo.toml

@@ -19,7 +19,8 @@ appveyor = { repository = "assert-rs/predicates-rs" }
 
 [dependencies]
 difference = { version = "2.0", optional = true }
+regex = { version="0.2", optional = true }
 
 [features]
-default = ["difference"]
+default = ["difference", "regex"]
 unstable = []

src/lib.rs

@@ -87,6 +87,8 @@
 
 #[cfg(feature = "difference")]
 extern crate difference;
+#[cfg(feature = "regex")]
+extern crate regex;
 
 // core `Predicate` trait
 pub mod predicate;

src/predicate/str/mod.rs

@@ -14,3 +14,8 @@
 mod difference;
 #[cfg(feature = "difference")]
 pub use self::difference::{diff, similar, DifferencePredicate};
+
+#[cfg(feature = "regex")]
+mod regex;
+#[cfg(feature = "regex")]
+pub use self::regex::{is_match, RegexError, RegexPredicate};

src/predicate/str/regex.rs

@@ -0,0 +1,48 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use regex;
+
+use Predicate;
+
+/// An error that occurred during parsing or compiling a regular expression.
+pub type RegexError = regex::Error;
+
+/// Predicate that uses regex matching
+///
+/// This is created by the `predicate::str::is_match`.
+#[derive(Clone, Debug)]
+pub struct RegexPredicate {
+    re: regex::Regex,
+}
+
+impl Predicate for RegexPredicate {
+    type Item = str;
+
+    fn eval(&self, variable: &str) -> bool {
+        self.re.is_match(variable)
+    }
+}
+
+/// Creates a new `Predicate` that uses a regular expression to match the string.
+///
+/// # Examples
+///
+/// ```
+/// use predicates::predicate::*;
+///
+/// let predicate_fn = str::is_match("^Hel.o.*$").unwrap();
+/// assert_eq!(true, predicate_fn.eval("Hello World"));
+/// assert_eq!(false, predicate_fn.eval("Food World"));
+/// ```
+pub fn is_match<S>(pattern: S) -> Result<RegexPredicate, RegexError>
+where
+    S: AsRef<str>,
+{
+    regex::Regex::new(pattern.as_ref()).map(|re| RegexPredicate { re })
+}