method-ray 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8b9351553b262a65f3b398bbb715a2e9600f893e1ff12703c1e903942798201a
+  data.tar.gz: 677baf919f242bc8e47a4b252f0ed929b64548bc6f873c58bb954b52515e0042
+SHA512:
+  metadata.gz: b87a06709a8bb8dd57087f260a07a045c7f34f572d0595a4669d3d569d609d4076cfe7b2ae8897e67edb5e3d65c68a1259151e9ce40ce9b79f598430949c0450
+  data.tar.gz: 33703cf7ae417499620b85081e0e95f4bd5049e91cb40c8e3f9c8a5f4f4ed60d2cdaa57475022abd090f7ae3bc5314eb37d27a8275cda6f35769807305bdb704

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+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.1] - 2025-01-19
+
+### Added
+
+- aarch64-linux (ARM64 Linux) support
+- macOS support (arm64-darwin)
+
+## [0.1.0] - 2025-01-18
+
+### Added
+
+- Initial release
+- `methodray check` - Static type checking for Ruby files
+
+[0.1.1]: https://github.com/dak2/method-ray/releases/tag/v0.1.1
+[0.1.0]: https://github.com/dak2/method-ray/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daichi Kamiyama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Method-Ray
+
+A fast static callable method checker for Ruby code.
+
+## Requirements
+
+Method-Ray supports Ruby 3.4 or later.
+
+## Installation
+
+```bash
+gem install methodray
+```
+
+## Quick Start
+
+### VSCode Extension
+
+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
+
+```bash
+# Check a single file
+bundle exec methodray check app/models/user.rb
+
+# Watch mode - auto re-check on file changes
+bundle exec methodray watch app/models/user.rb
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at this repository!
+
+## License
+
+MIT License. See [LICENSE](https://github.com/dak2/method-ray/blob/main/LICENSE) file for details.

data/exe/methodray

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/methodray'
+require_relative '../lib/methodray/cli'
+
+MethodRay::CLI.start(ARGV)

data/ext/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "methodray"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+name = "methodray"
+path = "src/lib.rs"
+
+[[bin]]
+name = "methodray-cli"
+path = "src/cli.rs"
+required-features = ["cli"]
+
+[features]
+default = []
+cli = ["methodray-core/cli", "dep:clap", "dep:anyhow"]
+
+[dependencies]
+methodray-core = { path = "../rust", features = ["ruby-ffi"] }
+magnus = "0.8"
+clap = { version = "4", features = ["derive"], optional = true }
+anyhow = { version = "1", optional = true }

data/ext/extconf.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+# Check if precompiled binaries exist (platform gem)
+lib_dir = File.expand_path('../lib/methodray', __dir__)
+cli_binary = File.join(lib_dir, 'methodray-cli')
+extension = Dir.glob(File.join(lib_dir, 'methodray.{bundle,so,dll}')).first
+
+if File.exist?(cli_binary) && extension
+  # Precompiled gem - create dummy Makefile
+  File.write('Makefile', "install:\n\t@echo 'Using precompiled binaries'\n")
+  exit 0
+end
+
+# Source gem - build from Rust
+require 'rb_sys/mkmf'
+
+# Build the Ruby FFI extension
+create_rust_makefile('methodray/methodray')
+
+# Project root directory
+project_root = File.expand_path('..', __dir__)
+target_dir = File.join(project_root, 'target', 'release')
+
+# Append CLI binary build to the generated Makefile
+File.open('Makefile', 'a') do |f|
+  f.puts <<~MAKEFILE
+
+    # Build CLI binary after the extension
+    install: install-cli
+
+    install-cli:
+    \t@echo "Building CLI binary..."
+    \tcd #{__dir__} && cargo build --release --features cli --bin methodray-cli
+    \t@mkdir -p $(DESTDIR)$(sitearchdir)
+    \tcp #{target_dir}/methodray-cli $(DESTDIR)$(sitearchdir)/methodray-cli
+    \tchmod 755 $(DESTDIR)$(sitearchdir)/methodray-cli
+  MAKEFILE
+end

data/ext/src/cli.rs

@@ -0,0 +1,33 @@
+//! MethodRay CLI entry point for gem distribution
+
+use anyhow::Result;
+use clap::Parser;
+use methodray_core::cli::{commands, Cli, Commands};
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Check { file, verbose } => {
+            if let Some(file_path) = file {
+                let success = commands::check_single_file(&file_path, verbose)?;
+                if !success {
+                    std::process::exit(1);
+                }
+            } else {
+                commands::check_project(verbose)?;
+            }
+        }
+        Commands::Watch { file } => {
+            commands::watch_file(&file)?;
+        }
+        Commands::Version => {
+            commands::print_version();
+        }
+        Commands::ClearCache => {
+            commands::clear_cache()?;
+        }
+    }
+
+    Ok(())
+}

data/ext/src/lib.rs

@@ -0,0 +1,79 @@
+//! Ruby FFI bindings for Method-Ray
+//!
+//! This module provides the Ruby gem interface using magnus.
+
+use magnus::{function, method, prelude::*, Error, Ruby};
+use methodray_core::{
+    analyzer::AstInstaller,
+    env::{GlobalEnv, LocalEnv},
+    parser, 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 parse_result =
+            parser::parse_ruby_source(&source, "source.rb".to_string()).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();
+
+        // 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);
+
+        // 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();
+
+        // 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"))
+    }
+}
+
+#[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))?;
+
+    Ok(())
+}

data/lib/methodray/cli.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'commands'
+
+module MethodRay
+  class CLI
+    def self.start(args)
+      command = args.shift
+
+      case command
+      when 'help', '--help', '-h', nil
+        Commands.help
+      when 'version', '--version', '-v'
+        Commands.version
+      when 'check'
+        Commands.check(args)
+      when 'watch'
+        Commands.watch(args)
+      when 'clear-cache'
+        Commands.clear_cache(args)
+      else
+        puts "Unknown command: #{command}"
+        Commands.help
+        exit 1
+      end
+    end
+  end
+end

data/lib/methodray/commands.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module MethodRay
+  module Commands
+    COMMANDS_DIR = __dir__
+
+    class << self
+      def help
+        puts <<~HELP
+          MethodRay v#{MethodRay::VERSION} - A fast static analysis tool for Ruby methods.
+
+          Usage:
+            methodray help                    # Show this help
+            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
+            methodray watch app/models/user.rb
+        HELP
+      end
+
+      def version
+        puts "MethodRay v#{MethodRay::VERSION}"
+      end
+
+      def check(args)
+        exec_rust_cli('check', args)
+      end
+
+      def watch(args)
+        exec_rust_cli('watch', args)
+      end
+
+      def clear_cache(args)
+        exec_rust_cli('clear-cache', args)
+      end
+
+      private
+
+      def exec_rust_cli(command, args)
+        binary_path = find_rust_binary
+
+        unless binary_path
+          warn 'Error: CLI binary not found.'
+          warn ''
+          warn 'For development, build with:'
+          warn '  cd rust && cargo build --release --bin methodray --features cli'
+          warn ''
+          warn 'If installed via gem, this might be a platform compatibility issue.'
+          warn 'Please report at: https://github.com/dak2/method-ray/issues'
+          exit 1
+        end
+
+        exec(binary_path, command, *args)
+      end
+
+      def find_rust_binary
+        # Platform-specific binary name
+        cli_binary = Gem.win_platform? ? 'methodray-cli.exe' : 'methodray-cli'
+        legacy_binary = Gem.win_platform? ? 'methodray.exe' : 'methodray'
+
+        candidates = [
+          # CLI binary built during gem install (lib/methodray directory)
+          File.expand_path(cli_binary, COMMANDS_DIR),
+          # Development: target/release (project root)
+          File.expand_path("../../target/release/#{cli_binary}", COMMANDS_DIR),
+          # Development: rust/target/release (legacy standalone binary)
+          File.expand_path("../../rust/target/release/#{legacy_binary}", COMMANDS_DIR)
+        ]
+
+        candidates.find { |path| File.executable?(path) }
+      end
+    end
+  end
+end

data/lib/methodray/version.rb

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

data/lib/methodray.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require_relative 'methodray/version'
+require_relative 'methodray/methodray' # ネイティブ拡張
+
+module MethodRay
+  class Error < StandardError; end
+end

data/rust/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "methodray-core"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "methodray_core"
+path = "src/lib.rs"
+
+[[bin]]
+name = "methodray"
+path = "src/main.rs"
+required-features = ["cli"]
+
+[[bin]]
+name = "methodray-lsp"
+path = "src/lsp/main.rs"
+required-features = ["lsp"]
+
+[dependencies]
+rayon = "1.10"
+walkdir = "2.5"
+anyhow = "1.0"
+thiserror = "1.0"
+ruby-prism = "1.7"
+serde = { version = "1.0", features = ["derive"] }
+bincode = "1.3"
+dirs = "5.0"
+clap = { version = "4.5", features = ["derive"], optional = true }
+notify = { version = "6.1", optional = true }
+tower-lsp = { version = "0.20", optional = true }
+tokio = { version = "1.0", features = ["full"], optional = true }
+tempfile = { version = "3.13", optional = true }
+magnus = { version = "0.8", optional = true }
+
+[features]
+cli = ["clap", "notify"]
+lsp = ["tower-lsp", "tokio", "tempfile"]
+ruby-ffi = ["magnus"]

data/rust/src/analyzer/calls.rs

@@ -0,0 +1,56 @@
+//! Method Call Handlers - Processing Ruby method calls
+//!
+//! This module is responsible for:
+//! - Creating MethodCallBox for method invocations (x.upcase)
+//! - Managing return value vertices
+//! - Attaching source location for error reporting
+
+use crate::env::GlobalEnv;
+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(
+    genv: &mut GlobalEnv,
+    recv_vtx: VertexId,
+    method_name: String,
+    location: Option<SourceLocation>,
+) -> VertexId {
+    // Create Vertex for return value
+    let ret_vtx = genv.new_vertex();
+
+    // Create MethodCallBox with location
+    let box_id = genv.alloc_box_id();
+    let call_box = MethodCallBox::new(box_id, recv_vtx, method_name, ret_vtx, location);
+    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(), 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(), None);
+
+        // Box should be added
+        assert_eq!(genv.box_count(), 1);
+    }
+}

data/rust/src/analyzer/definitions.rs

@@ -0,0 +1,70 @@
+//! Definition Handlers - Processing Ruby class/method definitions
+//!
+//! This module is responsible for:
+//! - Class definition scope management (class Foo ... end)
+//! - Method definition scope management (def bar ... end)
+//! - Extracting class names from AST nodes
+
+use crate::env::GlobalEnv;
+
+/// Install class definition
+pub fn install_class(genv: &mut GlobalEnv, class_name: String) {
+    genv.enter_class(class_name);
+}
+
+/// Install method definition
+pub fn install_method(genv: &mut GlobalEnv, method_name: String) {
+    genv.enter_method(method_name);
+}
+
+/// Exit current scope (class or method)
+pub fn exit_scope(genv: &mut GlobalEnv) {
+    genv.exit_scope();
+}
+
+/// Extract class name from ClassNode
+pub fn extract_class_name(class_node: &ruby_prism::ClassNode) -> String {
+    if let Some(constant_read) = class_node.constant_path().as_constant_read_node() {
+        String::from_utf8_lossy(constant_read.name().as_slice()).to_string()
+    } else {
+        "UnknownClass".to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_enter_exit_class_scope() {
+        let mut genv = GlobalEnv::new();
+
+        install_class(&mut genv, "User".to_string());
+        assert_eq!(
+            genv.scope_manager.current_class_name(),
+            Some("User".to_string())
+        );
+
+        exit_scope(&mut genv);
+        assert_eq!(genv.scope_manager.current_class_name(), None);
+    }
+
+    #[test]
+    fn test_nested_method_scope() {
+        let mut genv = GlobalEnv::new();
+
+        install_class(&mut genv, "User".to_string());
+        install_method(&mut genv, "greet".to_string());
+
+        // Still in User class context
+        assert_eq!(
+            genv.scope_manager.current_class_name(),
+            Some("User".to_string())
+        );
+
+        exit_scope(&mut genv); // exit method
+        exit_scope(&mut genv); // exit class
+
+        assert_eq!(genv.scope_manager.current_class_name(), None);
+    }
+}