rfmt 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79f5e6c24f82f6552874aefda2a6b97d8f4612419810d76ebd9381e862edded4
-  data.tar.gz: f193dab59e9a02f62d3e599c8f0349ebbf6e7fda070ba55990e9a8d399990f72
+  metadata.gz: 7d2092d9d53fa47024fcb8a13fb635a6da7eba5d4c51d3a8df854d551380037b
+  data.tar.gz: 59bb09f50cb7ee5a033328300a581e973879aaad56067d267b041c2070cac8bf
 SHA512:
-  metadata.gz: 6ebfd2c04793445912e1edc28db74e5cfa218fcd3fc28f6e3b42a88b1794fe0bfc6643890fa34477291c7ad8624696f3bb7207436ecfeb6f756439be5d9065ae
-  data.tar.gz: e209cf0a8671786af5e1560979f70f5fe8bb4e2de3912613a59e6d6269effe54f123407ca8989b50578f330d16e8a0d2fa7a1b47c8c07d5731e893664892fe1a
+  metadata.gz: f7043e22d625b0b6a689f01950a6ed0fae7ab3fa1cfa2dcd51af544d72aadf8b0c3aa65a3465c9f9baabf2f1a000c37bddb2f2f57e2defd11344f6194ad3b68b
+  data.tar.gz: 407b70b3614da3ed19c74bd43d9491ee9bff1ce6cb1ef7f1e1d2d0b71068afb937bd5409668ae0c7454a6f2d12cb4764fa6df0273bef149980be30e0f9f1d7b6

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [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

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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');
         }
@@ -186,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 {
@@ -222,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');
             }
@@ -255,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 {
@@ -289,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);
         }
@@ -306,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;
         }
@@ -352,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);
         }
 
@@ -1311,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 {
@@ -1322,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/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.2'
+  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.2
+  version: 1.3.3
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-09 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