method-ray 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a219edf198245163ff36fbcc9e211dbfea2d5e5f41a467ee24636286967f4b9
-  data.tar.gz: 7a82426e9c5b0ba53a2d1ca8bab90da2a4b4eb58316af7cfb8a576dc6dc28b64
+  metadata.gz: ee779223feab7110e29256fdc4860ba480d13d676d18e85284fd0765eef2cc4b
+  data.tar.gz: 249087d8f6b7772aa7428a4828ffc35eacb1b0aa8b27d5cd909b803176d6a683
 SHA512:
-  metadata.gz: cac68a8608631ce81f145b17743ff7ec519e24f1ac2b92c90732d3f9fedd4badb26715fd5120b8a648fd574313383ac2dbd02d71cdfe98004ffafe5714e39cf3
-  data.tar.gz: ded1386c832dfc9784c360d3685ce3431437d7cae1c155e02dc6606e3e155789f9f2ad42d5e4285aed6c8cb1dbf8231ac8f81392bf25a0536e3fd18e882537f3
+  metadata.gz: 8d6534a955eaf4937c5ebc4c525e07f5f7cd8599861f128cbb10161e00a6a932f1b47760e1283e7e2f48940ea0a89bb5c038ac83cdd8ce8a629f8f91b05e534a
+  data.tar.gz: cbe0d247ffcbd0ce4965f9e20a2293336aca3d7a6eeb96878665cb7692e11ea4366d3c1f2a87ea32711dbcd00a404d4a41da3e84d34829d40568ec0bb37d74b4

