Add imports and modify mod.rs, adapter.rs and normalize.rs

Resolve adapter.rs

Added normalize_newlines adapter predicate

Created normalize file and added normalize-line-endings as default dependency
Created normalize trim predicate
Fixes #45

Normalize newlines

- Insert newline in adapter.rs for readability
- Add example code in adapter.rs for usability
- Add self to mod.rs
- Change to NormalizedPredicate in normalize.rs to avoid ambiguity

Normalize newlines syntax clean-up

Make comments "///" instead of "//" for consistency
Improve readability by making one commented block for function in adapter.rs
Delete extraneous whitespace for readability

Normalize NewLines

Add copyright notice to adapters.rs and normalize.rs

Amend doc tests for passing CI

Normalize NewLines passes all tests

Struct documentation added for NormalizedPredicate
Assert tests fixed in adapters.rs (string assertions did not match)

change struct description to pred.normalize() for consistency

Add Cfg feature to NormalizedPredicate in adapter.rs

Author: kammitama5

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)
+    }
+}