@herb-tools/linter 0.9.0 → 0.9.1

package/dist/index.js

@@ -1,5 +1,6 @@
 import picomatch from 'picomatch';
-import { getNodesBeforePosition, getNodesAfterPosition, filterNodes, ERBContentNode, isERBOutputNode, isERBIfNode, isERBUnlessNode, isERBElseNode, isHTMLTextNode, Visitor, isToken, isParseResult, forEachAttribute, getAttributeName, hasDynamicAttributeNameOnAttribute, getStaticAttributeValue, getAttributeValueNodes, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, getAttributeValue, getCombinedAttributeNameString, Location, Position, isERBOpenTagNode, isERBNode, isWhitespaceNode, isCommentNode, isLiteralNode, isERBCaseNode, isPureWhitespaceNode, isERBWhenNode, isHTMLElementNode, isEquivalentElement, findParentArray, removeNodeFromArray, replaceNodeWithBody, createLiteral, HTMLElementNode, PrismVisitor, splitLiteralsAtWhitespace, groupNodesByClass, filterERBContentNodes, isHTMLOpenTagNode, getTagLocalName, getAttribute, isERBCommentNode, getAttributes, findAttributeByName, isNode, LiteralNode, didyoumean, hasAttributeValue, isRubyLiteralNode, filterHTMLAttributeNodes, filterLiteralNodes, getAttributeValueQuoteType, Token, hasAttribute, isHTMLAttributeValueNode, isERBContentNode, getStaticAttributeName, isERBControlFlowNode, HTMLCloseTagNode, getTagName, createWhitespaceNode, filterWhitespaceNodes, getStaticContentFromNodes, getOpenTag, isHTMLCloseTagNode, HTMLOpenTagNode, DEFAULT_PARSER_OPTIONS } from '@herb-tools/core';
+import { getNodesBeforePosition, getNodesAfterPosition, filterNodes, ERBContentNode, isERBOutputNode, isERBIfNode, isERBUnlessNode, isERBElseNode, isHTMLTextNode, Visitor, isToken, isParseResult, forEachAttribute, getAttributeName, hasDynamicAttributeName, getStaticAttributeValue, getAttributeValueNodes, hasERBOutput, isEffectivelyStatic, getValidatableStaticContent, getAttributeValue, getCombinedAttributeNameString, Location, Position, isERBOpenTagNode, isERBNode, isWhitespaceNode, isCommentNode, isLiteralNode, findParentArray, isHTMLOpenTagNode, isERBCaseNode, isPureWhitespaceNode, isERBWhenNode, isHTMLElementNode, isEquivalentElement, removeNodeFromArray, createLiteral, replaceNodeWithBody, HTMLElementNode, PrismVisitor, splitLiteralsAtWhitespace, groupNodesByClass, filterERBContentNodes, getTagLocalName, getAttribute, isERBCommentNode, getAttributes, findAttributeByName, isNode, LiteralNode, didyoumean, hasAttributeValue, isRubyLiteralNode, filterHTMLAttributeNodes, filterLiteralNodes, getAttributeValueQuoteType, Token, hasAttribute, isHTMLAttributeValueNode, isERBContentNode, getStaticAttributeName, isERBControlFlowNode, HTMLCloseTagNode, getTagName, createWhitespaceNode, filterWhitespaceNodes, getStaticContentFromNodes, getOpenTag, isHTMLCloseTagNode, HTMLOpenTagNode, DEFAULT_PARSER_OPTIONS } from '@herb-tools/core';
+export { findAttributeByName, getAttribute, getAttributeName, getAttributeValue, getAttributeValueNodes, getAttributeValueQuoteType, getAttributes, getCombinedAttributeNameString, getStaticAttributeValue, getStaticAttributeValueContent, getTagName, hasAttribute, hasAttributeValue, hasDynamicAttributeName, hasDynamicAttributeValue, hasStaticAttributeValue, hasStaticAttributeValueContent, isAttributeValueQuoted } from '@herb-tools/core';
 
 class PrintContext {
     output = "";
@@ -439,6 +440,12 @@ class IdentityPrinter extends Printer {
             this.visit(node.end_node);
         }
     }
+    visitERBRenderNode(node) {
+        this.printERBNode(node);
+    }
+    visitRubyRenderLocalNode(_node) {
+        // extracted metadata, nothing to print
+    }
     visitERBYieldNode(node) {
         this.printERBNode(node);
     }
