lemma-engine 0.9.0

A pure, declarative language for business rules.
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

//! Show must list only data used by the spec's rules.

use lemma::DateTimeValue;
use lemma::Engine;
use std::collections::BTreeSet;

#[test]
fn show_lists_only_data_used_by_rules() {
    let code = r#"
spec t
data used: 4
data unused: 5
rule r: used
"#;

    let mut engine = Engine::new();
    engine
        .load([(lemma::SourceType::Volatile, code.to_string())])
        .expect("load");
    let show = engine
        .show(None, "t", Some(&DateTimeValue::now()))
        .expect("show");

    let keys: BTreeSet<&str> = show.data.keys().map(String::as_str).collect();
    assert_eq!(keys, BTreeSet::from(["used"]));
}

#[test]
fn show_omits_data_only_used_in_primary_arm_under_unless_true() {
    let code = r#"
spec t
data used: 4
data dead: 5
rule r: used * dead
 unless true then 1
"#;

    let mut engine = Engine::new();
    engine
        .load([(lemma::SourceType::Volatile, code.to_string())])
        .expect("load");
    let show = engine
        .show(None, "t", Some(&DateTimeValue::now()))
        .expect("show");

    let keys: BTreeSet<&str> = show.data.keys().map(String::as_str).collect();
    assert_eq!(keys, BTreeSet::new());
}

#[test]
fn show_omits_dead_under_unless_inlined_divide_rule() {
    let code = r#"
spec t
data dead: 5
rule dep: 5 / 2
rule r: dead
 unless dep < 4 then 1
"#;

    let mut engine = Engine::new();
    engine
        .load([(lemma::SourceType::Volatile, code.to_string())])
        .expect("load");
    let show = engine
        .show(None, "t", Some(&DateTimeValue::now()))
        .expect("show");

    assert!(
        !show.data.contains_key("dead"),
        "dead must not appear when unless dep < 4 is statically true; keys: {:?}",
        show.data.keys().collect::<Vec<_>>()
    );
}

#[test]
fn show_omits_dead_under_unless_nested_arithmetic() {
    let code = r#"
spec t
data dead: 5
rule r: dead
 unless (1 + 2) * 3 / 4 < 10 then 1
"#;

    let mut engine = Engine::new();
    engine
        .load([(lemma::SourceType::Volatile, code.to_string())])
        .expect("load");
    let show = engine
        .show(None, "t", Some(&DateTimeValue::now()))
        .expect("show");

    assert!(
        !show.data.contains_key("dead"),
        "dead must not appear when nested arithmetic unless is statically true; keys: {:?}",
        show.data.keys().collect::<Vec<_>>()
    );
}