nbcl 0.4.6

Configuration language designed to be easy and understandable.
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

use nbcl::{NativeNodeSchema, PropValidation, Type, Value};
use std::sync::{Arc, Mutex};

#[test]
fn test_native_fn_registration() {
    let call_count = Arc::new(Mutex::new(0));
    let call_count_captured = Arc::clone(&call_count);

    let mut engine = nbcl::NbclEngine::new();
    engine.register_native_fn("increment", vec![], Type::Null, move |_| {
        let mut count = call_count_captured.lock().unwrap();
        *count += 1;
        Ok(Value::Null)
    });

    let file = engine.parse_str("increment() increment()").unwrap();
    engine.evaluate_ast(file).unwrap();

    assert_eq!(*call_count.lock().unwrap(), 2);
}

#[test]
fn test_complex_logic_and_scoping() {
    let mut engine = nbcl::NbclEngine::new();
    engine.register_node(NativeNodeSchema {
        type_name: "Result".into(),
        enforce_id: false,
        validation: PropValidation::Loose,
        child_count: None,
    });

    let code = r#"
        let base_cpu = 2
        let multiplier = 4
        let total_cpu = (base_cpu + 2) * multiplier / 2 # (4 * 4) / 2 = 8
        
        let is_valid = total_cpu == 8 && true
        
        # Test truthy/falsy coalescing
        let version = null || "v1.0"
        
        Result "check" {
            cpu = total_cpu
            valid = is_valid
            ver = version
        }
    "#;

    let file = engine.parse_str(code).unwrap();
    let resolved = engine.evaluate_ast(file).unwrap();

    let node = &resolved.root_nodes[0];
    assert_eq!(node.props.get("cpu").unwrap(), &Value::Int(8));
    assert_eq!(node.props.get("valid").unwrap(), &Value::Bool(true));
    assert_eq!(node.props.get("ver").unwrap(), &Value::Str("v1.0".into()));
}