vibe/metamodel/
project.rs1use crate::ast::{Item, Program};
4
5use super::namespace::{term, LANGUAGE_VERSION_IRI, VIBE_NS};
6
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum StatementKind {
9 Type,
10 ClassAssertion,
11 Property,
12}
13
14#[derive(Debug, Clone, PartialEq, Eq)]
15pub struct SemanticStatement {
16 pub subject: String,
17 pub predicate: String,
18 pub object: String,
19 pub kind: StatementKind,
20}
21
22pub fn project_program_summary(program: &Program, module_iri: &str) -> Vec<SemanticStatement> {
24 let mut out = Vec::new();
25 out.push(SemanticStatement {
26 subject: module_iri.to_string(),
27 predicate: term("languageVersion"),
28 object: LANGUAGE_VERSION_IRI.to_string(),
29 kind: StatementKind::Property,
30 });
31 out.push(SemanticStatement {
32 subject: module_iri.to_string(),
33 predicate: format!("{VIBE_NS}type"),
34 object: term("Program"),
35 kind: StatementKind::ClassAssertion,
36 });
37 for (i, item) in program.items.iter().enumerate() {
38 let node = format!("{module_iri}#item-{i}");
39 let kind = item_kind_local(item);
40 out.push(SemanticStatement {
41 subject: module_iri.to_string(),
42 predicate: term("contains"),
43 object: node.clone(),
44 kind: StatementKind::Property,
45 });
46 out.push(SemanticStatement {
47 subject: node.clone(),
48 predicate: term("nodeKind"),
49 object: kind.to_string(),
50 kind: StatementKind::Property,
51 });
52 out.push(SemanticStatement {
53 subject: node,
54 predicate: format!("{VIBE_NS}type"),
55 object: term("AstNode"),
56 kind: StatementKind::ClassAssertion,
57 });
58 }
59 out
60}
61
62fn item_kind_local(item: &Item) -> &'static str {
63 match item {
64 Item::Function(_) => "Item.Function",
65 Item::Hook(_) => "Item.Hook",
66 Item::Const(_) => "Item.Const",
67 Item::Enum(_) => "Item.Enum",
68 Item::Field(_) => "Item.Field",
69 Item::Material(_) => "Item.Material",
70 Item::Law(_) => "Item.Law",
71 Item::Cell(_) => "Item.Cell",
72 Item::Present(_) => "Item.Present",
73 Item::Bind(_) => "Item.Bind",
74 Item::Statement(_) => "Item.Statement",
75 }
76}
77
78#[cfg(test)]
79mod tests {
80 use super::*;
81 use crate::parse::parse_program;
82 use crate::span::Span;
83
84 #[test]
85 fn projects_empty_program() {
86 let p = Program {
87 span: Span::point(0),
88 module: None,
89 imports: vec![],
90 prefixes: vec![],
91 locales: vec![],
92 requires: vec![],
93 items: vec![],
94 };
95 let stmts = project_program_summary(&p, "urn:qualia:vibe:fixture");
96 assert!(stmts.iter().any(|s| s.object.contains("LanguageVersion")));
97 }
98
99 #[test]
100 fn projects_function_item_kind() {
101 let src = "fn hello() {}";
102 let p = parse_program(src).expect("parse");
103 let stmts = project_program_summary(&p, "urn:qualia:vibe:hello");
104 assert!(stmts.iter().any(|s| s.object == "Item.Function"));
105 }
106}