RubyGems - rfmt - Versions diffs - 1.6.0 → 1.6.2 - Mend

rfmt 1.6.0 → 1.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +24 -0
data/Cargo.lock +1 -1
data/ext/rfmt/Cargo.toml +1 -1
data/ext/rfmt/src/doc/printer.rs +37 -0
data/ext/rfmt/src/format/formatter.rs +28 -4
data/ext/rfmt/src/format/rule.rs +245 -24
data/ext/rfmt/src/format/rules/begin.rs +161 -22
data/ext/rfmt/src/format/rules/body_end.rs +146 -22
data/ext/rfmt/src/format/rules/call.rs +81 -25
data/ext/rfmt/src/format/rules/fallback.rs +20 -6
data/ext/rfmt/src/format/rules/if_unless.rs +51 -4
data/ext/rfmt/src/format/rules/variable_write.rs +25 -7
data/lib/rfmt/prism_bridge.rb +43 -12
data/lib/rfmt/version.rb +1 -1
metadata +1 -1

data/ext/rfmt/src/format/rules/if_unless.rs CHANGED Viewed

@@ -13,7 +13,8 @@ use crate::error::Result;
 use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
-    format_leading_comments, format_statements, format_trailing_comment, FormatRule,
+    format_leading_comments, format_statements, format_trailing_comment,
+    strip_one_trailing_newline, FormatRule,
 };
 /// Rule for formatting if conditionals.
@@ -101,9 +102,30 @@ fn format_postfix(
         docs.push(leading);
     }
-    // Emit statement
+    // Emit statement. When the statement contains a heredoc whose body
+    // spills past the opener line, the bridge extends the statement's
+    // end_offset to cover the terminator — and that extended slice *also*
+    // sweeps in the intervening `if cond` modifier text that sits between
+    // the opener's `)` and the heredoc body. Appending our own
+    // ` if <cond>` after that text would then either produce
+    // `... if cond if cond` (duplicated modifier) or, worse, land the
+    // modifier on the same line as `SQL`, breaking heredoc termination.
+    //
+    // Detect the heredoc-in-statement case and emit the slice verbatim;
+    // the modifier is already baked into the source text right where
+    // Ruby expects it.
     if let Some(statements) = node.children.get(1) {
         if let Some(source_text) = ctx.extract_source(statements) {
+            if statement_contains_heredoc_tail(source_text) {
+                docs.push(text(source_text.trim_end_matches('\n').to_string()));
+                let trailing = format_trailing_comment(ctx, node.location.end_line);
+                if !trailing.is_empty() {
+                    docs.push(trailing);
+                }
+                return Ok(concat(docs));
+            }
             docs.push(text(source_text.trim()));
         }
     }
@@ -128,6 +150,26 @@ fn format_postfix(
     Ok(concat(docs))
 }
+/// True if `source` looks like `<opener_with_heredoc>…\n<body>\n<TERMINATOR>`:
+/// that is, line 1 contains a heredoc opening marker (`<<~`, `<<-`, `<<`) and
+/// at least one subsequent line is not a chain continuation. The bridge
+/// extends the node's end_offset to cover the heredoc tail, so this slice
+/// already contains any `if`/`unless` modifier that was typed between the
+/// opener's closing paren and the heredoc body on the opener line.
+fn statement_contains_heredoc_tail(source: &str) -> bool {
+    let source = source.trim_end_matches('\n');
+    let Some((first, rest)) = source.split_once('\n') else {
+        return false;
+    };
+    if !first.contains("<<~") && !first.contains("<<-") && !first.contains("<<") {
+        return false;
+    }
+    rest.lines().any(|l| {
+        let t = l.trim_start();
+        !t.is_empty() && !t.starts_with('.') && !t.starts_with("&.")
+    })
+}
 /// Formats ternary operator: `cond ? then_expr : else_expr`
 fn format_ternary(node: &Node, ctx: &mut FormatContext) -> Result<Doc> {
     let mut docs: Vec<Doc> = Vec::with_capacity(8);
@@ -240,10 +282,15 @@ fn format_normal(
         docs.push(text(" "));
     }
-    // Emit predicate (condition)
+    // Emit predicate (condition). When the predicate is something like
+    // `(sql = <<~SQL)`, Prism's bridge stretches the heredoc-containing
+    // nodes' end_offset past the terminator's newline. Leaving that
+    // newline in the emitted text combines with our own `hardline` before
+    // the then-clause to produce a spurious blank line after the
+    // terminator. Strip at most one trailing newline.
     if let Some(predicate) = node.children.first() {
         if let Some(source_text) = ctx.extract_source(predicate) {
-            docs.push(text(source_text));
+            docs.push(text(strip_one_trailing_newline(source_text).to_string()));
         }
     }

data/ext/rfmt/src/format/rules/variable_write.rs CHANGED Viewed

@@ -12,8 +12,8 @@ use crate::error::Result;
 use crate::format::context::FormatContext;
 use crate::format::registry::RuleRegistry;
 use crate::format::rule::{
-    format_child, format_leading_comments, format_trailing_comment, reformat_chain_lines,
-    FormatRule,
+    format_child, format_leading_comments, format_trailing_comment, line_leading_indent,
+    reformat_chain_lines, strip_one_trailing_newline, FormatRule,
 };
 /// Rule for formatting local variable write expressions.
@@ -88,7 +88,14 @@ fn format_variable_write(
             | NodeType::ForNode
     );
-    if is_block_value {
+    // Only split the assignment across two lines when the block value
+    // actually begins below the `=`. When the user wrote
+    // `x = begin\n  …\nend` (the opener is on the same line as the
+    // assignment), preserve that shape — splitting it mangles a common
+    // Rails idiom used for defaulted constants and service objects.
+    let inline_block_value = is_block_value && value.location.start_line == start_line;
+    if is_block_value && !inline_block_value {
         // Block value: format on new line with indent
         // x =
         //   if true
@@ -101,6 +108,9 @@ fn format_variable_write(
             hardline(),
             format_child(value, ctx, registry)?,
         ])));
