datalogic-rs 5.0.0

A fast, type-safe Rust implementation of JSONLogic for evaluating logical rules as JSON. Perfect for business rules engines and dynamic filtering in Rust applications.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

#![cfg(feature = "serde_json")]

use datalogic_rs::Engine;
use serde_json::json;

#[test]
fn test_basic_equality() {
    let engine = Engine::new();
    let logic = json!({"==": [1, 1]});
    let data = json!({});
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &data)
        .unwrap();
    assert_eq!(result, json!(true));
}

#[test]
fn test_variable_access() {
    let engine = Engine::new();
    let logic = json!({"var": "name"});
    let data = json!({"name": "Alice"});
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &data)
        .unwrap();
    assert_eq!(result, json!("Alice"));
}

#[test]
fn test_if_then_else() {
    let engine = Engine::new();
    let logic = json!({
        "if": [
            {"==": [{"var": "temp"}, 100]},
            "hot",
            "cold"
        ]
    });

    let result1 = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &json!({"temp": 100}))
        .unwrap();
    assert_eq!(result1, json!("hot"));

    let result2 = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &json!({"temp": 50}))
        .unwrap();
    assert_eq!(result2, json!("cold"));
}

// `val` and the metadata-hint `index` form are part of the ext-control extension.
#[cfg(feature = "ext-control")]
#[test]
fn test_map_with_context() {
    let engine = Engine::new();
    let logic = json!({
        "map": [
            [1, 2, 3],
            {"+": [{"val": []}, {"val": [[0], "index"]}]}
        ]
    });
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &json!({}))
        .unwrap();
    assert_eq!(result, json!([1, 3, 5]));
}

#[cfg(feature = "datetime")]
#[test]
fn test_now_operator() {
    use chrono::DateTime;
    let engine = Engine::new();

    let logic = json!({"now": []});
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &json!({}))
        .unwrap();

    assert!(result.is_string(), "Now operator should return a string");

    if let serde_json::Value::String(datetime_str) = &result {
        let parsed = DateTime::parse_from_rfc3339(datetime_str);
        assert!(
            parsed.is_ok(),
            "Now operator should return valid ISO datetime format"
        );
    }

    std::thread::sleep(std::time::Duration::from_millis(10));
    let result2 = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &json!({}))
        .unwrap();
    assert!(
        result2.is_string(),
        "Second call to now should also return a string"
    );
}

#[test]
fn test_evaluate_json_value_api() {
    let engine = Engine::new();
    let logic = json!({"+": [{"var": "a"}, {"var": "b"}]});
    let data = json!({"a": 3, "b": 4});
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &data)
        .unwrap();
    assert_eq!(result, json!(7));
}

#[cfg(feature = "ext-string")]
#[test]
fn test_evaluate_with_arena_dispatch() {
    let engine = Engine::new();
    // A rule that triggers arena dispatch (filter + length).
    let logic = json!({"length": {"filter": [{"var": "items"}, {">": [{"var": ""}, 2]}]}});
    let data = json!({"items": [1, 2, 3, 4, 5]});
    let result = engine
        .eval_into::<serde_json::Value, _, _>(&logic, &data)
        .unwrap();
    assert_eq!(result, json!(3));
}