expy 0.0.2

Embeddable & extensible expression evaluator
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Serde integration tests

use claims::*;
use expy::{BinaryOp::*, Calc, Context, Expr};
use serde::{Deserialize, Deserializer};
use serde_json::{self, from_value as from_json, json, to_value as to_json};


fn from_str(s: &str) -> Result<Expr, serde_json::Error> {
    from_json(json!(s))
}

fn to_string(expr: &Expr) -> Result<String, serde_json::Error> {
    to_json(expr).map(|value| value.as_str().unwrap().to_owned())
}


#[test]
fn basic_deserialize() {
    let expr = from_str("2 + 2").unwrap();
    assert_eq!(expr, Expr::binary(Add, Expr::literal(2), Expr::literal(2)));
}

#[test]
fn basic_serialize() {
    let expr = Expr::binary(Add, Expr::literal(2), Expr::literal(2));

    // binary operators always have parentheses
    assert_ok_eq!(to_string(&expr), "(2 + 2)");
}

#[test]
fn calc_deserialize_primitive() {
    #[derive(Deserialize)]
    struct Test {
        foo: Calc<usize>,
    }

    let from_verbatim: Test = from_json(json!({"foo": 42})).unwrap();
    assert_eq!(from_verbatim.foo.value(), &42);
    assert_none!(from_verbatim.foo.expr());

    let from_expr: Test = from_json(json!({"foo": "2 + 2 * 2"})).unwrap();
    assert_eq!(from_expr.foo.value(), &6);
    assert_some_eq!(from_expr.foo.expr(), "2 + 2 * 2");
}

#[cfg(glam)]
#[test]
fn calc_deserialize_vector() {
    #[derive(Deserialize)]
    struct Test {
        foo: Calc<glam::Vec2>,
    }

    let from_verbatim: Test = from_json(json!({"foo": [12., 45.]})).unwrap();
    assert_eq!(from_verbatim.foo.value(), &glam::Vec2::new(12., 45.));
    assert_none!(from_verbatim.foo.expr());

    let from_expr: Test = from_json(json!({"foo": "normalize([1., 2.])"})).unwrap();
    assert_eq!(from_expr.foo.value(), &glam::Vec2::new(1., 2.).normalize_or_zero());
    assert_some_eq!(from_expr.foo.expr(), "normalize([1., 2.])");
}

#[test]
fn calc_deserialize_primitive_with_context() {
    fn deserialize_ctx<'de, D>(deserializer: D) -> Result<Calc<u32>, D::Error>
        where D: Deserializer<'de>
    {
        Calc::deserialize_ctx(deserializer, Context::new().with("x", 13))
    }

    #[derive(Deserialize)]
    struct Test {
        #[serde(deserialize_with = "deserialize_ctx")]
        foo: Calc<u32>,
    }

    let from_verbatim: Test = from_json(json!({"foo": 42})).unwrap();
    assert_eq!(from_verbatim.foo.value(), &42);
    assert_none!(from_verbatim.foo.expr());

    let from_expr: Test = from_json(json!({"foo": "x"})).unwrap();
    assert_eq!(from_expr.foo.value(), &13);
    assert_some_eq!(from_expr.foo.expr(), "x");
}