rfmt 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe87cc473fd52b077095eda7b037967f646a97575fb4b9ad8ade73eb33052340
-  data.tar.gz: 8793f7c0480e2a4bc6b62b8274887993f38932a3a17d712a4e4f91f1eec02eee
+  metadata.gz: 7c95517c6abaad1c4bf47425dd4853dcd78bf5a2e47ab2bdc0cae1a3d3698c54
+  data.tar.gz: a207798a5811f989a5ebb3405e48e0c86ac60d40b208f141e6d31a83de62dc0d
 SHA512:
-  metadata.gz: da28021fbcabc8218b212797e5c6343b1f87b5769f30aeecacbf664788e82763d87c74a4edfc1db98e224b7980961c88267fc7e047e124c7bf5b195e802146e2
-  data.tar.gz: 2d22d732bfdfc34b4a9c53db73a5117735b93ef02c6a724c379f5c54c3fd0600bd8e6ba6de9306dc5c157ecbc480b869b78903ba58f3e3ee5cfd6a973ed15dc2
+  metadata.gz: 86307164b77b1836c57718c62ac84bbc920fbfc36a7f0367656bc4fadd65cd846df9f45e5d8985a3eff2f49a548a576a8a73cb05e8e78679fe666589e904762c
+  data.tar.gz: 69a7f17c2e547616ebea1a109628df5d3695fb9d9359715d90707a51c4d1c2d72095bad48ffc1d370e7229a01f193392235c3c7c2a0f13fd211dc0885ef2c447

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [1.2.4] - 2026-01-04
+
+### Fixed
+- Fix comment indent space handling
+
+## [1.2.3] - 2026-01-04
+
+### Fixed
+- Fix migration file formatting (`emit_rescue` handling for rescue blocks)
+
 ## [1.2.2] - 2026-01-04
 
 ### Fixed

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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

@@ -50,6 +50,12 @@ 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');
@@ -58,6 +64,43 @@ impl Emitter {
         Ok(self.buffer.clone())
     }
 
+    /// 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;
+            }
+        }
+        max_line
+    }
+
+    /// Emit all comments that haven't been emitted yet
+    fn emit_remaining_comments(&mut self, last_code_line: usize) -> Result<()> {
+        let mut last_end_line: Option<usize> = Some(last_code_line);
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            if self.emitted_comment_indices.contains(&idx) {
+                continue;
+            }
+            // Ensure we start on a new line for remaining comments
+            if !self.buffer.ends_with('\n') {
+                self.buffer.push('\n');
+            }
+            // Preserve blank lines between code/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());
@@ -80,16 +123,37 @@ impl Emitter {
             }
 
             if comment.location.end_line < line {
-                comments_to_emit.push((idx, comment.text.clone(), comment.location.end_line));
+                comments_to_emit.push((
+                    idx,
+                    comment.text.clone(),
+                    comment.location.start_line,
+                    comment.location.end_line,
+                ));
             }
         }
 
+        // Sort by start_line to emit in order
+        comments_to_emit.sort_by_key(|(_, _, start, _)| *start);
+
         let comments_count = comments_to_emit.len();
-        for (i, (idx, text, comment_end_line)) in comments_to_emit.into_iter().enumerate() {
+        let mut last_comment_end_line: Option<usize> = None;
+
+        for (i, (idx, text, 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 {
+                    self.buffer.push('\n');
+                }
+            }
+
             writeln!(self.buffer, "{}{}", indent_str, text)?;
             self.emitted_comment_indices.push(idx);
+            last_comment_end_line = Some(comment_end_line);
 
-            // Only add blank line after the LAST comment if there was a gap in the original
+            // 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');
             }
@@ -98,6 +162,65 @@ impl Emitter {
         Ok(())
     }
 
+    /// Check if there are any unemitted comments in the given line range
+    fn has_comments_in_range(&self, start_line: usize, end_line: usize) -> bool {
+        self.all_comments.iter().enumerate().any(|(idx, comment)| {
+            !self.emitted_comment_indices.contains(&idx)
+                && comment.location.start_line >= start_line
+                && comment.location.end_line < end_line
+        })
+    }
+
+    /// Emit comments that are within a given line range (exclusive of end_line)
+    fn emit_comments_in_range(
+        &mut self,
+        start_line: usize,
+        end_line: usize,
+        indent_level: usize,
+    ) -> Result<()> {
+        let indent_str = match self.config.formatting.indent_style {
+            IndentStyle::Spaces => " ".repeat(self.config.formatting.indent_width * indent_level),
+            IndentStyle::Tabs => "\t".repeat(indent_level),
+        };
+
+        let mut comments_to_emit = Vec::new();
+        for (idx, comment) in self.all_comments.iter().enumerate() {
+            if self.emitted_comment_indices.contains(&idx) {
+                continue;
+            }
+
+            if comment.location.start_line >= start_line && comment.location.end_line < end_line {
+                comments_to_emit.push((
+                    idx,
+                    comment.text.clone(),
+                    comment.location.start_line,
+                    comment.location.end_line,
+                ));
+            }
+        }
+
+        // Sort by start_line to emit in order
+        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
+            if let Some(prev_end) = last_comment_end_line {
+                let gap = comment_start_line.saturating_sub(prev_end);
+                for _ in 1..gap {
+                    self.buffer.push('\n');
+                }
+            }
+
+            writeln!(self.buffer, "{}{}", indent_str, text)?;
+            self.emitted_comment_indices.push(idx);
+            last_comment_end_line = Some(comment_end_line);
+        }
+
+        Ok(())
+    }
+
     /// Emit comments that appear on the same line (trailing comments)
     fn emit_trailing_comments(&mut self, line: usize) -> Result<()> {
         let mut indices_to_emit = Vec::new();
@@ -218,22 +341,35 @@ 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;
+        let class_end_line = node.location.end_line;
+        let mut has_body_content = false;
+
         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;
             }
