Skip to main content

vibe/metamodel/
project.rs

1//! Typed AST → neutral semantic statements (no Quin / core-db).
2
3use 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
22/// Project a program into a bounded list of neutral RDF-like statements.
23pub 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}