chore: Make find_case object safe

epage · epage · commit 7d2afb9a050e · 2018-07-21T16:27:08.000-06:00
Apparently, a provided function can't downcast `&amp;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.
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 {}

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`
`12`	`12`	`use std::fmt;`
`13`	`13`
	`14`	`+use core;`
`14`	`15`	`use reflection;`
`15`	`16`	`use Predicate;`
`16`	`17`
`@@ -70,6 +71,10 @@ where`
`70`	`71`	`fn eval(&self, variable: &Item) -> bool {`
`71`	`72`	`self.0.eval(variable)`
`72`	`73`	`}`
	`74`	`+`
	`75`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {`
	`76`	`+ core::default_find_case(self, expected, variable)`
	`77`	`+ }`
`73`	`78`	`}`
`74`	`79`
`75`	`80`	/// `Predicate` extension for boxing a `Predicate`.
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ use std::fmt;`
`13`	`13`	`use std::hash::Hash;`
`14`	`14`	`use std::iter::FromIterator;`
`15`	`15`
	`16`	`+use core;`
`16`	`17`	`use reflection;`
`17`	`18`	`use Predicate;`
`18`	`19`
`@@ -76,6 +77,10 @@ where`
`76`	`77`	`fn eval(&self, variable: &T) -> bool {`
`77`	`78`	`self.inner.debug.contains(variable)`
`78`	`79`	`}`
	`80`	`+`
	`81`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {`
	`82`	`+ core::default_find_case(self, expected, variable)`
	`83`	`+ }`
`79`	`84`	`}`
`80`	`85`
`81`	`86`	`impl<'a, T> Predicate<T> for InPredicate<&'a T>`
`@@ -85,6 +90,10 @@ where`
`85`	`90`	`fn eval(&self, variable: &T) -> bool {`
`86`	`91`	`self.inner.debug.contains(&variable)`
`87`	`92`	`}`
	`93`	`+`
	`94`	`+ fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {`
	`95`	`+ core::default_find_case(self, expected, variable)`
	`96`	`+ }`
`88`	`97`	`}`
`89`	`98`
`90`	`99`	`impl<T> reflection::PredicateReflection for InPredicate<T>`
`@@ -169,6 +178,10 @@ where`
`169`	`178`	`fn eval(&self, variable: &T) -> bool {`
`170`	`179`	`self.inner.debug.binary_search(variable).is_ok()`
`171`	`180`	`}`
	`181`	`+`
	`182`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {`
	`183`	`+ core::default_find_case(self, expected, variable)`
	`184`	`+ }`
`172`	`185`	`}`
`173`	`186`
`174`	`187`	`impl<'a, T> Predicate<T> for OrdInPredicate<&'a T>`
`@@ -178,6 +191,10 @@ where`
`178`	`191`	`fn eval(&self, variable: &T) -> bool {`
`179`	`192`	`self.inner.debug.binary_search(&variable).is_ok()`
`180`	`193`	`}`
	`194`	`+`
	`195`	`+ fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {`
	`196`	`+ core::default_find_case(self, expected, variable)`
	`197`	`+ }`
`181`	`198`	`}`
`182`	`199`
`183`	`200`	`impl<T> reflection::PredicateReflection for OrdInPredicate<T>`
`@@ -223,6 +240,10 @@ where`
`223`	`240`	`fn eval(&self, variable: &T) -> bool {`
`224`	`241`	`self.inner.debug.contains(variable)`
`225`	`242`	`}`
	`243`	`+`
	`244`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {`
	`245`	`+ core::default_find_case(self, expected, variable)`
	`246`	`+ }`
`226`	`247`	`}`
`227`	`248`
`228`	`249`	`impl<'a, T> Predicate<T> for HashableInPredicate<&'a T>`
`@@ -232,6 +253,10 @@ where`
`232`	`253`	`fn eval(&self, variable: &T) -> bool {`
`233`	`254`	`self.inner.debug.contains(&variable)`
`234`	`255`	`}`
	`256`	`+`
	`257`	`+ fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {`
	`258`	`+ core::default_find_case(self, expected, variable)`
	`259`	`+ }`
`235`	`260`	`}`
`236`	`261`
`237`	`262`	`impl<T> reflection::PredicateReflection for HashableInPredicate<T>`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`
`11`	`11`	`use std::fmt;`
`12`	`12`
	`13`	`+use core;`
`13`	`14`	`use reflection;`
`14`	`15`	`use Predicate;`
`15`	`16`
`@@ -52,6 +53,10 @@ where`
`52`	`53`	`EqOps::NotEqual => variable.ne(&self.constant),`
`53`	`54`	`}`
`54`	`55`	`}`
	`56`	`+`
	`57`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {`
	`58`	`+ core::default_find_case(self, expected, variable)`
	`59`	`+ }`
