WIP: Pretty error printer for predicates.

Cargo.toml

@@ -21,6 +21,7 @@ appveyor = { repository = "assert-rs/predicates-rs" }
 difference = { version = "2.0", optional = true }
 regex = { version="1.0", optional = true }
 float-cmp = { version="0.4", optional = true }
+treeline = { version = "0.1", optional = true }
 
 [features]
 default = ["difference", "regex", "float-cmp"]

examples/tree_eval.rs

@@ -0,0 +1,9 @@
+extern crate predicates;
+
+fn main() {
+    use predicates::prelude::*;
+    let predicate_fn = predicate::ne(5).not().and(predicate::ge(5));
+
+    let (result, output) = predicate_fn.tree_eval(&5);
+    println!("{}", output);
+}

src/boolean.rs

@@ -11,6 +11,9 @@
 use std::marker::PhantomData;
 use std::fmt;
 
+#[cfg(feature = "treeline")]
+use treeline::Tree;
+
 use Predicate;
 
 /// Predicate that combines two `Predicate`s, returning the AND of the results.
@@ -21,7 +24,7 @@ pub struct AndPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     a: M1,
     b: M2,
@@ -32,7 +35,7 @@ impl<M1, M2, Item> AndPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     /// Create a new `AndPredicate` over predicates `a` and `b`.
     pub fn new(a: M1, b: M2) -> AndPredicate<M1, M2, Item> {
@@ -48,18 +51,37 @@ impl<M1, M2, Item> Predicate<Item> for AndPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn eval(&self, item: &Item) -> bool {
         self.a.eval(item) && self.b.eval(item)
     }
+
+    #[cfg(feature = "treeline")]
+    fn make_tree(&self, item: &Item) -> Tree<String> {
+        Tree::new(
+            format!(
+                "{} {}",
+                self.stringify(item),
+                ::core::pass_fail(self.eval(item))
+            ),
+            vec![
+                self.a.make_tree(item),
+                self.b.make_tree(item),
+            ]
+        )
+    }
+
+    fn stringify(&self, item: &Item) -> String {
+        format!("{} && {}", self.a.stringify(item), self.b.stringify(item))
+    }
 }
 
 impl<M1, M2, Item> fmt::Display for AndPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "({} && {})", self.a, self.b)
@@ -74,7 +96,7 @@ pub struct OrPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     a: M1,
     b: M2,
@@ -85,7 +107,7 @@ impl<M1, M2, Item> OrPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     /// Create a new `OrPredicate` over predicates `a` and `b`.
     pub fn new(a: M1, b: M2) -> OrPredicate<M1, M2, Item> {
@@ -101,7 +123,7 @@ impl<M1, M2, Item> Predicate<Item> for OrPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn eval(&self, item: &Item) -> bool {
         self.a.eval(item) || self.b.eval(item)
@@ -112,7 +134,7 @@ impl<M1, M2, Item> fmt::Display for OrPredicate<M1, M2, Item>
 where
     M1: Predicate<Item>,
     M2: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "({} || {})", self.a, self.b)
@@ -126,7 +148,7 @@ where
 pub struct NotPredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     inner: M,
     _phantom: PhantomData<Item>,
@@ -135,7 +157,7 @@ where
 impl<M, Item> NotPredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     /// Create a new `NotPredicate` over predicate `inner`.
     pub fn new(inner: M) -> NotPredicate<M, Item> {
@@ -149,25 +171,41 @@ where
 impl<M, Item> Predicate<Item> for NotPredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn eval(&self, item: &Item) -> bool {
         !self.inner.eval(item)
     }
+
+    #[cfg(feature = "treeline")]
+    fn make_tree(&self, item: &Item) -> Tree<String> {
+        Tree::new(
+            format!(
+                "{} {}",
+                self.stringify(item),
+                ::core::pass_fail(self.eval(item))
+            ),
+            vec![self.inner.make_tree(item)]
+        )
+    }
+
+    fn stringify(&self, item: &Item) -> String {
+        format!("!({})", self.inner.stringify(item))
+    }
 }
 
 impl<M, Item> fmt::Display for NotPredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "(! {})", self.inner)
     }
 }
 
 /// `Predicate` extension that adds boolean logic.
-pub trait PredicateBooleanExt<Item: ?Sized>
+pub trait PredicateBooleanExt<Item: ?Sized + fmt::Debug>
 where
     Self: Predicate<Item>,
 {
@@ -233,6 +271,6 @@ where
 impl<P, Item> PredicateBooleanExt<Item> for P
 where
     P: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
 }

src/boxed.rs

@@ -15,11 +15,11 @@ use Predicate;
 
 /// `Predicate` that wraps another `Predicate` as a trait object, allowing
 /// sized storage of predicate types.
