refactor for maint

Author: Dean Karn

src/parser/coercions/constant.rs

@@ -0,0 +1,12 @@
+use crate::parser::{Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct CoercedConst {
+    pub value: Value,
+}
+
+impl Expression for CoercedConst {
+    fn calculate(&self, _json: &[u8]) -> crate::parser::parse::Result<Value> {
+        Ok(self.value.clone())
+    }
+}

src/parser/coercions/date_time.rs

@@ -0,0 +1,24 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct COERCEDateTime {
+    pub value: BoxedExpression,
+}
+
+impl Expression for COERCEDateTime {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let value = self.value.calculate(json)?;
+
+        match value {
+            Value::String(ref s) => match anydate::parse_utc(s) {
+                Err(_) => Ok(Value::Null),
+                Ok(dt) => Ok(Value::DateTime(dt)),
+            },
+            Value::Null => Ok(value),
+            value => Err(Error::UnsupportedCOERCE(
+                format!("{value} COERCE datetime",),
+            )),
+        }
+    }
+}

src/parser/coercions/lowercase.rs

@@ -0,0 +1,17 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct CoerceLowercase {
+    pub value: BoxedExpression,
+}
+
+impl Expression for CoerceLowercase {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let v = self.value.calculate(json)?;
+        match v {
+            Value::String(s) => Ok(Value::String(s.to_lowercase())),
+            v => Err(Error::UnsupportedCOERCE(format!("{v} COERCE lowercase",))),
+        }
+    }
+}

src/parser/coercions/mod.rs

@@ -0,0 +1,17 @@
+mod constant;
+mod date_time;
+mod lowercase;
+mod number;
+mod string;
+mod sub_str;
+mod title;
+mod uppercase;
+
+pub(super) use constant::CoercedConst;
+pub(super) use date_time::COERCEDateTime;
+pub(super) use lowercase::CoerceLowercase;
+pub(super) use number::COERCENumber;
+pub(super) use string::COERCEString;
+pub(super) use sub_str::CoerceSubstr;
+pub(super) use title::CoerceTitle;
+pub(super) use uppercase::CoerceUppercase;

src/parser/coercions/number.rs

@@ -0,0 +1,28 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct COERCENumber {
+    pub value: BoxedExpression,
+}
+
+impl Expression for COERCENumber {
+    #[allow(clippy::cast_precision_loss)]
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let value = self.value.calculate(json)?;
+        match value {
+            Value::String(s) => Ok(Value::Number(
+                s.parse::<f64>()
+                    .map_err(|e| Error::UnsupportedCOERCE(e.to_string()))?,
+            )),
+            Value::Number(num) => Ok(Value::Number(num)),
+            Value::Bool(b) => Ok(Value::Number(if b { 1.0 } else { 0.0 })),
+            Value::DateTime(dt) => Ok(Value::Number(
+                dt.timestamp_nanos_opt().unwrap_or_default() as f64
+            )),
+            _ => Err(Error::UnsupportedCOERCE(
+                format!("{value} COERCE datetime",),
+            )),
+        }
+    }
+}

src/parser/coercions/string.rs

@@ -0,0 +1,24 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Expression, Value};
+use chrono::SecondsFormat;
+
+#[derive(Debug)]
+pub(in crate::parser) struct COERCEString {
+    pub value: BoxedExpression,
+}
+
+impl Expression for COERCEString {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let value = self.value.calculate(json)?;
+        match value {
+            Value::Null => Ok(Value::String("null".to_string())),
+            Value::String(s) => Ok(Value::String(s)),
+            Value::Number(num) => Ok(Value::String(num.to_string())),
+            Value::Bool(b) => Ok(Value::String(b.to_string())),
+            Value::DateTime(dt) => Ok(Value::String(
+                dt.to_rfc3339_opts(SecondsFormat::AutoSi, true),
+            )),
+            Value::Array(_) | Value::Object(_) => Ok(Value::String(value.to_string())),
+        }
+    }
+}

src/parser/coercions/sub_str.rs

