eval::Rules - a Vec<Rule> but skips invalid Rule on Deserialization

Author: elpiel

primitives/src/targeting/eval.rs

@@ -10,6 +10,8 @@ use std::{
     str::FromStr,
 };
 
+pub use rules::Rules;
+
 use super::{
     input::{channel::Getter as ChannelGetter, Get},
     Input, Output,
@@ -72,6 +74,59 @@ impl fmt::Display for Error {
 
 impl std::error::Error for Error {}
 
+mod rules {
+    use serde::{
+        de::{SeqAccess, Visitor},
+        Deserialize, Deserializer, Serialize,
+    };
+    use std::fmt;
+
+    use super::Rule;
+
+    #[derive(Serialize, Debug, Clone, Eq, PartialEq)]
+    #[serde(transparent)]
+    /// The Rules is just a `Vec<Rule>` with one difference:
+    /// When Deserializing it will skip invalid `Rule` instead of returning an error
+    pub struct Rules(Vec<Rule>);
+
+    impl<'de> Deserialize<'de> for Rules {
+        fn deserialize<D>(deserializer: D) -> Result<Rules, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_seq(RulesVisitor)
+        }
+    }
+
+    struct RulesVisitor;
+
+    impl<'de> Visitor<'de> for RulesVisitor {
+        type Value = Rules;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            formatter.write_str("a sequence of Rules")
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let mut vec = Vec::with_capacity(seq.size_hint().unwrap_or(0));
+
+            // Since we want to filter wrong Rules, instead of returning an error
+            // we transpose the `Result<Option<T>, ..>` to `Option<Result<T, ..>>`
+            while let Some(result) = seq.next_element().transpose() {
+                // push only valid rules
+                if let Ok(rule) = result {
+                    vec.push(rule);
+                }
+            }
+
+            Ok(Rules(vec))
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum Rule {

primitives/src/targeting/eval_test.rs

@@ -38,6 +38,62 @@ fn get_default_input() -> Input {
         .with_balances(input_balances)
 }
 
+mod rules_test {
+    use super::{Function, Rule, Rules, Value};
+    use serde_json::{from_value, json};
+
+    #[test]
+    fn test_rules_should_be_empty_when_single_invalid_rule() {
+        let rule = json!([
+            {
+                "onlyShowIf": {
+                    "undefined": [
+                        [],
+                        {"get":"userAgentOS"}
+                    ]
+                }
+            }
+        ]);
+
+        let deser = from_value::<Rules>(rule).expect("should deserialize by skipping invalid rule");
+
+        assert!(deser.0.is_empty())
+    }
+
+    #[test]
+    fn test_rules_should_not_be_empty_when_one_invalid_rule() {
+        let rule = json!([
+            {
+                "intersects": [
+                    {"get": "adSlot.categories"},
+                    ["News", "Bitcoin"]
+                ]
+            },
+            {
+                "onlyShowIf": {
+                    "undefined": [
+                        [],
+                        {"get":"userAgentOS"}
+                    ]
+                }
+            }
+        ]);
+
+        let deser = from_value::<Rules>(rule).expect("should deserialize by skipping invalid rule");
+
+        assert_eq!(1, deser.0.len());
+
+        let expected = Rule::Function(Function::new_intersects(
+            Rule::Function(Function::new_get("adSlot.categories")),
+            Rule::Value(Value::Array(vec![
+                Value::new_string("News"),
+                Value::new_string("Bitcoin"),
+            ])),
+        ));
+        assert_eq!(expected, deser.0[0])
+    }
+}
+
 mod dsl_test {
     use super::*;