From 5d19c4fa32b3d8a7e2c607c701e6dc69afa34009 Mon Sep 17 00:00:00 2001
From: Vijay Misal <misalvijay153@gmail.com>
Date: Mon, 10 Aug 2026 21:12:50 +0530
Subject: [PATCH 1/2] Formatter: fix attribute spacing lost on elements nested
 in ERB blocks

When formatting a content-preserving element (e.g. <pre>) whose body
contains an ERB block/conditional, the formatter falls back to
IdentityPrinter to reconstruct that ERB-wrapped subtree byte-for-byte.

Without track_whitespace: true, the parser doesn't emit a node for the
whitespace that separates a tag name from its first attribute, or the
whitespace between attributes - that gap simply isn't represented in the
AST. IdentityPrinter.visitHTMLOpenTagNode wrote the tag name and then its
children back-to-back with no separator, so any HTML element with
attributes inside an ERB block lost its attribute spacing:

    <pre><% if condition %><span class="x">x</span><% end %></pre>

formatted to:

    <pre><% if condition %><spanclass="x">x</span><% end %></pre>

which changes browser behavior (the elements aren't equivalent - the
formatted version creates a bogus spanclass custom element and drops
the class attribute). Confirmed against @herb-tools/formatter 0.10.3
per the report in #2142.

Fix IdentityPrinter.visitHTMLOpenTagNode to compare each child's start
position against the end of the previously written node, restoring a
single separating space whenever the AST has left a gap. When whitespace
tracking is enabled the gap is already covered by an explicit
WhitespaceNode, so no extra space is added in that case (verified via the
printer package's own IndentPrinter/track_whitespace test suite, which
continues to pass unchanged).

Added regression tests to
javascript/packages/formatter/test/html/content-preserving-tags.test.ts
covering both a single-attribute and multi-attribute element nested in an
ERB block.

Tested via vitest run in javascript/packages/printer (116/116 passing,
matching baseline) and javascript/packages/formatter (1372/1480 passing,
2 more than baseline - the 2 new regression tests; the remaining failures
are pre-existing and unrelated, mostly CLI-binary and Tailwind-sorter
tests that need a built binary/tailwind config not available in this
sandbox).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../test/html/content-preserving-tags.test.ts | 12 ++++++++++
 .../packages/printer/src/identity-printer.ts  | 24 ++++++++++++++++++-
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/javascript/packages/formatter/test/html/content-preserving-tags.test.ts b/javascript/packages/formatter/test/html/content-preserving-tags.test.ts
index 593f854a9..e532fa6d1 100644
--- a/javascript/packages/formatter/test/html/content-preserving-tags.test.ts
+++ b/javascript/packages/formatter/test/html/content-preserving-tags.test.ts
@@ -178,6 +178,18 @@ describe("@herb-tools/formatter - content preserving tags", () => {
     expect(formatter.format(result)).toEqual(result)
   })
 