+            has_body_content = true;
             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))
+        // Emit comments that are inside the class body but not attached to any node
+        // These are comments between class_start_line and class_end_line
+        self.emit_comments_in_range(class_start_line + 1, class_end_line, indent_level + 1)?;
+
+        // Add newline before end if there was body content or internal comments
+        if (has_body_content || self.has_comments_in_range(class_start_line + 1, class_end_line))
+            && !self.buffer.ends_with('\n')
         {
             self.buffer.push('\n');
         }
@@ -256,21 +392,29 @@ 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');
 
+        let module_start_line = node.location.start_line;
+        let module_end_line = node.location.end_line;
+        let mut has_body_content = false;
+
         // Emit body (children), but skip structural nodes
         for child in &node.children {
             if self.is_structural_node(&child.node_type) {
                 continue;
             }
+            has_body_content = true;
             self.emit_node(child, indent_level + 1)?;
         }
 
-        // Add newline before end if there was body content
-        if node
-            .children
-            .iter()
-            .any(|c| !self.is_structural_node(&c.node_type))
+        // Emit comments that are inside the module body but not attached to any node
+        self.emit_comments_in_range(module_start_line + 1, module_end_line, indent_level + 1)?;
+
+        // Add newline before end if there was body content or internal comments
+        if (has_body_content || self.has_comments_in_range(module_start_line + 1, module_end_line))
+            && !self.buffer.ends_with('\n')
         {
             self.buffer.push('\n');
         }
@@ -289,6 +433,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 +470,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 +549,78 @@ 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
+                        // Add space after comma or if no trailing space
+                        if !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 +813,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 +891,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 +1016,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)
@@ -851,6 +1109,20 @@ impl Emitter {
             if let Some(text) = text_owned {
                 self.emit_indent(indent_level)?;
                 write!(self.buffer, "{}", text)?;
+
+                // Mark comments that are strictly inside this node's line range as emitted
+                // (they are included in the source extraction)
+                // Don't mark trailing comments on the last line (they come after the node ends)
+                for (idx, comment) in self.all_comments.iter().enumerate() {
+                    if !self.emitted_comment_indices.contains(&idx)
+                        && comment.location.start_line >= node.location.start_line
+                        && comment.location.end_line < node.location.end_line
+                    {
+                        self.emitted_comment_indices.push(idx);
+                    }
+                }
+
+                // Emit trailing comments on the same line (after the node ends)
                 self.emit_trailing_comments(node.location.end_line)?;
             }
         }
@@ -871,12 +1143,13 @@ impl Emitter {
                 self.emit_indent(indent_level)?;
                 write!(self.buffer, "{}", text)?;
 
-                // Mark comments within this node's range as emitted
+                // Mark comments that are strictly inside this node's line range as emitted
                 // (they are included in the source extraction)
+                // Don't mark trailing comments on the last line (they come after the node ends)
                 for (idx, comment) in self.all_comments.iter().enumerate() {
                     if !self.emitted_comment_indices.contains(&idx)
                         && comment.location.start_line >= node.location.start_line
-                        && comment.location.end_line <= node.location.end_line
+                        && comment.location.end_line < node.location.end_line
                     {
                         self.emitted_comment_indices.push(idx);
                     }
@@ -933,6 +1206,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 +1276,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/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.2'
+  VERSION = '1.2.4'
 end

metadata

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