Merge pull request #47 from kammitama5/removePredicateImplementations

Remove predicate implementations

Author: epage

src/assert.rs

@@ -404,27 +404,123 @@ where
     }
 }
 
-impl IntoCodePredicate<predicates::ord::EqPredicate<i32>> for i32 {
-    type Predicate = predicates::ord::EqPredicate<i32>;
+// Keep `predicates` concrete Predicates out of our public API.
+/// [Predicate] used by [`IntoCodePredicate`] for bytes.
+///
+/// [`IntoCodePredicate`]: trait.IntoCodePredicate.html
+/// [Predicate]: https://docs.rs/predicates-core/0.9.0/predicates_core/trait.Predicate.html
+#[derive(Debug)]
+pub struct EqCodePredicate(predicates::ord::EqPredicate<i32>);
+
+impl EqCodePredicate {
+    pub(crate) fn new(value: i32) -> Self {
+        let pred = predicates::ord::eq(value);
+        EqCodePredicate(pred)
+    }
+}
+
+impl predicates_core::reflection::PredicateReflection for EqCodePredicate {
+    fn parameters<'a>(
+        &'a self,
+    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+        self.0.parameters()
+    }
+
+    /// Nested `Predicate`s of the current `Predicate`.
+    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+        self.0.children()
+    }
+}
+
+impl predicates_core::Predicate<i32> for EqCodePredicate {
+    fn eval(&self, item: &i32) -> bool {
+        self.0.eval(item)
+    }
+
+    fn find_case<'a>(
+        &'a self,
+        expected: bool,
+        variable: &i32,
+    ) -> Option<predicates_core::reflection::Case<'a>> {
+        self.0.find_case(expected, variable)
+    }
+}
+
+impl fmt::Display for EqCodePredicate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl IntoCodePredicate<EqCodePredicate> for i32 {
+    type Predicate = EqCodePredicate;
 
     fn into_code(self) -> Self::Predicate {
-        predicates::ord::eq(self)
+        Self::Predicate::new(self)
     }
 }
 
-impl IntoCodePredicate<predicates::iter::InPredicate<i32>> for Vec<i32> {
-    type Predicate = predicates::iter::InPredicate<i32>;
+// Keep `predicates` concrete Predicates out of our public API.
+/// [Predicate] used by [`IntoCodePredicate`] for bytes.
+///
+/// [`IntoCodePredicate`]: trait.IntoCodePredicate.html
+/// [Predicate]: https://docs.rs/predicates-core/0.9.0/predicates_core/trait.Predicate.html
+#[derive(Debug)]
+pub struct InCodePredicate(predicates::iter::InPredicate<i32>);
+
+impl InCodePredicate {
+    pub(crate) fn new<I:IntoIterator<Item=i32>>(value: I) -> Self {
+        let pred = predicates::iter::in_iter(value);
+        InCodePredicate(pred)
+    }
+}
+
+impl predicates_core::reflection::PredicateReflection for InCodePredicate {
+    fn parameters<'a>(
+        &'a self,
+    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+        self.0.parameters()
+    }
+
+    /// Nested `Predicate`s of the current `Predicate`.
+    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+        self.0.children()
+    }
+}
+
+impl predicates_core::Predicate<i32> for InCodePredicate {
+    fn eval(&self, item: &i32) -> bool {
+        self.0.eval(item)
+    }
+
+    fn find_case<'a>(
+        &'a self,
+        expected: bool,
+        variable: &i32,
+    ) -> Option<predicates_core::reflection::Case<'a>> {
+        self.0.find_case(expected, variable)
+    }
+}
+
+impl fmt::Display for InCodePredicate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl IntoCodePredicate<InCodePredicate> for Vec<i32> {
+    type Predicate = InCodePredicate;
 
     fn into_code(self) -> Self::Predicate {
-        predicates::iter::in_iter(self)
+        Self::Predicate::new(self)
     }
 }
 
-impl IntoCodePredicate<predicates::iter::InPredicate<i32>> for &'static [i32] {
-    type Predicate = predicates::iter::InPredicate<i32>;
+impl IntoCodePredicate<InCodePredicate> for &'static [i32] {
+    type Predicate = InCodePredicate;
 
     fn into_code(self) -> Self::Predicate {
-        predicates::iter::in_iter(self.iter().cloned())
+        Self::Predicate::new(self.iter().cloned())
     }
 }