domainforge 0.13.0

package/domainforge-core/tests/primitives_integration_tests.rs

@@ -0,0 +1,151 @@
+use domainforge_core::primitives::{Entity, Flow, Resource, ResourceInstance};
+use domainforge_core::units::unit_from_string;
+use rust_decimal::Decimal;
+
+#[test]
+fn test_complete_supply_chain_model() {
+    let supplier = Entity::new_with_namespace("Supplier", "default".to_string());
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+
+    let steel =
+        Resource::new_with_namespace("Steel", unit_from_string("kg"), "default".to_string());
+    let camera =
+        Resource::new_with_namespace("Camera", unit_from_string("units"), "default".to_string());
+
+    let steel_shipment = Flow::new(
+        steel.id().clone(),
+        supplier.id().clone(),
+        warehouse.id().clone(),
+        Decimal::from(5000),
+    );
+
+    let camera_instance = ResourceInstance::new(camera.id().clone(), warehouse.id().clone());
+
+    assert!(steel_shipment.quantity() > Decimal::ZERO);
+    assert_eq!(camera_instance.entity_id(), warehouse.id());
+}
+
+#[test]
+fn test_multi_stage_flow() {
+    let supplier = Entity::new_with_namespace("Steel Supplier", "default".to_string());
+    let warehouse = Entity::new_with_namespace("Central Warehouse", "default".to_string());
+    let manufacturer = Entity::new_with_namespace("Camera Manufacturer", "default".to_string());
+    let retailer = Entity::new_with_namespace("Retail Store", "default".to_string());
+
+    let steel =
+        Resource::new_with_namespace("Steel", unit_from_string("kg"), "default".to_string());
+    let camera_parts = Resource::new_with_namespace(
+        "Camera Parts",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+    let finished_camera =
+        Resource::new_with_namespace("Camera", unit_from_string("units"), "default".to_string());
+
+    let flow1 = Flow::new(
+        steel.id().clone(),
+        supplier.id().clone(),
+        warehouse.id().clone(),
+        Decimal::from(1000),
+    );
+
+    let flow2 = Flow::new(
+        camera_parts.id().clone(),
+        warehouse.id().clone(),
+        manufacturer.id().clone(),
+        Decimal::from(500),
+    );
+
+    let flow3 = Flow::new(
+        finished_camera.id().clone(),
+        manufacturer.id().clone(),
+        retailer.id().clone(),
+        Decimal::from(100),
+    );
+
+    assert_eq!(flow1.from_id(), supplier.id());
+    assert_eq!(flow1.to_id(), warehouse.id());
+    assert_eq!(flow2.from_id(), warehouse.id());
+    assert_eq!(flow2.to_id(), manufacturer.id());
+    assert_eq!(flow3.from_id(), manufacturer.id());
+    assert_eq!(flow3.to_id(), retailer.id());
+}
+
+#[test]
+fn test_instance_tracking_across_entities() {
+    let warehouse_a = Entity::new_with_namespace("Warehouse A", "default".to_string());
+    let warehouse_b = Entity::new_with_namespace("Warehouse B", "default".to_string());
+    let camera = Resource::new_with_namespace(
+        "Camera Model X",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let instance1 = ResourceInstance::new(camera.id().clone(), warehouse_a.id().clone());
+
+    let instance2 = ResourceInstance::new(camera.id().clone(), warehouse_b.id().clone());
+
+    assert_eq!(instance1.resource_id(), camera.id());
+    assert_eq!(instance2.resource_id(), camera.id());
+    assert_ne!(instance1.entity_id(), instance2.entity_id());
+    assert_ne!(instance1.id(), instance2.id());
+}
+
+#[test]
+fn test_resource_flow_with_instances() {
+    let origin = Entity::new_with_namespace("Manufacturing Plant", "default".to_string());
+    let destination = Entity::new_with_namespace("Distribution Center", "default".to_string());
+    let product = Resource::new_with_namespace(
+        "Smartphone",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let transfer = Flow::new(
+        product.id().clone(),
+        origin.id().clone(),
+        destination.id().clone(),
+        Decimal::from(50),
+    );
+
+    let instance_at_origin = ResourceInstance::new(product.id().clone(), origin.id().clone());
+
+    let instance_at_destination =
+        ResourceInstance::new(product.id().clone(), destination.id().clone());
+
+    assert_eq!(transfer.resource_id(), product.id());
+    assert_eq!(transfer.from_id(), instance_at_origin.entity_id());
+    assert_eq!(transfer.to_id(), instance_at_destination.entity_id());
+}
+
+#[test]
+fn test_all_primitives_serialization() {
+    let entity = Entity::new_with_namespace("Test Entity", "default".to_string());
+    let resource = Resource::new_with_namespace(
+        "Test Resource",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+    let flow = Flow::new(
+        resource.id().clone(),
+        entity.id().clone(),
+        entity.id().clone(),
+        Decimal::from(10),
+    );
+    let instance = ResourceInstance::new(resource.id().clone(), entity.id().clone());
+
+    let entity_json = serde_json::to_string(&entity).unwrap();
+    let resource_json = serde_json::to_string(&resource).unwrap();
+    let flow_json = serde_json::to_string(&flow).unwrap();
+    let instance_json = serde_json::to_string(&instance).unwrap();
+
+    let entity_deserialized: Entity = serde_json::from_str(&entity_json).unwrap();
+    let resource_deserialized: Resource = serde_json::from_str(&resource_json).unwrap();
+    let flow_deserialized: Flow = serde_json::from_str(&flow_json).unwrap();
+    let instance_deserialized: ResourceInstance = serde_json::from_str(&instance_json).unwrap();
+
+    assert_eq!(entity, entity_deserialized);
+    assert_eq!(resource, resource_deserialized);
+    assert_eq!(flow, flow_deserialized);
+    assert_eq!(instance, instance_deserialized);
+}

package/domainforge-core/tests/print_rdf_xml.rs

@@ -0,0 +1,14 @@
+use domainforge_core::kg::KnowledgeGraph;
+use domainforge_core::kg::Triple;
+
+#[test]
+fn print_rdf_xml() {
+    let mut kg = KnowledgeGraph::new();
+    kg.triples.push(Triple {
+        subject: "sea:TestEntity".to_string(),
+        predicate: "rdfs:label".to_string(),
+        object: "\"Warehouse\"@en".to_string(),
+    });
+    let rdf_xml = kg.to_rdf_xml();
+    println!("XML:\n{}", rdf_xml);
+}

package/domainforge-core/tests/printer_tests.rs

@@ -0,0 +1,204 @@
+use domainforge_core::parser::ast::{Ast, AstNode, FileMetadata, Spanned};
+use domainforge_core::parser::ast::{MappingRule, PolicyKind, PolicyMetadata, PolicyModality};
+use domainforge_core::parser::printer::PrettyPrinter;
+use domainforge_core::policy::Expression;
+use serde_json::json;
+use std::collections::HashMap;
+
+fn spanned<T>(node: T) -> Spanned<T> {
+    Spanned {
+        node,
+        line: 0,
+        column: 0,
+    }
+}
+
+#[test]
+fn test_pretty_print_ast() {
+    let ast = Ast {
+        metadata: FileMetadata {
+            namespace: Some("test_ns".to_string()),
+            ..Default::default()
+        },
+        declarations: vec![
+            spanned(AstNode::Entity {
+                name: "Factory".to_string(),
+                version: None,
+                annotations: HashMap::new(),
+                domain: None,
+            }),
+            spanned(AstNode::Resource {
+                name: "Widget".to_string(),
+                annotations: HashMap::new(),
+                unit_name: Some("units".to_string()),
+                domain: None,
+            }),
+            spanned(AstNode::Flow {
+                resource_name: "Widget".to_string(),
+                annotations: HashMap::new(),
+                from_entity: "Warehouse".to_string(),
+                to_entity: "Factory".to_string(),
+                quantity: Some(rust_decimal::Decimal::from(100)),
+            }),
+        ],
+    };
+
+    let printer = PrettyPrinter::new();
+    let output = printer.print(&ast);
+
+    let expected = r#"@namespace "test_ns"
+
+Entity "Factory"
+
+Resource "Widget" units
+
+Flow "Widget" from "Warehouse" to "Factory" quantity 100
+"#;
+
+    assert_eq!(output, expected);
+}
+
+#[test]
+fn test_pretty_print_policy_header() {
+    let metadata = PolicyMetadata {
+        kind: Some(PolicyKind::Constraint),
+        modality: Some(PolicyModality::Obligation),
+        priority: Some(3),
+        rationale: Some("Test rationale".to_string()),
+        tags: vec![],
+    };
+
+    let ast = Ast {
+        metadata: FileMetadata::default(),
+        declarations: vec![spanned(AstNode::Policy {
+            name: "Limit".to_string(),
+            version: None,
+            metadata,
+            expression: Expression::literal(true),
+        })],
+    };
+
+    let printer = PrettyPrinter::new();
+    let output = printer.print(&ast);
+    assert!(output.contains("per Constraint Obligation"));
+    assert!(output.contains("priority 3"));
+}
+
+#[test]
+fn test_pretty_print_mapping_nested_and_trailing_commas() {
+    let mut fields = HashMap::new();
+    fields.insert("nested".to_string(), json!({ "bar": 1, "baz": [1, 2] }));
+    fields.insert("simple".to_string(), json!("ok"));
+
+    let rule = MappingRule {
+        primitive_type: "Resource".to_string(),
+        primitive_name: "Camera".to_string(),
+        target_type: "calm::Resource".to_string(),
+        fields,
+    };
+
+    let mapping_ast = Ast {
+        metadata: FileMetadata::default(),
+        declarations: vec![spanned(AstNode::MappingDecl {
+            name: "m1".to_string(),
+            target: domainforge_core::parser::ast::TargetFormat::Calm,
+            rules: vec![rule],
+        })],
+    };
+
+    // Default: no trailing commas
+    let printer = PrettyPrinter::new();
+    let output_default = printer.print(&mapping_ast);
+    assert!(output_default.contains("simple: \"ok\""));
+    assert!(output_default.contains("\"bar\" : 1"));
+    assert!(output_default.contains("\"baz\" : [1, 2]"));
+
+    // With trailing commas
+    let printer_comma = PrettyPrinter::new().with_trailing_commas(true);
+    let output_comma = printer_comma.print(&mapping_ast);
+    assert!(output_comma.contains("simple: \"ok\","));
+}
+
+#[test]
+fn test_pretty_print_projection_arrow_and_trailing_commas() {
+    use domainforge_core::parser::ast::ProjectionOverride;
+
+    let mut fields = HashMap::new();
+    fields.insert("nested".to_string(), json!({ "bar": 1, "baz": [1, 2] }));
+    fields.insert("simple".to_string(), json!("ok"));
+
+    let override_entry = ProjectionOverride {
+        primitive_type: "Resource".to_string(),
+        primitive_name: "Camera".to_string(),
+        fields,
+    };
+
+    let projection_ast = Ast {
+        metadata: FileMetadata::default(),
+        declarations: vec![spanned(AstNode::ProjectionDecl {
+            name: "p1".to_string(),
+            target: domainforge_core::parser::ast::TargetFormat::Calm,
+            overrides: vec![override_entry],
+        })],
+    };
+
+    let printer = PrettyPrinter::new();
+    let output_default = printer.print(&projection_ast);
+    assert!(output_default.contains("Projection \"p1\" for CALM"));
+    assert!(output_default.contains("Resource \"Camera\""));
+    // Arrow style separator should be used in nested object entries
+    assert!(output_default.contains("\"bar\" -> 1"));
+
+    let printer_comma = PrettyPrinter::new().with_trailing_commas(true);
+    let output_comma = printer_comma.print(&projection_ast);
+    // Trailing commas should appear on the simple field line
+    assert!(output_comma.contains("simple: \"ok\","));
+    // Arrow separators still present
+    assert!(output_comma.contains("\"baz\" -> [1, 2]"));
+}
+
+#[test]
+fn test_pretty_print_policy_kind_modality_display() {
+    let kinds = [
+        PolicyKind::Constraint,
+        PolicyKind::Derivation,
+        PolicyKind::Obligation,
+    ];
+    let modalities = [
+        PolicyModality::Obligation,
+        PolicyModality::Prohibition,
+        PolicyModality::Permission,
+    ];
+
+    for kind in kinds.iter() {
+        for modality in modalities.iter() {
+            let metadata = PolicyMetadata {
+                kind: Some(kind.clone()),
+                modality: Some(modality.clone()),
+                priority: Some(7),
+                rationale: None,
+                tags: vec![],
+            };
+            let ast = Ast {
+                metadata: FileMetadata::default(),
+                declarations: vec![spanned(AstNode::Policy {
+                    name: format!("{:?}-{:?}", kind, modality),
+                    version: None,
+                    metadata: metadata.clone(),
+                    expression: Expression::literal(true),
+                })],
+            };
+            let output = PrettyPrinter::new().print(&ast);
+            // The printed header must contain "per <Kind> <Modality>"
+            let expected_header = format!("per {} {}", kind, modality);
+            assert!(
+                output.contains(&expected_header),
+                "Missing header: {}\nGot: {}",
+                expected_header,
+                output
+            );
+            // Also contains priority
+            assert!(output.contains("priority 7"));
+        }
+    }
+}

package/domainforge-core/tests/profile_tests.rs

@@ -0,0 +1,35 @@
+use domainforge_core::parser::{parse, parse_to_graph};
+
+#[test]
+fn test_parse_profile_annotation() {
+    let source = r#"
+@profile "cloud"
+Entity "Server"
+"#;
+    let ast = parse(source).unwrap();
+    assert_eq!(ast.metadata.profile, Some("cloud".to_string()));
+}
+
+#[test]
+fn test_parse_unknown_profile() {
+    let source = r#"
+@profile "unknown_profile"
+Entity "Server"
+"#;
+    let result = parse_to_graph(source);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err
+        .to_string()
+        .contains("Unknown profile: 'unknown_profile'"));
+}
+
+#[test]
+fn test_parse_valid_profile() {
+    let source = r#"
+@profile "data"
+Entity "Table"
+"#;
+    let result = parse_to_graph(source);
+    assert!(result.is_ok());
+}

package/domainforge-core/tests/projection_contracts_tests.rs

@@ -0,0 +1,154 @@
+use domainforge_core::calm::export::export;
+use domainforge_core::kg::KnowledgeGraph;
+use domainforge_core::parser::ast::{AstNode, TargetFormat};
+use domainforge_core::parser::parse_source;
+
+#[test]
+fn test_parse_mapping_and_projection() {
+    let source = r#"
+    Mapping "payment_to_calm" for calm {
+        Entity "PaymentProcessor" -> Node {
+            node_type: "resource",
+            metadata: {
+                "team": "payments",
+                "tier": "critical"
+            }
+        }
+    }
+
+    Projection "custom_kg" for kg {
+        Entity "Vendor" {
+            rdf_class: "org:Organization",
+            properties: {
+                "name" -> "foaf:name"
+            }
+        }
+    }
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse source");
+    assert_eq!(ast.declarations.len(), 2);
+
+    match &ast.declarations[0].node {
+        AstNode::MappingDecl {
+            name,
+            target,
+            rules,
+        } => {
+            assert_eq!(name, "payment_to_calm");
+            assert_eq!(*target, TargetFormat::Calm);
+            assert_eq!(rules.len(), 1);
+            let rule = &rules[0];
+            assert_eq!(rule.primitive_type, "Entity");
+            assert_eq!(rule.primitive_name, "PaymentProcessor");
+            assert_eq!(rule.target_type, "Node");
+            assert!(rule.fields.contains_key("node_type"));
+            assert!(rule.fields.contains_key("metadata"));
+        }
+        _ => panic!("Expected MappingDecl"),
+    }
+
+    match &ast.declarations[1].node {
+        AstNode::ProjectionDecl {
+            name,
+            target,
+            overrides,
+        } => {
+            assert_eq!(name, "custom_kg");
+            assert_eq!(*target, TargetFormat::Kg);
+            assert_eq!(overrides.len(), 1);
+            let ov = &overrides[0];
+            assert_eq!(ov.primitive_type, "Entity");
+            assert_eq!(ov.primitive_name, "Vendor");
+            assert!(ov.fields.contains_key("rdf_class"));
+            assert!(ov.fields.contains_key("properties"));
+        }
+        _ => panic!("Expected ProjectionDecl"),
+    }
+}
+
+#[test]
+fn test_graph_integration() {
+    let source = r#"
+    Mapping "m1" for calm {
+        Entity "E1" -> Node { node_type: "actor" }
+    }
+    "#;
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = domainforge_core::parser::ast::ast_to_graph(ast).expect("Failed to build graph");
+
+    assert_eq!(graph.mapping_count(), 1);
+    let mappings = graph.all_mappings();
+    assert_eq!(mappings[0].name(), "m1");
+}
+
+#[test]
+fn test_calm_export_with_mapping() {
+    let source = r#"
+    Entity "PaymentProcessor"
+    
+    Mapping "m1" for calm {
+        Entity "PaymentProcessor" -> Node {
+            node_type: "resource",
+            metadata: { "custom": "value" }
+        }
+    }
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = domainforge_core::parser::ast::ast_to_graph(ast).expect("Failed to build graph");
+
+    let calm_json = export(&graph).expect("Failed to export");
+
+    let nodes = calm_json["nodes"].as_array().expect("Expected nodes array");
+    let node = nodes
+        .iter()
+        .find(|n| n["name"] == "PaymentProcessor")
+        .expect("Node not found");
+
+    // Check node_type is "resource" (serialized as lowercase usually? NodeType uses lowercase rename_all)
+    assert_eq!(node["node-type"], "resource");
+
+    // Check metadata
+    let metadata = node["metadata"]
+        .as_object()
+        .expect("Expected metadata object");
+    assert_eq!(metadata["custom"], "value");
+}
+
+#[test]
+fn test_kg_export_with_projection() {
+    let source = r#"
+    Entity "Vendor"
+    
+    Projection "custom_kg" for kg {
+        Entity "Vendor" {
+            rdf_class: "org:Organization",
+            properties: {
+                "name" -> "foaf:name"
+            }
+        }
+    }
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = domainforge_core::parser::ast::ast_to_graph(ast).expect("Failed to build graph");
+
+    let kg = KnowledgeGraph::from_graph(&graph).expect("Failed to create KG");
+
+    // Check for rdf:type org:Organization
+    let type_triple = kg.triples.iter().find(|t| {
+        t.subject.contains("Vendor") && t.predicate == "rdf:type" && t.object == "org:Organization"
+    });
+    assert!(type_triple.is_some(), "Did not find overridden rdf:type");
+
+    // Check for foaf:name
+    let name_triple = kg
+        .triples
+        .iter()
+        .find(|t| t.subject.contains("Vendor") && t.predicate == "foaf:name");
+    assert!(
+        name_triple.is_some(),
+        "Did not find overridden name property"
+    );
+}