+  test("preserves attribute spacing on an element nested inside an ERB block (#2142)", () => {
+    const source = `<pre><% if condition %><span class="x">x</span><% end %></pre>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<pre><% if condition %><span class="x">x</span><% end %></pre>`)
+  })
+
+  test("preserves spacing between multiple attributes on an element nested inside an ERB block", () => {
+    const source = `<pre><% if condition %><span class="x" id="y">x</span><% end %></pre>`
+    const result = formatter.format(source)
+    expect(result).toEqual(`<pre><% if condition %><span class="x" id="y">x</span><% end %></pre>`)
+  })
+
   test("preserves textarea with ERB control flow", () => {
     const source = dedent`
       <textarea>
diff --git a/javascript/packages/printer/src/identity-printer.ts b/javascript/packages/printer/src/identity-printer.ts
index 42e73e401..fff7fb470 100644
--- a/javascript/packages/printer/src/identity-printer.ts
+++ b/javascript/packages/printer/src/identity-printer.ts
@@ -44,13 +44,35 @@ export class IdentityPrinter extends Printer {
       this.write(node.tag_name.value)
     }
 
-    this.visitChildNodes(node)
+    // Without `track_whitespace: true` the parser doesn't emit a node for the
+    // whitespace that separates the tag name from the first attribute, or the
+    // whitespace between attributes, so reconstructing children back-to-back
+    // would merge them together (e.g. `<span class="x">` becoming
+    // `<spanclass="x">`). Restore a single separating space wherever the
+    // previous node's end position doesn't line up with the next node's start
+    // (when whitespace tracking is on, the gap is already covered by an
+    // explicit WhitespaceNode, so no extra space is added in that case).
+    let previousEnd = node.tag_name?.location.end ?? node.tag_opening?.location.end
+
+    node.children.forEach(child => {
+      if (previousEnd && !this.samePosition(previousEnd, child.location.start)) {
+        this.write(" ")
+      }
+
+      this.visit(child)
+
+      previousEnd = child.location.end
+    })
 
     if (node.tag_closing) {
       this.write(node.tag_closing.value)
     }
   }
 
+  private samePosition(a: Nodes.Position, b: Nodes.Position): boolean {
+    return a.line === b.line && a.column === b.column
+  }
+
   visitHTMLCloseTagNode(node: Nodes.HTMLCloseTagNode): void {
     if (node.tag_opening) {
       this.write(node.tag_opening.value)

From b3208534ad88e0175b5c28c1be12231d7c79fef8 Mon Sep 17 00:00:00 2001
From: Vijay Misal <misalvijay153@gmail.com>
Date: Tue, 11 Aug 2026 22:22:34 +0530
Subject: [PATCH 2/2] fix(printer): avoid duplicate space when a WhitespaceNode
 child already prints its own whitespace

IdentityPrinter's tag-open gap-filling compared node positions to decide
whether to insert a separating space between children. Synthetic
WhitespaceNode children inserted by autofix rules (e.g. html-no-space-in-tag,
erb-no-trailing-whitespace) don't have positions that line up with the
surrounding nodes, so the gap-fill logic inserted an extra space in addition
to the space the WhitespaceNode itself prints, producing doubled spaces like
'<div  />' instead of '<div />'.

WhitespaceNode children are now always skipped by the gap-fill heuristic
since they already print the correct whitespace themselves.
---
 .../packages/printer/src/identity-printer.ts    | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/javascript/packages/printer/src/identity-printer.ts b/javascript/packages/printer/src/identity-printer.ts
index fff7fb470..60911ae12 100644
--- a/javascript/packages/printer/src/identity-printer.ts
+++ b/javascript/packages/printer/src/identity-printer.ts
@@ -1,5 +1,5 @@
 import { Printer } from "./printer.js"
-import { getNodesBeforePosition, getNodesAfterPosition } from "@herb-tools/core"
+import { getNodesBeforePosition, getNodesAfterPosition, isWhitespaceNode } from "@herb-tools/core"
 
 import type * as Nodes from "@herb-tools/core"
 
@@ -49,19 +49,24 @@ export class IdentityPrinter extends Printer {
     // whitespace between attributes, so reconstructing children back-to-back
     // would merge them together (e.g. `<span class="x">` becoming
     // `<spanclass="x">`). Restore a single separating space wherever the
-    // previous node's end position doesn't line up with the next node's start
-    // (when whitespace tracking is on, the gap is already covered by an
-    // explicit WhitespaceNode, so no extra space is added in that case).
+    // previous node's end position doesn't line up with the next node's start.
+    //
+    // WhitespaceNode children already print their own whitespace (including
+    // synthetic ones inserted by autofixers, whose location doesn't line up
+    // with the surrounding nodes), so they're skipped here to avoid writing a
+    // duplicate separating space in addition to the whitespace they print.
     let previousEnd = node.tag_name?.location.end ?? node.tag_opening?.location.end
 
     node.children.forEach(child => {
-      if (previousEnd && !this.samePosition(previousEnd, child.location.start)) {
+      if (previousEnd && !isWhitespaceNode(child) && !this.samePosition(previousEnd, child.location.start)) {
         this.write(" ")
       }
 
       this.visit(child)
 
-      previousEnd = child.location.end
+      if (!isWhitespaceNode(child)) {
+        previousEnd = child.location.end
+      }
     })
 
     if (node.tag_closing) {