rusty-rules 0.2.1

A blazingly fast, flexible, and extensible rules engine written in 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

#![cfg(not(feature = "send"))]

use mlua::prelude::*;
use rusty_rules::{Engine, Operator, Value};
use serde_json::json;

#[test]
fn test_lua_operator() {
    let lua = Lua::new();

    let mut engine = Engine::<str>::new();

    // Register method fetcher
    engine.register_fetcher("sample", |_ctx, _args| Ok(Value::from("sample string")));

    let lua2 = lua.clone();
    engine.register_operator("eval", move |value| {
        let script = match value {
            serde_json::Value::String(s) => s,
            _ => return Err("`lua` requires a string script".into()),
        };
        let func = lua2
            .load(script)
            .eval::<LuaFunction>()
            .map_err(|err| err.to_string())?;

        Ok(Operator::new(move |ctx, value| match value {
            Value::String(s) => Ok(func.call((ctx, s))?),
            Value::Number(n) => Ok(func.call((ctx, n.is_i64()))?),
            _ => Ok(false),
        }))
    });

    // Run the tests
    let rule = engine
        .compile_rule(&json!({
            "sample": {
                "eval": "function(ctx, value) return ctx == '1' and string.find(value, 'sample') ~= nil end"
            },
        }))
        .unwrap();

    assert!(rule.evaluate(&"1").unwrap());
    assert!(!rule.evaluate(&"2").unwrap());
}