lemma-engine 0.10.2

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
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

//! Unit exponents stay within `MAX_UNIT_EXPONENT` (64): written exponents, compound units of
//! compound units, and measure products across rules are rejected at load, never overflowed.

use indexmap::IndexMap;
use lemma::DateTimeValue;
use lemma::Engine;
use std::path::PathBuf;
use std::sync::Arc;

fn source() -> lemma::SourceType {
    lemma::SourceType::Path(Arc::new(PathBuf::from("unit_exponent_limit.lemma")))
}

fn load_error(code: &str) -> String {
    let mut engine = Engine::new();
    let errors = engine
        .load([(source(), code.to_string())])
        .expect_err("load must reject the spec");
    errors
        .iter()
        .map(ToString::to_string)
        .collect::<Vec<_>>()
        .join("\n")
}

fn eval_rule(code: &str, rule_name: &str) -> String {
    let mut engine = Engine::new();
    engine
        .load([(source(), code.to_string())])
        .expect("spec must load");
    let now = DateTimeValue::now();
    let response = engine
        .evaluate(None, "physics", Some(&now), IndexMap::new(), None, false)
        .expect("evaluate must complete");
    let result = response.results.get(rule_name).expect("rule in response");
    assert!(!result.vetoed, "rule vetoed: {:?}", result.veto_reason);
    result.result().expect("result").to_string()
}

#[test]
fn written_exponent_above_limit_is_rejected() {
    let joined = load_error(
        r#"
spec physics
data length: measure
  -> unit meter: 1
data hyper: measure
  -> unit hyper_meter: meter^65
"#,
    );
    assert!(
        joined.contains("maximum unit exponent of 64"),
        "got: {joined}"
    );
}

#[test]
fn written_exponent_far_above_i32_product_range_is_rejected() {
    let joined = load_error(
        r#"
spec physics
data length: measure
  -> unit meter: 1
data hyper: measure
  -> unit hyper_meter: meter^1000000000
data hyper_cubed: measure
  -> unit hyper_meter_cubed: hyper_meter^3
data a: 2 hyper_meter_cubed
rule r: a * a
"#,
    );
    assert!(
        joined.contains("maximum unit exponent of 64"),
        "got: {joined}"
    );
}

#[test]
fn repeated_factor_summing_above_limit_is_rejected() {
    let joined = load_error(
        r#"
spec physics
data length: measure
  -> unit meter: 1
data hyper: measure
  -> unit hyper_meter: meter^40 * meter^40
"#,
    );
    assert!(
        joined.contains("maximum unit exponent of 64"),
        "got: {joined}"
    );
}

#[test]
fn compound_of_compound_above_limit_is_rejected() {
    let joined = load_error(
        r#"
spec physics
data length: measure
  -> unit meter: 1
data hyper: measure
  -> unit hyper_meter: meter^32
data hyper_cubed: measure
  -> unit hyper_meter_cubed: hyper_meter^3
"#,
    );
    assert!(
        joined.contains("hyper_meter_cubed") && joined.contains("maximum of 64"),
        "got: {joined}"
    );
}

#[test]
fn rule_products_doubling_exponent_past_limit_are_rejected() {
    let joined = load_error(
        r#"
spec physics
data length: measure
  -> unit meter: 1
data side: 2 meter
rule e2: side * side
rule e4: e2 * e2
rule e8: e4 * e4
rule e16: e8 * e8
rule e32: e16 * e16
rule e64: e32 * e32
rule e128: e64 * e64
"#,
    );
    assert!(
        joined.contains("resulting unit exponent exceeds the maximum of 64"),
        "got: {joined}"
    );
}

#[test]
fn exponent_at_limit_evaluates() {
    let code = r#"
spec physics
data length: measure
  -> unit meter: 1
data hyper: measure
  -> unit hyper_meter: meter^32
data hyper_squared: measure
  -> unit hyper_meter_squared: meter^64
data a: 2 hyper_meter
rule squared: a * a
"#;
    assert_eq!(eval_rule(code, "squared"), "4 hyper_meter_squared");
}