clean up, rustfmt & clippy

Author: elpiel

primitives/src/targeting.rs

@@ -1,25 +1,11 @@
 use crate::BigNum;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, convert::TryFrom};
+use std::collections::HashMap;
 
 pub use eval::*;
 
 mod eval;
 
-pub trait TryGet: Serialize {
-    const PATTERN: &'static str = ".";
-
-    fn try_get(&self, key: &str) -> Result<Value, Error> {
-        let serde_value = serde_json::json!(self);
-        let pointer = format!("/{pointer}", pointer = key.replace(Self::PATTERN, "/"));
-
-        match serde_value.pointer(&pointer) {
-            Some(serde_value) => Value::try_from(serde_value.clone()),
-            None => Err(Error::UnknownVariable),
-        }
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(test, derive(Default))]
 #[serde(rename_all = "camelCase")]
@@ -71,7 +57,9 @@ impl Input {
             )),
             "secondsSinceEpoch" => Ok(Value::Number(self.global.seconds_since_epoch.into())),
             "userAgentOS" => Ok(Value::String(self.global.user_agent_os.clone())),
-            "userAgentBrowserFamily" => Ok(Value::String(self.global.user_agent_browser_family.clone())),
+            "userAgentBrowserFamily" => {
+                Ok(Value::String(self.global.user_agent_browser_family.clone()))
+            }
             "adSlot.categories" => self
                 .ad_slot
                 .as_ref()
@@ -93,8 +81,8 @@ impl Input {
                 let ad_slot = self.ad_slot.as_ref().ok_or(Error::UnknownVariable)?;
 
                 match serde_json::Number::from_f64(ad_slot.alexa_rank) {
-                        Some(number) => Ok(Value::Number(number)),
-                        None => Err(Error::TypeError)
+                    Some(number) => Ok(Value::Number(number)),
+                    None => Err(Error::TypeError),
                 }
             }
             _unknown_field => Err(Error::UnknownVariable),

primitives/src/targeting/eval.rs

@@ -1,12 +1,11 @@
 use crate::BigNum;
 use serde::{Deserialize, Serialize};
 use serde_json::{value::Value as SerdeValue, Number};
-use std::convert::TryFrom;
-use std::{fmt, str::FromStr};
+use std::{convert::TryFrom, fmt, str::FromStr};
 
 pub type Map = serde_json::value::Map<String, SerdeValue>;
 
-use super::{Input, Output, TryGet};
+use super::{Input, Output};
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum Error {
@@ -52,6 +51,28 @@ impl Value {
     }
 }
 
+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)),
+            // String can be either a String or a BigNum
+            // but we handle this case by using Type casting with the Function::Bn
+            SerdeValue::String(string) => Ok(Value::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, Clone, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 // TODO: https://github.com/AdExNetwork/adex-validator-stack-rust/issues/296
@@ -94,26 +115,6 @@ impl Function {
     }
 }
 
-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(Value::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),
-        }
-    }
-}
-
 impl Value {
     pub fn try_bool(self) -> Result<bool, Error> {
         match self {
@@ -137,6 +138,7 @@ impl Value {
 ///     - Number
 ///     - String
 ///     - Array
+///     - BigNum
 /// - Mutates output
 /// - Throws an error
 fn eval(input: &Input, output: &mut Output, rule: &Rule) -> Result<Option<Value>, Error> {