@herb-tools/formatter 0.8.1 → 0.8.2

package/src/format-printer.ts

@@ -13,6 +13,8 @@ import {
   isERBNode,
   isCommentNode,
   isERBControlFlowNode,
+  isERBCommentNode,
+  isERBOutputNode,
   filterNodes,
 } from "@herb-tools/core"
 
@@ -47,9 +49,6 @@ import {
   FORMATTABLE_ATTRIBUTES,
   INLINE_ELEMENTS,
   SPACEABLE_CONTAINERS,
-  SPACING_THRESHOLD,
-  TIGHT_GROUP_CHILDREN,
-  TIGHT_GROUP_PARENTS,
   TOKEN_LIST_ATTRIBUTES,
 } from "./format-helpers.js"
 
@@ -122,6 +121,11 @@ export class FormatPrinter extends Printer {
   private currentAttributeName: string | null = null
   private elementStack: HTMLElementNode[] = []
   private elementFormattingAnalysis = new Map<HTMLElementNode, ElementFormattingAnalysis>()
+  private nodeIsMultiline = new Map<Node, boolean>()
+  private stringLineCount: number = 0
+  private tagGroupsCache = new Map<Node[], Map<number, { tagName: string; groupStart: number; groupEnd: number }>>()
+  private allSingleLineCache = new Map<Node[], boolean>()
+
 
   public source: string
 
@@ -141,6 +145,10 @@ export class FormatPrinter extends Printer {
     // TODO: refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
     this.lines = []
     this.indentLevel = 0
+    this.stringLineCount = 0
+    this.nodeIsMultiline.clear()
+    this.tagGroupsCache.clear()
+    this.allSingleLineCache.clear()
 
     this.visit(node)
 
@@ -179,19 +187,32 @@ export class FormatPrinter extends Printer {
   private capture(callback: () => void): string[] {
     const previousLines = this.lines
     const previousInlineMode = this.inlineMode
+    const previousStringLineCount = this.stringLineCount
 
     this.lines = []
+    this.stringLineCount = 0
 
     try {
       callback()
-
       return this.lines
     } finally {
       this.lines = previousLines
       this.inlineMode = previousInlineMode
+      this.stringLineCount = previousStringLineCount
     }
   }
 
+  /**
+   * Track a boundary node's multiline status by comparing line count before/after rendering.
+   */
+  private trackBoundary(node: Node, callback: () => void): void {
+    const startLineCount = this.stringLineCount
+    callback()
+    const endLineCount = this.stringLineCount
+
+    this.nodeIsMultiline.set(node, (endLineCount - startLineCount) > 1)
+  }
+
   /**
    * Capture all nodes that would be visited during a callback
    * Returns a flat list of all nodes without generating any output
@@ -232,6 +253,7 @@ export class FormatPrinter extends Printer {
    */
   private push(line: string) {
     this.lines.push(line)
+    this.stringLineCount++
   }
 
   /**
@@ -288,6 +310,96 @@ export class FormatPrinter extends Printer {
     return nodes.filter(child => isNoneOf(child, HTMLAttributeNode, WhitespaceNode))
   }
 
+  /**
+   * Check if a node will render as multiple lines when formatted.
+   */
+  private isMultilineElement(node: Node): boolean {
+    if (isNode(node, ERBContentNode)) {
+      return (node.content?.value || "").includes("\n")
+    }
+
+    if (isNode(node, HTMLElementNode) && isContentPreserving(node)) {
+      return true
+    }
+
+    const tracked = this.nodeIsMultiline.get(node)
+
+    if (tracked !== undefined) {
+      return tracked
+    }
+
+    return false
+  }
+
+  /**
+   * Get a grouping key for a node (tag name for HTML, ERB type for ERB)
+   */
+  private getGroupingKey(node: Node): string | null {
+    if (isNode(node, HTMLElementNode)) {
+      return getTagName(node)
+    }
+
+    if (isERBOutputNode(node)) return "erb-output"
+    if (isERBCommentNode(node)) return "erb-comment"
+    if (isERBNode(node)) return "erb-code"
+
+    return null
+  }
+
+  /**
+   * Detect groups of consecutive same-tag/same-type single-line elements
+   * Returns a map of index -> group info for efficient lookup
+   */
+  private detectTagGroups(siblings: Node[]): Map<number, { tagName: string; groupStart: number; groupEnd: number }> {
+    const cached = this.tagGroupsCache.get(siblings)
+    if (cached) return cached
+
+    const groupMap = new Map<number, { tagName: string; groupStart: number; groupEnd: number }>()
+    const meaningfulNodes: Array<{ index: number; groupKey: string }> = []
+
+    for (let i = 0; i < siblings.length; i++) {
+      const node = siblings[i]
+
+      if (!this.isMultilineElement(node)) {
+        const groupKey = this.getGroupingKey(node)
+
+        if (groupKey) {
+          meaningfulNodes.push({ index: i, groupKey })
+        }
+      }
+    }
+
+    let groupStart = 0
+
+    while (groupStart < meaningfulNodes.length) {
+      const startGroupKey = meaningfulNodes[groupStart].groupKey
+      let groupEnd = groupStart
+
+      while (groupEnd + 1 < meaningfulNodes.length && meaningfulNodes[groupEnd + 1].groupKey === startGroupKey) {
+        groupEnd++
+      }
+
+      if (groupEnd > groupStart) {
+        const groupStartIndex = meaningfulNodes[groupStart].index
+        const groupEndIndex = meaningfulNodes[groupEnd].index
+
+        for (let i = groupStart; i <= groupEnd; i++) {
+          groupMap.set(meaningfulNodes[i].index, {
+            tagName: startGroupKey,
+            groupStart: groupStartIndex,
+            groupEnd: groupEndIndex
+          })
+        }
+      }
+
+      groupStart = groupEnd + 1
+    }
+
+    this.tagGroupsCache.set(siblings, groupMap)
+
+    return groupMap
+  }
+
   /**
    * Determine if spacing should be added between sibling elements
    *
@@ -303,69 +415,73 @@ export class FormatPrinter extends Printer {
    * @param hasExistingSpacing - Whether user-added spacing already exists
    * @returns true if spacing should be added before the current element
    */
-  private shouldAddSpacingBetweenSiblings(
-    parentElement: HTMLElementNode | null,
-    siblings: Node[],
-    currentIndex: number,
-    hasExistingSpacing: boolean
-  ): boolean {
-    if (hasExistingSpacing) {
+  private shouldAddSpacingBetweenSiblings(parentElement: HTMLElementNode | null, siblings: Node[], currentIndex: number): boolean {
+    const currentNode = siblings[currentIndex]
+    const previousMeaningfulIndex = findPreviousMeaningfulSibling(siblings, currentIndex)
+    const previousNode = previousMeaningfulIndex !== -1 ? siblings[previousMeaningfulIndex] : null
+
+    if (previousNode && (isNode(previousNode, XMLDeclarationNode) || isNode(previousNode, HTMLDoctypeNode))) {
       return true
     }
 
     const hasMixedContent = siblings.some(child => isNode(child, HTMLTextNode) && child.content.trim() !== "")
 
-    if (hasMixedContent) {
-      return false
-    }
+    if (hasMixedContent) return false
 
-    const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
+    const isCurrentComment = isCommentNode(currentNode)
+    const isPreviousComment = previousNode ? isCommentNode(previousNode) : false
+    const isCurrentMultiline = this.isMultilineElement(currentNode)
+    const isPreviousMultiline = previousNode ? this.isMultilineElement(previousNode) : false
 
-    if (meaningfulSiblings.length < SPACING_THRESHOLD) {
+    if (isPreviousComment && !isCurrentComment && (isNode(currentNode, HTMLElementNode) || isERBNode(currentNode))) {
+      return isPreviousMultiline && isCurrentMultiline
+    }
+
+    if (isPreviousComment && isCurrentComment) {
       return false
     }
 
+    if (isCurrentMultiline || isPreviousMultiline) {
+      return true
+    }
+
+    const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
     const parentTagName = parentElement ? getTagName(parentElement) : null
+    const isSpaceableContainer = !parentTagName || SPACEABLE_CONTAINERS.has(parentTagName)
+    const tagGroups = this.detectTagGroups(siblings)
 
-    if (parentTagName && TIGHT_GROUP_PARENTS.has(parentTagName)) {
-      return false
+    const cached = this.allSingleLineCache.get(siblings)
+    let allSingleLineHTMLElements: boolean
+    if (cached !== undefined) {
+      allSingleLineHTMLElements = cached
+    } else {
+      allSingleLineHTMLElements = meaningfulSiblings.every(node => isNode(node, HTMLElementNode) && !this.isMultilineElement(node))
+      this.allSingleLineCache.set(siblings, allSingleLineHTMLElements)
     }
 
-    const isSpaceableContainer = !parentTagName || (parentTagName && SPACEABLE_CONTAINERS.has(parentTagName))
-
     if (!isSpaceableContainer && meaningfulSiblings.length < 5) {
       return false
     }
 
-    const currentNode = siblings[currentIndex]
-    const previousMeaningfulIndex = findPreviousMeaningfulSibling(siblings, currentIndex)
-    const isCurrentComment = isCommentNode(currentNode)
+    const currentGroup = tagGroups.get(currentIndex)
+    const previousGroup = previousNode ? tagGroups.get(previousMeaningfulIndex) : undefined
 
-    if (previousMeaningfulIndex !== -1) {
-      const previousNode = siblings[previousMeaningfulIndex]
-      const isPreviousComment = isCommentNode(previousNode)
+    if (currentGroup && previousGroup && currentGroup.groupStart === previousGroup.groupStart && currentGroup.groupEnd === previousGroup.groupEnd) {
+      return false
+    }
 
-      if (isPreviousComment && !isCurrentComment && (isNode(currentNode, HTMLElementNode) || isERBNode(currentNode))) {
-        return false
-      }
+    if (previousGroup && previousGroup.groupEnd === previousMeaningfulIndex) {
+      return true
+    }
 
-      if (isPreviousComment && isCurrentComment) {
-        return false
-      }
+    if (allSingleLineHTMLElements && tagGroups.size === 0) {
+      return false
     }
 
     if (isNode(currentNode, HTMLElementNode)) {
       const currentTagName = getTagName(currentNode)
 
-      if (INLINE_ELEMENTS.has(currentTagName)) {
-        return false
-      }
-
-      if (TIGHT_GROUP_CHILDREN.has(currentTagName)) {
-        return false
-      }
-
-      if (currentTagName === 'a' && parentTagName === 'nav') {
+      if (currentTagName && INLINE_ELEMENTS.has(currentTagName)) {
         return false
       }
     }
@@ -652,7 +768,7 @@ export class FormatPrinter extends Printer {
       return
     }
 
-    let lastWasMeaningful = false
+    let lastMeaningfulNode: Node | null = null
     let hasHandledSpacing = false
 
     for (let i = 0; i < children.length; i++) {
@@ -670,21 +786,27 @@ export class FormatPrinter extends Printer {
 
       if (shouldAppendToLastLine(child, children, i)) {
         this.appendChildToLastLine(child, children, i)
-        lastWasMeaningful = true
+        lastMeaningfulNode = child
         hasHandledSpacing = false
         continue
       }
 
-      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
-        this.push("")
-      }
+      if (!isNonWhitespaceNode(child)) continue
 
+      const childStartLine = this.stringLineCount
       this.visit(child)
 
-      if (isNonWhitespaceNode(child)) {
-        lastWasMeaningful = true
-        hasHandledSpacing = false
+      if (lastMeaningfulNode && !hasHandledSpacing) {
+        const shouldAddSpacing = this.shouldAddSpacingBetweenSiblings( null, children, i)
+
+        if (shouldAddSpacing) {
+          this.lines.splice(childStartLine, 0, "")
+          this.stringLineCount++
+        }
       }
+
+      lastMeaningfulNode = child
+      hasHandledSpacing = false
     }
   }
 
@@ -692,23 +814,23 @@ export class FormatPrinter extends Printer {
     this.elementStack.push(node)
     this.elementFormattingAnalysis.set(node, this.analyzeElementFormatting(node))
 
-    if (this.inlineMode && node.is_void && this.indentLevel === 0) {
-      const openTag = this.capture(() => this.visit(node.open_tag)).join('')
-      this.pushToLastLine(openTag)
-      this.elementStack.pop()
-
-      return
-    }
+    this.trackBoundary(node, () => {
+      if (this.inlineMode && node.is_void && this.indentLevel === 0) {
+        const openTag = this.capture(() => this.visit(node.open_tag)).join('')
+        this.pushToLastLine(openTag)
+        return
+      }
 
-    this.visit(node.open_tag)
+      this.visit(node.open_tag)
 
-    if (node.body.length > 0) {
-      this.visitHTMLElementBody(node.body, node)
-    }
+      if (node.body.length > 0) {
+        this.visitHTMLElementBody(node.body, node)
+      }
 
-    if (node.close_tag) {
-      this.visit(node.close_tag)
-    }
+      if (node.close_tag) {
+        this.visit(node.close_tag)
+      }
+    })
 
     this.elementStack.pop()
   }
@@ -883,21 +1005,22 @@ export class FormatPrinter extends Printer {
 
   /**
    * Visit element children with intelligent spacing logic
+   *
+   * Tracks line positions and immediately splices blank lines after rendering each child.
    */
   private visitElementChildren(body: Node[], parentElement: HTMLElementNode | null) {
-    let lastWasMeaningful = false
+    let lastMeaningfulNode: Node | null = null
     let hasHandledSpacing = false
 
-    for (let i = 0; i < body.length; i++) {
-      const child = body[i]
+    for (let index = 0; index < body.length; index++) {
+      const child = body[index]
 
       if (isNode(child, HTMLTextNode)) {
         const isWhitespaceOnly = child.content.trim() === ""
 
         if (isWhitespaceOnly) {
-          const hasPreviousNonWhitespace = i > 0 && isNonWhitespaceNode(body[i - 1])
-          const hasNextNonWhitespace = i < body.length - 1 && isNonWhitespaceNode(body[i + 1])
-
+          const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(body[index - 1])
+          const hasNextNonWhitespace = index < body.length - 1 && isNonWhitespaceNode(body[index + 1])
           const hasMultipleNewlines = child.content.includes('\n\n')
 
           if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
@@ -909,26 +1032,12 @@ export class FormatPrinter extends Printer {
         }
       }
 
-      if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
-        const element = body[i - 1]
-        const hasExistingSpacing = i > 0 && isNode(element, HTMLTextNode) && element.content.trim() === "" && (element.content.includes('\n\n') || element.content.split('\n').length > 2)
-
-        const shouldAddSpacing = this.shouldAddSpacingBetweenSiblings(
-          parentElement,
-          body,
-          i,
-          hasExistingSpacing
-        )
-
-        if (shouldAddSpacing) {
-          this.push("")
-        }
-      }
+      if (!isNonWhitespaceNode(child)) continue
 
       let hasTrailingHerbDisable = false
 
       if (isNode(child, HTMLElementNode) && child.close_tag) {
-        for (let j = i + 1; j < body.length; j++) {
+        for (let j = index + 1; j < body.length; j++) {
           const nextChild = body[j]
 
           if (isNode(nextChild, WhitespaceNode) || isPureWhitespaceNode(nextChild)) {
@@ -938,8 +1047,18 @@ export class FormatPrinter extends Printer {
           if (isNode(nextChild, ERBContentNode) && isHerbDisableComment(nextChild)) {
             hasTrailingHerbDisable = true
 
+            const childStartLine = this.stringLineCount
             this.visit(child)
 
+            if (lastMeaningfulNode && !hasHandledSpacing) {
+              const shouldAddSpacing = this.shouldAddSpacingBetweenSiblings(parentElement, body, index)
+
+              if (shouldAddSpacing) {
+                this.lines.splice(childStartLine, 0, "")
+                this.stringLineCount++
+              }
+            }
+
             const herbDisableString = this.capture(() => {
               const savedIndentLevel = this.indentLevel
               this.indentLevel = 0
@@ -951,7 +1070,9 @@ export class FormatPrinter extends Printer {
 
             this.pushToLastLine(' ' + herbDisableString)
 
-            i = j
+            index = j
+            lastMeaningfulNode = child
+            hasHandledSpacing = false
 
             break
           }
@@ -961,11 +1082,19 @@ export class FormatPrinter extends Printer {
       }
 
       if (!hasTrailingHerbDisable) {
+        const childStartLine = this.stringLineCount
         this.visit(child)
-      }
 
-      if (isNonWhitespaceNode(child)) {
-        lastWasMeaningful = true
+        if (lastMeaningfulNode && !hasHandledSpacing) {
+          const shouldAddSpacing = this.shouldAddSpacingBetweenSiblings(parentElement, body, index)
+
+          if (shouldAddSpacing) {
+            this.lines.splice(childStartLine, 0, "")
+            this.stringLineCount++
+          }
+        }
+
+        lastMeaningfulNode = child
         hasHandledSpacing = false
       }
     }
@@ -1087,6 +1216,14 @@ export class FormatPrinter extends Printer {
         }
       }).join("")
 
+      const trimmedInner = inner.trim()
+
+      if (trimmedInner.startsWith('[if ') && trimmedInner.endsWith('<![endif]')) {
+        this.pushWithIndent(open + inner + close)
+
+        return
+      }
+
       const hasNewlines = inner.includes('\n')
 
       if (hasNewlines) {
@@ -1189,8 +1326,7 @@ export class FormatPrinter extends Printer {
   }
 
   visitERBContentNode(node: ERBContentNode) {
-    // TODO: this feels hacky
-    if (node.tag_opening?.value === "<%#") {
+    if (isERBCommentNode(node)) {
       this.visitERBCommentNode(node)
     } else {
       this.printERBNode(node)
@@ -1202,91 +1338,101 @@ export class FormatPrinter extends Printer {
   }
 
   visitERBYieldNode(node: ERBYieldNode) {
-    this.printERBNode(node)
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+    })
   }
 
   visitERBInNode(node: ERBInNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
+    })
   }
 
   visitERBCaseMatchNode(node: ERBCaseMatchNode) {
-    this.printERBNode(node)
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
 
-    this.withIndent(() => this.visitAll(node.children))
-    this.visitAll(node.conditions)
+      this.withIndent(() => this.visitAll(node.children))
+      this.visitAll(node.conditions)
 
-    if (node.else_clause) this.visit(node.else_clause)
-    if (node.end_node) this.visit(node.end_node)
+      if (node.else_clause) this.visit(node.else_clause)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBBlockNode(node: ERBBlockNode) {
-    this.printERBNode(node)
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
 
-    this.withIndent(() => {
-      const hasTextFlow = this.isInTextFlowContext(null, node.body)
+      this.withIndent(() => {
+        const hasTextFlow = this.isInTextFlowContext(null, node.body)
 
-      if (hasTextFlow) {
-        this.visitTextFlowChildren(node.body)
-      } else {
-        this.visitElementChildren(node.body, null)
-      }
-    })
+        if (hasTextFlow) {
+          this.visitTextFlowChildren(node.body)
+        } else {
+          this.visitElementChildren(node.body, null)
+        }
+      })
 
-    if (node.end_node) this.visit(node.end_node)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBIfNode(node: ERBIfNode) {
-    if (this.inlineMode) {
-      this.printERBNode(node)
-
-      node.statements.forEach(child => {
-        if (isNode(child, HTMLAttributeNode)) {
-          this.lines.push(" ")
-          this.lines.push(this.renderAttribute(child))
-        } else {
-          const shouldAddSpaces = this.isInTokenListAttribute
+    this.trackBoundary(node, () => {
+      if (this.inlineMode) {
+        this.printERBNode(node)
 
-          if (shouldAddSpaces) {
+        node.statements.forEach(child => {
+          if (isNode(child, HTMLAttributeNode)) {
             this.lines.push(" ")
-          }
+            this.lines.push(this.renderAttribute(child))
+          } else {
+            const shouldAddSpaces = this.isInTokenListAttribute
 
-          this.visit(child)
+            if (shouldAddSpaces) {
+              this.lines.push(" ")
+            }
 
-          if (shouldAddSpaces) {
-            this.lines.push(" ")
+            this.visit(child)
+
+            if (shouldAddSpaces) {
+              this.lines.push(" ")
+            }
           }
-        }
-      })
+        })
 
-      const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode))
-      const isTokenList = this.isInTokenListAttribute
+        const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode))
+        const isTokenList = this.isInTokenListAttribute
 
-      if ((hasHTMLAttributes || isTokenList) && node.end_node) {
-        this.lines.push(" ")
-      }
+        if ((hasHTMLAttributes || isTokenList) && node.end_node) {
+          this.lines.push(" ")
+        }
 
-      if (node.subsequent) this.visit(node.subsequent)
-      if (node.end_node) this.visit(node.end_node)
-    } else {
-      this.printERBNode(node)
+        if (node.subsequent) this.visit(node.subsequent)
+        if (node.end_node) this.visit(node.end_node)
+      } else {
+        this.printERBNode(node)
 
-      this.withIndent(() => {
-        node.statements.forEach(child => this.visit(child))
-      })
+        this.withIndent(() => {
+          node.statements.forEach(child => this.visit(child))
+        })
 
-      if (node.subsequent) this.visit(node.subsequent)
-      if (node.end_node) this.visit(node.end_node)
-    }
+        if (node.subsequent) this.visit(node.subsequent)
+        if (node.end_node) this.visit(node.end_node)
+      }
+    })
   }
 
   visitERBElseNode(node: ERBElseNode) {
+    this.printERBNode(node)
+
     if (this.inlineMode) {
-      this.printERBNode(node)
-      node.statements.forEach(statement => this.visit(statement))
+      this.visitAll(node.statements)
     } else {
-      this.printERBNode(node)
-      this.withIndent(() => node.statements.forEach(statement => this.visit(statement)))
+      this.withIndent(() => this.visitAll(node.statements))
     }
   }
 
@@ -1296,44 +1442,54 @@ export class FormatPrinter extends Printer {
   }
 
   visitERBCaseNode(node: ERBCaseNode) {
-    this.printERBNode(node)
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
 
-    this.withIndent(() => this.visitAll(node.children))
-    this.visitAll(node.conditions)
+      this.withIndent(() => this.visitAll(node.children))
+      this.visitAll(node.conditions)
 
-    if (node.else_clause) this.visit(node.else_clause)
-    if (node.end_node) this.visit(node.end_node)
+      if (node.else_clause) this.visit(node.else_clause)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBBeginNode(node: ERBBeginNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
 
-    if (node.rescue_clause) this.visit(node.rescue_clause)
-    if (node.else_clause) this.visit(node.else_clause)
-    if (node.ensure_clause) this.visit(node.ensure_clause)
-    if (node.end_node) this.visit(node.end_node)
+      if (node.rescue_clause) this.visit(node.rescue_clause)
+      if (node.else_clause) this.visit(node.else_clause)
+      if (node.ensure_clause) this.visit(node.ensure_clause)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBWhileNode(node: ERBWhileNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
 
-    if (node.end_node) this.visit(node.end_node)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBUntilNode(node: ERBUntilNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
 
-    if (node.end_node) this.visit(node.end_node)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBForNode(node: ERBForNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
 
-    if (node.end_node) this.visit(node.end_node)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   visitERBRescueNode(node: ERBRescueNode) {
@@ -1347,11 +1503,13 @@ export class FormatPrinter extends Printer {
   }
 
   visitERBUnlessNode(node: ERBUnlessNode) {
-    this.printERBNode(node)
-    this.withIndent(() => this.visitAll(node.statements))
+    this.trackBoundary(node, () => {
+      this.printERBNode(node)
+      this.withIndent(() => this.visitAll(node.statements))
 
-    if (node.else_clause) this.visit(node.else_clause)
-    if (node.end_node) this.visit(node.end_node)
+      if (node.else_clause) this.visit(node.else_clause)
+      if (node.end_node) this.visit(node.end_node)
+    })
   }
 
   // --- Element Formatting Analysis Helpers ---
@@ -1418,6 +1576,16 @@ export class FormatPrinter extends Printer {
     if (!openTagInline) return false
     if (children.length === 0) return true
 
+    const hasNonInlineChildElements = children.some(child => {
+      if (isNode(child, HTMLElementNode)) {
+        return !this.shouldRenderElementContentInline(child)
+      }
+
+      return false
+    })
+
+    if (hasNonInlineChildElements) return false
+
     let hasLeadingHerbDisable = false
 
     for (const child of node.body) {
@@ -1439,7 +1607,7 @@ export class FormatPrinter extends Printer {
 
       if (fullInlineResult) {
         const totalLength = this.indent.length + fullInlineResult.length
-        return totalLength <= this.maxLineLength || totalLength <= 120
+        return totalLength <= this.maxLineLength
       }
 
       return false
@@ -1474,8 +1642,9 @@ export class FormatPrinter extends Printer {
 
       const childrenContent = this.renderChildrenInline(children)
       const fullLine = openTagResult + childrenContent + `</${tagName}>`
+      const totalLength = this.indent.length + fullLine.length
 
-      if ((this.indent.length + fullLine.length) <= this.maxLineLength) {
+      if (totalLength <= this.maxLineLength) {
         return true
       }
     }