@@ -0,0 +1,33 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct CoerceSubstr {
+    pub value: BoxedExpression,
+    pub start_idx: Option<usize>,
+    pub end_idx: Option<usize>,
+}
+
+impl Expression for CoerceSubstr {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let v = self.value.calculate(json)?;
+        match v {
+            Value::String(s) => match (self.start_idx, self.end_idx) {
+                (Some(start), Some(end)) => Ok(s
+                    .get(start..end)
+                    .map_or_else(|| Value::Null, |s| Value::String(s.to_string()))),
+                (Some(start), None) => Ok(s
+                    .get(start..)
+                    .map_or_else(|| Value::Null, |s| Value::String(s.to_string()))),
+                (None, Some(end)) => Ok(s
+                    .get(..end)
+                    .map_or_else(|| Value::Null, |s| Value::String(s.to_string()))),
+                _ => Err(Error::UnsupportedCOERCE(format!(
+                    "COERCE substr for {s}, [{:?}:{:?}]",
+                    self.start_idx, self.end_idx
+                ))),
+            },
+            v => Err(Error::UnsupportedCOERCE(format!("{v} COERCE substr",))),
+        }
+    }
+}

src/parser/coercions/title.rs

@@ -0,0 +1,25 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct CoerceTitle {
+    pub value: BoxedExpression,
+}
+
+impl Expression for CoerceTitle {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let v = self.value.calculate(json)?;
+        match v {
+            Value::String(s) => {
+                let mut c = s.chars();
+                match c.next() {
+                    None => Ok(Value::String(s)),
+                    Some(f) => Ok(Value::String(
+                        f.to_uppercase().collect::<String>() + c.as_str().to_lowercase().as_str(),
+                    )),
+                }
+            }
+            v => Err(Error::UnsupportedCOERCE(format!("{v} COERCE title",))),
+        }
+    }
+}

src/parser/coercions/uppercase.rs

@@ -0,0 +1,17 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct CoerceUppercase {
+    pub value: BoxedExpression,
+}
+
+impl Expression for CoerceUppercase {
+    fn calculate(&self, json: &[u8]) -> crate::parser::parse::Result<Value> {
+        let v = self.value.calculate(json)?;
+        match v {
+            Value::String(s) => Ok(Value::String(s.to_uppercase())),
+            v => Err(Error::UnsupportedCOERCE(format!("{v} COERCE uppercase",))),
+        }
+    }
+}

src/parser/expressions/add.rs

@@ -0,0 +1,25 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct Add {
+    pub left: BoxedExpression,
+    pub right: BoxedExpression,
+}
+
+impl Expression for Add {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let left = self.left.calculate(json)?;
+        let right = self.right.calculate(json)?;
+
+        match (left, right) {
+            (Value::String(s1), Value::String(ref s2)) => Ok(Value::String(s1 + s2)),
+            (Value::String(s1), Value::Null) => Ok(Value::String(s1)),
+            (Value::Null, Value::String(s2)) => Ok(Value::String(s2)),
+            (Value::Number(n1), Value::Number(n2)) => Ok(Value::Number(n1 + n2)),
+            (Value::Number(n1), Value::Null) => Ok(Value::Number(n1)),
+            (Value::Null, Value::Number(n2)) => Ok(Value::Number(n2)),
+            (l, r) => Err(Error::UnsupportedTypeComparison(format!("{l} + {r}",))),
+        }
+    }
+}

src/parser/expressions/and.rs

@@ -0,0 +1,27 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct And {
+    pub left: BoxedExpression,
+    pub right: BoxedExpression,
+}
+
+impl Expression for And {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let left = self.left.calculate(json)?;
+
+        if let Value::Bool(is_true) = left {
+            if !is_true {
+                return Ok(left);
+            }
+        }
+
+        let right = self.right.calculate(json)?;
+
+        match (left, right) {
+            (Value::Bool(b1), Value::Bool(b2)) => Ok(Value::Bool(b1 && b2)),
+            (l, r) => Err(Error::UnsupportedTypeComparison(format!("{l} && {r}",))),
+        }
+    }
+}

src/parser/expressions/arr.rs

