dapt 0.1.9

serializing and unseralizing unstructured data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

mod literal;
mod math;
mod path;
mod strings;

use dyn_clone::DynClone;
use std::fmt::Display;

pub use literal::*;
pub use math::*;
pub use path::*;
pub use strings::*;

use crate::{Any, Dapt};

// Expression is a trait that takes in a dapt packet and returns an
// optional value. This value can be Any type, which is what a dapt packet
// can return.
pub trait Expression: Display + DynClone + Send + Sync {
    fn evaluate<'a, 'b: 'a>(&'a self, d: &'b Dapt) -> Option<Any<'a>>;
}
dyn_clone::clone_trait_object!(Expression);

#[cfg(test)]
mod test {
    use super::*;
    use crate::query::parser::Parser;

    macro_rules! assert_expression {
        ( $source:expr, $expr:expr, $expected:expr) => {
            let mut parser = Parser::from($expr);
            let expr = parser.parse_expression().unwrap();
            let d: Dapt = serde_json::from_str($source).unwrap();
            let result = expr.evaluate(&d).unwrap();
            assert_eq!(result, $expected);
        };
    }

    #[test]
    fn test_expression() {
        assert_expression!(r#"{"a": 10}"#, "\"a\"", Any::U64(10));
        assert_expression!(r#"{"a": 10}"#, "add(\"a\", 10)", Any::U64(20));
        assert_expression!(r#"{"a": 10}"#, "neg(\"a\", 10)", Any::U64(0));
        assert_expression!(r#"{"a": 10}"#, "mul(\"a\", 10)", Any::U64(100));
        assert_expression!(r#"{"a": 10}"#, "div(\"a\", 5)", Any::U64(2));
        assert_expression!(r#"{"a": 10}"#, "mod(\"a\", 4)", Any::USize(2));
        assert_expression!(r#"{"a": "HELLO"}"#, "lower(\"a\")", "hello");
        assert_expression!(r#"{"a": "hello"}"#, "upper(\"a\")", "HELLO");
        assert_expression!(r#"{"a": " hello "}"#, "trim(\"a\")", "hello");
        assert_expression!(r#"{"a": " hello "}"#, "trim_left(\"a\")", "hello ");
        assert_expression!(r#"{"a": " hello "}"#, "trim_right(\"a\")", " hello");
        assert_expression!(
            r#"{"a": "hello", "b": "world"}"#,
            "concat(\"a\", ' ', \"b\")",
            "hello world"
        );
        assert_expression!(
            r#"{"a": "hello world"}"#,
            "split(\"a\", ' ')",
            Any::Array(vec![Any::Str("hello"), Any::Str("world")])
        );
        assert_expression!(r#"{"a.b.c": "hello"}"#, r#"length("a\.b\.c")"#, 5);
        // assert_expression!(r#"{"a.b.c": "hello"}"#, r#"length("\"a.b.c\"")"#, 5);
    }
}