method-ray 0.1.9 → 0.1.10

data/core/src/env/scope.rs

@@ -297,378 +297,3 @@ impl ScopeManager {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_scope_manager_default() {
-        let sm = ScopeManager::default();
-        assert_eq!(sm.current_scope().id, ScopeId(0));
-        assert!(matches!(sm.current_scope().kind, ScopeKind::TopLevel));
-    }
-
-    #[test]
-    fn test_scope_manager_creation() {
-        let sm = ScopeManager::new();
-        assert_eq!(sm.current_scope().id, ScopeId(0));
-        assert!(matches!(sm.current_scope().kind, ScopeKind::TopLevel));
-    }
-
-    #[test]
-    fn test_scope_manager_new_scope() {
-        let mut sm = ScopeManager::new();
-
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-
-        assert_eq!(class_id, ScopeId(1));
-        assert_eq!(sm.current_scope().id, ScopeId(0)); // Still in top-level
-    }
-
-    #[test]
-    fn test_scope_manager_enter_exit() {
-        let mut sm = ScopeManager::new();
-
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-
-        sm.enter_scope(class_id);
-        assert_eq!(sm.current_scope().id, ScopeId(1));
-
-        sm.exit_scope();
-        assert_eq!(sm.current_scope().id, ScopeId(0));
-    }
-
-    #[test]
-    fn test_scope_manager_local_var() {
-        let mut sm = ScopeManager::new();
-
-        sm.current_scope_mut()
-            .set_local_var("x".to_string(), VertexId(10));
-
-        assert_eq!(sm.lookup_var("x"), Some(VertexId(10)));
-        assert_eq!(sm.lookup_var("y"), None);
-    }
-
-    #[test]
-    fn test_scope_manager_nested_lookup() {
-        let mut sm = ScopeManager::new();
-
-        // Top level: x = 10
-        sm.current_scope_mut()
-            .set_local_var("x".to_string(), VertexId(10));
-
-        // Enter class
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(class_id);
-
-        // Class level: y = 20
-        sm.current_scope_mut()
-            .set_local_var("y".to_string(), VertexId(20));
-
-        // Can lookup both x (from parent) and y (from current)
-        assert_eq!(sm.lookup_var("x"), Some(VertexId(10)));
-        assert_eq!(sm.lookup_var("y"), Some(VertexId(20)));
-    }
-
-    #[test]
-    fn test_scope_manager_current_class_name() {
-        let mut sm = ScopeManager::new();
-
-        assert_eq!(sm.current_class_name(), None);
-
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(class_id);
-
-        assert_eq!(sm.current_class_name(), Some("User".to_string()));
-
-        // Enter method within class
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "test".to_string(),
-            receiver_type: None,
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-
-        // Should still find parent class name
-        assert_eq!(sm.current_class_name(), Some("User".to_string()));
-    }
-
-    #[test]
-    fn test_scope_manager_module_scope() {
-        let mut sm = ScopeManager::new();
-
-        assert_eq!(sm.current_module_name(), None);
-
-        let module_id = sm.new_scope(ScopeKind::Module {
-            name: "Utils".to_string(),
-        });
-        sm.enter_scope(module_id);
-
-        assert_eq!(sm.current_module_name(), Some("Utils".to_string()));
-
-        // Enter method within module
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "helper".to_string(),
-            receiver_type: Some("Utils".to_string()),
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-
-        // Should still find parent module name
-        assert_eq!(sm.current_module_name(), Some("Utils".to_string()));
-
-        sm.exit_scope(); // exit method
-        sm.exit_scope(); // exit module
-
-        assert_eq!(sm.current_module_name(), None);
-    }
-
-    #[test]
-    fn test_scope_manager_module_instance_var() {
-        let mut sm = ScopeManager::new();
-
-        let module_id = sm.new_scope(ScopeKind::Module {
-            name: "Config".to_string(),
-        });
-        sm.enter_scope(module_id);
-
-        // Set instance variable in module
-        sm.set_instance_var_in_module("@setting".to_string(), VertexId(100));
-
-        // Enter method within module
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "get_setting".to_string(),
-            receiver_type: Some("Config".to_string()),
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-
-        // Should find instance variable from module scope
-        assert_eq!(
-            sm.lookup_instance_var_in_module("@setting"),
-            Some(VertexId(100))
-        );
-    }
-
-    #[test]
-    fn test_current_qualified_name_simple_class() {
-        let mut sm = ScopeManager::new();
-
-        // module Api; class User; end; end
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(class_id);
-
-        assert_eq!(
-            sm.current_qualified_name(),
-            Some("User".to_string())
-        );
-    }
-
-    #[test]
-    fn test_current_qualified_name_nested_module_class() {
-        let mut sm = ScopeManager::new();
-
-        // module Api
-        let api_id = sm.new_scope(ScopeKind::Module {
-            name: "Api".to_string(),
-        });
-        sm.enter_scope(api_id);
-
-        // module V1
-        let v1_id = sm.new_scope(ScopeKind::Module {
-            name: "V1".to_string(),
-        });
-        sm.enter_scope(v1_id);
-
-        // class User
-        let user_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(user_id);
-
-        assert_eq!(
-            sm.current_qualified_name(),
-            Some("Api::V1::User".to_string())
-        );
-
-        // def greet
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "greet".to_string(),
-            receiver_type: None,
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-
-        // Inside method, should still get the qualified class name
-        assert_eq!(
-            sm.current_qualified_name(),
-            Some("Api::V1::User".to_string())
-        );
-    }
-
-    #[test]
-    fn test_current_qualified_name_with_inline_qualified_class() {
-        let mut sm = ScopeManager::new();
-
-        // class Api::User (defined at top level with qualified name)
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "Api::User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(class_id);
-
-        assert_eq!(
-            sm.current_qualified_name(),
-            Some("Api::User".to_string())
-        );
-    }
-
-    #[test]
-    fn test_current_qualified_name_at_top_level() {
-        let sm = ScopeManager::new();
-
-        // At top level, no class/module
-        assert_eq!(sm.current_qualified_name(), None);
-    }
-
-    #[test]
-    fn test_constant_registration_and_lookup() {
-        let mut sm = ScopeManager::new();
-
-        // module Api
-        sm.current_scope_mut().constants.insert("Api".to_string(), "Api".to_string());
-        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
-        sm.enter_scope(api_id);
-
-        // class User (inside Api) — register in parent scope (Api)
-        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
-        let user_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(user_id);
-
-        assert_eq!(sm.lookup_constant("User"), Some("Api::User".to_string()));
-        assert_eq!(sm.lookup_constant("Api"), Some("Api".to_string()));
-        assert_eq!(sm.lookup_constant("Unknown"), None);
-    }
-
-    #[test]
-    fn test_constant_lookup_from_method_scope() {
-        let mut sm = ScopeManager::new();
-
-        sm.current_scope_mut().constants.insert("Api".to_string(), "Api".to_string());
-        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
-        sm.enter_scope(api_id);
-
-        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
-        let user_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(user_id);
-
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "greet".to_string(),
-            receiver_type: None,
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-
-        // Should find constant by traversing parent scopes from method scope
-        assert_eq!(sm.lookup_constant("User"), Some("Api::User".to_string()));
-    }
-
-    #[test]
-    fn test_constant_same_name_different_namespaces() {
-        let mut sm = ScopeManager::new();
-
-        // module Api
-        let api_id = sm.new_scope(ScopeKind::Module { name: "Api".to_string() });
-        sm.enter_scope(api_id);
-        sm.current_scope_mut().constants.insert("User".to_string(), "Api::User".to_string());
-
-        sm.exit_scope();
-
-        // module Admin
-        let admin_id = sm.new_scope(ScopeKind::Module { name: "Admin".to_string() });
-        sm.enter_scope(admin_id);
-        sm.current_scope_mut().constants.insert("User".to_string(), "Admin::User".to_string());
-
-        // Inside Admin scope, User should resolve to Admin::User
-        assert_eq!(sm.lookup_constant("User"), Some("Admin::User".to_string()));
-    }
-
-    #[test]
-    fn test_current_method_name() {
-        let mut sm = ScopeManager::new();
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: None,
-        });
-        sm.enter_scope(class_id);
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "greet".to_string(),
-            receiver_type: None,
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-        assert_eq!(sm.current_method_name(), Some("greet".to_string()));
-
-        sm.exit_scope();
-        assert_eq!(sm.current_method_name(), None);
-    }
-
-    #[test]
-    fn test_current_superclass() {
-        let mut sm = ScopeManager::new();
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "Dog".to_string(),
-            superclass: Some("Animal".to_string()),
-        });
-        sm.enter_scope(class_id);
-        assert_eq!(sm.current_superclass(), Some("Animal".to_string()));
-
-        sm.exit_scope();
-        assert_eq!(sm.current_superclass(), None);
-    }
-
-    #[test]
-    fn test_current_method_name_from_nested_block() {
-        let mut sm = ScopeManager::new();
-        let class_id = sm.new_scope(ScopeKind::Class {
-            name: "User".to_string(),
-            superclass: Some("Base".to_string()),
-        });
-        sm.enter_scope(class_id);
-        let method_id = sm.new_scope(ScopeKind::Method {
-            name: "process".to_string(),
-            receiver_type: None,
-            return_vertex: None,
-        });
-        sm.enter_scope(method_id);
-        let block_id = sm.new_scope(ScopeKind::Block);
-        sm.enter_scope(block_id);
-
-        // Inside a block, should still find enclosing method/superclass
-        assert_eq!(sm.current_method_name(), Some("process".to_string()));
-        assert_eq!(sm.current_superclass(), Some("Base".to_string()));
-    }
-}

