Added normalize_newlines adapter predicate

Created normalize file and added normalize-line-endings as default dependency
Created normalize trim predicate
Issue assert-rs#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)

Author: kammitama5

Cargo.toml

@@ -24,5 +24,5 @@ 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,8 +95,8 @@
 extern crate difference;
 #[cfg(feature = "float-cmp")]
 extern crate float_cmp;
-#[cfg(feature = "normalized-line-endings")]
-extern crate normalized_line_endings;
+#[cfg(feature = "normalize-line-endings")]
+extern crate normalize_line_endings;
 #[cfg(feature = "regex")]
 extern crate regex;
 

src/str/adapters.rs

@@ -1,8 +1,17 @@
+// 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 self::normalized::NormalizedTrimPredicate;
+
 use Predicate;
+use str::normalize::NormalizedPredicate;
 
 /// Predicate adaper that trims the variable being tested.
 ///
@@ -111,10 +120,25 @@ where
     fn from_utf8(self) -> Utf8Predicate<Self> {
         Utf8Predicate { p: self }
     }
-    /// Returns a `NormalizedTrimPredicate` that ensures the data passed
-    /// to `Self` is trimmed and Normalized.
-    fn normalized_trim(self) -> NormalizedTrimPredicate<Self> {
-        NormalizedTrimPredicate { 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 }
     }
 
 }

src/str/mod.rs

@@ -19,11 +19,10 @@ pub use self::adapters::*;
 mod difference;
 #[cfg(feature = "difference")]
 pub use self::difference::{diff, similar, DifferencePredicate};
-// need to double check this part
-#[cfg(feature = "normalized-line-endings")]
+#[cfg(feature = "normalize-line-endings")]
 mod normalize;
-#[cfg(feature = "normalized-line-endings")]
-pub use normalized_line_endings::normalized;
+#[cfg(feature = "normalize-line-endings")]
+pub use self::normalize::NormalizedPredicate;
 
 #[cfg(feature = "regex")]
 mod regex;

src/str/normalize.rs

@@ -1,24 +1,38 @@
+// 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)]
-pub struct NormalizedTrimPredicate<P>
+/// Predicate adapter that normalizes the newlines contained in the variable being tested.
+///
+/// This is created by `pred.normalized()`.
+pub struct NormalizedPredicate<P>
 where
     P: Predicate<str>,
 {
-    p: P,
+    pub(crate) p: P,
 }
 
-impl<P> Predicate<str> for NormalizedTrimPredicate<P>
+impl<P> Predicate<str> for NormalizedPredicate<P>
 where
     P: Predicate<str>,
 {
     fn eval(&self, variable: &str) -> bool {
-        self.p.eval(variable.normalised())
+        self.p.eval(&String::from_iter(normalized(variable.chars())))
     }
 }
 
-impl<P> fmt::Display for NormalizedTrimPredicate<P>
+impl<P> fmt::Display for NormalizedPredicate<P>
 where
     P: Predicate<str>,
 {