method-ray 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc17c7a50f5d33ee2d219ff5f28c1447b162cdc8c9e832e2e3a4c4d89885dd98
-  data.tar.gz: 6a746447dcfe70be3c7da02052697bd5dec36306810d972b5c05e5800e00e566
+  metadata.gz: 228f256ea9848bd9b2447e097aee95f59f47db2bd252611a7dfa30363be34a23
+  data.tar.gz: 0ff2217ee68021004331bd580f26739ce067f223ea113b741ab0636f2771e30e
 SHA512:
-  metadata.gz: 2c4ceefe7929f02f14d2574dda3b5f04e8f5e67d1fd7746939318d5e7f49b932ad07d78a16975f83c16014e70222d251912608eea8d8a2ee901ea1f13415a187
-  data.tar.gz: 57c9411ff5c60a8fa5e3c5283b401c3869ef3a644d4959e0b426b49570d15641141e2aa4da98deaeadc216656257e3eebff9a5ba9209872b53bd8f018e59bbb5
+  metadata.gz: 3c274c68e498eed4f432b60c4a68a6ca469b7850db539954f584d89bd96cbf3612e03a9a9f43a1b8a8941be6302142e7f34e886b279cde41bc22a0376ba48ac7
+  data.tar.gz: 57e66add8decf8c951f890f140f76fca86b642af91a7df9d7622c5144414b20f158444838aeca5082a46efa185280747a32117980654ae5f03d0c1dc23bbcd35

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.10] - 2026-03-24
+
+### Added
+
+- Add safe navigation operator (`&.`) support ([#65](https://github.com/dak2/method-ray/pull/65))
+- Add inheritance chain method resolution for user-defined classes ([#66](https://github.com/dak2/method-ray/pull/66))
+- Add extend support for module methods as class methods ([#67](https://github.com/dak2/method-ray/pull/67))
+- Add pull request template ([#82](https://github.com/dak2/method-ray/pull/82))
+
+### Changed
+
+- Migrate Rust integration tests to Ruby integration tests ([#68](https://github.com/dak2/method-ray/pull/68), [#69](https://github.com/dak2/method-ray/pull/69), [#70](https://github.com/dak2/method-ray/pull/70), [#71](https://github.com/dak2/method-ray/pull/71), [#72](https://github.com/dak2/method-ray/pull/72), [#73](https://github.com/dak2/method-ray/pull/73), [#74](https://github.com/dak2/method-ray/pull/74), [#75](https://github.com/dak2/method-ray/pull/75))
+- Remove redundant Rust unit tests ([#77](https://github.com/dak2/method-ray/pull/77), [#78](https://github.com/dak2/method-ray/pull/78), [#80](https://github.com/dak2/method-ray/pull/80), [#83](https://github.com/dak2/method-ray/pull/83), [#84](https://github.com/dak2/method-ray/pull/84), [#85](https://github.com/dak2/method-ray/pull/85), [#86](https://github.com/dak2/method-ray/pull/86))
+- Simplify README to focus on core value proposition ([#76](https://github.com/dak2/method-ray/pull/76))
+
+### Fixed
+
+- Fix release workflow to include gem assets in GitHub Release ([#63](https://github.com/dak2/method-ray/pull/63), [#64](https://github.com/dak2/method-ray/pull/64))
+
 ## [0.1.9] - 2026-03-15
 
 ### Added
@@ -140,6 +159,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial release
 - `methodray check` - Static type checking for Ruby files
 
+[0.1.10]: https://github.com/dak2/method-ray/releases/tag/v0.1.10
 [0.1.9]: https://github.com/dak2/method-ray/releases/tag/v0.1.9
 [0.1.8]: https://github.com/dak2/method-ray/releases/tag/v0.1.8
 [0.1.7]: https://github.com/dak2/method-ray/releases/tag/v0.1.7

data/README.md

@@ -16,28 +16,26 @@ gem install methodray
 
 ## Quick Start
 
-### VSCode Extension (under development)
-
-1. Install the [Method-Ray VSCode extension](https://github.com/dak2/method-ray-vscode)
-2. Open a Ruby file in VSCode
-3. Errors will be highlighted automatically
-
-### CLI
+### Checking Methods
 
 ```bash
 # Check a single file
 bundle exec methodray check app/models/user.rb
+```
 
-# Watch mode - auto re-check on file changes
+### Watching for File Changes, Re-checking Methods
+
+```bash
+# Watch a file for changes and re-check on save
 bundle exec methodray watch app/models/user.rb
 ```
 
-#### Example
-
-`methodray check <file>`: Performs static type checking on the specified Ruby file.
+#### Example Usage
 
+`bundle exec methodray check app/models/user.rb`
 
 ```ruby
+# app/models/user.rb
 class User
   def greeting
     name = "Alice"

data/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray-core"
-version = "0.1.9"
+version = "0.1.10"
 edition = "2021"
 
 [lib]

data/core/src/analyzer/assignments.rs

@@ -217,283 +217,3 @@ pub(crate) fn process_multi_write_node(
 
     last_vtx
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::analyzer::install::AstInstaller;
-    use crate::env::{GlobalEnv, LocalEnv};
-    use crate::graph::VertexId;
-    use crate::parser::ParseSession;
-
-    fn analyze(source: &str) -> (GlobalEnv, LocalEnv) {
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
-        for stmt in &program.statements().body() {
-            installer.install_node(&stmt);
-        }
-        installer.finish();
-
-        (genv, lenv)
-    }
-
-    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
-        if let Some(vertex) = genv.get_vertex(vtx) {
-            vertex.show()
-        } else if let Some(source) = genv.get_source(vtx) {
-            source.ty.show()
-        } else {
-            panic!("vertex {:?} not found as either Vertex or Source", vtx);
-        }
-    }
-
-    #[test]
-    fn test_multi_write_integer_and_string() {
-        let source = r#"a, b = 1, "hello""#;
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "String");
-    }
-
-    #[test]
-    fn test_multi_write_all_integer() {
-        let source = "a, b, c = 1, 2, 3";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "Integer");
-
-        let c_vtx = lenv.get_var("c").expect("c should be registered");
-        assert_eq!(get_type_show(&genv, c_vtx), "Integer");
-    }
-
-    #[test]
-    fn test_multi_write_variable_reference_after_assignment() {
-        let source = r#"
-a, b = 1, "hello"
-x = a
-"#;
-        let (genv, lenv) = analyze(source);
-
-        let x_vtx = lenv.get_var("x").expect("x should be registered");
-        assert_eq!(get_type_show(&genv, x_vtx), "Integer");
-    }
-
-    #[test]
-    fn test_multi_write_lhs_longer_than_rhs() {
-        let source = "a, b, c = 1, 2";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "Integer");
-
-        let c_vtx = lenv.get_var("c").expect("c should be registered with nil");
-        assert_eq!(get_type_show(&genv, c_vtx), "nil");
-    }
-
-    #[test]
-    fn test_multi_write_does_not_panic_on_non_array_rhs() {
-        let source = "a, b = some_expr";
-        let (_, lenv) = analyze(source);
-
-        // Variables should be registered (untyped) without panic
-        assert!(lenv.get_var("a").is_some(), "a should be registered");
-        assert!(lenv.get_var("b").is_some(), "b should be registered");
-    }
-
-    #[test]
-    fn test_multi_write_splat_basic() {
-        let source = "first, *rest = 1, 2, 3";
-        let (genv, lenv) = analyze(source);
-
-        let first_vtx = lenv.get_var("first").expect("first should be registered");
-        assert_eq!(get_type_show(&genv, first_vtx), "Integer");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[Integer]");
-    }
-
-    #[test]
-    fn test_multi_write_splat_mixed_types() {
-        let source = r#"first, *rest = 1, "hello", :sym"#;
-        let (genv, lenv) = analyze(source);
-
-        let first_vtx = lenv.get_var("first").expect("first should be registered");
-        assert_eq!(get_type_show(&genv, first_vtx), "Integer");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        let type_str = get_type_show(&genv, rest_vtx);
-        assert!(
-            type_str.contains("Array"),
-            "should be Array type: {}",
-            type_str
-        );
-        assert!(
-            type_str.contains("String"),
-            "should contain String: {}",
-            type_str
-        );
-        assert!(
-            type_str.contains("Symbol"),
-            "should contain Symbol: {}",
-            type_str
-        );
-    }
-
-    #[test]
-    fn test_multi_write_splat_empty() {
-        let source = "first, *rest = 1";
-        let (genv, lenv) = analyze(source);
-
-        let first_vtx = lenv.get_var("first").expect("first should be registered");
-        assert_eq!(get_type_show(&genv, first_vtx), "Integer");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[untyped]");
-    }
-
-    #[test]
-    fn test_multi_write_splat_with_rights() {
-        let source = "first, *rest, last = 1, 2, 3, 4";
-        let (genv, lenv) = analyze(source);
-
-        let first_vtx = lenv.get_var("first").expect("first should be registered");
-        assert_eq!(get_type_show(&genv, first_vtx), "Integer");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[Integer]");
-
-        let last_vtx = lenv.get_var("last").expect("last should be registered");
-        assert_eq!(get_type_show(&genv, last_vtx), "Integer");
-    }
-
-    #[test]
-    fn test_multi_write_splat_only() {
-        let source = "*all = 1, 2, 3";
-        let (genv, lenv) = analyze(source);
-
-        let all_vtx = lenv.get_var("all").expect("all should be registered");
-        assert_eq!(get_type_show(&genv, all_vtx), "Array[Integer]");
-    }
-
-    #[test]
-    fn test_multi_write_splat_rights_no_lefts() {
-        let source = "*rest, last = 1, 2, 3";
-        let (genv, lenv) = analyze(source);
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[Integer]");
-
-        let last_vtx = lenv.get_var("last").expect("last should be registered");
-        assert_eq!(get_type_show(&genv, last_vtx), "Integer");
-    }
-
-    #[test]
-    fn test_multi_write_array_literal_rhs() {
-        // Explicit array literal RHS is decomposed element-by-element (same as comma-separated form)
-        let source = r#"a, b = [1, "hi"]"#;
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "String");
-    }
-
-    #[test]
-    fn test_multi_write_splat_lefts_exceed_rhs() {
-        // Edge case: more left targets than RHS elements with splat
-        let source = "a, b, c, *rest = 1, 2";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "Integer");
-
-        let c_vtx = lenv.get_var("c").expect("c should be registered");
-        assert_eq!(get_type_show(&genv, c_vtx), "nil");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[untyped]");
-    }
-
-    #[test]
-    fn test_multi_write_splat_with_rights_insufficient_rhs() {
-        // Edge case: lefts + rights > total elements, splat between them
-        let source = "a, *rest, z = 1";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[untyped]");
-
-        let z_vtx = lenv.get_var("z").expect("z should be registered");
-        assert_eq!(get_type_show(&genv, z_vtx), "nil");
-    }
-
-    #[test]
-    fn test_multi_write_rights_exceed_rhs() {
-        // Edge case: more right targets than available elements
-        let source = r#"*rest, x, y, z = "a", 1"#;
-        let (genv, lenv) = analyze(source);
-
-        let rest_vtx = lenv.get_var("rest").expect("rest should be registered");
-        assert_eq!(get_type_show(&genv, rest_vtx), "Array[untyped]");
-
-        let x_vtx = lenv.get_var("x").expect("x should be registered");
-        assert_eq!(get_type_show(&genv, x_vtx), "nil");
-
-        let y_vtx = lenv.get_var("y").expect("y should be registered");
-        assert_eq!(get_type_show(&genv, y_vtx), "String");
-
-        let z_vtx = lenv.get_var("z").expect("z should be registered");
-        assert_eq!(get_type_show(&genv, z_vtx), "Integer");
-    }
-
-    #[test]
-    fn test_multi_write_scalar_rhs() {
-        // Single non-array expression: first target gets value, rest get nil
-        let source = "a, b = 42";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "nil");
-    }
-
-    #[test]
-    fn test_multi_write_rhs_longer_than_lhs() {
-        // Extra RHS elements are silently discarded
-        let source = "a, b = 1, 2, 3, 4";
-        let (genv, lenv) = analyze(source);
-
-        let a_vtx = lenv.get_var("a").expect("a should be registered");
-        assert_eq!(get_type_show(&genv, a_vtx), "Integer");
-
-        let b_vtx = lenv.get_var("b").expect("b should be registered");
-        assert_eq!(get_type_show(&genv, b_vtx), "Integer");
-    }
-}

data/core/src/analyzer/blocks.rs

@@ -124,193 +124,3 @@ fn exit_block_scope(genv: &mut GlobalEnv) {
 fn install_block_parameter(genv: &mut GlobalEnv, lenv: &mut LocalEnv, name: String) -> VertexId {
     install_required_parameter(genv, lenv, name)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::analyzer::install::AstInstaller;
-    use crate::env::LocalEnv;
-    use crate::parser::ParseSession;
-    use crate::types::Type;
-
-    fn get_type_show(genv: &GlobalEnv, vtx: VertexId) -> String {
-        if let Some(vertex) = genv.get_vertex(vtx) {
-            vertex.show()
-        } else if let Some(source) = genv.get_source(vtx) {
-            source.ty.show()
-        } else {
-            panic!("vertex {:?} not found as either Vertex or Source", vtx);
-        }
-    }
-
-    fn analyze_with_stdlib(source: &str) -> GlobalEnv {
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(source, "test.rb").unwrap();
-        let root = parse_result.node();
-        let program = root.as_program_node().unwrap();
-
-        let mut genv = GlobalEnv::new();
-
-        // Register stdlib methods needed for block tests
-        genv.register_builtin_method_with_block(
-            Type::array(),
-            "each",
-            Type::array(),
-            Some(vec![Type::instance("Elem")]),
-        );
-        genv.register_builtin_method_with_block(
-            Type::string(),
-            "each_char",
-            Type::string(),
-            Some(vec![Type::string()]),
-        );
-        genv.register_builtin_method(Type::integer(), "even?", Type::instance("TrueClass"));
-        genv.register_builtin_method(Type::string(), "upcase", Type::string());
-
-        let mut lenv = LocalEnv::new();
-
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, source);
-        for stmt in &program.statements().body() {
-            installer.install_node(&stmt);
-        }
-        installer.finish();
-
-        genv
-    }
-
-    #[test]
-    fn test_enter_exit_block_scope() {
-        let mut genv = GlobalEnv::new();
-
-        let initial_scope_id = genv.scope_manager.current_scope().id;
-
-        enter_block_scope(&mut genv);
-        let block_scope_id = genv.scope_manager.current_scope().id;
-
-        assert_ne!(initial_scope_id, block_scope_id);
-
-        exit_block_scope(&mut genv);
-
-        assert_eq!(genv.scope_manager.current_scope().id, initial_scope_id);
-    }
-
-    #[test]
-    fn test_install_block_parameter() {
-        let mut genv = GlobalEnv::new();
-        let mut lenv = LocalEnv::new();
-
-        enter_block_scope(&mut genv);
-
-        let vtx = install_block_parameter(&mut genv, &mut lenv, "x".to_string());
-
-        assert_eq!(lenv.get_var("x"), Some(vtx));
-
-        exit_block_scope(&mut genv);
-    }
-
-    #[test]
-    fn test_block_inherits_parent_scope_vars() {
-        let mut genv = GlobalEnv::new();
-
-        genv.scope_manager
-            .current_scope_mut()
-            .set_local_var("outer".to_string(), VertexId(100));
-
-        enter_block_scope(&mut genv);
-
-        assert_eq!(genv.scope_manager.lookup_var("outer"), Some(VertexId(100)));
-
-        exit_block_scope(&mut genv);
-    }
-
-    #[test]
-    fn test_block_parameter_type_from_array() {
-        let source = r#"
-class Foo
-  def bar
-    [1, 2, 3].each { |x| x.even? }
-  end
-end
-"#;
-        let genv = analyze_with_stdlib(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "x.even? should not produce type errors: {:?}",
-            genv.type_errors
-        );
-        // Verify bar returns Array (each returns its receiver)
-        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "Array");
-    }
-
-    #[test]
-    fn test_block_external_variable_access() {
-        let source = r#"
-class Foo
-  def bar
-    y = "hello"
-    [1].each { y.upcase }
-  end
-end
-"#;
-        let genv = analyze_with_stdlib(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "y.upcase should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    #[test]
-    fn test_block_parameter_from_each_char() {
-        let source = r#"
-class Foo
-  def bar
-    "hello".each_char { |c| c.upcase }
-  end
-end
-"#;
-        let genv = analyze_with_stdlib(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "c.upcase should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-
-    #[test]
-    fn test_block_body_does_not_affect_method_return() {
-        let source = r#"
-class Foo
-  def bar
-    [1, 2].each { |x| "string" }
-  end
-end
-"#;
-        let genv = analyze_with_stdlib(source);
-        // each returns its receiver (Array), not the block body result (String)
-        let info = genv.resolve_method(&Type::instance("Foo"), "bar").unwrap();
-        let ret_vtx = info.return_vertex.unwrap();
-        assert_eq!(get_type_show(&genv, ret_vtx), "Array");
-    }
-
-    #[test]
-    fn test_nested_blocks() {
-        let source = r#"
-class Foo
-  def bar
-    [1, 2].each { |x|
-      "hello".each_char { |c| c.upcase }
-    }
-  end
-end
-"#;
-        let genv = analyze_with_stdlib(source);
-        assert!(
-            genv.type_errors.is_empty(),
-            "nested block should not produce type errors: {:?}",
-            genv.type_errors
-        );
-    }
-}

data/core/src/analyzer/calls.rs

@@ -12,13 +12,14 @@ use crate::graph::{MethodCallBox, VertexId};
 use crate::source_map::SourceLocation;
 
 /// Install method call and return the return value's VertexId
-pub fn install_method_call(
+pub(crate) fn install_method_call(
     genv: &mut GlobalEnv,
     recv_vtx: VertexId,
     method_name: String,
     arg_vtxs: Vec<VertexId>,
     kwarg_vtxs: Option<HashMap<String, VertexId>>,
     location: Option<SourceLocation>,
+    safe_navigation: bool,
 ) -> VertexId {
     // Create Vertex for return value
     let ret_vtx = genv.new_vertex();
@@ -26,38 +27,8 @@ pub fn install_method_call(
     // Create MethodCallBox with location and argument vertices
     let box_id = genv.alloc_box_id();
     let call_box =
-        MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, kwarg_vtxs, location);
+        MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, arg_vtxs, kwarg_vtxs, location, safe_navigation);
     genv.register_box(box_id, Box::new(call_box));
 
     ret_vtx
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::types::Type;
-
-    #[test]
-    fn test_install_method_call_creates_vertex() {
-        let mut genv = GlobalEnv::new();
-
-        let recv_vtx = genv.new_source(Type::string());
-        let ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
-
-        // Return vertex should exist
-        assert!(genv.get_vertex(ret_vtx).is_some());
-    }
-
-    #[test]
-    fn test_install_method_call_adds_box() {
-        let mut genv = GlobalEnv::new();
-
-        let recv_vtx = genv.new_source(Type::string());
-        let _ret_vtx =
-            install_method_call(&mut genv, recv_vtx, "upcase".to_string(), vec![], None, None);
-
-        // Box should be added
-        assert_eq!(genv.box_count(), 1);
-    }
-}