rfmt 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79d925cc8ef6ccbc3509abb49f62ef9e1129f40dcb81bf3d2cf27e4148bbb32c
-  data.tar.gz: 7519420a2f5fdddc3da5bfe0f89cb7e39ea5b244aefe46049362f143dd58d547
+  metadata.gz: b5c30419e6083cc4be5e665f6cd4f5d40a725a1790df70ef78cf68638681459c
+  data.tar.gz: 066f373ebe30238a91b34a3d01acccdfbbd270256f8c0e7ba5c909e280e009b0
 SHA512:
-  metadata.gz: 39209b9927d02d53345484f43454b3e633e2d6c3839c1d472b31052dd97bf137835778034c1b734527a3296a530d6cffebb8fe6f398075d846beeabac82d2d1d
-  data.tar.gz: 45de5f91b06fe9c5294742adcc8c91b401f085c1b2bf4b8179efd396ff99936baff8bfd3f82d804f743a100b3cde75597b15dc7aec4d3decda7acaff6d51744c
+  metadata.gz: c17af15dfa819de322a14bde2c318f85d7db27f8d2446f1793550dac256e3309bf4cc3b30269c86cf5bd8aef4269f4666040d7e163b078902c4f75197e72424e
+  data.tar.gz: c3d5a19ed768dcbd8616321dcdfb4374645e933d1eb89e0530683ff28a4f6aec848870f263d94b69a123315c5f505587d183e8c8fca13c6cbc2e406278c8e3c7

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [1.2.3] - 2026-01-04
+
+### Fixed
+- Fix migration file formatting (`emit_rescue` handling for rescue blocks)
+
+## [1.2.2] - 2026-01-04
+
+### Fixed
+- Ruby 3.4.1 compatibility: Use `OpenSSL::Digest::SHA256` instead of `Digest::SHA2` to avoid `metadata is not initialized properly` error in Ruby 3.4.1
+
 ## [1.2.1] - 2026-01-04
 
 ### Fixed

data/Cargo.lock

@@ -1219,7 +1219,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rfmt"
-version = "1.2.1"
+version = "1.2.3"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

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

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

