@herb-tools/linter 0.9.0 → 0.9.1

package/dist/index.cjs

@@ -441,6 +441,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);
     }
@@ -991,7 +997,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,
@@ -1000,6 +1006,7 @@ class ParserRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1019,7 +1026,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,
@@ -1028,6 +1035,7 @@ class LexerRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1053,7 +1061,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,
@@ -1062,6 +1070,7 @@ class SourceRule {
             location,
             autofixContext,
             severity,
+            tags,
         };
     }
 }
@@ -1087,7 +1096,7 @@ class BaseRuleVisitor extends core.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,
@@ -1096,13 +1105,14 @@ class BaseRuleVisitor extends core.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));
     }
 }
 /**
@@ -1378,7 +1388,7 @@ class AttributeVisitorMixin extends BaseRuleVisitor {
         core.forEachAttribute(node, (attributeNode) => {
             const staticAttributeName = core.getAttributeName(attributeNode);
             const originalAttributeName = core.getAttributeName(attributeNode, false) || "";
-            const isDynamicName = core.hasDynamicAttributeNameOnAttribute(attributeNode);
+            const isDynamicName = core.hasDynamicAttributeName(attributeNode);
             const staticAttributeValue = core.getStaticAttributeValue(attributeNode);
             const valueNodes = core.getAttributeValueNodes(attributeNode);
             const hasOutputERB = core.hasERBOutput(valueNodes);
@@ -1455,7 +1465,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,
@@ -1464,13 +1474,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
@@ -1511,7 +1522,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,
@@ -1520,13 +1531,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
@@ -1876,6 +1888,34 @@ class ActionViewNoSilentHelperRule extends ParserRule {
     }
 }
 
+class ActionViewNoSilentRenderVisitor extends BaseRuleVisitor {
+    visitERBRenderNode(node) {
+        if (!core.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 || "";
@@ -1940,7 +1980,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);
             }
         }
     }
@@ -1970,6 +2012,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 = core.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 (core.isHTMLTextNode(statement)) {
+                return statement.content.trim() !== "";
+            }
+            return true;
+        });
+    }
+    markIfChainAsProcessed(node) {
+        this.processedIfNodes.add(node);
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (core.isERBIfNode(current)) {
+                this.processedIfNodes.add(current);
+            }
+        });
+    }
+    markElseNodesInIfChain(node) {
+        this.traverseSubsequentNodes(node.subsequent, (current) => {
+            if (core.isERBElseNode(current)) {
+                this.processedElseNodes.add(current);
+            }
+        });
+    }
+    traverseSubsequentNodes(startNode, callback) {
+        let current = startNode;
+        while (current) {
+            if (core.isERBIfNode(current)) {
+                callback(current);
+                current = current.subsequent;
+            }
+            else if (core.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 = core.isERBIfNode(current) ? "elsif" : "else";
+            const nextSubsequent = core.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; }
@@ -2128,6 +2357,15 @@ class ERBNoConditionalOpenTagRule extends ParserRule {
 function getSignificantNodes(statements) {
     return statements.filter(node => !core.isPureWhitespaceNode(node));
 }
+function trimWhitespaceNodes(nodes) {
+    let start = 0;
+    let end = nodes.length;
+    while (start < end && core.isPureWhitespaceNode(nodes[start]))
+        start++;
+    while (end > start && core.isPureWhitespaceNode(nodes[end - 1]))
+        end--;
+    return nodes.slice(start, end);
+}
 function allEquivalentElements(nodes) {
     if (nodes.length < 2)
         return false;
@@ -2245,9 +2483,19 @@ class ERBNoDuplicateBranchElementsVisitor extends BaseRuleVisitor {
         if (core.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) {
@@ -2281,11 +2529,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 = core.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);
@@ -2314,6 +2574,15 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
         const branches = collectBranches(conditionalNode);
         if (!branches)
             return null;
+        if (offense.autofixContext.allIdentical) {
+            const parentInfo = core.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;
@@ -2327,23 +2596,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++) {
                     core.removeNodeFromArray(branches[i], elements[i]);
                 }
-                if (position === "before") {
-                    parentArray.splice(conditionalIndex, 0, elements[0]);
-                    conditionalIndex++;
+                if (actualPosition === "before") {
+                    parentArray.splice(conditionalIndex, 0, elements[0], core.createLiteral("\n"));
+                    conditionalIndex += 2;
+                    hoistedBefore = true;
                 }
                 else {
-                    parentArray.splice(conditionalIndex + 1, 0, elements[0]);
+                    parentArray.splice(conditionalIndex + 1, 0, core.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++) {
                     core.replaceNodeWithBody(branches[i], elements[i]);
                 }
@@ -2352,6 +2649,7 @@ class ERBNoDuplicateBranchElementsRule extends ParserRule {
                 parentArray = wrapper.body;
                 conditionalIndex = 1;
                 hasWrapped = true;
+                didMutate = true;
             }
         };
         for (let index = 0; index < prefixCount; index++) {
@@ -2362,7 +2660,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++) {
+                        core.replaceNodeWithBody(branches[i], elements[i]);
+                    }
+                    const wrapper = createWrapper(elements[0], [core.createLiteral("\n"), conditionalNode, core.createLiteral("\n")]);
+                    parentArray[conditionalIndex] = wrapper;
+                    didMutate = true;
+                }
+            }
+        }
+        return didMutate ? result : null;
     }
 }
 
@@ -2888,6 +3201,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 (core.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 = core.filterERBContentNodes(node.children);
@@ -3150,7 +3504,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))
@@ -3161,7 +3515,7 @@ class ERBNoUnsafeJSAttributeVisitor extends AttributeVisitorMixin {
             if (!core.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);
         }
@@ -3242,7 +3596,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 core.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 (!core.isHTMLOpenTagNode(node.open_tag)) {
@@ -3271,9 +3645,17 @@ class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
                 continue;
             if (!core.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);
         }
     }
@@ -3286,6 +3668,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);
@@ -4293,7 +4680,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 (core.getTagLocalName(node) === "script") {
@@ -4831,6 +5218,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 (!core.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);
@@ -4880,47 +5308,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 (!core.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) {
@@ -6603,8 +6990,10 @@ class TurboPermanentRequireIdRule extends ParserRule {
 
 const rules = [
     ActionViewNoSilentHelperRule,
+    ActionViewNoSilentRenderRule,
     ERBCommentSyntax,
     ERBNoCaseNodeChildrenRule,
+    ERBNoEmptyControlFlowRule,
     ERBNoConditionalHTMLElementRule,
     ERBNoConditionalOpenTagRule,
     ERBNoDuplicateBranchElementsRule,
@@ -6619,6 +7008,7 @@ const rules = [
     ERBNoOutputInAttributeNameRule,
     ERBNoOutputInAttributePositionRule,
     ERBNoRawOutputInAttributeValueRule,
+    ERBNoSilentStatementRule,
     ERBNoSilentTagInAttributeNameRule,
     ERBNoStatementInScriptRule,
     ERBNoThenInControlFlowRule,
@@ -6650,8 +7040,8 @@ const rules = [
     HTMLAttributeValuesRequireQuotesRule,
     HTMLAvoidBothDisabledAndAriaDisabledRule,
     HTMLBodyOnlyElementsRule,
-    HTMLDetailsHasSummaryRule,
     HTMLBooleanAttributesNoValueRule,
+    HTMLDetailsHasSummaryRule,
     HTMLHeadOnlyElementsRule,
     HTMLIframeHasTitleRule,
     HTMLImgRequireAltRule,
@@ -7209,8 +7599,82 @@ function ruleDocumentationUrl(ruleId) {
     return `${DOCS_BASE_URL}/${ruleId}`;
 }
 
+Object.defineProperty(exports, "findAttributeByName", {
+    enumerable: true,
+    get: function () { return core.findAttributeByName; }
+});
+Object.defineProperty(exports, "getAttribute", {
+    enumerable: true,
+    get: function () { return core.getAttribute; }
+});
+Object.defineProperty(exports, "getAttributeName", {
+    enumerable: true,
+    get: function () { return core.getAttributeName; }
+});
+Object.defineProperty(exports, "getAttributeValue", {
+    enumerable: true,
+    get: function () { return core.getAttributeValue; }
+});
+Object.defineProperty(exports, "getAttributeValueNodes", {
+    enumerable: true,
+    get: function () { return core.getAttributeValueNodes; }
+});
+Object.defineProperty(exports, "getAttributeValueQuoteType", {
+    enumerable: true,
+    get: function () { return core.getAttributeValueQuoteType; }
+});
+Object.defineProperty(exports, "getAttributes", {
+    enumerable: true,
+    get: function () { return core.getAttributes; }
+});
+Object.defineProperty(exports, "getCombinedAttributeNameString", {
+    enumerable: true,
+    get: function () { return core.getCombinedAttributeNameString; }
+});
+Object.defineProperty(exports, "getStaticAttributeValue", {
+    enumerable: true,
+    get: function () { return core.getStaticAttributeValue; }
+});
+Object.defineProperty(exports, "getStaticAttributeValueContent", {
+    enumerable: true,
+    get: function () { return core.getStaticAttributeValueContent; }
+});
+Object.defineProperty(exports, "getTagName", {
+    enumerable: true,
+    get: function () { return core.getTagName; }
+});
+Object.defineProperty(exports, "hasAttribute", {
+    enumerable: true,
+    get: function () { return core.hasAttribute; }
+});
+Object.defineProperty(exports, "hasAttributeValue", {
+    enumerable: true,
+    get: function () { return core.hasAttributeValue; }
+});
+Object.defineProperty(exports, "hasDynamicAttributeName", {
+    enumerable: true,
+    get: function () { return core.hasDynamicAttributeName; }
+});
+Object.defineProperty(exports, "hasDynamicAttributeValue", {
+    enumerable: true,
+    get: function () { return core.hasDynamicAttributeValue; }
+});
+Object.defineProperty(exports, "hasStaticAttributeValue", {
+    enumerable: true,
+    get: function () { return core.hasStaticAttributeValue; }
+});
+Object.defineProperty(exports, "hasStaticAttributeValueContent", {
+    enumerable: true,
+    get: function () { return core.hasStaticAttributeValueContent; }
+});
+Object.defineProperty(exports, "isAttributeValueQuoted", {
+    enumerable: true,
+    get: function () { return core.isAttributeValueQuoted; }
+});
 exports.ABSTRACT_ARIA_ROLES = ABSTRACT_ARIA_ROLES;
 exports.ARIA_ATTRIBUTES = ARIA_ATTRIBUTES;
+exports.ActionViewNoSilentHelperRule = ActionViewNoSilentHelperRule;
+exports.ActionViewNoSilentRenderRule = ActionViewNoSilentRenderRule;
 exports.AttributeVisitorMixin = AttributeVisitorMixin;
 exports.BaseLexerRuleVisitor = BaseLexerRuleVisitor;
 exports.BaseRuleVisitor = BaseRuleVisitor;
@@ -7224,6 +7688,7 @@ exports.ERBCommentSyntax = ERBCommentSyntax;
 exports.ERBNoCaseNodeChildrenRule = ERBNoCaseNodeChildrenRule;
 exports.ERBNoConditionalOpenTagRule = ERBNoConditionalOpenTagRule;
 exports.ERBNoDuplicateBranchElementsRule = ERBNoDuplicateBranchElementsRule;
+exports.ERBNoEmptyControlFlowRule = ERBNoEmptyControlFlowRule;
 exports.ERBNoEmptyTagsRule = ERBNoEmptyTagsRule;
 exports.ERBNoExtraNewLineRule = ERBNoExtraNewLineRule;
 exports.ERBNoExtraWhitespaceRule = ERBNoExtraWhitespaceRule;
@@ -7234,6 +7699,7 @@ exports.ERBNoOutputControlFlowRule = ERBNoOutputControlFlowRule;
 exports.ERBNoOutputInAttributeNameRule = ERBNoOutputInAttributeNameRule;
 exports.ERBNoOutputInAttributePositionRule = ERBNoOutputInAttributePositionRule;
 exports.ERBNoRawOutputInAttributeValueRule = ERBNoRawOutputInAttributeValueRule;
+exports.ERBNoSilentStatementRule = ERBNoSilentStatementRule;
 exports.ERBNoSilentTagInAttributeNameRule = ERBNoSilentTagInAttributeNameRule;
 exports.ERBNoStatementInScriptRule = ERBNoStatementInScriptRule;
 exports.ERBNoThenInControlFlowRule = ERBNoThenInControlFlowRule;