data/core/src/env/vertex_manager.rs

@@ -119,76 +119,3 @@ impl VertexManager {
         lines.join("\n")
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_new_vertex() {
-        let mut manager = VertexManager::new();
-
-        let v1 = manager.new_vertex();
-        let v2 = manager.new_vertex();
-
-        assert_eq!(v1.0, 0);
-        assert_eq!(v2.0, 1);
-        assert!(manager.get_vertex(v1).is_some());
-        assert!(manager.get_vertex(v2).is_some());
-    }
-
-    #[test]
-    fn test_new_source() {
-        let mut manager = VertexManager::new();
-
-        let s1 = manager.new_source(Type::string());
-        let s2 = manager.new_source(Type::integer());
-
-        assert_eq!(manager.get_source(s1).unwrap().ty.show(), "String");
-        assert_eq!(manager.get_source(s2).unwrap().ty.show(), "Integer");
-    }
-
-    #[test]
-    fn test_edge_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src = manager.new_source(Type::string());
-        let vtx = manager.new_vertex();
-
-        manager.add_edge(src, vtx);
-
-        assert_eq!(manager.get_vertex(vtx).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_chain_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src = manager.new_source(Type::string());
-        let v1 = manager.new_vertex();
-        let v2 = manager.new_vertex();
-
-        manager.add_edge(src, v1);
-        manager.add_edge(v1, v2);
-
-        assert_eq!(manager.get_vertex(v1).unwrap().show(), "String");
-        assert_eq!(manager.get_vertex(v2).unwrap().show(), "String");
-    }
-
-    #[test]
-    fn test_union_propagation() {
-        let mut manager = VertexManager::new();
-
-        let src1 = manager.new_source(Type::string());
-        let src2 = manager.new_source(Type::integer());
-        let vtx = manager.new_vertex();
-
-        manager.add_edge(src1, vtx);
-        manager.add_edge(src2, vtx);
-
-        assert_eq!(
-            manager.get_vertex(vtx).unwrap().show(),
-            "(Integer | String)"
-        );
-    }
-}