chore: Make find_case object safe

Apparently, a provided function can't downcast `&self` but I can if I spread the implementation around. Overall, trying to meet the goal of making it simple to write a Predicate. Anyone besides us will need to copy `default_find_case` if they want the reference. Not sure what would be a good way to make that good enough for being stable.
epage · Jul 21, 2018 · 7d2afb9 · 7d2afb9
1 parent 5d6f8da
commit 7d2afb9
Show file tree

Hide file tree

Showing 10 changed files with 132 additions and 5 deletions.
diff --git a/src/boxed.rs b/src/boxed.rs
@@ -11,6 +11,7 @@
 
 use std::fmt;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -70,6 +71,10 @@ where
     fn eval(&self, variable: &Item) -> bool {
         self.0.eval(variable)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 /// `Predicate` extension for boxing a `Predicate`.

diff --git a/src/constant.rs b/src/constant.rs
@@ -11,6 +11,7 @@
 use std::fmt;
 use std::marker::PhantomData;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -27,6 +28,10 @@ impl<Item> Predicate<Item> for BooleanPredicate<Item> {
     fn eval(&self, _variable: &Item) -> bool {
         self.retval
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<Item> reflection::PredicateReflection for BooleanPredicate<Item> {

diff --git a/src/core.rs b/src/core.rs
@@ -21,15 +21,29 @@ pub trait Predicate<Item: ?Sized>: reflection::PredicateReflection {
     fn eval(&self, variable: &Item) -> bool;
 
     /// Find a case that proves this predicate as `expected` when run against `variable`.
-    fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>>
-    where
-        Self: Sized,
-    {
+    fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {
         let actual = self.eval(variable);
         if expected == actual {
-            Some(reflection::Case::new(Some(self), actual))
+            Some(reflection::Case::new(None, actual))
         } else {
             None
         }
     }
 }
+
+pub(crate) fn default_find_case<'a, P, Item>(
+    pred: &'a P,
+    expected: bool,
+    variable: &Item,
+) -> Option<reflection::Case<'a>>
+where
+    P: Predicate<Item>,
+    Item: ?Sized,
+{
+    let actual = pred.eval(variable);
+    if expected == actual {
+        Some(reflection::Case::new(Some(pred), actual))
+    } else {
+        None
+    }
+}
diff --git a/src/function.rs b/src/function.rs
@@ -11,6 +11,7 @@
 use std::fmt;
 use std::marker::PhantomData;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -59,6 +60,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         (self.function)(variable)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<F, T> reflection::PredicateReflection for FnPredicate<F, T>

diff --git a/src/iter.rs b/src/iter.rs
@@ -13,6 +13,7 @@ use std::fmt;
 use std::hash::Hash;
 use std::iter::FromIterator;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -76,6 +77,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.contains(variable)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<'a, T> Predicate<T> for InPredicate<&'a T>
@@ -85,6 +90,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.contains(&variable)
     }
+
+    fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<T> reflection::PredicateReflection for InPredicate<T>
@@ -169,6 +178,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.binary_search(variable).is_ok()
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<'a, T> Predicate<T> for OrdInPredicate<&'a T>
@@ -178,6 +191,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.binary_search(&variable).is_ok()
     }
+
+    fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<T> reflection::PredicateReflection for OrdInPredicate<T>
@@ -223,6 +240,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.contains(variable)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<'a, T> Predicate<T> for HashableInPredicate<&'a T>
@@ -232,6 +253,10 @@ where
     fn eval(&self, variable: &T) -> bool {
         self.inner.debug.contains(&variable)
     }
+
+    fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<T> reflection::PredicateReflection for HashableInPredicate<T>

diff --git a/src/ord.rs b/src/ord.rs
@@ -10,6 +10,7 @@
 
 use std::fmt;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -52,6 +53,10 @@ where
             EqOps::NotEqual => variable.ne(&self.constant),
         }
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<'a, T> Predicate<T> for EqPredicate<&'a T>
@@ -64,6 +69,10 @@ where
             EqOps::NotEqual => variable.ne(self.constant),
         }
     }