-pub struct BoxPredicate<Item: ?Sized>(Box<Predicate<Item> + Send + Sync>);
+pub struct BoxPredicate<Item: ?Sized + fmt::Debug>(Box<Predicate<Item> + Send + Sync>);
 
 impl<Item> BoxPredicate<Item>
 where
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     /// Creates a new `BoxPredicate`, a wrapper around a dynamically-dispatched
     /// `Predicate` type with useful trait impls.
@@ -33,7 +33,7 @@ where
 
 impl<Item> fmt::Debug for BoxPredicate<Item>
 where
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("BoxPredicate").finish()
@@ -42,7 +42,7 @@ where
 
 impl<Item> fmt::Display for BoxPredicate<Item>
 where
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.0)
@@ -51,15 +51,15 @@ where
 
 impl<Item> Predicate<Item> for BoxPredicate<Item>
 where
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn eval(&self, variable: &Item) -> bool {
         self.0.eval(variable)
     }
 }
 
 /// `Predicate` extension for boxing a `Predicate`.
-pub trait PredicateBoxExt<Item: ?Sized>
+pub trait PredicateBoxExt<Item: ?Sized + fmt::Debug>
 where
     Self: Predicate<Item>,
 {
@@ -98,5 +98,6 @@ where
 impl<P, Item> PredicateBoxExt<Item> for P
 where
     P: Predicate<Item>,
+    Item: ?Sized + fmt::Debug
 {
 }

src/constant.rs

@@ -22,7 +22,7 @@ pub struct BooleanPredicate<Item> {
     _phantom: PhantomData<Item>,
 }
 
-impl<Item> Predicate<Item> for BooleanPredicate<Item> {
+impl<Item: fmt::Debug> Predicate<Item> for BooleanPredicate<Item> {
     fn eval(&self, _variable: &Item) -> bool {
         self.retval
     }

src/core.rs

@@ -8,15 +8,43 @@
 
 use std::fmt;
 
+#[cfg(feature = "treeline")]
+use treeline::Tree;
+
+pub(crate) fn pass_fail(b: bool) -> &'static str {
+    if b {
+        "PASSED"
+    } else {
+        "FAILED"
+    }
+}
+
 /// Trait for generically evaluating a type against a dynamically created
 /// predicate function.
 ///
 /// The exact meaning of `eval` depends on the situation, but will usually
 /// mean that the evaluated item is in some sort of pre-defined set.  This is
 /// different from `Ord` and `Eq` in that an `item` will almost never be the
 /// same type as the implementing `Predicate` type.
-pub trait Predicate<Item: ?Sized>: fmt::Display {
+pub trait Predicate<Item: ?Sized + fmt::Debug>: fmt::Display {
     /// Execute this `Predicate` against `variable`, returning the resulting
     /// boolean.
     fn eval(&self, variable: &Item) -> bool;
+
+    /// TODO
+    fn stringify(&self, _item: &Item) -> String {
+        unimplemented!()
+    }
+
+    /// TODO
+    #[cfg(feature = "treeline")]
+    fn make_tree(&self, _item: &Item) -> Tree<String> {
+        unimplemented!()
+    }
+
+    /// TODO
+    #[cfg(feature = "treeline")]
+    fn tree_eval(&self, item: &Item) -> (bool, Tree<String>) {
+        (self.eval(item), self.make_tree(item))
+    }
 }

src/function.rs

@@ -51,11 +51,12 @@ where
     }
 }
 
-impl<F, T> Predicate<T> for FnPredicate<F, T>
+impl<F, Item> Predicate<Item> for FnPredicate<F, Item>
 where
-    F: Fn(&T) -> bool,
+    F: Fn(&Item) -> bool,
+    Item: fmt::Debug
 {
-    fn eval(&self, variable: &T) -> bool {
+    fn eval(&self, variable: &Item) -> bool {
         (self.function)(variable)
     }
 }

src/lib.rs

@@ -97,6 +97,8 @@ extern crate difference;
 extern crate float_cmp;
 #[cfg(feature = "regex")]
 extern crate regex;
+#[cfg(feature = "treeline")]
+extern crate treeline;
 
 pub mod prelude;
 

src/name.rs

@@ -20,7 +20,7 @@ use Predicate;
 pub struct NamePredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     inner: M,
     name: &'static str,
@@ -30,7 +30,7 @@ where
 impl<M, Item> Predicate<Item> for NamePredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn eval(&self, item: &Item) -> bool {
         self.inner.eval(item)
@@ -40,15 +40,15 @@ where
 impl<M, Item> fmt::Display for NamePredicate<M, Item>
 where
     M: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)
     }
 }
 
 /// `Predicate` extension that adds naming predicate expressions.
-pub trait PredicateNameExt<Item: ?Sized>
+pub trait PredicateNameExt<Item: ?Sized + fmt::Debug>
 where
     Self: Predicate<Item>,
 {
@@ -77,6 +77,6 @@ where
 impl<P, Item> PredicateNameExt<Item> for P
 where
     P: Predicate<Item>,
-    Item: ?Sized,
+    Item: ?Sized + fmt::Debug,
 {
 }