`55`	`60`	`}`
`56`	`61`
`57`	`62`	`impl<'a, T> Predicate<T> for EqPredicate<&'a T>`
`@@ -64,6 +69,10 @@ where`
`64`	`69`	`EqOps::NotEqual => variable.ne(self.constant),`
`65`	`70`	`}`
`66`	`71`	`}`
	`72`	`+`
	`73`	`+ fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {`
	`74`	`+ core::default_find_case(self, expected, variable)`
	`75`	`+ }`
`67`	`76`	`}`
`68`	`77`
`69`	`78`	`impl<T> reflection::PredicateReflection for EqPredicate<T>`
`@@ -174,6 +183,10 @@ where`
`174`	`183`	`OrdOps::GreaterThan => variable.gt(&self.constant),`
`175`	`184`	`}`
`176`	`185`	`}`
	`186`	`+`
	`187`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &T) -> Option<reflection::Case<'a>> {`
	`188`	`+ core::default_find_case(self, expected, variable)`
	`189`	`+ }`
`177`	`190`	`}`
`178`	`191`
`179`	`192`	`impl<'a, T> Predicate<T> for OrdPredicate<&'a T>`
`@@ -188,6 +201,10 @@ where`
`188`	`201`	`OrdOps::GreaterThan => variable.gt(self.constant),`
`189`	`202`	`}`
`190`	`203`	`}`
	`204`	`+`
	`205`	`+ fn find_case<'b>(&'b self, expected: bool, variable: &T) -> Option<reflection::Case<'b>> {`
	`206`	`+ core::default_find_case(self, expected, variable)`
	`207`	`+ }`
`191`	`208`	`}`
`192`	`209`
`193`	`210`	`impl<T> reflection::PredicateReflection for OrdPredicate<T>`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`
`9`	`9`	`use std::fmt;`
`10`	`10`
	`11`	`+use core;`
`11`	`12`	`use reflection;`
`12`	`13`	`use Predicate;`
`13`	`14`
`@@ -21,6 +22,10 @@ impl Predicate<str> for IsEmptyPredicate {`
`21`	`22`	`fn eval(&self, variable: &str) -> bool {`
`22`	`23`	`variable.is_empty()`
`23`	`24`	`}`
	`25`	`+`
	`26`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {`
	`27`	`+ core::default_find_case(self, expected, variable)`
	`28`	`+ }`
`24`	`29`	`}`
`25`	`30`
`26`	`31`	`impl reflection::PredicateReflection for IsEmptyPredicate {}`
`@@ -58,6 +63,10 @@ impl Predicate<str> for StartsWithPredicate {`
`58`	`63`	`fn eval(&self, variable: &str) -> bool {`
`59`	`64`	`variable.starts_with(&self.pattern)`
`60`	`65`	`}`
	`66`	`+`
	`67`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {`
	`68`	`+ core::default_find_case(self, expected, variable)`
	`69`	`+ }`
`61`	`70`	`}`
`62`	`71`
`63`	`72`	`impl reflection::PredicateReflection for StartsWithPredicate {}`
`@@ -100,6 +109,10 @@ impl Predicate<str> for EndsWithPredicate {`
`100`	`109`	`fn eval(&self, variable: &str) -> bool {`
`101`	`110`	`variable.ends_with(&self.pattern)`
`102`	`111`	`}`
	`112`	`+`
	`113`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {`
	`114`	`+ core::default_find_case(self, expected, variable)`
	`115`	`+ }`
`103`	`116`	`}`
`104`	`117`
`105`	`118`	`impl reflection::PredicateReflection for EndsWithPredicate {}`
`@@ -162,6 +175,10 @@ impl Predicate<str> for ContainsPredicate {`
`162`	`175`	`fn eval(&self, variable: &str) -> bool {`
`163`	`176`	`variable.contains(&self.pattern)`
`164`	`177`	`}`
	`178`	`+`
	`179`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {`
	`180`	`+ core::default_find_case(self, expected, variable)`
	`181`	`+ }`
`165`	`182`	`}`
`166`	`183`
`167`	`184`	`impl reflection::PredicateReflection for ContainsPredicate {}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ use std::fmt;`
`10`	`10`
`11`	`11`	`use regex;`
`12`	`12`
	`13`	`+use core;`
`13`	`14`	`use reflection;`
`14`	`15`	`use Predicate;`
`15`	`16`
`@@ -45,6 +46,10 @@ impl Predicate<str> for RegexPredicate {`
`45`	`46`	`fn eval(&self, variable: &str) -> bool {`
`46`	`47`	`self.re.is_match(variable)`
`47`	`48`	`}`
	`49`	`+`
	`50`	`+ fn find_case<'a>(&'a self, expected: bool, variable: &str) -> Option<reflection::Case<'a>> {`
	`51`	`+ core::default_find_case(self, expected, variable)`
	`52`	`+ }`
`48`	`53`	`}`
`49`	`54`
`50`	`55`	`impl reflection::PredicateReflection for RegexPredicate {}`