+
+    fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<T> reflection::PredicateReflection for EqPredicate<T>
@@ -174,6 +183,10 @@ where
             OrdOps::GreaterThan => variable.gt(&self.constant),
         }
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<'a, T> Predicate<T> for OrdPredicate<&'a T>
@@ -188,6 +201,10 @@ where
             OrdOps::GreaterThan => variable.gt(self.constant),
         }
     }
+
+    fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl<T> reflection::PredicateReflection for OrdPredicate<T>

diff --git a/src/path/existence.rs b/src/path/existence.rs
@@ -9,6 +9,7 @@
 use std::fmt;
 use std::path;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -24,6 +25,14 @@ impl Predicate<path::Path> for ExistencePredicate {
     fn eval(&self, path: &path::Path) -> bool {
         path.exists() == self.exists
     }
+
+    fn find_case<'a>(
+        &'a self,
+        expected: bool,
+        variable: &path::Path,
+    ) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for ExistencePredicate {}

diff --git a/src/path/fs.rs b/src/path/fs.rs
@@ -11,6 +11,7 @@ use std::fs;
 use std::io::{self, Read};
 use std::path;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -59,12 +60,24 @@ impl Predicate<path::Path> for BinaryFilePredicate {
     fn eval(&self, path: &path::Path) -> bool {
         self.eval(path).unwrap_or(false)
     }
+
+    fn find_case<'a>(
+        &'a self,
+        expected: bool,
+        variable: &path::Path,
+    ) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl Predicate<[u8]> for BinaryFilePredicate {
     fn eval(&self, actual: &[u8]) -> bool {
         self.content.debug == actual
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &[u8]) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for BinaryFilePredicate {
@@ -120,12 +133,24 @@ impl Predicate<path::Path> for StrFilePredicate {
     fn eval(&self, path: &path::Path) -> bool {
         self.eval(path).unwrap_or(false)
     }
+
+    fn find_case<'a>(
+        &'a self,
+        expected: bool,
+        variable: &path::Path,
+    ) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl Predicate<str> for StrFilePredicate {
     fn eval(&self, actual: &str) -> bool {
         self.content == actual
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for StrFilePredicate {

diff --git a/src/str/basics.rs b/src/str/basics.rs
@@ -8,6 +8,7 @@
 
 use std::fmt;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -21,6 +22,10 @@ impl Predicate<str> for IsEmptyPredicate {
     fn eval(&self, variable: &str) -> bool {
         variable.is_empty()
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for IsEmptyPredicate {}
@@ -58,6 +63,10 @@ impl Predicate<str> for StartsWithPredicate {
     fn eval(&self, variable: &str) -> bool {
         variable.starts_with(&self.pattern)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for StartsWithPredicate {}
@@ -100,6 +109,10 @@ impl Predicate<str> for EndsWithPredicate {
     fn eval(&self, variable: &str) -> bool {
         variable.ends_with(&self.pattern)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for EndsWithPredicate {}
@@ -162,6 +175,10 @@ impl Predicate<str> for ContainsPredicate {
     fn eval(&self, variable: &str) -> bool {
         variable.contains(&self.pattern)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for ContainsPredicate {}

diff --git a/src/str/regex.rs b/src/str/regex.rs
@@ -10,6 +10,7 @@ use std::fmt;
 
 use regex;
 
+use core;
 use reflection;
 use Predicate;
 
@@ -45,6 +46,10 @@ impl Predicate<str> for RegexPredicate {
     fn eval(&self, variable: &str) -> bool {
         self.re.is_match(variable)
     }
+
+    fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {
+        core::default_find_case(self, expected, variable)
+    }
 }
 
 impl reflection::PredicateReflection for RegexPredicate {}