feat(str): Edit-distance predicate

This will be more helpful when assert-rs#7 is implemented.

Fixes assert-rs#9

Author: epage

Cargo.toml

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

src/lib.rs

@@ -85,6 +85,9 @@
 
 #![deny(missing_docs, missing_debug_implementations)]
 
+#[cfg(feature = "difference")]
+extern crate difference;
+
 // core `Predicate` trait
 pub mod predicate;
 pub use self::predicate::{BoxPredicate, Predicate};

src/predicate/mod.rs

@@ -22,6 +22,9 @@ pub use self::ord::{eq, ge, gt, le, lt, ne, EqPredicate, OrdPredicate};
 pub use self::set::{contains, contains_hashable, contains_ord, ContainsPredicate,
                     HashableContainsPredicate, OrdContainsPredicate};
 
+// specialized primitive `Predicate` types
+pub mod str;
+
 // combinators
 mod boolean;
 mod boxed;

src/predicate/str/difference.rs

@@ -0,0 +1,140 @@
+// 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 std::borrow;
+
+use difference;
+
+use Predicate;
+
+#[derive(Clone, Copy, Debug)]
+enum DistanceOp {
+    Similar,
+    Different,
+}
+
+impl DistanceOp {
+    fn eval(self, limit: i32, distance: i32) -> bool {
+        match self {
+            DistanceOp::Similar => distance <= limit,
+            DistanceOp::Different => limit < distance,
+        }
+    }
+}
+
+/// Predicate that diffs two strings.
+///
+/// This is created by the `predicate::str::similar`.
+#[derive(Clone, Debug)]
+pub struct DifferencePredicate {
+    orig: borrow::Cow<'static, str>,
+    split: borrow::Cow<'static, str>,
+    distance: i32,
+    op: DistanceOp,
+}
+
+impl DifferencePredicate {
+    /// The split used when identifying changes.
+    ///
+    /// Common splits include:
+    /// - `""` for char-level.
+    /// - `" "` for word-level.
+    /// - `"\n" for line-level.
+    ///
+    /// Default: `"\n"`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::predicate::*;
+    ///
+    /// let predicate_fn = str::similar("Hello World").split(" ");
+    /// assert_eq!(true, predicate_fn.eval("Hello World"));
+    /// ```
+    pub fn split<S>(mut self, split: S) -> Self
+    where
+        S: Into<borrow::Cow<'static, str>>,
+    {
+        self.split = split.into();
+        self
+    }
+
+    /// The maximum allowed edit distance.
+    ///
+    /// Default: `0`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::predicate::*;
+    ///
+    /// let predicate_fn = str::similar("Hello World!").split("").distance(1);
+    /// assert_eq!(true, predicate_fn.eval("Hello World!"));
+    /// assert_eq!(true, predicate_fn.eval("Hello World"));
+    /// assert_eq!(false, predicate_fn.eval("Hello World?"));
+    /// ```
+    pub fn distance(mut self, distance: i32) -> Self {
+        self.distance = distance;
+        self
+    }
+}
+
+impl Predicate for DifferencePredicate {
+    type Item = str;
+
+    fn eval(&self, edit: &str) -> bool {
+        let change = difference::Changeset::new(&self.orig, edit, &self.split);
+        self.op.eval(self.distance, change.distance)
+    }
+}
+
+/// Creates a new `Predicate` that diffs two strings.
+///
+/// # Examples
+///
+/// ```
+/// use predicates::predicate::*;
+///
+/// let predicate_fn = str::diff("Hello World");
+/// assert_eq!(false, predicate_fn.eval("Hello World"));
+/// assert_eq!(true, predicate_fn.eval("Goodbye World"));
+/// ```
+pub fn diff<S>(orig: S) -> DifferencePredicate
+where
+    S: Into<borrow::Cow<'static, str>>,
+{
+    DifferencePredicate {
+        orig: orig.into(),
+        split: "\n".into(),
+        distance: 0,
+        op: DistanceOp::Different,
+    }
+}
+
+/// Creates a new `Predicate` that checks strings for how similar they are.
+///
+/// # Examples
+///
+/// ```
+/// use predicates::predicate::*;
+///
+/// let predicate_fn = str::similar("Hello World");
+/// assert_eq!(true, predicate_fn.eval("Hello World"));
+/// assert_eq!(false, predicate_fn.eval("Goodbye World"));
+/// ```
+pub fn similar<S>(orig: S) -> DifferencePredicate
+where
+    S: Into<borrow::Cow<'static, str>>,
+{
+    DifferencePredicate {
+        orig: orig.into(),
+        split: "\n".into(),
+        distance: 0,
+        op: DistanceOp::Similar,
+    }
+}

src/predicate/str/mod.rs

@@ -0,0 +1,16 @@
+// 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.
+
+//! String Predicates
+//!
+//! This module contains predicates specifiuc to string handling.
+
+#[cfg(feature = "difference")]
+mod difference;
+#[cfg(feature = "difference")]
+pub use self::difference::{diff, similar, DifferencePredicate};