rfmt 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5c30419e6083cc4be5e665f6cd4f5d40a725a1790df70ef78cf68638681459c
-  data.tar.gz: 066f373ebe30238a91b34a3d01acccdfbbd270256f8c0e7ba5c909e280e009b0
+  metadata.gz: 7c95517c6abaad1c4bf47425dd4853dcd78bf5a2e47ab2bdc0cae1a3d3698c54
+  data.tar.gz: a207798a5811f989a5ebb3405e48e0c86ac60d40b208f141e6d31a83de62dc0d
 SHA512:
-  metadata.gz: c17af15dfa819de322a14bde2c318f85d7db27f8d2446f1793550dac256e3309bf4cc3b30269c86cf5bd8aef4269f4666040d7e163b078902c4f75197e72424e
-  data.tar.gz: c3d5a19ed768dcbd8616321dcdfb4374645e933d1eb89e0530683ff28a4f6aec848870f263d94b69a123315c5f505587d183e8c8fca13c6cbc2e406278c8e3c7
+  metadata.gz: 86307164b77b1836c57718c62ac84bbc920fbfc36a7f0367656bc4fadd65cd846df9f45e5d8985a3eff2f49a548a576a8a73cb05e8e78679fe666589e904762c
+  data.tar.gz: 69a7f17c2e547616ebea1a109628df5d3695fb9d9359715d90707a51c4d1c2d72095bad48ffc1d370e7229a01f193392235c3c7c2a0f13fd211dc0885ef2c447

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [1.2.4] - 2026-01-04
+
+### Fixed
+- Fix comment indent space handling
+
 ## [1.2.3] - 2026-01-04
 
 ### Fixed

data/Cargo.lock

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

data/ext/rfmt/Cargo.toml

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

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

@@ -50,8 +50,11 @@ 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()?;
+        self.emit_remaining_comments(last_code_line)?;
 
         // Ensure file ends with a newline
         if !self.buffer.ends_with('\n') {
@@ -61,14 +64,30 @@ 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) -> Result<()> {
-        let mut last_end_line: Option<usize> = None;
+    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;
             }
-            // Preserve blank lines between comments
+            // 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 {
@@ -104,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');
             }
@@ -122,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();
@@ -249,6 +348,9 @@ impl Emitter {
         // 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 {
@@ -257,13 +359,18 @@ impl Emitter {
             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| {
-            c.location.start_line != class_start_line && !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');
         }
 
@@ -289,19 +396,25 @@ impl Emitter {
         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');
         }
@@ -463,7 +576,8 @@ impl Emitter {
                         }
                     } else if expect_continuation {
                         // Continuation line after trailing comma or backslash
-                        if !rescue_decl.ends_with(' ') && !rescue_decl.ends_with(',') {
+                        // Add space after comma or if no trailing space
+                        if !rescue_decl.ends_with(' ') {
                             rescue_decl.push(' ');
                         }
                         let content = trimmed.trim_end_matches('\\').trim();
@@ -995,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)?;
             }
         }
@@ -1015,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);
                     }

data/lib/rfmt/version.rb

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

metadata

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