@@ -0,0 +1,17 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct Arr {
+    pub arr: Vec<BoxedExpression>,
+}
+
+impl Expression for Arr {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let mut arr = Vec::new();
+        for e in &self.arr {
+            arr.push(e.calculate(json)?);
+        }
+        Ok(Value::Array(arr))
+    }
+}

src/parser/expressions/between.rs

@@ -0,0 +1,35 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct Between {
+    pub left: BoxedExpression,
+    pub right: BoxedExpression,
+    pub value: BoxedExpression,
+}
+
+impl Expression for Between {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let left = self.left.calculate(json)?;
+        let right = self.right.calculate(json)?;
+        let value = self.value.calculate(json)?;
+
+        match (value, left, right) {
+            (Value::String(v), Value::String(lhs), Value::String(rhs)) => {
+                Ok(Value::Bool(v > lhs && v < rhs))
+            }
+            (Value::Number(v), Value::Number(lhs), Value::Number(rhs)) => {
+                Ok(Value::Bool(v > lhs && v < rhs))
+            }
+            (Value::DateTime(v), Value::DateTime(lhs), Value::DateTime(rhs)) => {
+                Ok(Value::Bool(v > lhs && v < rhs))
+            }
+            (Value::Null, _, _) | (_, Value::Null, _) | (_, _, Value::Null) => {
+                Ok(Value::Bool(false))
+            }
+            (v, lhs, rhs) => Err(Error::UnsupportedTypeComparison(format!(
+                "{v} BETWEEN {lhs} {rhs}",
+            ))),
+        }
+    }
+}

src/parser/expressions/bool.rs

@@ -0,0 +1,12 @@
+use crate::parser::{Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct Bool {
+    pub b: bool,
+}
+
+impl Expression for Bool {
+    fn calculate(&self, _: &[u8]) -> Result<Value> {
+        Ok(Value::Bool(self.b))
+    }
+}

src/parser/expressions/contains.rs

@@ -0,0 +1,22 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct Contains {
+    pub left: BoxedExpression,
+    pub right: BoxedExpression,
+}
+
+impl Expression for Contains {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let left = self.left.calculate(json)?;
+        let right = self.right.calculate(json)?;
+        match (left, right) {
+            (Value::String(s1), Value::String(s2)) => Ok(Value::Bool(s1.contains(&s2))),
+            (Value::Array(arr1), v) => Ok(Value::Bool(arr1.contains(&v))),
+            (l, r) => Err(Error::UnsupportedTypeComparison(format!(
+                "{l} CONTAINS {r}",
+            ))),
+        }
+    }
+}

src/parser/expressions/contains_all.rs

@@ -0,0 +1,35 @@
+use crate::parser::parse::BoxedExpression;
+use crate::parser::{Error, Expression, Result, Value};
+
+#[derive(Debug)]
+pub(in crate::parser) struct ContainsAll {
+    pub left: BoxedExpression,
+    pub right: BoxedExpression,
+}
+
+impl Expression for ContainsAll {
+    fn calculate(&self, json: &[u8]) -> Result<Value> {
+        let left = self.left.calculate(json)?;
+        let right = self.right.calculate(json)?;
+        match (left, right) {
+            (Value::String(s1), Value::String(s2)) => {
+                let b1: Vec<char> = s1.chars().collect();
+                Ok(Value::Bool(s2.chars().all(|b| b1.contains(&b))))
+            }
+            (Value::Array(arr1), Value::Array(arr2)) => {
+                Ok(Value::Bool(arr2.iter().all(|v| arr1.contains(v))))
+            }
+            (Value::Array(arr), Value::String(s)) => Ok(Value::Bool(
+                s.chars()
+                    .all(|v| arr.contains(&Value::String(v.to_string()))),
+            )),
+            (Value::String(s), Value::Array(arr)) => Ok(Value::Bool(arr.iter().all(|v| match v {
+                Value::String(s2) => s.contains(s2),
+                _ => false,
+            }))),
+            (l, r) => Err(Error::UnsupportedTypeComparison(format!(
+                "{l} CONTAINS_ALL {r}",
+            ))),
+        }
+    }
+}