method-ray 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b9351553b262a65f3b398bbb715a2e9600f893e1ff12703c1e903942798201a
-  data.tar.gz: 677baf919f242bc8e47a4b252f0ed929b64548bc6f873c58bb954b52515e0042
+  metadata.gz: b03f7efedd583d2cda9e59cd651ded78d5357c53eb06eac8980aae25db0529de
+  data.tar.gz: c02996cc2a511f800d34cec0ce46744c6ae2bddb8974e361f994a332b898c467
 SHA512:
-  metadata.gz: b87a06709a8bb8dd57087f260a07a045c7f34f572d0595a4669d3d569d609d4076cfe7b2ae8897e67edb5e3d65c68a1259151e9ce40ce9b79f598430949c0450
-  data.tar.gz: 33703cf7ae417499620b85081e0e95f4bd5049e91cb40c8e3f9c8a5f4f4ed60d2cdaa57475022abd090f7ae3bc5314eb37d27a8275cda6f35769807305bdb704
+  metadata.gz: 3aa19e8a26274f5d8c7b5b746e67f10d4e47ac281852251c737ebed4f933b5426e8b842d575f26110ee279fc48079a1dc382e78b2a184e0d4211d241dabae77a
+  data.tar.gz: '08e6b8bf49475c874538c007b52fec615459eb0c376357e1b2429868a67885eb695d261ba02d078b7fb0835321b92e84f06a6ac5366066379229b0e78072d786'

data/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.2] - 2025-01-19
+
+### Added
+
+- Pre-built RBS cache bundled with gem (no initialization required)
+- `MethodRay.setup` for cache generation (internal API)
+
+### Changed
+
+- Separated `setup` logic from `infer_types` for cleaner cache generation
+
 ## [0.1.1] - 2025-01-19
 
 ### Added
@@ -19,5 +30,6 @@ 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.2]: https://github.com/dak2/method-ray/releases/tag/v0.1.2
 [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/ext/src/lib.rs

@@ -66,6 +66,18 @@ impl Analyzer {
     }
 }
 
+/// Setup function that only generates RBS cache
+/// This is used during gem build to pre-generate the cache
+fn setup() -> Result<String, 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)?;
+
+    Ok(format!("RBS cache generated with {} methods", count))
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("MethodRay")?;
@@ -75,5 +87,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("version", method!(Analyzer::version, 0))?;
     class.define_method("infer_types", method!(Analyzer::infer_types, 1))?;
 
+    // Module-level setup function for cache generation
+    module.define_singleton_method("setup", function!(setup, 0))?;
+
     Ok(())
 }

data/lib/methodray/version.rb

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

data/rust/Cargo.toml

@@ -37,3 +37,6 @@ magnus = { version = "0.8", optional = true }
 cli = ["clap", "notify"]
 lsp = ["tower-lsp", "tokio", "tempfile"]
 ruby-ffi = ["magnus"]
+
+[dev-dependencies]
+tempfile = "3.13"

data/rust/src/cache/rbs_cache.rs

