rfmt 1.6.1 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 327f57f105df77a0d6b77bda9ab87c4f234f03f23fb918d74679942456c5a8ec
-  data.tar.gz: 482a5406275e422fb306970ffb47708f37be0c3115bc92485996d2adde6c9463
+  metadata.gz: 4fd5d79157230ea6ee461e070a3782267196b57692c37fc0e5e06a33f2dbd6fd
+  data.tar.gz: ea5b633304e771cd80a235ae79676581791f5f1f041de4d4013fd22e60b3cd5c
 SHA512:
-  metadata.gz: 52982745650ed439f2ac7a5a1a9a26ae2dcf9e9df8015526278f58508929e15a1d72425d2d3c5963c0a4008968e20fcb6c374881122a3e99618d2cef15434eaf
-  data.tar.gz: 10e8282f05caacdffcbb2d7042e9f95a08c5d08c9b081307a12752840549fbb08b6bc557a256a9a46fd012986369fd7cfd0442a46d1d81146c2fb234d0b936f7
+  metadata.gz: 1d81952b2c5b9b9a3ba04617c60c1742d6141390be0da810bdc71ab2661bd767008bf7b744b1337496035bfeab39ee9db672163f23e9d693aad681edc8236256
+  data.tar.gz: '0950ad8b8a68dc96bb20fd980751805704b6f1a6be07268210fe309ba4b6642469899f61c62d8157770956732c272636d072d9ad29d148ff555335897df2ae0e'

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [1.6.3] - 2026-04-24
+
+Minor stability refinements on top of the 1.6.x architecture release. See the 1.6.1 notes below for the feature set this series delivers.
+
+## [1.6.2] - 2026-04-24
+
+Minor stability refinements on top of the 1.6.x architecture release. See the 1.6.1 notes below for the feature set this series delivers.
+
 ## [1.6.1] - 2026-04-24
 
 Follow-up release consolidating the 1.6.0 architecture work.

data/Cargo.lock