@@ -989,7 +996,7 @@ class ParserRule {
     get parserOptions() {
         return DEFAULT_LINTER_PARSER_OPTIONS;
     }
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -998,6 +1005,7 @@ class ParserRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1017,7 +1025,7 @@ class LexerRule {
     get defaultConfig() {
         return DEFAULT_RULE_CONFIG;
     }
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1026,6 +1034,7 @@ class LexerRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1051,7 +1060,7 @@ class SourceRule {
     get defaultConfig() {
         return DEFAULT_RULE_CONFIG;
     }
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1060,6 +1069,7 @@ class SourceRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1085,7 +1095,7 @@ class BaseRuleVisitor extends Visitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1094,13 +1104,14 @@ class BaseRuleVisitor extends Visitor {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext, severity) {
-        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
+    addOffense(message, location, autofixContext, severity, tags) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags));
     }
 }
 /**
@@ -1376,7 +1387,7 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
         forEachAttribute(node, (attributeNode) => {
             const staticAttributeName = getAttributeName(attributeNode);
             const originalAttributeName = getAttributeName(attributeNode, false) || "";
-            const isDynamicName = hasDynamicAttributeNameOnAttribute(attributeNode);
+            const isDynamicName = hasDynamicAttributeName(attributeNode);
             const staticAttributeValue = getStaticAttributeValue(attributeNode);
             const valueNodes = getAttributeValueNodes(attributeNode);
             const hasOutputERB = hasERBOutput(valueNodes);
@@ -1453,7 +1464,7 @@ class BaseLexerRuleVisitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1462,13 +1473,14 @@ class BaseLexerRuleVisitor {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext, severity) {
-        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
+    addOffense(message, location, autofixContext, severity, tags) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags));
     }
     /**
      * Main entry point for lexer rule visitors
@@ -1509,7 +1521,7 @@ class BaseSourceRuleVisitor {
      * Helper method to create an unbound lint offense (without severity).
      * The Linter will bind severity based on the rule's config.
      */
