primitives - impl TryGet & scoped structs

Author: elpiel

primitives/src/targeting.rs

@@ -1,218 +1,133 @@
 use crate::BigNum;
 use serde::{Deserialize, Serialize};
-use serde_json::{
-    value::{Map as SerdeMap, Value as SerdeValue},
-    Number,
-};
-use std::convert::TryFrom;
-use std::fmt;
-
-pub type Map = SerdeMap<String, SerdeValue>;
-
-#[derive(Debug)]
-pub enum Error {
-    TypeError,
-    UnknownVariable,
+use std::{collections::HashMap, convert::TryFrom};
+
+pub use eval::*;
+
+mod eval;
+
+pub trait TryGet {
+    const PATTERN: &'static str;
+
+    fn try_get(&self, key: &str) -> Result<Value, Error>;
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::TypeError => write!(f, "TypeError: Wrong type"),
-            Error::UnknownVariable => write!(f, "UnknownVariable: Unknown varialbe passed"),
+impl<T: Serialize> TryGet for T {
+    const PATTERN: &'static str = ".";
+
+    fn try_get(&self, key: &str) -> Result<Value, Error> {
+        let mut splitn = key.splitn(2, '.');
+
+        let (field, remaining_key) = (splitn.next(), splitn.next());
+        let serde_value = serde_json::json!(self);
+
+        // filter empty string
+        let field = field.filter(|s| !s.is_empty());
+        let remaining_key = remaining_key.filter(|s| !s.is_empty());
+
+        // TODO: Check what type of error we should return in each case
+        match (field, remaining_key, serde_value) {
+            (Some(field), remaining_key, serde_json::Value::Object(map)) => {
+                match map.get(field) {
+                    Some(serde_value) => serde_value.try_get(remaining_key.unwrap_or_default()),
+                    None => Err(Error::TypeError),
+                }
+            },
+            (None, None, serde_value) => Value::try_from(serde_value.clone()),
+            // if we have any other field or remaining_key, it's iligal:
+            // i.e. `first.second` for values that are not map
+            _ => Err(Error::UnknownVariable),
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(try_from = "SerdeValue")]
-pub enum Value {
-    Bool(bool),
-    Number(Number),
-    String(String),
-    Array(Vec<Value>),
-    BigNum(BigNum),
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-#[serde(untagged)]
-pub enum Rule {
-    Function(Function),
-    Value(Value),
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(Default))]
+#[serde(rename_all = "camelCase")]
+pub struct Input {
+    /// AdView scope, accessible only on the AdView
+    #[serde(default)]
+    pub ad_view: Option<AdView>,
+    /// Global scope, accessible everywhere
+    #[serde(flatten)]
+    pub global: Global,
+    /// adSlot scope, accessible on Supermarket and AdView
+    #[serde(default)]
+    pub ad_slot: Option<AdSlot>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(Default))]
 #[serde(rename_all = "camelCase")]
-pub enum Function {
-    If(Box<Rule>, Box<Rule>),
-    And(Box<Rule>, Box<Rule>),
-    Intersects(Box<Rule>, Box<Rule>),
-    Get(String),
+pub struct AdView {
+    pub seconds_since_show: u64,
+    pub has_custom_preferences: bool,
 }
 
-impl TryFrom<SerdeValue> for Value {
-    type Error = Error;
-
-    fn try_from(serde_value: SerdeValue) -> Result<Self, Self::Error> {
-        match serde_value {
-            SerdeValue::Bool(bool) => Ok(Self::Bool(bool)),
-            SerdeValue::Number(number) => Ok(Self::Number(number)),
-            SerdeValue::String(string) => Ok(Self::String(string)),
-            SerdeValue::Array(serde_array) => {
-                let array = serde_array
-                    .into_iter()
-                    .map(Value::try_from)
-                    .collect::<Result<_, _>>()?;
-                Ok(Self::Array(array))
-            }
-            SerdeValue::Object(_) | SerdeValue::Null => Err(Error::TypeError),
-        }
-    }
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(Default))]
+#[serde(rename_all = "camelCase")]
+pub struct Global {
+    pub ad_slot_id: String,
+    pub ad_unit_id: String,
+    pub ad_unit_type: String,
+    pub publisher_id: String,
+    pub advertiser_id: String,
+    pub country: String,
+    pub event_type: String,
+    pub campaign_total_spent: String,
+    pub campaign_seconds_active: u64,
+    pub campaign_seconds_duration: u64,
+    pub campaign_budget: BigNum,
+    pub event_min_price: BigNum,
+    pub event_max_price: BigNum,
+    pub publisher_earned_from_campaign: BigNum,
+    pub seconds_since_epoch: u64,
+    #[serde(rename = "userAgentOS")]
+    pub user_agent_os: String,
+    pub user_agent_browser_family: String,
 }
 
-impl Value {
-    pub fn try_bool(self) -> Result<bool, Error> {
-        match self {
-            Self::Bool(b) => Ok(b),
-            _ => Err(Error::TypeError),
-        }
-    }
 
-    pub fn try_array(self) -> Result<Vec<Value>, Error> {
-        match self {
-            Self::Array(array) => Ok(array),
-            _ => Err(Error::TypeError),
-        }
-    }
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(Default))]
+#[serde(rename_all = "camelCase")]
+pub struct AdSlot {
+    pub categories: Vec<String>,
+    pub hostname: String,
+    pub alexa_rank: f64,
 }
 
-/// Evaluates a Rule to be applied and has 3 outcomes:
-/// - Does nothing
-///     Rules returned directly:
-///     - Bool
-///     - Number
-///     - String
-///     - Array
-/// - Mutates output
-/// - Throws an error
-pub fn eval(input: &Map, output: &mut Map, rule: &Rule) -> Result<Option<Value>, Error> {
-    let function = match rule {
-        Rule::Value(value) => return Ok(Some(value.clone())),
-        Rule::Function(function) => function,
-    };
-
-    // basic operators
-    let value = match function {
-        Function::If(first_rule, second_rule) => {
-            let eval_if = eval(input, output, first_rule)?
-                .ok_or(Error::TypeError)?
-                .try_bool()?;
-
-            if eval_if {
-                let bool = eval(input, output, second_rule)?
-                    .ok_or(Error::TypeError)?
-                    .try_bool()?;
-                Some(Value::Bool(bool))
-            } else {
-                None
-            }
-        }
-        Function::And(first_rule, second_rule) => {
-            let a = eval(input, output, first_rule)?
-                .ok_or(Error::TypeError)?
-                .try_bool()?;
-            let b = eval(input, output, second_rule)?
-                .ok_or(Error::TypeError)?
-                .try_bool()?;
-
-            Some(Value::Bool(a && b))
-        }
-        Function::Intersects(first_rule, second_rule) => {
-            let a = eval(input, output, first_rule)?
-                .ok_or(Error::TypeError)?
-                .try_array()?;
-            let b = eval(input, output, second_rule)?
-                .ok_or(Error::TypeError)?
-                .try_array()?;
-
-            Some(Value::Bool(a.iter().any(|x| b.contains(x))))
-        }
-        Function::Get(key) => {
-            let input_value = input.get(key).ok_or(Error::UnknownVariable)?;
-
-            Some(Value::try_from(input_value.clone())?)
-        }
-    };
-
-    Ok(value)
+pub struct Output {
+    /// Whether to show the ad
+    /// Default: true
+    pub show: bool,
+    /// The boost is a number between 0 and 5 that increases the likelyhood for the ad
+    /// to be chosen if there is random selection applied on the AdView (multiple ad candidates with the same price)
+    /// Default: 1.0
+    pub boost: f64,
+    /// price.{eventType}
+    /// For example: price.IMPRESSION
+    /// The default is the min of the bound of event type:
+    /// Default: pricingBounds.IMPRESSION.min
+    pub price: HashMap<String, BigNum>,
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
 
     #[test]
-    fn deserialzes_intersects_rule() {
-        let json = r#"{"intersects": [{ "get": "adSlot.categories" }, ["News", "Bitcoin"]]}"#;
-
-        let parsed_rule = serde_json::from_str::<Rule>(json).expect("Should deserialize");
-
-        let mut expected_map = SerdeMap::new();
-        expected_map.insert(
-            "get".to_string(),
-            SerdeValue::String("adSlot.categories".to_string()),
-        );
-
-        let expected = Rule::Function(Function::Intersects(
-            Box::new(Rule::Function(Function::Get(
-                "adSlot.categories".to_string(),
-            ))),
-            Box::new(Rule::Value(Value::Array(vec![
-                Value::String("News".to_string()),
-                Value::String("Bitcoin".to_string()),
-            ]))),
-        ));
-
-        assert_eq!(expected, parsed_rule)
-    }
+    fn test_try_get_of_input() {
+        let mut input = Input::default();
+        input.ad_view = Some(AdView {
+            seconds_since_show: 10, has_custom_preferences: false
+        });
 
-    /// ```json
-    /// {
-    ///   "intersects": [
-    ///     {
-    ///       "get": "publisherId"
-    ///     },
-    ///     [
-    ///       "0xd5860D6196A4900bf46617cEf088ee6E6b61C9d6",
-    ///       "0xd5860D6196A4900bf46617cEf088ee6E6b61C9d3"
-    ///     ]
-    ///   ]
-    /// }
-    /// ```
-    #[test]
-    fn test_simple_intersect_eval() {
-        let input: Map = vec![(
-            "publisherId".to_string(),
-            SerdeValue::Array(vec![SerdeValue::String(
-                "0xd5860D6196A4900bf46617cEf088ee6E6b61C9d6".to_string(),
-            )]),
-        )]
-        .into_iter()
-        .collect();
-        let mut output = SerdeMap::new();
-
-        let publishers = vec![
-            Value::String("0xd5860D6196A4900bf46617cEf088ee6E6b61C9d6".to_string()),
-            Value::String("0xd5860D6196A4900bf46617cEf088ee6E6b61C9d3".to_string()),
-        ];
-
-        let rules = Rule::Function(Function::Intersects(
-            Box::new(Rule::Function(Function::Get("publisherId".to_string()))),
-            Box::new(Rule::Value(Value::Array(publishers))),
-        ));
-
-        let result = eval(&input, &mut output, &rules).expect("Should eval rules");
-
-        assert_eq!(Value::Bool(true), result.expect("Sould be Some!"));
+        let result = input.try_get("adView.secondsSinceShow").expect("Should get the adView field");
+
+        let expected = serde_json::from_str::<serde_json::Number>("10").expect("Should create number");
+
+        assert_eq!(Value::Number(expected), result)
     }
 }