json-eval-rs 0.0.83

High-performance JSON Logic evaluator with schema validation and dependency tracking. Built on blazing-fast Rust engine.
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

use json_eval_rs::RLogic;
use serde_json::json;

/// Test that logical operators return actual values, not just booleans
/// This matches JavaScript behavior where:
/// - `true || "error"` returns `true` (not true converted to boolean)
/// - `false || 42` returns `42` (not 42 converted to boolean)
/// - `1 && 2` returns `2` (the last truthy value)
/// - `0 && 2` returns `0` (the first falsy value)
#[test]
fn test_logical_operators_return_actual_values() {
    let mut engine = RLogic::new();
    let data = json!({});

    // OR operator should return the first truthy value
    let logic_id = engine
        .compile(&json!({"or": [false, 0, "", 42, "never"]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(
        result,
        json!(42),
        "OR should return first truthy value (42)"
    );

    // OR with all falsy should return the last value
    let logic_id = engine.compile(&json!({"or": [false, 0, null]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(
        result,
        json!(null),
        "OR with all falsy should return last value (null)"
    );

    // AND operator should return the first falsy value
    let logic_id = engine
        .compile(&json!({"and": [1, "hello", 0, "never"]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(0), "AND should return first falsy value (0)");

    // AND with all truthy should return the last value
    let logic_id = engine.compile(&json!({"and": [1, "hello", 42]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(
        result,
        json!(42),
        "AND with all truthy should return last value (42)"
    );

    // OR with strings
    let logic_id = engine
        .compile(&json!({"or": ["", "first", "second"]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(
        result,
        json!("first"),
        "OR should return first non-empty string"
    );

    // AND with strings
    let logic_id = engine
        .compile(&json!({"and": ["first", "second", "third"]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(
        result,
        json!("third"),
        "AND with all truthy strings should return last"
    );

    // AND stops at first falsy
    let logic_id = engine
        .compile(&json!({"and": ["first", false, "third"]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(false), "AND should stop and return false");

    // OR stops at first truthy
    let logic_id = engine
        .compile(&json!({"or": [false, "found", false]}))
        .unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!("found"), "OR should stop and return 'found'");

    // Numbers with OR
    let logic_id = engine.compile(&json!({"or": [0, 5]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(5), "OR: 0 || 5 should return 5");

    // Numbers with AND
    let logic_id = engine.compile(&json!({"and": [5, 10]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(10), "AND: 5 && 10 should return 10");

    let logic_id = engine.compile(&json!({"and": [0, 10]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(0), "AND: 0 && 10 should return 0");
}

#[test]
fn test_logical_operators_with_arrays_and_objects() {
    let mut engine = RLogic::new();
    let data = json!({});

    // Arrays are truthy if non-empty, falsy if empty
    let logic_id = engine.compile(&json!({"or": [[], [1, 2, 3]]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!([1, 2, 3]), "OR should return non-empty array");

    let logic_id = engine.compile(&json!({"and": [[1, 2], [3, 4]]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!([3, 4]), "AND should return last array");

    // Empty arrays are falsy, test with strings instead
    let logic_id = engine.compile(&json!({"or": ["", "value"]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!("value"), "OR should return non-empty string");
}

#[test]
fn test_js_compatibility_examples() {
    let mut engine = RLogic::new();
    let data = json!({});

    // Examples from JS that should work identically:
    // true || false => true
    let logic_id = engine.compile(&json!({"or": [true, false]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(true));

    // false || true => true
    let logic_id = engine.compile(&json!({"or": [false, true]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(true));

    // true && false => false
    let logic_id = engine.compile(&json!({"and": [true, false]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(false));

    // false && true => false
    let logic_id = engine.compile(&json!({"and": [false, true]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(false));

    // "hello" || "world" => "hello"
    let logic_id = engine.compile(&json!({"or": ["hello", "world"]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!("hello"));

    // "" || "world" => "world"
    let logic_id = engine.compile(&json!({"or": ["", "world"]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!("world"));

    // "hello" && "world" => "world"
    let logic_id = engine.compile(&json!({"and": ["hello", "world"]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!("world"));

    // "" && "world" => ""
    let logic_id = engine.compile(&json!({"and": ["", "world"]})).unwrap();
    let result = engine.run(&logic_id, &data).unwrap();
    assert_eq!(result, json!(""));
}