data/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.6] - 2026-02-23
+
+### Fixed
+
+- Embed `method_loader.rb` at compile time with `include_str!` to eliminate runtime dependency on source directory ([#35](https://github.com/dak2/method-ray/pull/35))
+
+## [0.1.5] - 2026-02-23
+
+### Added
+
+- String interpolation type inference (`InterpolatedStringNode`, `InterpolatedSymbolNode`, `InterpolatedRegularExpressionNode`) ([#26](https://github.com/dak2/method-ray/pull/26))
+- Parentheses node type inference for parenthesized expressions ([#27](https://github.com/dak2/method-ray/pull/27))
+- Qualified name method registration to resolve namespace conflicts ([#28](https://github.com/dak2/method-ray/pull/28))
+- Return statement type inference with merge vertex pattern ([#29](https://github.com/dak2/method-ray/pull/29))
+- Ternary operator type inference tests ([#30](https://github.com/dak2/method-ray/pull/30))
+- Logical operator (`&&`/`||`) type inference with union type approximation ([#31](https://github.com/dak2/method-ray/pull/31))
+- Class method (`def self.foo`) type registration and checking ([#32](https://github.com/dak2/method-ray/pull/32))
+
+### Changed
+
+- Removed stateless `Analyzer` class and simplified Ruby FFI surface to module functions ([#33](https://github.com/dak2/method-ray/pull/33))
+
+### Deprecated
+
+- `clear_cache` command ([#25](https://github.com/dak2/method-ray/pull/25))
+
 ## [0.1.4] - 2026-02-16
 
 ### Added
@@ -69,6 +95,8 @@ 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.6]: https://github.com/dak2/method-ray/releases/tag/v0.1.6
+[0.1.5]: https://github.com/dak2/method-ray/releases/tag/v0.1.5
 [0.1.4]: https://github.com/dak2/method-ray/releases/tag/v0.1.4
 [0.1.3]: https://github.com/dak2/method-ray/releases/tag/v0.1.3
 [0.1.2]: https://github.com/dak2/method-ray/releases/tag/v0.1.2

data/ext/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "methodray"
-version = "0.1.4"
+version = "0.1.6"
 edition = "2021"
 
 [lib]

data/ext/src/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! This module provides the Ruby gem interface using magnus.
 
-use magnus::{function, method, prelude::*, Error, Ruby};
+use magnus::{function, prelude::*, Error, Ruby};
 use methodray_core::{
     analyzer::AstInstaller,
     env::{GlobalEnv, LocalEnv},
@@ -10,86 +10,65 @@ use methodray_core::{
     rbs,
 };
 
-#[magnus::wrap(class = "MethodRay::Analyzer")]
-pub struct Analyzer {
-    #[allow(dead_code)]
-    path: String,
-}
-
-impl Analyzer {
-    fn new(path: String) -> Self {
-        Self { path }
-    }
-
-    fn version(&self) -> String {
-        "0.1.0".to_string()
-    }
-
-    /// Execute type inference
-    fn infer_types(&self, source: String) -> Result<String, Error> {
-        // Parse
-        let session = ParseSession::new();
-        let parse_result = session.parse_source(&source, "source.rb").map_err(|e| {
-            let ruby = unsafe { Ruby::get_unchecked() };
-            Error::new(ruby.exception_runtime_error(), e.to_string())
-        })?;
+/// Type inference (public module function)
+fn infer_types(source: String) -> Result<String, Error> {
+    // Parse
+    let session = ParseSession::new();
+    let parse_result = session.parse_source(&source, "source.rb").map_err(|e| {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        Error::new(ruby.exception_runtime_error(), e.to_string())
+    })?;
 
-        // Build graph
-        let mut genv = GlobalEnv::new();
+    // Build graph
+    let mut genv = GlobalEnv::new();
 
-        // Register built-in methods from RBS
-        let ruby = unsafe { Ruby::get_unchecked() };
-        rbs::register_rbs_methods(&mut genv, &ruby)?;
+    // Register built-in methods from RBS
+    let ruby = unsafe { Ruby::get_unchecked() };
+    rbs::register_rbs_methods(&mut genv, &ruby)?;
 
-        let mut lenv = LocalEnv::new();
-        let mut installer = AstInstaller::new(&mut genv, &mut lenv, &source);
+    let mut lenv = LocalEnv::new();
+    let mut installer = AstInstaller::new(&mut genv, &mut lenv, &source);
 
-        // Process AST
-        let root = parse_result.node();
-        if let Some(program_node) = root.as_program_node() {
-            let statements = program_node.statements();
-            for stmt in &statements.body() {
-                installer.install_node(&stmt);
-            }
+    // Process AST
+    let root = parse_result.node();
+    if let Some(program_node) = root.as_program_node() {
+        let statements = program_node.statements();
+        for stmt in &statements.body() {
+            installer.install_node(&stmt);
         }
+    }
 
-        installer.finish();
+    installer.finish();
 
-        // Return results as string
-        let mut results = Vec::new();
-        for (var_name, vtx_id) in lenv.all_vars() {
-            if let Some(vtx) = genv.get_vertex(*vtx_id) {
-                results.push(format!("{}: {}", var_name, vtx.show()));
-            }
+    // Return results as string
+    let mut results = Vec::new();
+    for (var_name, vtx_id) in lenv.all_vars() {
+        if let Some(vtx) = genv.get_vertex(*vtx_id) {
+            results.push(format!("{}: {}", var_name, vtx.show()));
         }
-
-        Ok(results.join("\n"))
     }
+
+    Ok(results.join("\n"))
 }
 
-/// Setup function that only generates RBS cache
-/// This is used during gem build to pre-generate the cache
-fn setup() -> Result<String, Error> {
+/// RBS cache generation (executed when requiring methodray/setup)
+fn setup() -> Result<(), Error> {
     let ruby = unsafe { Ruby::get_unchecked() };
     let mut genv = GlobalEnv::new();
 
     // This will load RBS and save to cache if not already cached
-    let count = rbs::register_rbs_methods(&mut genv, &ruby)?;
+    rbs::register_rbs_methods(&mut genv, &ruby)?;
 
-    Ok(format!("RBS cache generated with {} methods", count))
+    Ok(())
 }
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("MethodRay")?;
-    let class = module.define_class("Analyzer", ruby.class_object())?;
-
-    class.define_singleton_method("new", function!(Analyzer::new, 1))?;
-    class.define_method("version", method!(Analyzer::version, 0))?;
-    class.define_method("infer_types", method!(Analyzer::infer_types, 1))?;
+    module.define_singleton_method("infer_types", function!(infer_types, 1))?;
 
-    // Module-level setup function for cache generation
-    module.define_singleton_method("setup", function!(setup, 0))?;
+    // require methodray/setup to generate RBS cache on Ruby side
+    setup()?;
 
     Ok(())
 }

data/lib/methodray/cli.rb

@@ -17,6 +17,7 @@ module MethodRay
       when 'watch'
         Commands.watch(args)
       when 'clear-cache'
+        warn "WARNING: 'clear-cache' is deprecated and will be removed in a future version."
         Commands.clear_cache(args)
       else
         puts "Unknown command: #{command}"

data/lib/methodray/commands.rb

@@ -14,7 +14,6 @@ module MethodRay
             methodray version                 # Show version
             methodray check [FILE] [OPTIONS]  # Type check a Ruby file
             methodray watch FILE              # Watch file for changes and auto-check
-            methodray clear-cache             # Clear RBS method cache
 
           Examples:
             methodray check app/models/user.rb

data/lib/methodray/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MethodRay
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
 end

data/rust/Cargo.toml

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

data/rust/src/analyzer/attributes.rs

@@ -18,10 +18,10 @@ pub(crate) fn process_attr_declaration(
     kind: AttrKind,
     attr_names: Vec<String>,
 ) {
-    let Some(class_name) = genv.scope_manager.current_class_name() else {
+    let Some(qualified_name) = genv.scope_manager.current_qualified_name() else {
         return;
     };
-    let recv_ty = Type::instance(&class_name);
+    let recv_ty = Type::instance(&qualified_name);
 
     for attr_name in attr_names {
         let ivar_name = format!("@{}", attr_name);

data/rust/src/analyzer/conditionals.rs

@@ -463,4 +463,76 @@ end
         let ret_vtx = info.return_vertex.unwrap();
         assert_eq!(get_type_show(&genv, ret_vtx), "String");
     }
+
+    // Test 11: ternary operator - different types → union
+    #[test]
+    fn test_ternary_union_type() {
+        let source = r#"
+class Foo
+  def bar
+    true ? "hello" : 42
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "(Integer | String)");
+    }
+
+    // Test 12: ternary operator - same type → single type
+    #[test]
+    fn test_ternary_same_type() {
+        let source = r#"
+class Foo
+  def bar
+    true ? "hello" : "world"
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "String");
+    }
+
+    // Test 13: ternary operator - nil branch → union with nil
+    #[test]
+    fn test_ternary_nil_branch() {
+        let source = r#"
+class Foo
+  def bar
+    true ? "hello" : nil
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "(String | nil)");
+    }
+
+    // Test 14: nested ternary operator
+    #[test]
+    fn test_ternary_nested() {
+        let source = r#"
+class Foo
+  def bar
+    true ? (false ? "inner" : 42) : :sym
+  end
+end
+"#;
+        let genv = analyze(source);
+        let info = genv
+            .resolve_method(&Type::instance("Foo"), "bar")
+            .expect("Foo#bar should be registered");
+        let ret_vtx = info.return_vertex.unwrap();
+        assert_eq!(get_type_show(&genv, ret_vtx), "(Integer | String | Symbol)");
+    }
 }