rfmt 1.3.1 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3711e11ba344ee0b9e1e76d0885fd99bd7ccbd7901ab5ba819619ae40647365f
-  data.tar.gz: 95f1b17c4c9a542cc24d9b89df6dee44398f59d27da0446961ac320b338a6bb4
+  metadata.gz: 7d2092d9d53fa47024fcb8a13fb635a6da7eba5d4c51d3a8df854d551380037b
+  data.tar.gz: 59bb09f50cb7ee5a033328300a581e973879aaad56067d267b041c2070cac8bf
 SHA512:
-  metadata.gz: 7bb8aff9825e2a8d44f3161786b7952a2b2e3b679d0e607eb748102971d4c8a417ca8dcaac80e171a97ef223814c229b14b63af505321309393edc9432550fe6
-  data.tar.gz: 110a42ff056ac3dd6939d0f67b50a4784bbdafd513c4c0a1ab6e9eb8d0a040a0aa65bc39d0b37975ffb1972cf81d8396868d33e627b71ed017894cf1674d3cc4
+  metadata.gz: f7043e22d625b0b6a689f01950a6ed0fae7ab3fa1cfa2dcd51af544d72aadf8b0c3aa65a3465c9f9baabf2f1a000c37bddb2f2f57e2defd11344f6194ad3b68b
+  data.tar.gz: 407b70b3614da3ed19c74bd43d9491ee9bff1ce6cb1ef7f1e1d2d0b71068afb937bd5409668ae0c7454a6f2d12cb4764fa6df0273bef149980be30e0f9f1d7b6

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [1.3.3] - 2026-01-17
+
+### Fixed
+- Add native extension loader for Ruby 3.3+ compatibility (#65)
+  - Resolves LoadError on Ruby 3.3+ arm64-darwin systems
+  - Implements dynamic path resolution for version-specific directories
+
+### Changed
+- Remove unnecessary String clones in comment emission (performance optimization)
+- Remove debug logs and obvious comments from codebase
+- Update .gitignore with development artifacts
+
+## [1.3.2] - 2026-01-09
+
+### Added
+- Implement `std::str::FromStr` trait for `NodeType`
+- Unit tests for validation module
+
+### Changed
+- Use serde enum for comment type deserialization (type-safe JSON parsing)
+- Convert recursive `find_last_code_line` to iterative approach (prevent stack overflow)
+- Use BTreeMap index for comment lookup in `emit_statements` (O(n) → O(log n))
+
+### Fixed
+- Remove panic-prone `unwrap()` on Mutex lock in logger (prevent Ruby VM crash)
+
 ## [1.3.1] - 2026-01-08
 
 ### Added

data/Cargo.lock

@@ -1214,7 +1214,7 @@ checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "rfmt"
-version = "1.3.1"
+version = "1.3.3"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.3.1"
+version = "1.3.3"
 edition = "2021"
 authors = ["fujitani sora <fujitanisora0414@gmail.com>"]
 license = "MIT"

data/ext/rfmt/src/ast/mod.rs

@@ -235,9 +235,11 @@ pub enum NodeType {
     Unknown(String),
 }
 
-impl NodeType {
-    pub fn from_str(s: &str) -> Self {
-        match s {
+impl std::str::FromStr for NodeType {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
             "program_node" => Self::ProgramNode,
             "statements_node" => Self::StatementsNode,
             "class_node" => Self::ClassNode,
@@ -383,7 +385,14 @@ impl NodeType {
             "implicit_node" => Self::ImplicitNode,
             "implicit_rest_node" => Self::ImplicitRestNode,
             _ => Self::Unknown(s.to_string()),
-        }
+        })
+    }
+}
+
+impl NodeType {
+    /// Parse a node type from a string (convenience wrapper for `FromStr`)
+    pub fn from_str(s: &str) -> Self {
+        s.parse().unwrap()
     }
 
     /// Check if this node type is a definition (class, module, or method)

data/ext/rfmt/src/emitter/mod.rs

@@ -62,13 +62,9 @@ impl Emitter {
 
         self.emit_node(ast, 0)?;
 
-        // Find the last emitted code line for proper blank line handling
         let last_code_line = Self::find_last_code_line(ast);
-
-        // Emit any remaining comments that weren't emitted
         self.emit_remaining_comments(last_code_line)?;
 
-        // Ensure file ends with a newline
         if !self.buffer.ends_with('\n') {
             self.buffer.push('\n');
         }
@@ -79,12 +75,13 @@ impl Emitter {
     /// Find the last line of code in the AST (excluding comments)
     fn find_last_code_line(ast: &Node) -> usize {
         let mut max_line = ast.location.end_line;
-        for child in &ast.children {
-            let child_end = Self::find_last_code_line(child);
-            if child_end > max_line {
-                max_line = child_end;
-            }
+        let mut stack = vec![ast];
+
+        while let Some(node) = stack.pop() {
+            max_line = max_line.max(node.location.end_line);
+            stack.extend(node.children.iter());
         }
+
         max_line
     }
 
@@ -185,35 +182,26 @@ impl Emitter {
     /// Emit comments that appear before a given line
     /// Uses BTreeMap index for O(log n) lookup instead of O(n) iteration
     fn emit_comments_before(&mut self, line: usize, indent_level: usize) -> Result<()> {
-        let indent_str = self.get_indent(indent_level).to_string();
+        self.ensure_indent_cache(indent_level);
 
-        // Use indexed lookup instead of iterating all comments
         let indices = self.get_comment_indices_before(line);
 
-        // Build list of comments to emit with their data
         let mut comments_to_emit: Vec<_> = indices
             .into_iter()
             .map(|idx| {
                 let comment = &self.all_comments[idx];
-                (
-                    idx,
-                    comment.text.clone(),
-                    comment.location.start_line,
-                    comment.location.end_line,
-                )
+                (idx, comment.location.start_line, comment.location.end_line)
             })
             .collect();
 
-        // Sort by start_line to emit in order
-        comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
+        comments_to_emit.sort_by_key(|(_, start, _)| *start);
 
         let comments_count = comments_to_emit.len();
         let mut last_comment_end_line: Option<usize> = None;
 
-        for (i, (idx, text, comment_start_line, comment_end_line)) in
+        for (i, (idx, comment_start_line, comment_end_line)) in
             comments_to_emit.into_iter().enumerate()
         {
-            // Preserve blank lines between comments
             if let Some(prev_end) = last_comment_end_line {
                 let gap = comment_start_line.saturating_sub(prev_end);
                 for _ in 1..gap {
@@ -221,11 +209,14 @@ impl Emitter {
                 }
             }
 
-            writeln!(self.buffer, "{}{}", indent_str, text)?;
+            writeln!(
+                self.buffer,
+                "{}{}",
+                &self.indent_cache[indent_level], &self.all_comments[idx].text
+            )?;
             self.emitted_comment_indices.insert(idx);
             last_comment_end_line = Some(comment_end_line);
 
-            // Add blank line after the LAST comment if there was a gap to the code
             if i == comments_count - 1 && line > comment_end_line + 1 {
                 self.buffer.push('\n');
             }
@@ -254,33 +245,24 @@ impl Emitter {
         end_line: usize,
         indent_level: usize,
     ) -> Result<()> {
-        let indent_str = self.get_indent(indent_level).to_string();
+        self.ensure_indent_cache(indent_level);
 
-        // Use indexed lookup instead of iterating all comments
         let indices = self.get_comment_indices_in_range(start_line, end_line);
 
-        // Build list of comments to emit, filtering by end_line
         let mut comments_to_emit: Vec<_> = indices
             .into_iter()
             .filter(|&idx| self.all_comments[idx].location.end_line < end_line)
             .map(|idx| {
                 let comment = &self.all_comments[idx];
-                (
-                    idx,
-                    comment.text.clone(),
-                    comment.location.start_line,
-                    comment.location.end_line,
-                )
+                (idx, comment.location.start_line, comment.location.end_line)
             })
             .collect();
 
-        // Sort by start_line to emit in order
-        comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
+        comments_to_emit.sort_by_key(|(_, start, _)| *start);
 
         let mut last_comment_end_line: Option<usize> = None;
 
-        for (idx, text, comment_start_line, comment_end_line) in comments_to_emit {
-            // Preserve blank lines between comments
+        for (idx, comment_start_line, comment_end_line) in comments_to_emit {
             if let Some(prev_end) = last_comment_end_line {
                 let gap = comment_start_line.saturating_sub(prev_end);
                 for _ in 1..gap {
@@ -288,7 +270,11 @@ impl Emitter {
                 }
             }
 
-            writeln!(self.buffer, "{}{}", indent_str, text)?;
+            writeln!(
+                self.buffer,
+                "{}{}",
+                &self.indent_cache[indent_level], &self.all_comments[idx].text
+            )?;
             self.emitted_comment_indices.insert(idx);
             last_comment_end_line = Some(comment_end_line);
         }
@@ -305,39 +291,35 @@ impl Emitter {
         indent_level: usize,
         prev_line: usize,
     ) -> Result<()> {
-        let indent_str = self.get_indent(indent_level).to_string();
+        self.ensure_indent_cache(indent_level);
 
-        // Use indexed lookup instead of iterating all comments
         let indices = self.get_comment_indices_in_range(start_line, end_line);
 
-        // Build list of comments to emit, filtering by end_line
         let mut comments_to_emit: Vec<_> = indices
             .into_iter()
             .filter(|&idx| self.all_comments[idx].location.end_line < end_line)
             .map(|idx| {
                 let comment = &self.all_comments[idx];
-                (
-                    idx,
-                    comment.text.clone(),
-                    comment.location.start_line,
-                    comment.location.end_line,
-                )
+                (idx, comment.location.start_line, comment.location.end_line)
             })
             .collect();
 
-        // Sort by start_line to emit in order
-        comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
+        comments_to_emit.sort_by_key(|(_, start, _)| *start);
 
         let mut last_end_line: usize = prev_line;
 
-        for (idx, text, comment_start_line, comment_end_line) in comments_to_emit {
+        for (idx, comment_start_line, comment_end_line) in comments_to_emit {
             // Preserve blank lines between previous content and this comment
             let gap = comment_start_line.saturating_sub(last_end_line);
             for _ in 1..gap {
                 self.buffer.push('\n');
             }
 
-            writeln!(self.buffer, "{}{}", indent_str, text)?;
+            writeln!(
+                self.buffer,
+                "{}{}",
+                &self.indent_cache[indent_level], &self.all_comments[idx].text
+            )?;
             self.emitted_comment_indices.insert(idx);
             last_end_line = comment_end_line;
         }
@@ -351,15 +333,12 @@ impl Emitter {
         // Use indexed lookup for O(log n) access
         let indices = self.get_comment_indices_on_line(line);
 
-        // Build list of comments to emit
-        let indices_to_emit: Vec<_> = indices
-            .into_iter()
-            .map(|idx| (idx, self.all_comments[idx].text.clone()))
-            .collect();
+        // Collect indices only (no text clone needed)
+        let indices_to_emit: Vec<usize> = indices;
 
-        // Now emit the collected comments
-        for (idx, text) in indices_to_emit {
-            write!(self.buffer, " {}", text)?;
+        // Now emit the collected comments by accessing text at write time
+        for idx in indices_to_emit {
+            write!(self.buffer, " {}", &self.all_comments[idx].text)?;
             self.emitted_comment_indices.insert(idx);
         }
 
@@ -426,15 +405,12 @@ impl Emitter {
                 let next_start_line = next_child.location.start_line;
 
                 // Find the first comment between current and next node (if any)
+                // Uses BTreeMap range for O(log n) lookup instead of O(n) iteration
                 let first_comment_line = self
-                    .all_comments
-                    .iter()
-                    .filter(|c| {
-                        c.location.start_line > current_end_line
-                            && c.location.end_line < next_start_line
-                    })
-                    .map(|c| c.location.start_line)
-                    .min();
+                    .comments_by_line
+                    .range((current_end_line + 1)..next_start_line)
+                    .next()
+                    .map(|(line, _)| *line);
 
                 // Calculate line diff based on whether there's a comment
                 let effective_next_line = first_comment_line.unwrap_or(next_start_line);
@@ -1313,9 +1289,9 @@ impl Emitter {
         Ok(())
     }
 
-    /// Get cached indent string for a given level
-    fn get_indent(&mut self, level: usize) -> &str {
-        // Extend cache if needed
+    /// Ensure indent cache has entries up to and including the given level
+    /// This allows pre-building the cache before borrowing self.indent_cache
+    fn ensure_indent_cache(&mut self, level: usize) {
         while self.indent_cache.len() <= level {
             let len = self.indent_cache.len();
             let indent = match self.config.formatting.indent_style {
@@ -1324,13 +1300,12 @@ impl Emitter {
             };
             self.indent_cache.push(indent);
         }
-        &self.indent_cache[level]
     }
 
     /// Emit indentation
     fn emit_indent(&mut self, level: usize) -> Result<()> {
-        let indent_str = self.get_indent(level).to_string();
-        write!(self.buffer, "{}", indent_str)?;
+        self.ensure_indent_cache(level);
+        write!(self.buffer, "{}", &self.indent_cache[level])?;
         Ok(())
     }
 

data/ext/rfmt/src/lib.rs

@@ -14,25 +14,16 @@ use magnus::{define_module, function, prelude::*, Error, Ruby};
 use parser::{PrismAdapter, RubyParser};
 
 fn format_ruby_code(ruby: &Ruby, source: String, json: String) -> Result<String, Error> {
-    log::info!("format_ruby_code called");
     let policy = SecurityPolicy::default();
 
     policy
         .validate_source_size(&source)
         .map_err(|e| e.to_magnus_error(ruby))?;
 
-    log::debug!("Source code validated, size: {} bytes", source.len());
-
     let parser = PrismAdapter::new();
     let ast = parser.parse(&json).map_err(|e| e.to_magnus_error(ruby))?;
 
-    // Load configuration from file or use defaults
-    log::info!("Attempting to discover config file...");
     let config = Config::discover().map_err(|e| e.to_magnus_error(ruby))?;
-    log::info!(
-        "Config loaded successfully, line_length: {}",
-        config.formatting.line_length
-    );
     let mut emitter = Emitter::with_source(config, source);
 
     let formatted = emitter.emit(&ast).map_err(|e| e.to_magnus_error(ruby))?;
@@ -56,7 +47,6 @@ fn rust_version() -> String {
 #[magnus::init]
 fn init(_ruby: &Ruby) -> Result<(), Error> {
     logging::RfmtLogger::init();
-    log::info!("Initializing rfmt Rust extension");
 
     let module = define_module("Rfmt")?;
 
@@ -64,6 +54,5 @@ fn init(_ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("parse_to_json", function!(parse_to_json, 1))?;
     module.define_singleton_method("rust_version", function!(rust_version, 0))?;
 
-    log::info!("rfmt Rust extension initialized successfully");
     Ok(())
 }

data/ext/rfmt/src/logging/logger.rs

@@ -54,7 +54,12 @@ impl Log for RfmtLogger {
             return;
         }
 
-        let mut output = self.output.lock().unwrap();
+        // Use unwrap_or_else to recover from poisoned mutex.
+        // Logging should never cause a panic, even if another thread panicked while holding the lock.
+        let mut output = self
+            .output
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
 
         writeln!(
             output,
@@ -67,7 +72,11 @@ impl Log for RfmtLogger {
     }
 
     fn flush(&self) {
-        let mut output = self.output.lock().unwrap();
+        // Recover from poisoned mutex - flushing should not panic
+        let mut output = self
+            .output
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
         output.flush().ok();
     }
 }

data/ext/rfmt/src/parser/prism_adapter.rs

@@ -13,8 +13,8 @@ impl PrismAdapter {
         Self
     }
 
-    /// Parse JSON from Ruby's PrismBridge
-    fn parse_json(&self, json: &str) -> Result<(PrismNode, Vec<PrismComment>)> {
+    /// Parse JSON from Ruby's `PrismBridge`
+    fn parse_json(json: &str) -> Result<(PrismNode, Vec<PrismComment>)> {
         // Try to parse as new format with comments first
         if let Ok(wrapper) = serde_json::from_str::<PrismWrapper>(json) {
             return Ok((wrapper.ast, wrapper.comments));
@@ -26,8 +26,8 @@ impl PrismAdapter {
         Ok((node, Vec::new()))
     }
 
-    /// Convert PrismNode to internal Node representation
-    fn convert_node(&self, prism_node: &PrismNode) -> Result<Node> {
+    /// Convert `PrismNode` to internal `Node` representation
+    fn convert_node(prism_node: &PrismNode) -> Result<Node> {
         // Convert node type (always succeeds, returns Unknown for unsupported types)
         let node_type = NodeType::from_str(&prism_node.node_type);
 
@@ -42,18 +42,15 @@ impl PrismAdapter {
         );
 
         // Convert children recursively
-        let children: Result<Vec<Node>> = prism_node
-            .children
-            .iter()
-            .map(|child| self.convert_node(child))
-            .collect();
+        let children: Result<Vec<Node>> =
+            prism_node.children.iter().map(Self::convert_node).collect();
         let children = children?;
 
         // Convert comments
         let comments: Vec<Comment> = prism_node
             .comments
             .iter()
-            .map(|c| self.convert_comment(c))
+            .map(Self::convert_comment)
             .collect();
 
         // Convert formatting info
@@ -76,21 +73,8 @@ impl PrismAdapter {
         })
     }
 
-    /// Convert PrismComment to internal Comment
-    fn convert_comment(&self, comment: &PrismComment) -> Comment {
-        let comment_type = match comment.comment_type.as_str() {
-            "line" => CommentType::Line,
-            "block" => CommentType::Block,
-            _ => CommentType::Line, // default to line comment
-        };
-
-        let position = match comment.position.as_str() {
-            "leading" => CommentPosition::Leading,
-            "trailing" => CommentPosition::Trailing,
-            "inner" => CommentPosition::Inner,
-            _ => CommentPosition::Leading, // default to leading
-        };
-
+    /// Convert `PrismComment` to internal `Comment`
+    fn convert_comment(comment: &PrismComment) -> Comment {
         Comment {
             text: comment.text.clone(),
             location: Location::new(
@@ -101,21 +85,21 @@ impl PrismAdapter {
                 comment.location.start_offset,
                 comment.location.end_offset,
             ),
-            comment_type,
-            position,
+            comment_type: comment.comment_type.into(),
+            position: comment.position.into(),
         }
     }
 }
 
 impl RubyParser for PrismAdapter {
     fn parse(&self, json: &str) -> Result<Node> {
-        let (prism_ast, top_level_comments) = self.parse_json(json)?;
-        let mut node = self.convert_node(&prism_ast)?;
+        let (prism_ast, top_level_comments) = Self::parse_json(json)?;
+        let mut node = Self::convert_node(&prism_ast)?;
 
         // Attach top-level comments to the root node
         if !top_level_comments.is_empty() {
             node.comments
-                .extend(top_level_comments.iter().map(|c| self.convert_comment(c)));
+                .extend(top_level_comments.iter().map(Self::convert_comment));
         }
 
         Ok(node)
@@ -160,8 +144,46 @@ pub struct PrismLocation {
 pub struct PrismComment {
     pub text: String,
     pub location: PrismLocation,
-    pub comment_type: String,
-    pub position: String,
+    #[serde(rename = "type", default)]
+    pub comment_type: PrismCommentType,
+    #[serde(default)]
+    pub position: PrismCommentPosition,
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PrismCommentType {
+    #[default]
+    Line,
+    Block,
+}
+
+impl From<PrismCommentType> for CommentType {
+    fn from(t: PrismCommentType) -> Self {
+        match t {
+            PrismCommentType::Line => CommentType::Line,
+            PrismCommentType::Block => CommentType::Block,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PrismCommentPosition {
+    #[default]
+    Leading,
+    Trailing,
+    Inner,
+}
+
+impl From<PrismCommentPosition> for CommentPosition {
+    fn from(p: PrismCommentPosition) -> Self {
+        match p {
+            PrismCommentPosition::Leading => CommentPosition::Leading,
+            PrismCommentPosition::Trailing => CommentPosition::Trailing,
+            PrismCommentPosition::Inner => CommentPosition::Inner,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

data/ext/rfmt/src/policy/validation.rs

@@ -16,3 +16,38 @@ pub fn validate_source_size(source: &str, max_size: u64) -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_source_size_ok() {
+        assert!(validate_source_size("small", 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_at_limit() {
+        let source = "a".repeat(1000);
+        assert!(validate_source_size(&source, 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_exceeds_limit() {
+        let source = "a".repeat(1001);
+        assert!(validate_source_size(&source, 1000).is_err());
+    }
+
+    #[test]
+    fn test_validate_source_size_empty() {
+        assert!(validate_source_size("", 1000).is_ok());
+    }
+
+    #[test]
+    fn test_validate_source_size_unicode() {
+        // "日本語" = 9 bytes in UTF-8
+        let source = "日本語";
+        assert!(validate_source_size(source, 9).is_ok());
+        assert!(validate_source_size(source, 8).is_err());
+    }
+}

data/lib/rfmt/native_extension_loader.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Rfmt
+  # Handles loading of native extension across different Ruby versions
+  # Ruby 3.3+ places native extensions in version-specific subdirectories
+  module NativeExtensionLoader
+    class << self
+      # Load the native extension, trying multiple possible paths
+      # @return [Boolean] true if successfully loaded
+      # @raise [LoadError] if the extension cannot be found
+      def load_extension
+        debug_log "Loading native extension for Ruby #{RUBY_VERSION}"
+
+        possible_paths = build_possible_paths
+        debug_log "Trying paths: #{possible_paths.inspect}"
+
+        load_from_paths(possible_paths) || raise(LoadError, build_error_message(possible_paths))
+      end
+
+      private
+
+      # Try loading from multiple paths
+      # @param paths [Array<String>] paths to try
+      # @return [Boolean, nil] true if loaded, nil otherwise
+      def load_from_paths(paths)
+        paths.each do |path|
+          if try_load_extension(path)
+            debug_log "Successfully loaded from: #{path}"
+            return true
+          end
+        end
+        nil
+      end
+
+      # Build list of possible paths for the native extension
+      # @return [Array<String>] paths to try, in order of preference
+      def build_possible_paths
+        paths = []
+
+        # Ruby 3.3+ style: version-specific subdirectory
+        paths << version_specific_path if ruby_version >= '3.3'
+
+        # Ruby 3.0-3.2 style: might use version directory
+        paths << version_specific_path if ruby_version >= '3.0' && ruby_version < '3.3'
+
+        # Legacy/fallback: direct placement
+        paths << File.join(__dir__, 'rfmt')
+
+        # Additional fallback: check for .bundle extension explicitly
+        paths << File.join(__dir__, 'rfmt.bundle')
+
+        paths.uniq
+      end
+
+      # Get version-specific path
+      # @return [String] path with version directory
+      def version_specific_path
+        File.join(__dir__, ruby_version_dir, 'rfmt')
+      end
+
+      # Try to load extension from a specific path
+      # @param path [String] path to try
+      # @return [Boolean] true if successful, false otherwise
+      def try_load_extension(path)
+        require path
+        true
+      rescue LoadError => e
+        debug_log "Failed to load from #{path}: #{e.message}"
+        false
+      end
+
+      # Get Ruby version for comparison
+      # @return [String] Ruby version string
+      def ruby_version
+        RUBY_VERSION
+      end
+
+      # Get Ruby version directory name (e.g., "3.3" for Ruby 3.3.0)
+      # @return [String] version directory name
+      def ruby_version_dir
+        RUBY_VERSION.split('.')[0..1].join('.')
+      end
+
+      # Build detailed error message when extension cannot be loaded
+      # @param tried_paths [Array<String>] paths that were tried
+      # @return [String] error message
+      def build_error_message(tried_paths)
+        [
+          error_header,
+          format_tried_paths(tried_paths),
+          error_explanation,
+          workaround_instructions
+        ].join("\n")
+      end
+
+      # Error message header
+      # @return [String] header text
+      def error_header
+        "Unable to load rfmt native extension for Ruby #{RUBY_VERSION}.\n"
+      end
+
+      # Format list of tried paths
+      # @param paths [Array<String>] paths that were tried
+      # @return [String] formatted path list
+      def format_tried_paths(paths)
+        "Tried the following paths:\n#{paths.map { |p| "  - #{p}" }.join("\n")}\n"
+      end
+
+      # Error explanation text
+      # @return [String] explanation
+      def error_explanation
+        "This might be a packaging issue with the gem for your Ruby version.\n"
+      end
+
+      # Workaround instructions
+      # @return [String] instructions
+      def workaround_instructions
+        <<~MSG.chomp
+          Workaround:
+          1. Check if rfmt.bundle exists in: #{__dir__}/
+          2. If it's in a subdirectory, create a symlink:
+             cd #{__dir__}
+             ln -sf <subdirectory>/rfmt.bundle rfmt.bundle
+
+          Please report this issue at: https://github.com/fs0414/rfmt/issues
+        MSG
+      end
+
+      # Log debug information if RFMT_DEBUG is set
+      # @param message [String] message to log
+      def debug_log(message)
+        return unless ENV['RFMT_DEBUG']
+
+        warn "[RFMT::NativeExtensionLoader] #{message}"
+      end
+    end
+  end
+end

data/lib/rfmt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rfmt
-  VERSION = '1.3.1'
+  VERSION = '1.3.3'
 end

data/lib/rfmt.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require_relative 'rfmt/version'
-require_relative 'rfmt/rfmt'
+require_relative 'rfmt/native_extension_loader'
 require_relative 'rfmt/prism_bridge'
 
+# Load native extension with version-aware loader
+Rfmt::NativeExtensionLoader.load_extension
+
 module Rfmt
   class Error < StandardError; end
   # Errors from Rust side

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.3
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-07 00:00:00.000000000 Z
+date: 2026-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -56,6 +56,7 @@ files:
 - lib/rfmt/cache.rb
 - lib/rfmt/cli.rb
 - lib/rfmt/configuration.rb
+- lib/rfmt/native_extension_loader.rb
 - lib/rfmt/prism_bridge.rb
 - lib/rfmt/prism_node_extractor.rb
 - lib/rfmt/version.rb