+    } else if inline_block_value {
+        docs.push(text(format!("{} = ", name)));
+        docs.push(format_child(value, ctx, registry)?);
     } else {
         // Check for multiline method chain
         let is_multiline_call = matches!(value.node_type, NodeType::CallNode)
@@ -109,11 +119,19 @@ fn format_variable_write(
         docs.push(text(format!("{} = ", name)));
         if is_multiline_call {
-            // Multiline call: reformat chain with indented style
+            // Multiline call: reformat chain with indented style.
+            // Also trim a trailing newline left over from a heredoc tail
+            // (`x = foo(<<~SQL)\n…\nSQL\n`) so it doesn't compound with the
+            // surrounding hardline.
             if let Some(source_text) = ctx.extract_source(value) {
-                let reformatted =
-                    reformat_chain_lines(source_text, ctx.config().formatting.indent_width);
-                docs.push(text(reformatted.trim_start().to_string()));
+                let base_indent = line_leading_indent(ctx.source(), node.location.start_offset);
+                let reformatted = reformat_chain_lines(
+                    source_text,
+                    base_indent,
+                    ctx.config().formatting.indent_width,
+                );
+                let trimmed = strip_one_trailing_newline(reformatted.trim_start());
+                docs.push(text(trimmed.to_string()));
             }
         } else {
             // Simple value: extract from source trimmed

data/lib/rfmt/prism_bridge.rb CHANGED Viewed

@@ -62,17 +62,28 @@ module Rfmt
     # Serialize the Prism AST with comments to JSON
     def self.serialize_ast_with_comments(result)
       comments = result.comments.map do |comment|
+        loc = comment.location
+        end_line = loc.end_line
+        # Prism's `=begin ... =end` (EmbDocComment) location ends at
+        # `<=end_line>:0`, i.e. the column-0 start of the line AFTER the
+        # `=end` terminator. Reporting that larger end_line makes the
+        # comment appear to overlap with the next statement, so the
+        # comment gets misattributed to a deeper node (e.g. the first
+        # expression inside the next method body) and ends up emitted in
+        # the wrong place. Snap it back to the terminator line.
+        end_line = loc.end_line - 1 if loc.end_column.zero? && loc.end_line > loc.start_line
         {
           comment_type: comment.class.name.split('::').last.downcase.gsub('comment', ''),
           location: {
-            start_line: comment.location.start_line,
-            start_column: comment.location.start_column,
-            end_line: comment.location.end_line,
-            end_column: comment.location.end_column,
-            start_offset: comment.location.start_offset,
-            end_offset: comment.location.end_offset
+            start_line: loc.start_line,
+            start_column: loc.start_column,
+            end_line: end_line,
+            end_column: loc.end_column,
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset
           },
-          text: comment.location.slice,
+          text: loc.slice,
           position: 'leading' # Default position, will be refined by Rust
         }
       end
@@ -120,7 +131,7 @@ module Rfmt
         closing = node.closing_loc
         if closing.end_offset > end_offset
           end_offset = closing.end_offset
-          end_line = closing.end_line
+          end_line = heredoc_terminator_line(closing)
           end_column = closing.end_column
         end
       end
@@ -145,6 +156,19 @@ module Rfmt
       }
     end
+    # Prism reports a heredoc's `closing_loc` as `<terminator_line>:0..(terminator_line+1):0`,
+    # i.e. its `end_line` is the LINE AFTER the terminator. Using that as the
+    # node's `end_line` makes blank-line preservation fail: a real blank line
+    # right after the terminator looks identical (diff == 1) to two adjacent
+    # statements with no separator. Use the terminator's own line instead.
+    def self.heredoc_terminator_line(closing_loc)
+      if closing_loc.end_column.zero? && closing_loc.end_line > closing_loc.start_line
+        closing_loc.start_line
+      else
+        closing_loc.end_line
+      end
+    end
     # Recursively find the maximum closing_loc among all descendant nodes
     # Returns nil if no closing_loc found, otherwise { end_offset:, end_line:, end_column: }
     def self.find_max_closing_loc_recursive(node, depth: 0)
@@ -158,7 +182,7 @@ module Rfmt
           if max_closing.nil? || closing.end_offset > max_closing[:end_offset]
             max_closing = {
               end_offset: closing.end_offset,
-              end_line: closing.end_line,
+              end_line: heredoc_terminator_line(closing),
               end_column: closing.end_column
             }
           end
@@ -424,9 +448,16 @@ module Rfmt
           metadata['name'] = name
         end
       when Prism::DefNode
-        if (name = extract_node_name(node))
-          metadata['name'] = name
-        end
+        # Prefer `name_loc.slice` over `name.to_s` so unary operator suffixes
+        # (`def !@`, `def +@`, `def -@`) survive the round-trip. Prism
+        # normalizes `name` to the symbol with the `@` stripped for `!@`,
+        # which would otherwise rewrite `def !@` to `def !` silently.
+        name = if node.respond_to?(:name_loc) && node.name_loc
+                 node.name_loc.slice
+               else
+                 extract_node_name(node)
+               end
+        metadata['name'] = name if name
         metadata['parameters_count'] = extract_parameter_count(node).to_s
         # Extract parameters text directly from source
         if node.parameters

data/lib/rfmt/version.rb CHANGED Viewed

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

metadata CHANGED Viewed

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