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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#[macro_use]
extern crate quote;
use syn::parse_str;
use std::collections::{BTreeMap, HashMap};
mod operator;
mod reflect;
mod values;
pub use self::reflect::eval;
pub use self::values::Value;
pub struct Eval(HashMap<String, syn::Expr>);
impl Default for Eval {
fn default() -> Self {
Self(HashMap::new())
}
}
impl Eval {
pub fn new(c: HashMap<String, syn::Expr>) -> Self {
Self(c)
}
pub fn insert(mut self, k: &str, v: &str) -> Result<Self, ()> {
let e = parse_str::<syn::Expr>(v).map_err(|_| ())?;
self.0.insert(k.to_owned(), e);
Ok(self)
}
pub fn remove(mut self, k: &str) -> Self {
self.0.remove(k);
self
}
pub fn eval(&self, src: &str) -> Option<Value> {
parse_str::<syn::Expr>(src)
.ok()
.map_or(None, |src| eval(&ctx_as_ref(&self.0), &src))
}
}
pub fn ctx_as_ref(ctx: &HashMap<String, syn::Expr>) -> BTreeMap<&str, &syn::Expr> {
let mut b: BTreeMap<&str, &syn::Expr> = BTreeMap::new();
for (k, v) in ctx {
b.insert(k, v);
}
b
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test() -> Result<(), ()> {
let e = Eval::default()
.insert("foo", "true")?
.insert("bar", "false")?;
assert_eq!(e.eval("foo != bar").unwrap(), Value::Bool(true));
assert_eq!(
e.eval("true && foo != bar && true").unwrap(),
Value::Bool(true)
);
assert_eq!(e.eval("1 == 1 != bar").unwrap(), Value::Bool(true));
assert_eq!(e.eval("1 == 1 + 1 == bar").unwrap(), Value::Bool(true));
Ok(())
}
}