cadi-core 2.0.0

CADI core types and utilities for content-addressed development
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

use cadi_core::parser::parse_file;
use cadi_core::ast::*;

#[test]
fn test_parse_simple_interface() {
    let input = r#"
    @interface VideoCodec {
        encode(frame: ImageData, quality: u8) -> Blob
    }
    "#;
    
    let doc = parse_file(input).expect("Failed to parse");
    assert_eq!(doc.interfaces.len(), 1);
    assert_eq!(doc.interfaces[0].name, "VideoCodec");
    assert_eq!(doc.interfaces[0].methods.len(), 1);
    assert_eq!(doc.interfaces[0].methods[0].name, "encode");
    assert_eq!(doc.interfaces[0].methods[0].params.len(), 2);
    assert_eq!(doc.interfaces[0].methods[0].return_type, "Blob");
}

#[test]
fn test_parse_with_contract() {
    let input = r#"
    @interface VideoCodec {
        @contract {
            codec: "h264"
            profile: "baseline"
            ensures: ["decode(encode(x)) == x"]
        }
    }
    "#;

    let doc = parse_file(input).expect("Failed to parse");
    assert_eq!(doc.interfaces.len(), 1);
    let contract = doc.interfaces[0].annotations.iter().find_map(|a| match a {
        Annotation::Contract(c) => Some(c),
        _ => None,
    }).expect("Contract not found");

    assert_eq!(contract.codec.as_deref(), Some("h264"));
    assert_eq!(contract.profile.as_deref(), Some("baseline"));
    assert_eq!(contract.ensures.len(), 1);
}

#[test]
fn test_parse_full_v2_spec_features() {
    let input = r#"
    @interface Advanced {
        @effects {
            concurrency: "thread_safe"
            io: ["network.send"]
        }
        @resources {
            memory: { peak: "1GB" }
        }
    }
    "#;

    let doc = parse_file(input).expect("Failed to parse");
    assert_eq!(doc.interfaces.len(), 1);
    
    let effects = doc.interfaces[0].annotations.iter().find_map(|a| match a {
        Annotation::Effects(e) => Some(e),
        _ => None,
    }).expect("Effects not found");
    assert_eq!(effects.concurrency.as_deref(), Some("thread_safe"));
    assert_eq!(effects.io.len(), 1);

    let resources = doc.interfaces[0].annotations.iter().find_map(|a| match a {
        Annotation::Resources(r) => Some(r),
        _ => None,
    }).expect("Resources not found");
    
    assert!(resources.memory.contains_key("peak"));
}

#[test]
fn test_parse_impl_and_constraints() {
    let input = r#"
    @impl VideoCodec.webgl1 {
        chunk_id: "chunk:sha256:abc123..."
        caps: ["webgl>=1.0"]
        
        @contract_impl {
            codec: "h264"
        }
    }
    
    @constraints {
        match_contract {
             // simplified rule for now
        }
    }
    "#;
    
    let doc = parse_file(input).expect("Failed to parse");
    assert_eq!(doc.implementations.len(), 1);
    assert_eq!(doc.implementations[0].name, "VideoCodec.webgl1");
    // caps is an attribute
    assert!(doc.implementations[0].attributes.contains_key("caps"));
    
    // Check constraints
    assert_eq!(doc.constraints.len(), 1);
}