1pub mod cbor_ld;
4mod codec;
5mod decode;
6mod encode;
7
8pub const TAG_VIBE_AST: u64 = 4200;
9
10#[derive(Debug, Clone, PartialEq)]
11pub enum DecodeError {
12 UnexpectedTag(u64),
13 UnexpectedType(&'static str),
14 MissingField(&'static str),
15 InvalidCbor(String),
16 Eof,
17}
18
19impl std::fmt::Display for DecodeError {
20 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21 match self {
22 Self::UnexpectedTag(t) => write!(f, "unexpected CBOR tag {t}"),
23 Self::UnexpectedType(t) => write!(f, "unexpected type: {t}"),
24 Self::MissingField(fld) => write!(f, "missing field: {fld}"),
25 Self::InvalidCbor(s) => write!(f, "invalid CBOR: {s}"),
26 Self::Eof => write!(f, "unexpected end of input"),
27 }
28 }
29}
30
31impl std::error::Error for DecodeError {}
32
33pub use cbor_ld::{
34 call_cbor_ld, compress_iri, decode_value_cbor_ld, derive_provider_namespace,
35 encode_value_cbor_ld, expand_term, ingest_json_with_provider_ns, DEFAULT_CONTEXT_IRI,
36 TAG_CBOR_LD_COMPRESSED, TAG_CBOR_LD_UNCOMPRESSED, TAG_VIBE_DISCLOSURE_DENIED,
37 TAG_VIBE_DURATION, TAG_VIBE_INSTANT, TAG_VIBE_IRI, TAG_VIBE_QUANTITY, TAG_VIBE_QUIN_REF,
38};
39pub use decode::decode;
40pub use encode::encode;
41
42#[cfg(test)]
43mod tests {
44 use super::codec::{CborDecoder, CborEncoder};
45 use super::*;
46 use crate::ast::*;
47 use crate::span::Span;
48
49 #[test]
50 fn encode_decode_empty_program() {
51 let prog = Program {
52 span: Span::new(0, 0),
53 module: None,
54 imports: Vec::new(),
55 prefixes: Vec::new(),
56 locales: Vec::new(),
57 requires: Vec::new(),
58 items: Vec::new(),
59 };
60 let bytes = encode(&prog);
61 assert!(!bytes.is_empty());
62 assert_eq!(bytes[0], (6 << 5) | 25);
65 let decoded = decode(&bytes).unwrap();
66 assert_eq!(decoded, prog);
67 }
68
69 #[test]
70 fn encode_decode_simple_program() {
71 let prog = Program {
72 span: Span::new(0, 50),
73 module: Some(ModuleDecl {
74 span: Span::new(0, 20),
75 name: Name::Ident("test".to_string()),
76 }),
77 imports: vec![ImportDecl {
78 span: Span::new(21, 40),
79 path: "vibe:0.1/render".to_string(),
80 alias: Some("r".to_string()),
81 }],
82 prefixes: vec![PrefixDecl {
83 span: Span::new(41, 45),
84 prefix: "ex".to_string(),
85 iri: "http://example.org/".to_string(),
86 }],
87 locales: Vec::new(),
88 requires: vec![CapSpec {
89 span: Span::new(46, 48),
90 id: "capability.invoke".to_string(),
91 args: Vec::new(),
92 }],
93 items: vec![Item::Const(ConstDecl {
94 span: Span::new(49, 50),
95 name: "x".to_string(),
96 ty: None,
97 value: Expr {
98 span: Span::new(49, 50),
99 kind: ExprKind::Literal(Literal::Int(42)),
100 },
101 })],
102 };
103 let bytes = encode(&prog);
104 let decoded = decode(&bytes).unwrap();
105 assert_eq!(decoded, prog);
106 }
107
108 #[test]
109 fn cbor_encoder_basic() {
110 let mut enc = CborEncoder::new();
111 enc.uint(42);
112 assert_eq!(enc.finish(), vec![24, 42]);
114
115 let mut enc = CborEncoder::new();
116 enc.uint(5);
117 assert_eq!(enc.finish(), vec![5]);
119
120 let mut enc = CborEncoder::new();
121 enc.str("hello");
122 let bytes = enc.finish();
123 assert_eq!(bytes[0], (3 << 5) | 5); assert_eq!(&bytes[1..], b"hello");
125 }
126
127 #[test]
128 fn cbor_encoder_array() {
129 let mut enc = CborEncoder::new();
130 enc.array(3);
131 enc.uint(1);
132 enc.uint(2);
133 enc.uint(3);
134 assert_eq!(enc.finish(), vec![0x83, 1, 2, 3]);
135 }
136
137 #[test]
138 fn cbor_encoder_map() {
139 let mut enc = CborEncoder::new();
140 enc.map(2);
141 enc.str("a");
142 enc.uint(1);
143 enc.str("b");
144 enc.uint(2);
145 let bytes = enc.finish();
146 assert_eq!(bytes[0], (5 << 5) | 2); }
148
149 #[test]
150 fn cbor_encoder_tag() {
151 let mut enc = CborEncoder::new();
152 enc.tag(4200);
153 let bytes = enc.finish();
154 assert_eq!(bytes, vec![(6 << 5) | 25, 0x10, 0x68]);
156 }
157
158 #[test]
159 fn cbor_decoder_basic() {
160 let mut dec = CborDecoder::new(&[24, 42]);
162 assert_eq!(dec.uint().unwrap(), 42);
163 let mut dec = CborDecoder::new(&[5]);
165 assert_eq!(dec.uint().unwrap(), 5);
166 }
167
168 #[test]
169 fn cbor_decoder_string() {
170 let bytes = [(3 << 5) | 5, b'h', b'e', b'l', b'l', b'o'];
171 let mut dec = CborDecoder::new(&bytes);
172 assert_eq!(dec.str().unwrap(), "hello");
173 }
174
175 #[test]
176 fn cbor_decoder_array() {
177 let mut dec = CborDecoder::new(&[0x83, 1, 2, 3]);
178 assert_eq!(dec.array().unwrap(), 3);
179 assert_eq!(dec.uint().unwrap(), 1);
180 assert_eq!(dec.uint().unwrap(), 2);
181 assert_eq!(dec.uint().unwrap(), 3);
182 }
183
184 #[test]
185 fn cbor_decoder_tag() {
186 let bytes = [(6 << 5) | 25, 0x10, 0x68];
187 let mut dec = CborDecoder::new(&bytes);
188 assert_eq!(dec.tag().unwrap(), 4200);
189 }
190
191 #[test]
192 fn decode_wrong_tag_errors() {
193 let mut enc = CborEncoder::new();
194 enc.tag(9999);
195 enc.uint(0);
196 let bytes = enc.finish();
197 let result = decode(&bytes);
198 assert!(result.is_err());
199 match result.unwrap_err() {
200 DecodeError::UnexpectedTag(t) => assert_eq!(t, 9999),
201 _ => panic!("expected UnexpectedTag"),
202 }
203 }
204
205 #[test]
206 fn round_trip_parsed_program() {
207 use crate::parse::parse_program;
208 let src = r#"module test;
209import "vibe:0.1/render" as r;
210prefix ex: <http://example.org/>;
211requires [ capability("capability.invoke") ];
212effect fn go() {
213 let x = 42;
214 let y = "hello";
215 return x;
216}
217"#;
218 let prog = parse_program(src).unwrap();
219 let bytes = encode(&prog);
220 assert!(!bytes.is_empty());
221 assert_eq!(bytes[0], (6 << 5) | 25);
223 let decoded = decode(&bytes).unwrap();
224 assert_eq!(decoded.module, prog.module);
228 assert_eq!(decoded.imports, prog.imports);
229 assert_eq!(decoded.prefixes, prog.prefixes);
230 assert_eq!(decoded.requires, prog.requires);
231 assert_eq!(decoded.items.len(), prog.items.len());
232 }
233
234 #[test]
235 fn round_trip_function_with_body() {
236 use crate::parse::parse_program;
237 let src = r#"effect fn add(a: f32, b: f32) {
238 return a + b;
239}"#;
240 let prog = parse_program(src).unwrap();
241 let bytes = encode(&prog);
242 let decoded = decode(&bytes).unwrap();
243 assert_eq!(decoded.items.len(), 1);
244 match &decoded.items[0] {
245 Item::Function(f) => {
246 assert_eq!(f.name, "add");
247 assert_eq!(f.params.len(), 2);
248 assert_eq!(f.params[0].name, "a");
249 assert_eq!(f.params[1].name, "b");
250 }
251 _ => panic!("expected Function item"),
252 }
253 }
254
255 #[test]
256 fn round_trip_const_with_literal() {
257 use crate::parse::parse_program;
258 let src = r#"const PI = 3.14;"#;
259 let prog = parse_program(src).unwrap();
260 let bytes = encode(&prog);
261 let decoded = decode(&bytes).unwrap();
262 assert_eq!(decoded.items.len(), 1);
263 match &decoded.items[0] {
264 Item::Const(c) => {
265 assert_eq!(c.name, "PI");
266 match &c.value.kind {
267 ExprKind::Literal(Literal::Float(bits)) => {
268 let expected = 3.14_f64.to_bits();
270 assert_eq!(*bits, expected);
271 }
272 _ => panic!("expected Float literal"),
273 }
274 }
275 _ => panic!("expected Const item"),
276 }
277 }
278
279 #[test]
280 fn round_trip_if_statement() {
281 use crate::parse::parse_program;
282 let src = r#"effect fn go() {
283 if true {
284 return 1;
285 } else {
286 return 0;
287 }
288}"#;
289 let prog = parse_program(src).unwrap();
290 let bytes = encode(&prog);
291 let decoded = decode(&bytes).unwrap();
292 assert_eq!(decoded.items.len(), 1);
293 if let Item::Function(f) = &decoded.items[0] {
294 assert_eq!(f.body.stmts.len(), 1);
295 match &f.body.stmts[0] {
296 Stmt::If {
297 then_block,
298 else_block,
299 ..
300 } => {
301 assert_eq!(then_block.stmts.len(), 1);
302 assert!(else_block.is_some());
303 }
304 _ => panic!("expected If statement"),
305 }
306 }
307 }
308
309 #[test]
310 fn round_trip_triple_expression() {
311 use crate::parse::parse_program;
312 let src = r#"effect fn go() {
313 <<(ex:s ex:p ex:o)>>;
314}"#;
315 let prog = parse_program(src).unwrap();
316 let bytes = encode(&prog);
317 let decoded = decode(&bytes).unwrap();
318 assert_eq!(decoded.items.len(), 1);
319 }
320
321 #[test]
322 fn encode_produces_valid_cbor() {
323 let prog = Program {
324 span: Span::new(0, 0),
325 module: None,
326 imports: Vec::new(),
327 prefixes: Vec::new(),
328 locales: Vec::new(),
329 requires: Vec::new(),
330 items: Vec::new(),
331 };
332 let bytes = encode(&prog);
333 assert_eq!(bytes[0], (6 << 5) | 25);
335 assert_eq!(bytes[1], 0x10);
337 assert_eq!(bytes[2], 0x68);
338 assert!((bytes[3] >> 5) == 5);
340 }
341
342 #[test]
345 fn t31_round_trip_field_decl() {
346 use crate::parse::parse_program;
347 let src = r#"module test;
348field pressure_ambient: Pressure unit: <qudt:KiloPascal> support: region representation: grid;
349"#;
350 let prog = parse_program(src).unwrap();
351 let bytes = encode(&prog);
352 assert!(!bytes.is_empty());
353 assert_eq!(bytes[0], (6 << 5) | 25);
355 let decoded = decode(&bytes).unwrap();
356 assert_eq!(decoded.items.len(), prog.items.len());
357 assert!(matches!(decoded.items.first(), Some(Item::Field(_))));
359 if let Some(Item::Field(f)) = decoded.items.first() {
360 assert_eq!(f.name, "pressure_ambient");
361 }
362 }
363
364 #[test]
365 fn t31_round_trip_material_decl() {
366 use crate::parse::parse_program;
367 let src = r#"module test;
368material sucrose_cube: Material yield: 50.0;
369"#;
370 let prog = parse_program(src).unwrap();
371 let bytes = encode(&prog);
372 assert!(!bytes.is_empty());
373 let decoded = decode(&bytes).unwrap();
374 assert_eq!(decoded.items.len(), prog.items.len());
375 assert!(matches!(decoded.items.first(), Some(Item::Material(_))));
376 if let Some(Item::Material(m)) = decoded.items.first() {
377 assert_eq!(m.name, "sucrose_cube");
378 }
379 }
380
381 #[test]
382 fn t31_round_trip_law_decl() {
383 use crate::parse::parse_program;
384 let src = r#"module test;
385law crush when true => 1;
386"#;
387 let prog = parse_program(src).unwrap();
388 let bytes = encode(&prog);
389 assert!(!bytes.is_empty());
390 let decoded = decode(&bytes).unwrap();
391 assert_eq!(decoded.items.len(), prog.items.len());
392 assert!(matches!(decoded.items.first(), Some(Item::Law(_))));
393 if let Some(Item::Law(l)) = decoded.items.first() {
394 assert_eq!(l.name, "crush");
395 }
396 }
397}