Normalize newlines

Cargo.toml

@@ -19,9 +19,10 @@ appveyor = { repository = "assert-rs/predicates-rs" }
 
 [dependencies]
 difference = { version = "2.0", optional = true }
+normalize-line-endings = { version = "0.2.2", optional = true }
 regex = { version="1.0", optional = true }
 float-cmp = { version="0.4", optional = true }
 
 [features]
-default = ["difference", "regex", "float-cmp"]
+default = ["difference", "regex", "float-cmp", "normalize-line-endings"]
 unstable = []

src/lib.rs

@@ -95,6 +95,8 @@
 extern crate difference;
 #[cfg(feature = "float-cmp")]
 extern crate float_cmp;
+#[cfg(feature = "normalize-line-endings")]
+extern crate normalize_line_endings;
 #[cfg(feature = "regex")]
 extern crate regex;
 

src/str/adapters.rs

@@ -1,8 +1,18 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/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::ffi;
 use std::fmt;
 use std::str;
 
 use Predicate;
+#[cfg(feature = "normalize-line-endings")]
+use str::normalize::NormalizedPredicate;
 
 /// Predicate adaper that trims the variable being tested.
 ///
@@ -111,6 +121,27 @@ where
     fn from_utf8(self) -> Utf8Predicate<Self> {
         Utf8Predicate { p: self }
     }
+
+    /// Returns a `NormalizedPredicate` that ensures
+    ///  the newlines within the data passed to `Self` is normalised.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::prelude::*;
+    /// 
+    /// let predicate_fn = predicate::eq("Hello World!\n").normalize();
+    /// assert_eq!(true, predicate_fn.eval("Hello World!\n"));
+    /// assert_eq!(true, predicate_fn.eval("Hello World!\r"));
+    /// assert_eq!(true, predicate_fn.eval("Hello World!\r\n"));
+    /// assert_eq!(false, predicate_fn.eval("Goodbye"));
+    /// ```
+    ///
+    #[cfg(feature = "normalize-line-endings")]
+    fn normalize(self) -> NormalizedPredicate<Self> {
+        NormalizedPredicate { p: self }
+    }
+
 }
 
 impl<P> PredicateStrExt for P

src/str/mod.rs

@@ -19,6 +19,10 @@ pub use self::adapters::*;
 mod difference;
 #[cfg(feature = "difference")]
 pub use self::difference::{diff, similar, DifferencePredicate};
+#[cfg(feature = "normalize-line-endings")]
+mod normalize;
+#[cfg(feature = "normalize-line-endings")]
+pub use self::normalize::NormalizedPredicate;
 
 #[cfg(feature = "regex")]
 mod regex;

src/str/normalize.rs

@@ -0,0 +1,42 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/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::fmt;
+use Predicate;
+
+use normalize_line_endings::normalized;
+use std::iter::FromIterator;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// Predicate adapter that normalizes the newlines contained in the variable being tested.
+///
+/// This is created by `pred.normalize()`.
+pub struct NormalizedPredicate<P>
+where
+    P: Predicate<str>,
+{
+    pub(crate) p: P,
+}
+
+impl<P> Predicate<str> for NormalizedPredicate<P>
+where
+    P: Predicate<str>,
+{
+    fn eval(&self, variable: &str) -> bool {
+        self.p.eval(&String::from_iter(normalized(variable.chars())))
+    }
+}
+
+impl<P> fmt::Display for NormalizedPredicate<P>
+where
+    P: Predicate<str>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.p)
+    }
+}