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

//! Custom API tests.

use std::sync::{Arc, Mutex};

use expy::{Context, EvalError, Value, eval_in};


#[test]
fn function_constant() {
    let mut ctx = Context::new();
    ctx.set("foo", |_: &mut Context, _: &_| Ok(Value::Integer(42)));
    assert_eq!(eval_in(&mut ctx, "foo()").unwrap().unwrap_integer(), 42);
}

#[test]
fn function_pure() {
    let mut ctx = Context::new();
    ctx.set("foo", |_: &mut Context, args: &[Value]| {
        let Some(&Value::Integer(x)) = args.get(0) else {
            return Err(EvalError::custom("wrong arguments"));
        };
        Ok(Value::Integer(x * 2 + 1))
    });
    assert_eq!(eval_in(&mut ctx, "foo(3)").unwrap().unwrap_integer(), 7);
    assert_eq!(eval_in(&mut ctx, "foo(11)").unwrap().unwrap_integer(), 23);
}

#[test]
fn function_pure_external() {
    fn foo(_: &mut Context, args: &[Value]) -> Result<Value, EvalError> {
        let Some(&Value::Integer(x)) = args.get(0) else {
            return Err(EvalError::custom("wrong arguments"));
        };
        Ok(Value::Integer(x * 2 + 1))
    }

    let mut ctx = Context::new();
    ctx.set("foo", foo);
    assert_eq!(eval_in(&mut ctx, "foo(3)").unwrap().unwrap_integer(), 7);
    assert_eq!(eval_in(&mut ctx, "foo(11)").unwrap().unwrap_integer(), 23);
}

#[test]
fn function_stateful() {
    let mut ctx = Context::new();
    ctx.set("inc", |ctx: &mut Context, _: &_| {
        let mut c = ctx.get("counter").and_then(Value::as_integer).copied().unwrap_or_default();
        c += 1;
        ctx.set("counter", c);
        Ok(Value::Integer(c))
    });
    for c in 1..=100 {
        assert_eq!(eval_in(&mut ctx, "inc()").unwrap().unwrap_integer(), c);
    }
}

#[test]
fn function_local() {
    let mut ctx = Context::new();

    // we'd normally use atomics for counters but this is meant to be general
    let counter = Arc::new(Mutex::new(0));
    ctx.set("inc", {
        let counter = counter.clone();
        move |_: &mut Context, _: &_| {
            let mut c = counter.lock().unwrap();
            *c += 1;
            Ok(Value::Integer(*c))
        }
    });
    for c in 1..=100 {
        assert_eq!(eval_in(&mut ctx, "inc()").unwrap().unwrap_integer(), c);
    }
}