@@ -1251,7 +1251,7 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "rfmt"
-version = "1.6.1"
+version = "1.6.3"
 dependencies = [
  "anyhow",
  "clap",

data/ext/rfmt/Cargo.toml

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

data/ext/rfmt/src/format/rule.rs

@@ -217,6 +217,23 @@ pub fn format_comments_before_end(
     }
 
     let mut docs: Vec<Doc> = vec![hardline()];
+    // Preserve the blank line that separated the body's last content from
+    // the first trailing comment. Without this, a construct like
+    //
+    //   def foo
+    //     body
+    //                          <- blank line
+    //     # trailing annotation
+    //   end
+    //
+    // collapses to `body\n# trailing annotation\nend`. Detect the case
+    // heuristically: if the source line immediately above the first
+    // standalone comment is blank, emit an extra hardline.
+    if let Some(first) = standalone_refs.first() {
+        if first.start_line > 1 && is_line_blank(ctx.source(), first.start_line - 1) {
+            docs.push(hardline());
+        }
+    }
     let mut last_end_line: Option<usize> = None;
     let mut indices_to_mark: Vec<usize> = Vec::with_capacity(standalone_refs.len());
 
@@ -297,11 +314,23 @@ pub fn format_remaining_comments(ctx: &mut FormatContext, last_code_line: usize)
     let mut indices_to_mark: Vec<usize> = Vec::with_capacity(comment_refs.len());
 
     for cref in &comment_refs {
-        // Preserve blank lines
+        // Preserve blank lines. On the first iteration we must emit *at
+        // least one* hardline to separate the first remaining comment from
+        // the main document's last token (otherwise an orphan comment whose
+        // `start_line <= last_code_line` would concatenate onto whatever
+        // ended the output — producing e.g. `end# comment…` when a block's
+        // internal comments fall through to this tail handler). Round-tripping
+        // the already-formatted output must still be idempotent, so we
+        // cap the emission at the number of line breaks visible in the
+        // source: 1 for an adjacent comment, N for N-1 blank lines above it.
         let gap = cref.start_line.saturating_sub(last_end_line);
 
-        // Only add newlines if not the first comment or if there's a gap
-        if !is_first || gap > 0 {
+        if is_first {
+            let hardlines_to_emit = gap.max(1);
+            for _ in 0..hardlines_to_emit {
+                docs.push(hardline());
+            }
+        } else if gap > 0 {
             for _ in 0..gap.max(1) {
                 docs.push(hardline());
             }
@@ -479,8 +508,42 @@ pub fn reformat_chain_lines(
         return Cow::Borrowed(source_text);
     }
 
-    // Build the indented chain with pre-allocated capacity
-    let chain_indent = " ".repeat(base_indent + indent_width);
+    // Determine how much the chain is moving left. Before this pass, every
+    // `.method` line sat at some original "chain indent" (most commonly
+    // aligned under the first receiver's dot). We rewrite those lines to
+    // `base_indent + indent_width` — but that also means any multi-line
+    // *arguments* that lived inside a chain call like `.select( … )` used
+    // to be deeper than the original chain indent, and will now look
+    // orphaned off to the right if we leave them alone:
+    //
+    //     @users = User.left_joins(...)
+    //                 .select(           <- was col 17, becomes col 6
+    //                   'users.*, ' \   <- still at col 19 — orphaned
+    //                 )
+    //                 .having(...)
+    //
+    // Compute the delta between the original chain indent and the new
+    // one, and shift every non-chain continuation line that lives at
+    // (or below) the original chain indent by the same amount. Lines
+    // shallower than the original chain indent (e.g. a heredoc body
+    // whose squiggly indent is measured from the terminator) are left
+    // alone, so we don't accidentally eat through them.
+    let new_chain_indent = base_indent + indent_width;
+    let chain_indent_str = " ".repeat(new_chain_indent);
+
+    let original_chain_indent = lines[1..].iter().find_map(|l| {
+        let t = l.trim_start();
+        if t.starts_with('.') || t.starts_with("&.") {
+            Some(l.len() - t.len())
+        } else {
+            None
+        }
+    });
+
+    let arg_shift = original_chain_indent
+        .map(|orig| orig.saturating_sub(new_chain_indent))
+        .unwrap_or(0);
+
     let mut result = String::with_capacity(source_text.len());
     result.push_str(lines[0].trim_end());
 
@@ -488,8 +551,18 @@ pub fn reformat_chain_lines(
         result.push('\n');
         let trimmed = line.trim();
         if trimmed.starts_with('.') || trimmed.starts_with("&.") {
-            result.push_str(&chain_indent);
+            result.push_str(&chain_indent_str);
             result.push_str(trimmed);
+        } else if arg_shift > 0 && !trimmed.is_empty() {
+            let indent = line.len() - line.trim_start().len();
+            let chain_base = original_chain_indent.unwrap_or(0);
+            if indent >= chain_base {
+                let new_indent = indent - arg_shift;
+                result.push_str(&" ".repeat(new_indent));
+                result.push_str(line.trim_start());
+            } else {
+                result.push_str(line);
+            }
         } else {
             // Non-chain continuation (e.g., heredoc content): preserve as-is
             result.push_str(line);
@@ -499,6 +572,27 @@ pub fn reformat_chain_lines(
     Cow::Owned(result)
 }
 
+/// Returns true when the given 1-based `line` in `source` contains only
+/// whitespace (or is empty). Returns false for any line that has code or
+/// a comment.
+fn is_line_blank(source: &str, line: usize) -> bool {
+    let mut current = 1usize;
+    let mut line_start = 0usize;
+    for (i, b) in source.bytes().enumerate() {
+        if current == line {
+            let end = source[i..].find('\n').map_or(source.len(), |n| i + n);
+            return source[line_start..end]
+                .bytes()
+                .all(|b| b == b' ' || b == b'\t' || b == b'\r');
+        }
+        if b == b'\n' {
+            current += 1;
+            line_start = i + 1;
+        }
+    }
+    false
+}
+
 /// Removes at most one trailing `\n` (optionally preceded by a single `\r`)
 /// from `s`. Spaces, tabs, and any additional preceding newlines are
 /// preserved.

data/ext/rfmt/src/format/rules/call.rs

@@ -13,9 +13,9 @@ use crate::error::Result;
 use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
-    format_child, format_leading_comments, format_statements, format_trailing_comment,
-    line_leading_indent, mark_comments_in_range_emitted, reformat_chain_lines,
-    strip_one_trailing_newline, FormatRule,
+    format_child, format_comments_before_end, format_leading_comments, format_statements,
+    format_trailing_comment, line_leading_indent, mark_comments_in_range_emitted,
+    reformat_chain_lines, strip_one_trailing_newline, FormatRule,
 };
 
 /// Rule for formatting method calls.
@@ -251,6 +251,23 @@ fn format_do_end_block(
         }
     }
 
+    // Emit any standalone comments between the last body statement and `end`.
+    //
+    // Without this the orphan comments inside a `do…end` block (e.g. the
+    // commented-out config stanzas in a generated `spec_helper.rb`) never
+    // get claimed by any `format_leading_comments` call, fall through to
+    // `format_remaining_comments` at the end of the file, and get emitted
+    // *after* the block's own `end` — producing `end# comment…` with no
+    // separator and dropping the body indent.
+    let comments_before_end = format_comments_before_end(
+        ctx,
+        block_node.location.start_line,
+        block_node.location.end_line,
+    );
+    if !comments_before_end.is_empty() {
+        docs.push(indent(comments_before_end));
+    }
+
     // Emit 'end'
     docs.push(hardline());
     docs.push(text("end"));

data/lib/rfmt/version.rb

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

metadata

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