kotoba_rewrite/
lib.rs

1//! kotoba-rewrite - Kotoba Rewrite Components
2
3pub mod rewrite;
4pub mod prelude {
5    // Re-export commonly used items
6    pub use crate::rewrite::*;
7}
8
9#[cfg(test)]
10mod tests {
11    use super::*;
12    use crate::prelude::*;
13    use kotoba_core::{types::*, ir::*};
14    use kotoba_graph::prelude::*;
15    use std::collections::HashMap;
16
17    #[test]
18    fn test_rewrite_engine_creation() {
19        // Test that RewriteEngine can be created
20        let engine = RewriteEngine::new();
21        // Just check that it can be created
22        assert!(true);
23    }
24
25    #[test]
26    fn test_rule_matcher_creation() {
27        // Test that RuleMatcher can be created
28        let matcher = RuleMatcher::new();
29        assert!(true);
30    }
31
32    #[test]
33    fn test_rule_applier_creation() {
34        // Test that RuleApplier can be created
35        let applier = RuleApplier::new();
36        assert!(true);
37    }
38
39    #[test]
40    fn test_rule_ir_creation() {
41        // Test creating a basic rule
42        let rule = RuleIR {
43            name: "test_rule".to_string(),
44            types: std::collections::HashMap::new(),
45            lhs: GraphPattern { nodes: vec![], edges: vec![] },
46            context: GraphPattern { nodes: vec![], edges: vec![] },
47            rhs: GraphPattern { nodes: vec![], edges: vec![] },
48            nacs: vec![],
49            guards: vec![],
50        };
51        assert_eq!(rule.name, "test_rule");
52        assert!(rule.lhs.nodes.is_empty());
53        assert!(rule.rhs.nodes.is_empty());
54    }
55
56    #[test]
57    fn test_strategy_ir_creation() {
58        // Test creating a basic strategy
59        let strategy = StrategyIR {
60            strategy: StrategyOp::Once {
61                rule: "test_rule".to_string(),
62            },
63        };
64
65        if let StrategyOp::Once { rule } = &strategy.strategy {
66            assert_eq!(rule, "test_rule");
67        } else {
68            panic!("Expected Once strategy");
69        }
70    }
71
72    #[test]
73    fn test_pattern_creation() {
74        // Test pattern creation
75        let mut pattern = GraphPattern { nodes: vec![], edges: vec![] };
76        assert!(pattern.nodes.is_empty());
77        assert!(pattern.edges.is_empty());
78
79        // Add a node to pattern
80        let element = GraphElement {
81            id: "person1".to_string(),
82            type_: Some("Person".to_string()),
83            props: Some(HashMap::new()),
84        };
85        pattern.nodes.push(element);
86        assert_eq!(pattern.nodes.len(), 1);
87        assert!(pattern.nodes.iter().any(|e| e.id == "person1"));
88    }
89
90    #[test]
91    fn test_patch_creation() {
92        // Test patch creation
93        let patch = Patch::empty();
94        assert!(patch.adds.vertices.is_empty() && patch.adds.edges.is_empty());
95        assert!(patch.dels.vertices.is_empty() && patch.dels.edges.is_empty());
96        assert!(patch.updates.props.is_empty() && patch.updates.relinks.is_empty());
97    }
98
99    #[test]
100    fn test_match_creation() {
101        // Test match creation
102        let mut mapping = HashMap::new();
103        mapping.insert("x".to_string(), VertexId::new_v4());
104
105        let match_result = Match { mapping, score: 1.0 };
106        assert_eq!(match_result.mapping.len(), 1);
107        assert!(match_result.mapping.contains_key("x"));
108    }
109
110    #[test]
111    fn test_catalog_creation() {
112        // Test catalog creation
113        let catalog = Catalog::empty();
114        assert!(catalog.labels.is_empty());
115        assert!(catalog.indexes.is_empty());
116        assert!(catalog.invariants.is_empty());
117    }
118
119    #[test]
120    fn test_rewrite_engine_with_empty_graph() {
121        // Test rewrite engine with empty graph
122        let engine = RewriteEngine::new();
123        let graph = GraphRef::new(Graph::empty());
124        let rule = RuleIR {
125            name: "empty_rule".to_string(),
126            types: std::collections::HashMap::new(),
127            lhs: GraphPattern { nodes: vec![], edges: vec![] },
128            context: GraphPattern { nodes: vec![], edges: vec![] },
129            rhs: GraphPattern { nodes: vec![], edges: vec![] },
130            nacs: vec![],
131            guards: vec![],
132        };
133        let catalog = Catalog::empty();
134
135        // Test matching (should work with empty rule)
136        let matches = engine.match_rule(&graph, &rule, &catalog);
137        assert!(matches.is_ok());
138    }
139
140    #[test]
141    fn test_rewrite_engine_with_strategy() {
142        // Test rewrite with strategy
143        let engine = RewriteEngine::new();
144        let graph = GraphRef::new(Graph::empty());
145        let rule = RuleIR {
146            name: "test_rule".to_string(),
147            types: std::collections::HashMap::new(),
148            lhs: GraphPattern { nodes: vec![], edges: vec![] },
149            context: GraphPattern { nodes: vec![], edges: vec![] },
150            rhs: GraphPattern { nodes: vec![], edges: vec![] },
151            nacs: vec![],
152            guards: vec![],
153        };
154        let strategy = StrategyIR {
155            strategy: StrategyOp::Once {
156                rule: "test_rule".to_string(),
157            },
158        };
159
160        // Test rewrite application
161        let result = engine.rewrite(&graph, &rule, &strategy);
162        assert!(result.is_ok());
163    }
164}
kotoba_rewrite/lib.rs

kotoba_rewrite/
lib.rs