@@ -50,6 +50,9 @@ impl Emitter {
 
         self.emit_node(ast, 0)?;
 
+        // Emit any remaining comments that weren't emitted
+        self.emit_remaining_comments()?;
+
         // Ensure file ends with a newline
         if !self.buffer.ends_with('\n') {
             self.buffer.push('\n');
@@ -58,6 +61,27 @@ impl Emitter {
         Ok(self.buffer.clone())
     }
 
+    /// Emit all comments that haven't been emitted yet
+    fn emit_remaining_comments(&mut self) -> Result<()> {
+        let mut last_end_line: Option<usize> = None;
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            if self.emitted_comment_indices.contains(&idx) {
+                continue;
+            }
+            // Preserve blank lines between comments
+            if let Some(prev_line) = last_end_line {
+                let gap = comment.location.start_line.saturating_sub(prev_line);
+                for _ in 1..gap {
+                    self.buffer.push('\n');
+                }
+            }
+            writeln!(self.buffer, "{}", comment.text)?;
+            self.emitted_comment_indices.push(idx);
+            last_end_line = Some(comment.location.end_line);
+        }
+        Ok(())
+    }
+
     /// Recursively collect all comments from the AST
     fn collect_comments(&mut self, node: &Node) {
         self.all_comments.extend(node.comments.clone());
@@ -218,23 +242,28 @@ impl Emitter {
             write!(self.buffer, " < {}", superclass)?;
         }
 
+        // Emit trailing comments on the class definition line (e.g., # rubocop:disable)
+        self.emit_trailing_comments(node.location.start_line)?;
         self.buffer.push('\n');
 
-        // Emit body (children), but skip structural nodes like constant_read_node
+        // Emit body (children), but skip structural nodes (class name, superclass)
+        // Use start_line check to properly handle CallNode superclasses like ActiveRecord::Migration[8.0]
+        let class_start_line = node.location.start_line;
         for child in &node.children {
+            // Skip nodes on the same line as class definition (name, superclass)
+            if child.location.start_line == class_start_line {
+                continue;
+            }
             if self.is_structural_node(&child.node_type) {
                 continue;
             }
             self.emit_node(child, indent_level + 1)?;
-            // Note: don't add newline here, statements node will handle it
         }
 
         // Add newline before end if there was body content
-        if node
-            .children
-            .iter()
-            .any(|c| !self.is_structural_node(&c.node_type))
-        {
+        if node.children.iter().any(|c| {
+            c.location.start_line != class_start_line && !self.is_structural_node(&c.node_type)
+        }) {
             self.buffer.push('\n');
         }
 
@@ -256,6 +285,8 @@ impl Emitter {
             write!(self.buffer, "{}", name)?;
         }
 
+        // Emit trailing comments on the module definition line
+        self.emit_trailing_comments(node.location.start_line)?;
         self.buffer.push('\n');
 
         // Emit body (children), but skip structural nodes
@@ -289,6 +320,11 @@ impl Emitter {
         self.emit_indent(indent_level)?;
         write!(self.buffer, "def ")?;
 
+        // Handle class methods (def self.method_name)
+        if let Some(receiver) = node.metadata.get("receiver") {
+            write!(self.buffer, "{}.", receiver)?;
+        }
+
         if let Some(name) = node.metadata.get("name") {
             write!(self.buffer, "{}", name)?;
         }
@@ -321,6 +357,8 @@ impl Emitter {
             }
         }
 
+        // Emit trailing comment on same line as def
+        self.emit_trailing_comments(node.location.start_line)?;
         self.buffer.push('\n');
 
         // Emit body (children), but skip structural nodes like parameter nodes
@@ -398,28 +436,77 @@ impl Emitter {
         write!(self.buffer, "rescue")?;
 
         // Extract exception classes and variable from source
+        // Handle multi-line rescue clauses (e.g., multiple exception classes spanning lines)
         if !self.source.is_empty() && node.location.end_offset <= self.source.len() {
             if let Some(source_text) = self
                 .source
                 .get(node.location.start_offset..node.location.end_offset)
             {
-                // Get the rescue line to extract exception class and variable
-                if let Some(rescue_line) = source_text.lines().next() {
-                    // Remove "rescue" prefix and get the rest (exception class => var)
-                    let after_rescue = rescue_line.trim_start_matches("rescue").trim();
-                    if !after_rescue.is_empty() {
-                        write!(self.buffer, " {}", after_rescue)?;
+                // Find the rescue declaration part (first line only, unless trailing comma/backslash)
+                let mut rescue_decl = String::new();
+                let mut expect_continuation = false;
+
+                for line in source_text.lines() {
+                    let trimmed = line.trim();
+
+                    if rescue_decl.is_empty() {
+                        // First line - remove "rescue" prefix
+                        let after_rescue = trimmed.trim_start_matches("rescue").trim();
+                        if !after_rescue.is_empty() {
+                            // Check if line ends with continuation marker
+                            expect_continuation =
+                                after_rescue.ends_with(',') || after_rescue.ends_with('\\');
+                            rescue_decl.push_str(after_rescue.trim_end_matches('\\').trim());
+                        }
+                        if !expect_continuation {
+                            break;
+                        }
+                    } else if expect_continuation {
+                        // Continuation line after trailing comma or backslash
+                        if !rescue_decl.ends_with(' ') && !rescue_decl.ends_with(',') {
+                            rescue_decl.push(' ');
+                        }
+                        let content = trimmed.trim_end_matches('\\').trim();
+                        rescue_decl.push_str(content);
+                        expect_continuation = trimmed.ends_with(',') || trimmed.ends_with('\\');
+                        if !expect_continuation {
+                            break;
+                        }
+                    } else {
+                        break;
                     }
                 }
+
+                if !rescue_decl.is_empty() {
+                    write!(self.buffer, " {}", rescue_decl)?;
+                }
             }
         }
 
         self.buffer.push('\n');
 
-        // Emit rescue body (last child is typically StatementsNode)
-        if let Some(body) = node.children.last() {
-            if matches!(body.node_type, NodeType::StatementsNode) {
-                self.emit_node(body, indent_level)?;
+        // Emit rescue body and handle subsequent rescue nodes
+        // Children structure:
+        // - ConstantReadNode/ConstantPathNode (exception classes)
+        // - LocalVariableTargetNode (optional, exception variable)
+        // - StatementsNode (rescue body)
+        // - RescueNode (optional, subsequent rescue clause)
+        for child in &node.children {
+            match &child.node_type {
+                NodeType::StatementsNode => {
+                    self.emit_node(child, indent_level)?;
+                }
+                NodeType::RescueNode => {
+                    // Emit subsequent rescue clause
+                    // Ensure newline before subsequent rescue
+                    if !self.buffer.ends_with('\n') {
+                        self.buffer.push('\n');
+                    }
+                    self.emit_rescue(child, indent_level)?;
+                }
+                _ => {
+                    // Skip exception classes and variable (already handled above)
+                }
             }
         }
 
@@ -612,6 +699,59 @@ impl Emitter {
             return Ok(());
         }
 
+        // Check for ternary operator
+        let is_ternary = node
+            .metadata
+            .get("is_ternary")
+            .map(|v| v == "true")
+            .unwrap_or(false);
+
+        if is_ternary && !is_elsif {
+            self.emit_comments_before(node.location.start_line, indent_level)?;
+            self.emit_indent(indent_level)?;
+
+            // Emit condition
+            if let Some(predicate) = node.children.first() {
+                if !self.source.is_empty() {
+                    let start = predicate.location.start_offset;
+                    let end = predicate.location.end_offset;
+                    if let Some(text) = self.source.get(start..end) {
+                        write!(self.buffer, "{}", text)?;
+                    }
+                }
+            }
+
+            write!(self.buffer, " ? ")?;
+
+            // Emit then expression
+            if let Some(statements) = node.children.get(1) {
+                if !self.source.is_empty() {
+                    let start = statements.location.start_offset;
+                    let end = statements.location.end_offset;
+                    if let Some(text) = self.source.get(start..end) {
+                        write!(self.buffer, "{}", text.trim())?;
+                    }
+                }
+            }
+
+            write!(self.buffer, " : ")?;
+
+            // Emit else expression
+            if let Some(else_node) = node.children.get(2) {
+                if let Some(else_statements) = else_node.children.first() {
+                    if !self.source.is_empty() {
+                        let start = else_statements.location.start_offset;
+                        let end = else_statements.location.end_offset;
+                        if let Some(text) = self.source.get(start..end) {
+                            write!(self.buffer, "{}", text.trim())?;
+                        }
+                    }
+                }
+            }
+
+            return Ok(());
+        }
+
         // Normal if/unless/elsif
         if !is_elsif {
             self.emit_comments_before(node.location.start_line, indent_level)?;
@@ -637,6 +777,8 @@ impl Emitter {
             }
         }
 
+        // Emit trailing comment on same line as if/unless/elsif
+        self.emit_trailing_comments(node.location.start_line)?;
         self.buffer.push('\n');
 
         // Emit then clause (second child is StatementsNode)
@@ -760,6 +902,8 @@ impl Emitter {
         // Emit block parameters if present (|x, y|)
         self.emit_block_parameters(block_node)?;
 
+        // Emit trailing comment on same line as do |...|
+        self.emit_trailing_comments(block_node.location.start_line)?;
         self.buffer.push('\n');
 
         // Find and emit the body (StatementsNode among children)
@@ -933,6 +1077,8 @@ impl Emitter {
             }
         }
 
+        // Emit trailing comment on same line as while/until
+        self.emit_trailing_comments(node.location.start_line)?;
         self.buffer.push('\n');
 
         // Emit body - second child (StatementsNode)
@@ -1001,6 +1147,7 @@ impl Emitter {
     }
 
     /// Check if node is structural (part of definition syntax, not body)
+    /// These nodes are part of class/module/method definitions and should not be emitted as body
     fn is_structural_node(&self, node_type: &NodeType) -> bool {
         matches!(
             node_type,

data/lib/rfmt/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest/sha2'
+require 'openssl'
 require 'json'
 require 'fileutils'
 
@@ -105,7 +105,7 @@ module Rfmt
 
     def file_hash(file_path)
       content = File.read(file_path)
-      Digest::SHA2.new(256).hexdigest(content)
+      OpenSSL::Digest::SHA256.hexdigest(content)
     rescue StandardError => e
       raise CacheError, "Failed to read file #{file_path}: #{e.message}"
     end

data/lib/rfmt/prism_bridge.rb

@@ -312,14 +312,14 @@ module Rfmt
 
       case node
       when Prism::ClassNode
-        if (name = extract_node_name(node))
+        if (name = extract_class_or_module_name(node))
           metadata['name'] = name
         end
         if (superclass = extract_superclass_name(node))
           metadata['superclass'] = superclass
         end
       when Prism::ModuleNode
-        if (name = extract_node_name(node))
+        if (name = extract_class_or_module_name(node))
           metadata['name'] = name
         end
       when Prism::DefNode
@@ -327,6 +327,15 @@ module Rfmt
           metadata['name'] = name
         end
         metadata['parameters_count'] = extract_parameter_count(node).to_s
+        # Check if this is a class method (def self.method_name)
+        if node.respond_to?(:receiver) && node.receiver
+          receiver = node.receiver
+          if receiver.is_a?(Prism::SelfNode)
+            metadata['receiver'] = 'self'
+          elsif receiver.respond_to?(:slice)
+            metadata['receiver'] = receiver.slice
+          end
+        end
       when Prism::CallNode
         if (name = extract_node_name(node))
           metadata['name'] = name
@@ -350,6 +359,9 @@ module Rfmt
         if (value = extract_literal_value(node))
           metadata['value'] = value
         end
+      when Prism::IfNode, Prism::UnlessNode
+        # Detect ternary operator: if_keyword_loc is nil for ternary
+        metadata['is_ternary'] = node.if_keyword_loc.nil?.to_s if node.respond_to?(:if_keyword_loc)
       end
 
       metadata

data/lib/rfmt/prism_node_extractor.rb

@@ -14,6 +14,31 @@ module Rfmt
       node.name.to_s
     end
 
+    # Extract full name from class or module node (handles namespaced names like Foo::Bar::Baz)
+    # @param node [Prism::ClassNode, Prism::ModuleNode] The class or module node
+    # @return [String, nil] The full name or nil if not available
+    def extract_class_or_module_name(node)
+      return nil unless node.respond_to?(:constant_path)
+
+      cp = node.constant_path
+      return node.name.to_s if cp.nil?
+
+      case cp
+      when Prism::ConstantReadNode
+        cp.name.to_s
+      when Prism::ConstantPathNode
+        if cp.respond_to?(:full_name)
+          cp.full_name.to_s
+        elsif cp.respond_to?(:slice)
+          cp.slice
+        else
+          cp.location.slice
+        end
+      else
+        node.name.to_s
+      end
+    end
+
     # Extract superclass name from a class node
     # @param class_node [Prism::ClassNode] The class node
     # @return [String, nil] The superclass name or nil if not available

data/lib/rfmt/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - fujitani sora