@@ -39,7 +39,7 @@ impl SerializableMethodInfo {
 
 #[allow(dead_code)]
 impl RbsCache {
-    /// Get cache file path
+    /// Get user cache file path (in ~/.cache/methodray/)
     pub fn cache_path() -> Result<PathBuf> {
         let cache_dir = dirs::cache_dir()
             .context("Failed to get cache directory")?
@@ -50,8 +50,42 @@ impl RbsCache {
         Ok(cache_dir.join("rbs_cache.bin"))
     }
 
+    /// Get bundled cache path (shipped with gem)
+    ///
+    /// Gem structure after install:
+    ///   lib/methodray/
+    ///     methodray-cli      # CLI binary
+    ///     methodray.bundle   # FFI extension (macOS) or methodray.so (Linux)
+    ///     rbs_cache.bin      # Pre-built cache
+    ///
+    /// The CLI binary and cache are in the same directory.
+    fn bundled_cache_path() -> Option<PathBuf> {
+        if let Ok(exe_path) = std::env::current_exe() {
+            if let Some(exe_dir) = exe_path.parent() {
+                // Cache is in the same directory as CLI binary
+                let bundled = exe_dir.join("rbs_cache.bin");
+                if bundled.exists() {
+                    return Some(bundled);
+                }
+            }
+        }
+        None
+    }
+
     /// Load cache from disk
+    /// Tries bundled cache first, then user cache
     pub fn load() -> Result<Self> {
+        // Try bundled cache first (shipped with gem)
+        if let Some(bundled_path) = Self::bundled_cache_path() {
+            if let Ok(bytes) = fs::read(&bundled_path) {
+                if let Ok(cache) = bincode::deserialize::<Self>(&bytes) {
+                    eprintln!("Loaded bundled cache from {}", bundled_path.display());
+                    return Ok(cache);
+                }
+            }
+        }
+
+        // Fall back to user cache
         let path = Self::cache_path()?;
         let bytes = fs::read(&path)
             .with_context(|| format!("Failed to read cache from {}", path.display()))?;
@@ -121,6 +155,7 @@ impl RbsCache {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use tempfile::tempdir;
 
     #[test]
     fn test_cache_serialization() {
@@ -155,4 +190,113 @@ mod tests {
         assert!(!cache.is_valid("0.2.0", "3.7.0"));
         assert!(!cache.is_valid("0.1.0", "3.8.0"));
     }
+
+    #[test]
+    fn test_serializable_method_info_return_type() {
+        let method_info = SerializableMethodInfo {
+            receiver_class: "String".to_string(),
+            method_name: "upcase".to_string(),
+            return_type_str: "String".to_string(),
+        };
+
+        let return_type = method_info.return_type();
+        assert_eq!(return_type.show(), "String");
+    }
+
+    #[test]
+    fn test_cache_methods_accessor() {
+        let cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![
+                SerializableMethodInfo {
+                    receiver_class: "String".to_string(),
+                    method_name: "upcase".to_string(),
+                    return_type_str: "String".to_string(),
+                },
+                SerializableMethodInfo {
+                    receiver_class: "Integer".to_string(),
+                    method_name: "to_s".to_string(),
+                    return_type_str: "String".to_string(),
+                },
+            ],
+            timestamp: SystemTime::now(),
+        };
+
+        let methods = cache.methods();
+        assert_eq!(methods.len(), 2);
+        assert_eq!(methods[0].receiver_class, "String");
+        assert_eq!(methods[0].method_name, "upcase");
+        assert_eq!(methods[1].receiver_class, "Integer");
+        assert_eq!(methods[1].method_name, "to_s");
+    }
+
+    #[test]
+    fn test_cache_save_and_load() {
+        let temp_dir = tempdir().unwrap();
+        let cache_path = temp_dir.path().join("test_cache.bin");
+
+        let original_cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![
+                SerializableMethodInfo {
+                    receiver_class: "String".to_string(),
+                    method_name: "upcase".to_string(),
+                    return_type_str: "String".to_string(),
+                },
+                SerializableMethodInfo {
+                    receiver_class: "Array".to_string(),
+                    method_name: "first".to_string(),
+                    return_type_str: "Object".to_string(),
+                },
+            ],
+            timestamp: SystemTime::now(),
+        };
+
+        // Save to temp file
+        let bytes = bincode::serialize(&original_cache).unwrap();
+        fs::write(&cache_path, &bytes).unwrap();
+
+        // Load from temp file
+        let loaded_bytes = fs::read(&cache_path).unwrap();
+        let loaded_cache: RbsCache = bincode::deserialize(&loaded_bytes).unwrap();
+
+        assert_eq!(loaded_cache.version, "0.1.0");
+        assert_eq!(loaded_cache.rbs_version, "3.7.0");
+        assert_eq!(loaded_cache.methods.len(), 2);
+        assert_eq!(loaded_cache.methods[0].method_name, "upcase");
+        assert_eq!(loaded_cache.methods[1].method_name, "first");
+    }
+
+    #[test]
+    fn test_cache_with_empty_methods() {
+        let cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![],
+            timestamp: SystemTime::now(),
+        };
+
+        let bytes = bincode::serialize(&cache).unwrap();
+        let deserialized: RbsCache = bincode::deserialize(&bytes).unwrap();
+
+        assert_eq!(deserialized.methods.len(), 0);
+        assert!(deserialized.is_valid("0.1.0", "3.7.0"));
+    }
+
+    #[test]
+    fn test_cache_validation_version_mismatch() {
+        let cache = RbsCache {
+            version: "0.1.0".to_string(),
+            rbs_version: "3.7.0".to_string(),
+            methods: vec![],
+            timestamp: SystemTime::now(),
+        };
+
+        // Both versions must match
+        assert!(!cache.is_valid("0.1.1", "3.7.0"));
+        assert!(!cache.is_valid("0.1.0", "3.7.1"));
+        assert!(!cache.is_valid("0.2.0", "4.0.0"));
+    }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: method-ray
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - dak2