-    createOffense(message, location, autofixContext, severity) {
+    createOffense(message, location, autofixContext, severity, tags) {
         return {
             rule: this.ruleName,
             code: this.ruleName,
@@ -1518,13 +1530,14 @@ class BaseSourceRuleVisitor {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
     /**
      * Helper method to add an offense to the offenses array
      */
-    addOffense(message, location, autofixContext, severity) {
-        this.offenses.push(this.createOffense(message, location, autofixContext, severity));
+    addOffense(message, location, autofixContext, severity, tags) {
+        this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags));
     }
     /**
      * Main entry point for source rule visitors
@@ -1874,6 +1887,34 @@ class ActionViewNoSilentHelperRule extends ParserRule {
     }
 }
 
+class ActionViewNoSilentRenderVisitor extends BaseRuleVisitor {
+    visitERBRenderNode(node) {
+        if (!isERBOutputNode(node)) {
+            this.addOffense(`Avoid using \`${node.tag_opening?.value} %>\` with \`render\`. Use \`<%= %>\` to ensure the rendered content is output.`, node.location);
+        }
+        this.visitChildNodes(node);
+    }
+}
+class ActionViewNoSilentRenderRule extends ParserRule {
+    static ruleName = "actionview-no-silent-render";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    get parserOptions() {
+        return {
+            render_nodes: true,
+        };
+    }
+    check(result, context) {
+        const visitor = new ActionViewNoSilentRenderVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 class ERBCommentSyntaxVisitor extends BaseRuleVisitor {
     visitERBContentNode(node) {
         const content = node.content?.value || "";
@@ -1938,7 +1979,9 @@ class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
         for (const child of node.children) {
             if (!this.isAllowedContent(child)) {
                 const childCode = IdentityPrinter.print(child).trim();
-                this.addOffense(`Do not place \`${childCode}\` between \`${caseCode}\` and \`${conditionCode}\`. Content here is not part of any branch and will not be rendered.`, child.location);
+                const offense = this.createOffense(`Do not place \`${childCode}\` between \`${caseCode}\` and \`${conditionCode}\`. Content here is not part of any branch and will not be rendered.`, child.location);
+                offense.tags = ["unnecessary"];
+                this.offenses.push(offense);
             }
         }
     }
@@ -1968,6 +2011,193 @@ class ERBNoCaseNodeChildrenRule extends ParserRule {
     }
 }
 
+class ERBNoEmptyControlFlowVisitor extends BaseRuleVisitor {
+    processedIfNodes = new Set();
+    processedElseNodes = new Set();
+    visitERBIfNode(node) {
+        if (this.processedIfNodes.has(node)) {
+            return;
+        }
+        this.markIfChainAsProcessed(node);
+        this.markElseNodesInIfChain(node);
+        const entireChainEmpty = this.isEntireIfChainEmpty(node);
+        if (entireChainEmpty) {
+            this.addEmptyBlockOffense(node, node.statements, "if");
+        }
+        else {
+            this.checkIfChainParts(node);
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBElseNode(node) {
+        if (this.processedElseNodes.has(node)) {
+            this.visitChildNodes(node);
+            return;
+        }
+        this.addEmptyBlockOffense(node, node.statements, "else");
+        this.visitChildNodes(node);
+    }
+    visitERBUnlessNode(node) {
+        const unlessHasContent = this.statementsHaveContent(node.statements);
+        const elseHasContent = node.else_clause && this.statementsHaveContent(node.else_clause.statements);
+        if (node.else_clause) {
+            this.processedElseNodes.add(node.else_clause);
+        }
+        const entireBlockEmpty = !unlessHasContent && !elseHasContent;
+        if (entireBlockEmpty) {
+            this.addEmptyBlockOffense(node, node.statements, "unless");
+        }
+        else {
+            if (!unlessHasContent) {
+                this.addEmptyBlockOffenseWithEnd(node, node.statements, "unless", node.else_clause);
+            }
+            if (node.else_clause && !elseHasContent) {
+                this.addEmptyBlockOffense(node.else_clause, node.else_clause.statements, "else");
+            }
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBForNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "for");
+        this.visitChildNodes(node);
+    }
+    visitERBWhileNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "while");
+        this.visitChildNodes(node);
+    }
+    visitERBUntilNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "until");
+        this.visitChildNodes(node);
+    }
+    visitERBWhenNode(node) {
+        if (!node.then_keyword) {
+            this.addEmptyBlockOffense(node, node.statements, "when");
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBInNode(node) {
+        if (!node.then_keyword) {
+            this.addEmptyBlockOffense(node, node.statements, "in");
+        }
+        this.visitChildNodes(node);
+    }
+    visitERBBeginNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "begin");
+        this.visitChildNodes(node);
+    }
+    visitERBRescueNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "rescue");
+        this.visitChildNodes(node);
+    }
+    visitERBEnsureNode(node) {
+        this.addEmptyBlockOffense(node, node.statements, "ensure");
+        this.visitChildNodes(node);
+    }
+    visitERBBlockNode(node) {
+        this.addEmptyBlockOffense(node, node.body, "do");
+        this.visitChildNodes(node);
+    }
+    addEmptyBlockOffense(node, statements, blockType) {
+        this.addEmptyBlockOffenseWithEnd(node, statements, blockType, null);
+    }
+    addEmptyBlockOffenseWithEnd(node, statements, blockType, subsequentNode) {
+        if (this.statementsHaveContent(statements)) {
+            return;
+        }
+        const startLocation = node.location.start;
+        const endLocation = subsequentNode
+            ? subsequentNode.location.start
+            : node.location.end;
+        const location = Location.from(startLocation.line, startLocation.column, endLocation.line, endLocation.column);
+        const offense = this.createOffense(`Empty ${blockType} block: this control flow statement has no content`, location);
+        offense.tags = ["unnecessary"];
+        this.offenses.push(offense);
+    }
+    statementsHaveContent(statements) {
+        return statements.some(statement => {
+            if (isHTMLTextNode(statement)) {
+                return statement.content.trim() !== "";
+            }
+            return true;
+        });
+    }
+    markIfChainAsProcessed(node) {
+        this.processedIfNodes.add(node);
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (isERBIfNode(current)) {
+                this.processedIfNodes.add(current);
+            }
+        });
+    }
+    markElseNodesInIfChain(node) {
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (isERBElseNode(current)) {
+                this.processedElseNodes.add(current);
+            }
+        });
+    }
+    traverseSubsequentNodes(startNode, callback) {
+        let current = startNode;
+        while (current) {
+            if (isERBIfNode(current)) {
+                callback(current);
+                current = current.subsequent;
+            }
+            else if (isERBElseNode(current)) {
+                callback(current);
+                break;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    checkIfChainParts(node) {
+        if (!this.statementsHaveContent(node.statements)) {
+            this.addEmptyBlockOffenseWithEnd(node, node.statements, "if", node.subsequent);
+        }
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (this.statementsHaveContent(current.statements)) {
+                return;
+            }
+            const blockType = isERBIfNode(current) ? "elsif" : "else";
+            const nextSubsequent = isERBIfNode(current) ? current.subsequent : null;
+            if (nextSubsequent) {
+                this.addEmptyBlockOffenseWithEnd(current, current.statements, blockType, nextSubsequent);
+            }
+            else {
+                this.addEmptyBlockOffense(current, current.statements, blockType);
+            }
+        });
+    }
+    isEntireIfChainEmpty(node) {
+        if (this.statementsHaveContent(node.statements)) {
+            return false;
+        }
+        let hasContent = false;
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (this.statementsHaveContent(current.statements)) {
+                hasContent = true;
+            }
+        });
+        return !hasContent;
+    }
+}
+class ERBNoEmptyControlFlowRule extends ParserRule {
+    static ruleName = "erb-no-empty-control-flow";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "hint"
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoEmptyControlFlowVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -2126,6 +2356,15 @@ class ERBNoConditionalOpenTagRule extends ParserRule {
 function getSignificantNodes(statements) {
     return statements.filter(node => !isPureWhitespaceNode(node));
 }
+function trimWhitespaceNodes(nodes) {
+    let start = 0;
+    let end = nodes.length;
+    while (start < end && isPureWhitespaceNode(nodes[start]))
+        start++;
+    while (end > start && isPureWhitespaceNode(nodes[end - 1]))
+        end--;
+    return nodes.slice(start, end);
+}
 function allEquivalentElements(nodes) {
     if (nodes.length < 2)
         return false;
@@ -2243,9 +2482,19 @@ class ERBNoDuplicateBranchElementsVisitor extends BaseRuleVisitor {
         if (isERBIfNode(node)) {
             this.markSubsequentIfNodesAsProcessed(node);
         }
+        if (this.allBranchesIdentical(branches)) {
+            this.addOffense("All branches of this conditional have identical content. The conditional can be removed.", node.location, { node: node, allIdentical: true }, "warning");
+            return;
+        }
         const state = { isFirstOffense: true };
         this.checkBranches(branches, node, state);
     }
+    allBranchesIdentical(branches) {
+        if (branches.length < 2)
+            return false;
+        const first = branches[0].map(node => IdentityPrinter.print(node)).join("");
+        return branches.slice(1).every(branch => branch.map(node => IdentityPrinter.print(node)).join("") === first);
+    }
     markSubsequentIfNodesAsProcessed(node) {
         let current = node.subsequent;
         while (current) {
@@ -2279,11 +2528,23 @@ class ERBNoDuplicateBranchElementsVisitor extends BaseRuleVisitor {
         const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]));
         for (const element of elements) {
             const printed = IdentityPrinter.print(element.open_tag);
-            const autofixContext = state.isFirstOffense
-                ? { node: conditionalNode }
-                : undefined;
-            this.addOffense(`The \`${printed}\` element is duplicated across all branches of this conditional and can be moved outside.`, bodiesMatch ? element.location : (element?.open_tag?.location || element.location), autofixContext);
-            state.isFirstOffense = false;
+            if (bodiesMatch) {
+                const autofixContext = state.isFirstOffense
+                    ? { node: conditionalNode }
+                    : undefined;
+                this.addOffense(`The \`${printed}\` element is duplicated across all branches of this conditional and can be moved outside.`, element.location, autofixContext);
+                state.isFirstOffense = false;
+            }
+            else {
+                const autofixContext = state.isFirstOffense
+                    ? { node: conditionalNode }
+                    : undefined;
+                const tagNameLocation = isHTMLOpenTagNode(element.open_tag) && element.open_tag.tag_name?.location
+                    ? element.open_tag.tag_name.location
+                    : element?.open_tag?.location || element.location;
+                this.addOffense(`The \`${printed}\` tag is repeated across all branches with different content. Consider extracting the shared tag outside the conditional.`, tagNameLocation, autofixContext, "hint");
+                state.isFirstOffense = false;
+            }
         }
         if (!bodiesMatch && bodies.every(body => body.length > 0)) {
             this.checkBranches(bodies, conditionalNode, state);
@@ -2312,6 +2573,15 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
         const branches = collectBranches(conditionalNode);
         if (!branches)
             return null;
+        if (offense.autofixContext.allIdentical) {
+            const parentInfo = findParentArray(result.value, conditionalNode);
+            if (!parentInfo)
+                return null;
+            const { array: parentArray, index: conditionalIndex } = parentInfo;
+            const firstBranchContent = trimWhitespaceNodes(branches[0]);
+            parentArray.splice(conditionalIndex, 1, ...firstBranchContent);
+            return result;
+        }
         const significantBranches = branches.map(getSignificantNodes);
         if (significantBranches.some(branch => branch.length === 0))
             return null;
@@ -2325,23 +2595,51 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
             return null;
         let { array: parentArray, index: conditionalIndex } = parentInfo;
         let hasWrapped = false;
+        let didMutate = false;
+        let failedToHoistPrefix = false;
+        let hoistedBefore = false;
         const hoistElement = (elements, position) => {
+            const actualPosition = (position === "before" && failedToHoistPrefix) ? "after" : position;
             const bodiesMatch = elements.every(element => IdentityPrinter.print(element) === IdentityPrinter.print(elements[0]));
             if (bodiesMatch) {
+                if (actualPosition === "after") {
+                    const currentLengths = branches.map(b => getSignificantNodes(b).length);
+                    if (currentLengths.some(l => l !== currentLengths[0]))
+                        return;
+                }
+                if (actualPosition === "after" && position === "before") {
+                    const isAtEnd = branches.every((branch, index) => {
+                        const nodes = getSignificantNodes(branch);
+                        return nodes.length > 0 && nodes[nodes.length - 1] === elements[index];
+                    });
+                    if (!isAtEnd)
+                        return;
+                }
                 for (let i = 0; i < branches.length; i++) {
                     removeNodeFromArray(branches[i], elements[i]);
                 }
-                if (position === "before") {
-                    parentArray.splice(conditionalIndex, 0, elements[0]);
-                    conditionalIndex++;
+                if (actualPosition === "before") {
+                    parentArray.splice(conditionalIndex, 0, elements[0], createLiteral("\n"));
+                    conditionalIndex += 2;
+                    hoistedBefore = true;
                 }
                 else {
-                    parentArray.splice(conditionalIndex + 1, 0, elements[0]);
+                    parentArray.splice(conditionalIndex + 1, 0, createLiteral("\n"), elements[0]);
                 }
+                didMutate = true;
             }
             else {
                 if (hasWrapped)
                     return;
+                const canWrap = branches.every((branch, index) => {
+                    const remaining = getSignificantNodes(branch);
+                    return remaining.length === 1 && remaining[0] === elements[index];
+                });
+                if (!canWrap) {
+                    if (position === "before")
+                        failedToHoistPrefix = true;
+                    return;
+                }
                 for (let i = 0; i < branches.length; i++) {
                     replaceNodeWithBody(branches[i], elements[i]);
                 }
@@ -2350,6 +2648,7 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
                 parentArray = wrapper.body;
                 conditionalIndex = 1;
                 hasWrapped = true;
+                didMutate = true;
             }
         };
         for (let index = 0; index < prefixCount; index++) {
@@ -2360,7 +2659,22 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
             const elements = significantBranches.map(branch => branch[branch.length - 1 - offset]);
             hoistElement(elements, "after");
         }
-        return result;
+        if (!hasWrapped && hoistedBefore) {
+            const remaining = branches.map(branch => getSignificantNodes(branch));
+            if (remaining.every(branch => branch.length === 1) && allEquivalentElements(remaining.map(b => b[0]))) {
+                const elements = remaining.map(b => b[0]);
+                const bodiesMatch = elements.every(el => IdentityPrinter.print(el) === IdentityPrinter.print(elements[0]));
+                if (!bodiesMatch && elements.every(el => el.body.length > 0)) {
+                    for (let i = 0; i < branches.length; i++) {
+                        replaceNodeWithBody(branches[i], elements[i]);
+                    }
+                    const wrapper = createWrapper(elements[0], [createLiteral("\n"), conditionalNode, createLiteral("\n")]);
+                    parentArray[conditionalIndex] = wrapper;
+                    didMutate = true;
+                }
+            }
+        }
+        return didMutate ? result : null;
     }
 }
 
@@ -2886,6 +3200,47 @@ class ERBNoRawOutputInAttributeValueRule extends ParserRule {
     }
 }
 
+function isAssignmentNode(prismNode) {
+    const type = prismNode?.constructor?.name;
+    if (!type)
+        return false;
+    return type.endsWith("WriteNode");
+}
+class ERBNoSilentStatementVisitor extends BaseRuleVisitor {
+    visitERBContentNode(node) {
+        if (isERBOutputNode(node))
+            return;
+        const prismNode = node.prismNode;
+        if (!prismNode)
+            return;
+        if (isAssignmentNode(prismNode))
+            return;
+        const content = node.content?.value?.trim();
+        if (!content)
+            return;
+        this.addOffense(`Avoid using silent ERB tags for statements. Move \`${content}\` to a controller, helper, or presenter.`, node.location);
+    }
+}
+class ERBNoSilentStatementRule extends ParserRule {
+    static ruleName = "erb-no-silent-statement";
+    get defaultConfig() {
+        return {
+            enabled: false,
+            severity: "warning"
+        };
+    }
+    get parserOptions() {
+        return {
+            prism_nodes: true,
+        };
+    }
+    check(result, context) {
+        const visitor = new ERBNoSilentStatementVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+}
+
 class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
     visitHTMLAttributeNameNode(node) {
         const erbNodes = filterERBContentNodes(node.children);
@@ -3148,7 +3503,7 @@ class ERBNoTrailingWhitespaceRule extends ParserRule {
 }
 
 const JS_ATTRIBUTE_PATTERN = /^on/i;
-const SAFE_PATTERN$1 = /\.to_json\s*$|\bj\s*[\s(]|\bescape_javascript\s*[\s(]/;
+const SAFE_PATTERN = /\.to_json\s*$|\bj\s*[\s(]|\bescape_javascript\s*[\s(]/;
 class ERBNoUnsafeJSAttributeVisitor extends AttributeVisitorMixin {
     checkStaticAttributeDynamicValue({ attributeName, valueNodes }) {
         if (!JS_ATTRIBUTE_PATTERN.test(attributeName))
@@ -3159,7 +3514,7 @@ class ERBNoUnsafeJSAttributeVisitor extends AttributeVisitorMixin {
             if (!isERBOutputNode(node))
                 continue;
             const content = node.content?.value?.trim() || "";
-            if (SAFE_PATTERN$1.test(content))
+            if (SAFE_PATTERN.test(content))
                 continue;
             this.addOffense(`Unsafe ERB output in \`${attributeName}\` attribute. Use \`.to_json\`, \`j()\`, or \`escape_javascript()\` to safely encode values.`, node.location);
         }
@@ -3240,7 +3595,27 @@ class ERBNoUnsafeRawRule extends ParserRule {
     }
 }
 
-const SAFE_PATTERN = /\.to_json\b/;
+const SAFE_METHOD_NAMES = new Set([
+    "to_json",
+    "json_escape",
+]);
+const ESCAPE_JAVASCRIPT_METHOD_NAMES = new Set([
+    "j",
+    "escape_javascript",
+]);
+class SafeCallDetector extends PrismVisitor {
+    hasSafeCall = false;
+    hasEscapeJavascriptCall = false;
+    visitCallNode(node) {
+        if (SAFE_METHOD_NAMES.has(node.name)) {
+            this.hasSafeCall = true;
+        }
+        if (ESCAPE_JAVASCRIPT_METHOD_NAMES.has(node.name)) {
+            this.hasEscapeJavascriptCall = true;
+        }
+        this.visitChildNodes(node);
+    }
+}
 class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
         if (!isHTMLOpenTagNode(node.open_tag)) {
@@ -3269,9 +3644,17 @@ class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
                 continue;
             if (!isERBOutputNode(child))
                 continue;
-            const content = child.content?.value?.trim() || "";
-            if (SAFE_PATTERN.test(content))
+            const erbContent = child;
+            const prismNode = erbContent.prismNode;
+            const detector = new SafeCallDetector();
+            if (prismNode)
+                detector.visit(prismNode);
+            if (detector.hasSafeCall)
                 continue;
+            if (detector.hasEscapeJavascriptCall) {
+                this.addOffense("Avoid `j()` / `escape_javascript()` in `<script>` tags. It is only safe inside quoted string literals. Use `.to_json` instead, which is safe in any position.", child.location);
+                continue;
+            }
             this.addOffense("Unsafe ERB output in `<script>` tag. Use `.to_json` to safely serialize values into JavaScript.", child.location);
         }
     }
@@ -3284,6 +3667,11 @@ class ERBNoUnsafeScriptInterpolationRule extends ParserRule {
             severity: "error"
         };
     }
+    get parserOptions() {
+        return {
+            prism_nodes: true,
+        };
+    }
     check(result, context) {
         const visitor = new ERBNoUnsafeScriptInterpolationVisitor(this.ruleName, context);
         visitor.visit(result.value);
@@ -4291,7 +4679,7 @@ class HerbDisableCommentValidRuleNameRule extends ParserRule {
     }
 }
 
-const ALLOWED_TYPES = ["text/javascript"];
+const ALLOWED_TYPES = ["text/javascript", "module", "importmap", "speculationrules"];
 class AllowedScriptTypeVisitor extends BaseRuleVisitor {
     visitHTMLOpenTagNode(node) {
         if (getTagLocalName(node) === "script") {
@@ -4829,6 +5217,47 @@ class HTMLBodyOnlyElementsRule extends ParserRule {
     }
 }
 
+class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
+    checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }) {
+        this.checkAttribute(originalAttributeName, attributeNode);
+    }
+    checkStaticAttributeDynamicValue({ originalAttributeName, attributeNode }) {
+        this.checkAttribute(originalAttributeName, attributeNode);
+    }
+    checkAttribute(attributeName, attributeNode) {
+        if (!isBooleanAttribute(attributeName))
+            return;
+        if (!hasAttributeValue(attributeNode))
+            return;
+        this.addOffense(`Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`, attributeNode.value.location, {
+            node: attributeNode
+        });
+    }
+}
+class HTMLBooleanAttributesNoValueRule extends ParserRule {
+    static autocorrectable = true;
+    static ruleName = "html-boolean-attributes-no-value";
+    get defaultConfig() {
+        return {
+            enabled: true,
+            severity: "error"
+        };
+    }
+    check(result, context) {
+        const visitor = new BooleanAttributesNoValueVisitor(this.ruleName, context);
+        visitor.visit(result.value);
+        return visitor.offenses;
+    }
+    autofix(offense, result, _context) {
+        if (!offense.autofixContext)
+            return null;
+        const { node } = offense.autofixContext;
+        node.equals = null;
+        node.value = null;
+        return result;
+    }
+}
+
 class DetailsHasSummaryVisitor extends BaseRuleVisitor {
     visitHTMLElementNode(node) {
         this.checkDetailsElement(node);
@@ -4878,47 +5307,6 @@ class HTMLDetailsHasSummaryRule extends ParserRule {
     }
 }
 
-class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
-    checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }) {
-        this.checkAttribute(originalAttributeName, attributeNode);
-    }
-    checkStaticAttributeDynamicValue({ originalAttributeName, attributeNode }) {
-        this.checkAttribute(originalAttributeName, attributeNode);
-    }
-    checkAttribute(attributeName, attributeNode) {
-        if (!isBooleanAttribute(attributeName))
-            return;
-        if (!hasAttributeValue(attributeNode))
-            return;
-        this.addOffense(`Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`, attributeNode.value.location, {
-            node: attributeNode
-        });
-    }
-}
-class HTMLBooleanAttributesNoValueRule extends ParserRule {
-    static autocorrectable = true;
-    static ruleName = "html-boolean-attributes-no-value";
-    get defaultConfig() {
-        return {
-            enabled: true,
-            severity: "error"
-        };
-    }
-    check(result, context) {
-        const visitor = new BooleanAttributesNoValueVisitor(this.ruleName, context);
-        visitor.visit(result.value);
-        return visitor.offenses;
-    }
-    autofix(offense, result, _context) {
-        if (!offense.autofixContext)
-            return null;
-        const { node } = offense.autofixContext;
-        node.equals = null;
-        node.value = null;
-        return result;
-    }
-}
-
 class HeadOnlyElementsVisitor extends BaseRuleVisitor {
     elementStack = [];
     visitHTMLElementNode(node) {
@@ -6601,8 +6989,10 @@ class TurboPermanentRequireIdRule extends ParserRule {
 
 const rules = [
     ActionViewNoSilentHelperRule,
+    ActionViewNoSilentRenderRule,
     ERBCommentSyntax,
     ERBNoCaseNodeChildrenRule,
+    ERBNoEmptyControlFlowRule,
     ERBNoConditionalHTMLElementRule,
     ERBNoConditionalOpenTagRule,
     ERBNoDuplicateBranchElementsRule,
@@ -6617,6 +7007,7 @@ const rules = [
     ERBNoOutputInAttributeNameRule,
     ERBNoOutputInAttributePositionRule,
     ERBNoRawOutputInAttributeValueRule,
+    ERBNoSilentStatementRule,
     ERBNoSilentTagInAttributeNameRule,
     ERBNoStatementInScriptRule,
     ERBNoThenInControlFlowRule,
@@ -6648,8 +7039,8 @@ const rules = [
     HTMLAttributeValuesRequireQuotesRule,
     HTMLAvoidBothDisabledAndAriaDisabledRule,
     HTMLBodyOnlyElementsRule,
-    HTMLDetailsHasSummaryRule,
     HTMLBooleanAttributesNoValueRule,
+    HTMLDetailsHasSummaryRule,
     HTMLHeadOnlyElementsRule,
     HTMLIframeHasTitleRule,
     HTMLImgRequireAltRule,
@@ -7207,5 +7598,5 @@ function ruleDocumentationUrl(ruleId) {
     return `${DOCS_BASE_URL}/${ruleId}`;
 }
 
-export { ABSTRACT_ARIA_ROLES, ARIA_ATTRIBUTES, AttributeVisitorMixin, BaseLexerRuleVisitor, BaseRuleVisitor, BaseSourceRuleVisitor, ControlFlowTrackingVisitor, ControlFlowType, DEFAULT_LINTER_PARSER_OPTIONS, DEFAULT_LINT_CONTEXT, DEFAULT_RULE_CONFIG, DOCUMENT_ONLY_TAG_NAMES, ERBCommentSyntax, ERBNoCaseNodeChildrenRule, ERBNoConditionalOpenTagRule, ERBNoDuplicateBranchElementsRule, ERBNoEmptyTagsRule, ERBNoExtraNewLineRule, ERBNoExtraWhitespaceRule, ERBNoInlineCaseConditionsRule, ERBNoInstanceVariablesInPartialsRule, ERBNoJavascriptTagHelperRule, ERBNoOutputControlFlowRule, ERBNoOutputInAttributeNameRule, ERBNoOutputInAttributePositionRule, ERBNoRawOutputInAttributeValueRule, ERBNoSilentTagInAttributeNameRule, ERBNoStatementInScriptRule, ERBNoThenInControlFlowRule, ERBNoTrailingWhitespaceRule, ERBNoUnsafeJSAttributeRule, ERBNoUnsafeRawRule, ERBNoUnsafeScriptInterpolationRule, ERBPreferImageTagHelperRule, ERBRequireTrailingNewlineRule, ERBRequireWhitespaceRule, ERBRightTrimRule, ERBStrictLocalsCommentSyntaxRule, ERBStrictLocalsRequiredRule, HEADING_TAGS, HEAD_AND_BODY_TAG_NAMES, HEAD_ONLY_TAG_NAMES, HTMLAllowedScriptTypeRule, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBodyOnlyElementsRule, HTMLBooleanAttributesNoValueRule, HTMLDetailsHasSummaryRule, HTMLHeadOnlyElementsRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLInputRequireAutocompleteRule, HTMLNavigationHasLabelRule, HTMLNoAbstractRolesRule, HTMLNoAriaHiddenOnBodyRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoDuplicateMetaNamesRule, HTMLNoEmptyAttributesRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoSpaceInTagRule, HTMLNoTitleAttributeRule, HTMLNoUnderscoresInAttributeNamesRule, HTMLRequireClosingTagsRule, HTMLTagNameLowercaseRule, HTML_BLOCK_ELEMENTS, HTML_BOOLEAN_ATTRIBUTES, HTML_INLINE_ELEMENTS, HTML_ONLY_TAG_NAMES, HTML_VOID_ELEMENTS, HerbDisableCommentBaseVisitor, HerbDisableCommentMalformedRule, HerbDisableCommentMissingRulesRule, HerbDisableCommentNoDuplicateRulesRule, HerbDisableCommentNoRedundantAllRule, HerbDisableCommentParsedVisitor, HerbDisableCommentUnnecessaryRule, HerbDisableCommentValidRuleNameRule, LexerRule, Linter, ParserRule, STRICT_LOCALS_PATTERN, SVGTagNameCapitalizationRule, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE, SourceRule, VALID_ARIA_ROLES, createEndOfFileLocation, findNodeAtPosition, findNodeByLocation, findParent, getBasename, hasBalancedParentheses, isBlockElement, isBodyOnlyTag, isBodyTag, isBooleanAttribute, isDocumentOnlyTag, isHeadAndBodyTag, isHeadOnlyTag, isHeadTag, isHtmlOnlyTag, isInlineElement, isPartialFile, isVoidElement, locationFromOffset, locationsEqual, positionFromOffset, ruleDocumentationUrl, rules, splitByTopLevelComma };
+export { ABSTRACT_ARIA_ROLES, ARIA_ATTRIBUTES, ActionViewNoSilentHelperRule, ActionViewNoSilentRenderRule, AttributeVisitorMixin, BaseLexerRuleVisitor, BaseRuleVisitor, BaseSourceRuleVisitor, ControlFlowTrackingVisitor, ControlFlowType, DEFAULT_LINTER_PARSER_OPTIONS, DEFAULT_LINT_CONTEXT, DEFAULT_RULE_CONFIG, DOCUMENT_ONLY_TAG_NAMES, ERBCommentSyntax, ERBNoCaseNodeChildrenRule, ERBNoConditionalOpenTagRule, ERBNoDuplicateBranchElementsRule, ERBNoEmptyControlFlowRule, ERBNoEmptyTagsRule, ERBNoExtraNewLineRule, ERBNoExtraWhitespaceRule, ERBNoInlineCaseConditionsRule, ERBNoInstanceVariablesInPartialsRule, ERBNoJavascriptTagHelperRule, ERBNoOutputControlFlowRule, ERBNoOutputInAttributeNameRule, ERBNoOutputInAttributePositionRule, ERBNoRawOutputInAttributeValueRule, ERBNoSilentStatementRule, ERBNoSilentTagInAttributeNameRule, ERBNoStatementInScriptRule, ERBNoThenInControlFlowRule, ERBNoTrailingWhitespaceRule, ERBNoUnsafeJSAttributeRule, ERBNoUnsafeRawRule, ERBNoUnsafeScriptInterpolationRule, ERBPreferImageTagHelperRule, ERBRequireTrailingNewlineRule, ERBRequireWhitespaceRule, ERBRightTrimRule, ERBStrictLocalsCommentSyntaxRule, ERBStrictLocalsRequiredRule, HEADING_TAGS, HEAD_AND_BODY_TAG_NAMES, HEAD_ONLY_TAG_NAMES, HTMLAllowedScriptTypeRule, HTMLAnchorRequireHrefRule, HTMLAriaLabelIsWellFormattedRule, HTMLAriaLevelMustBeValidRule, HTMLAriaRoleHeadingRequiresLevelRule, HTMLAriaRoleMustBeValidRule, HTMLAttributeDoubleQuotesRule, HTMLAttributeEqualsSpacingRule, HTMLAttributeValuesRequireQuotesRule, HTMLAvoidBothDisabledAndAriaDisabledRule, HTMLBodyOnlyElementsRule, HTMLBooleanAttributesNoValueRule, HTMLDetailsHasSummaryRule, HTMLHeadOnlyElementsRule, HTMLIframeHasTitleRule, HTMLImgRequireAltRule, HTMLInputRequireAutocompleteRule, HTMLNavigationHasLabelRule, HTMLNoAbstractRolesRule, HTMLNoAriaHiddenOnBodyRule, HTMLNoAriaHiddenOnFocusableRule, HTMLNoBlockInsideInlineRule, HTMLNoDuplicateAttributesRule, HTMLNoDuplicateIdsRule, HTMLNoDuplicateMetaNamesRule, HTMLNoEmptyAttributesRule, HTMLNoEmptyHeadingsRule, HTMLNoNestedLinksRule, HTMLNoPositiveTabIndexRule, HTMLNoSelfClosingRule, HTMLNoSpaceInTagRule, HTMLNoTitleAttributeRule, HTMLNoUnderscoresInAttributeNamesRule, HTMLRequireClosingTagsRule, HTMLTagNameLowercaseRule, HTML_BLOCK_ELEMENTS, HTML_BOOLEAN_ATTRIBUTES, HTML_INLINE_ELEMENTS, HTML_ONLY_TAG_NAMES, HTML_VOID_ELEMENTS, HerbDisableCommentBaseVisitor, HerbDisableCommentMalformedRule, HerbDisableCommentMissingRulesRule, HerbDisableCommentNoDuplicateRulesRule, HerbDisableCommentNoRedundantAllRule, HerbDisableCommentParsedVisitor, HerbDisableCommentUnnecessaryRule, HerbDisableCommentValidRuleNameRule, LexerRule, Linter, ParserRule, STRICT_LOCALS_PATTERN, SVGTagNameCapitalizationRule, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE, SourceRule, VALID_ARIA_ROLES, createEndOfFileLocation, findNodeAtPosition, findNodeByLocation, findParent, getBasename, hasBalancedParentheses, isBlockElement, isBodyOnlyTag, isBodyTag, isBooleanAttribute, isDocumentOnlyTag, isHeadAndBodyTag, isHeadOnlyTag, isHeadTag, isHtmlOnlyTag, isInlineElement, isPartialFile, isVoidElement, locationFromOffset, locationsEqual, positionFromOffset, ruleDocumentationUrl, rules, splitByTopLevelComma };
 //# sourceMappingURL=index.js.map