rfmt 1.2.3 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5c30419e6083cc4be5e665f6cd4f5d40a725a1790df70ef78cf68638681459c
-  data.tar.gz: 066f373ebe30238a91b34a3d01acccdfbbd270256f8c0e7ba5c909e280e009b0
+  metadata.gz: 67e0ceb39e5630237f92ac2d78fcf2438313dcd883c72ec44066ede9e9868735
+  data.tar.gz: 69b818c97c55f1ffc4f09518393c2249b71e0e084207249ba8fa631679d66167
 SHA512:
-  metadata.gz: c17af15dfa819de322a14bde2c318f85d7db27f8d2446f1793550dac256e3309bf4cc3b30269c86cf5bd8aef4269f4666040d7e163b078902c4f75197e72424e
-  data.tar.gz: c3d5a19ed768dcbd8616321dcdfb4374645e933d1eb89e0530683ff28a4f6aec848870f263d94b69a123315c5f505587d183e8c8fca13c6cbc2e406278c8e3c7
+  metadata.gz: 2e7cc3e550d2506c0f6691f6b4823f76a2c88e94519d46ca080c2d3b57a7330d5e3df4bca1ab4e18ae1551ea6821c92210638d657997cb6a72631512e47d2bc5
+  data.tar.gz: '0491cb8029834d053692a9cc251da952c5bbbf6e38045bcfe3a90dfb2a9ebf31cb3dfb09bfa640b0c22b427d1ab47f0e801ecd44a88c79626f05ab4898d19c64'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [1.2.5] - 2026-01-04
+
+### Fixed
+- Fix trailing comments on `end` keyword (e.g., `end # rubocop:disable`)
+- Fix block internal comments being moved outside the block
+- Fix blank line preservation between code and comments inside blocks
+
+## [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.5"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rfmt"
-version = "1.2.3"
+version = "1.2.5"
 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,114 @@ 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 are within a given line range, preserving blank lines from prev_line
+    fn emit_comments_in_range_with_prev_line(
+        &mut self,
+        start_line: usize,
+        end_line: usize,
+        indent_level: usize,
+        prev_line: 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_end_line: usize = prev_line;
+
+        for (idx, text, 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)?;
+            self.emitted_comment_indices.push(idx);
+            last_end_line = 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 +397,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,18 +408,25 @@ 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');
         }
 
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line (e.g., `end # rubocop:disable`)
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }
@@ -289,25 +447,33 @@ 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');
         }
 
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line (e.g., `end # rubocop:disable`)
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }
@@ -380,6 +546,8 @@ impl Emitter {
 
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line (e.g., `end # rubocop:disable`)
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }
@@ -411,6 +579,8 @@ impl Emitter {
 
             self.emit_indent(indent_level)?;
             write!(self.buffer, "end")?;
+            // Emit trailing comments on end line
+            self.emit_trailing_comments(node.location.end_line)?;
         } else {
             // Implicit begin - emit children directly
             for (i, child) in node.children.iter().enumerate() {
@@ -463,7 +633,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();
@@ -600,6 +771,8 @@ impl Emitter {
         // Emit "end" keyword
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }
@@ -817,6 +990,8 @@ impl Emitter {
         if !is_elsif {
             self.emit_indent(indent_level)?;
             write!(self.buffer, "end")?;
+            // Emit trailing comments on end line
+            self.emit_trailing_comments(node.location.end_line)?;
         }
 
         Ok(())
@@ -907,17 +1082,46 @@ impl Emitter {
         self.buffer.push('\n');
 
         // Find and emit the body (StatementsNode among children)
+        let block_start_line = block_node.location.start_line;
+        let block_end_line = block_node.location.end_line;
+        let mut last_stmt_end_line = block_start_line;
+
         for child in &block_node.children {
             if matches!(child.node_type, NodeType::StatementsNode) {
                 self.emit_statements(child, indent_level + 1)?;
+                // Track the last statement's end line for blank line preservation
+                if let Some(last_child) = child.children.last() {
+                    last_stmt_end_line = last_child.location.end_line;
+                }
                 self.buffer.push('\n');
                 break;
             }
         }
 
+        // Emit comments that are inside the block but not attached to any node
+        // (comments between last statement and 'end')
+        let had_internal_comments =
+            self.has_comments_in_range(block_start_line + 1, block_end_line);
+        if had_internal_comments {
+            // Preserve blank line between last statement and first comment
+            self.emit_comments_in_range_with_prev_line(
+                block_start_line + 1,
+                block_end_line,
+                indent_level + 1,
+                last_stmt_end_line,
+            )?;
+        }
+
+        // Add newline if there were internal comments
+        if had_internal_comments && !self.buffer.ends_with('\n') {
+            self.buffer.push('\n');
+        }
+
         // Emit 'end'
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line
+        self.emit_trailing_comments(block_end_line)?;
 
         Ok(())
     }
@@ -995,6 +1199,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 +1233,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);
                     }
@@ -1091,6 +1310,8 @@ impl Emitter {
 
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }
@@ -1142,6 +1363,8 @@ impl Emitter {
 
         self.emit_indent(indent_level)?;
         write!(self.buffer, "end")?;
+        // Emit trailing comments on end line
+        self.emit_trailing_comments(node.location.end_line)?;
 
         Ok(())
     }

data/lib/rfmt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfmt
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.5
 platform: ruby
 authors:
 - fujitani sora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-03 00:00:00.000000000 Z
+date: 2026-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys