feat(output): Generic predicate support

This accepts a message with it.  This should hit the 90% case of a
`satisfies_ok` (or whatever it'd be called).

I'm also assuming that it'll be a best practice to document the custom
predicates, so its acceptable to force it on everyone.

If a `satisfies_ok` is found to be needed, I'm assuming its because the
user wants to tie into existing machinery that has error reporting.  This
means we'll probably need to accept an `Fn` that `Box`es the error to
preserve it.

Fixes assert-rs#55

Author: epage

src/assert.rs

@@ -475,6 +475,26 @@ impl OutputAssertionBuilder {
         self.assertion.expect_output.push(pred);
         self.assertion
     }
+
+    /// Expect the command output to satisfy the given predicate.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// extern crate assert_cli;
+    ///
+    /// assert_cli::Assert::command(&["echo", "-n", "42"])
+    ///     .stdout().satisfies(|x| x.len() == 2, "bad length")
+    ///     .unwrap();
+    /// ```
+    pub fn satisfies<F, M>(mut self, pred: F, msg: M) -> Assert
+        where F: 'static + Fn(&str) -> bool,
+              M: Into<String>
+    {
+        let pred = OutputPredicate::new(self.kind, Output::satisfies(pred, msg));
+        self.assertion.expect_output.push(pred);
+        self.assertion
+    }
 }
 
 #[cfg(test)]

src/output.rs

@@ -1,8 +1,12 @@
+use std::fmt;
+use std::process;
+use std::rc;
+
+use difference::Changeset;
+
+use diff;
 use self::errors::*;
 pub use self::errors::{Error, ErrorKind};
-use diff;
-use difference::Changeset;
-use std::process;
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -57,17 +61,42 @@ impl ContainsPredicate {
     }
 }
 
+#[derive(Clone)]
+struct FnPredicate {
+    pub pred: rc::Rc<Fn(&str) -> bool>,
+    pub msg: String,
+}
+
+impl FnPredicate {
+    pub fn verify_str(&self, got: &str) -> Result<()> {
+        let pred = &self.pred;
+        if ! pred(got) {
+            bail!(ErrorKind::PredicateFailed(got.into(), self.msg.clone()));
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for FnPredicate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
 #[derive(Debug, Clone)]
 enum StrPredicate {
     Is(IsPredicate),
     Contains(ContainsPredicate),
+	Fn(FnPredicate),
 }
 
 impl StrPredicate {
     pub fn verify_str(&self, got: &str) -> Result<()> {
         match *self {
             StrPredicate::Is(ref pred) => pred.verify_str(got),
             StrPredicate::Contains(ref pred) => pred.verify_str(got),
+            StrPredicate::Fn(ref pred) => pred.verify_str(got),
         }
     }
 }
@@ -159,6 +188,28 @@ impl Output {
         Self::new(StrPredicate::Is(pred))
     }
 
+    /// Expect the command output to satisfy the given predicate.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// extern crate assert_cli;
+    ///
+    /// assert_cli::Assert::command(&["echo", "-n", "42"])
+    ///     .stdout().satisfies(|x| x.len() == 2, "bad length")
+    ///     .unwrap();
+    /// ```
+    pub fn satisfies<F, M>(pred: F, msg: M) -> Self
+        where F: 'static + Fn(&str) -> bool,
+              M: Into<String>
+    {
+        let pred = FnPredicate {
+            pred: rc::Rc::new(pred),
+            msg: msg.into(),
+        };
+        Self::new(StrPredicate::Fn(pred))
+    }
+
     fn new(pred: StrPredicate) -> Self {
         Self { pred }
     }
@@ -232,6 +283,10 @@ mod errors {
                 description("Output was not as expected")
                 display("expected to not match\noutput=```{}```", got)
             }
+            PredicateFailed(got: String, msg: String) {
+                description("Output predicate failed")
+                display("{}\noutput=```{}```", msg, got)
+            }
             OutputMismatch(kind: super::OutputKind) {
                 description("Output was not as expected")
                 display(