cel-rs 0.2.0

Common Expression Language (cel) for Rust.
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
87
88
89
90
91
92
93
94

use crate::parser::Expression;
use crate::parser::cel::ExpressionParser;
use std::fmt;
use std::result::Result;
use crate::context::Context;
use crate::eval::{Bag, Eval};
use crate::Value;

pub struct Program {
    expr: Expression
}

#[derive(Debug)]
pub struct ParseError {
    message: String,
}


impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.message)
    }
}

impl Program {
    pub fn new(source: &str) -> Result<Program, ParseError> {
        match ExpressionParser::new().parse(source) {
            Ok(expr) => Ok(Program {expr}),
            Err(e) => Err(ParseError{message: format!("{}", e)}),
        }
    }

    pub fn execute(self, context: &mut Context) -> bool {
        self.eval(context).unpack().into()
    }

    pub fn eval(self, context: &mut Context) -> Value {
        let e = Eval::default();
        e.eval(self.expr, context).unpack()
    }
}



#[cfg(test)]
pub mod tests {
    use std::rc::Rc;

    use crate::{program, value::{FnValue, Overload}, Value};

    macro_rules! string {
        ($q:literal) => {
            crate::Value::String(std::rc::Rc::new($q.into()))
        };
    }
    macro_rules! eval_program {
        ($expr:literal) => ({
           eval_program!($expr, &mut crate::context::Context::default())
        });
        ($expr:literal, $ctx:expr) => ({
            let program = crate::program::Program::new($expr);
            assert!(program.is_ok(), "failed to create the program {:?}", program.err());
            let program = program.unwrap();
            program.eval($ctx)
        });
    }

    #[test]
    fn basic_test() {
        assert_eq!(eval_program!(r#"r"""#), string!(""));
    }

    fn calc_string_string(lhs: &Value, rhs: &Value) -> Value {
        Value::Null
    }

    #[test]
    fn fn_test() {
        let func = FnValue {
            name: "calc",
            overloads: &[
                Overload {
                    key: "calc_string",
                    func: calc_string_string
                }
            ],
        };
        let mut ctx = program::Context::default()
        .add_variable("a", Value::String(Rc::new("".into())))
        .add_variable("b", Value::Int(0))
        .add_variable("calc", crate::Value::Function(Rc::new(func)));
        assert_eq!(eval_program!(r#"b.calc(a)"#, &mut ctx), string!(""));
    }
}