@herb-tools/linter 0.9.0 → 0.9.1

package/src/rules/erb-no-empty-control-flow.ts

@@ -0,0 +1,255 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+import { isHTMLTextNode, isERBIfNode, isERBElseNode, Location } from "@herb-tools/core"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type {
+  Node,
+  ERBIfNode,
+  ERBElseNode,
+  ERBUnlessNode,
+  ERBForNode,
+  ERBWhileNode,
+  ERBUntilNode,
+  ERBWhenNode,
+  ERBBeginNode,
+  ERBRescueNode,
+  ERBEnsureNode,
+  ERBBlockNode,
+  ERBInNode,
+  ParseResult,
+} from "@herb-tools/core"
+
+class ERBNoEmptyControlFlowVisitor extends BaseRuleVisitor {
+  private processedIfNodes: Set<ERBIfNode> = new Set()
+  private processedElseNodes: Set<ERBElseNode> = new Set()
+
+  visitERBIfNode(node: ERBIfNode): void {
+    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: ERBElseNode): void {
+    if (this.processedElseNodes.has(node)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    this.addEmptyBlockOffense(node, node.statements, "else")
+    this.visitChildNodes(node)
+  }
+
+  visitERBUnlessNode(node: ERBUnlessNode): void {
+    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: ERBForNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "for")
+    this.visitChildNodes(node)
+  }
+
+  visitERBWhileNode(node: ERBWhileNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "while")
+    this.visitChildNodes(node)
+  }
+
+  visitERBUntilNode(node: ERBUntilNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "until")
+    this.visitChildNodes(node)
+  }
+
+  visitERBWhenNode(node: ERBWhenNode): void {
+    if (!node.then_keyword) {
+      this.addEmptyBlockOffense(node, node.statements, "when")
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBInNode(node: ERBInNode): void {
+    if (!node.then_keyword) {
+      this.addEmptyBlockOffense(node, node.statements, "in")
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBBeginNode(node: ERBBeginNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "begin")
+    this.visitChildNodes(node)
+  }
+
+  visitERBRescueNode(node: ERBRescueNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "rescue")
+    this.visitChildNodes(node)
+  }
+
+  visitERBEnsureNode(node: ERBEnsureNode): void {
+    this.addEmptyBlockOffense(node, node.statements, "ensure")
+    this.visitChildNodes(node)
+  }
+
+  visitERBBlockNode(node: ERBBlockNode): void {
+    this.addEmptyBlockOffense(node, node.body, "do")
+    this.visitChildNodes(node)
+  }
+
+  private addEmptyBlockOffense(node: Node, statements: Node[], blockType: string): void {
+    this.addEmptyBlockOffenseWithEnd(node, statements, blockType, null)
+  }
+
+  private addEmptyBlockOffenseWithEnd(node: Node, statements: Node[], blockType: string, subsequentNode: Node | null): void {
+    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)
+  }
+
+  private statementsHaveContent(statements: Node[]): boolean {
+    return statements.some(statement => {
+      if (isHTMLTextNode(statement)) {
+        return statement.content.trim() !== ""
+      }
+
+      return true
+    })
+  }
+
+  private markIfChainAsProcessed(node: ERBIfNode): void {
+    this.processedIfNodes.add(node)
+    this.traverseSubsequentNodes(node.subsequent, (current) => {
+      if (isERBIfNode(current)) {
+        this.processedIfNodes.add(current)
+      }
+    })
+  }
+
+  private markElseNodesInIfChain(node: ERBIfNode): void {
+    this.traverseSubsequentNodes(node.subsequent, (current) => {
+      if (isERBElseNode(current)) {
+        this.processedElseNodes.add(current)
+      }
+    })
+  }
+
+  private traverseSubsequentNodes(startNode: Node | null, callback: (node: ERBIfNode | ERBElseNode) => void): void {
+    let current: Node | null = startNode
+    while (current) {
+      if (isERBIfNode(current)) {
+        callback(current)
+        current = current.subsequent
+      } else if (isERBElseNode(current)) {
+        callback(current)
+        break
+      } else {
+        break
+      }
+    }
+  }
+
+  private checkIfChainParts(node: ERBIfNode): void {
+    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)
+      }
+    })
+  }
+
+  private isEntireIfChainEmpty(node: ERBIfNode): boolean {
+    if (this.statementsHaveContent(node.statements)) {
+      return false
+    }
+
+    let hasContent = false
+    this.traverseSubsequentNodes(node.subsequent, (current) => {
+      if (this.statementsHaveContent(current.statements)) {
+        hasContent = true
+      }
+    })
+
+    return !hasContent
+  }
+}
+
+export class ERBNoEmptyControlFlowRule extends ParserRule {
+  static ruleName = "erb-no-empty-control-flow"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "hint"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoEmptyControlFlowVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-no-silent-statement.ts

@@ -0,0 +1,58 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import { isERBOutputNode, PrismNode } from "@herb-tools/core"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, ERBContentNode, ParserOptions } from "@herb-tools/core"
+
+function isAssignmentNode(prismNode: PrismNode): boolean {
+  const type: string = prismNode?.constructor?.name
+  if (!type) return false
+
+  return type.endsWith("WriteNode")
+}
+
+class ERBNoSilentStatementVisitor extends BaseRuleVisitor {
+  visitERBContentNode(node: ERBContentNode): void {
+    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,
+    )
+  }
+}
+
+export class ERBNoSilentStatementRule extends ParserRule {
+  static ruleName = "erb-no-silent-statement"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "warning"
+    }
+  }
+
+  get parserOptions(): Partial<ParserOptions> {
+    return {
+      prism_nodes: true,
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoSilentStatementVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-no-unsafe-script-interpolation.ts

@@ -1,5 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
+import { PrismVisitor } from "@herb-tools/core"
+
 import {
   getTagLocalName,
   getAttribute,
@@ -10,9 +12,34 @@ import {
 } from "@herb-tools/core"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
-import type { ParseResult, HTMLElementNode, Node } from "@herb-tools/core"
+import type { ParseResult, HTMLElementNode, Node, ERBContentNode, ParserOptions, PrismNode } from "@herb-tools/core"
+
+const SAFE_METHOD_NAMES = new Set([
+  "to_json",
+  "json_escape",
+])
+
+const ESCAPE_JAVASCRIPT_METHOD_NAMES = new Set([
+  "j",
+  "escape_javascript",
+])
+
+class SafeCallDetector extends PrismVisitor {
+  public hasSafeCall = false
+  public hasEscapeJavascriptCall = false
+
+  visitCallNode(node: PrismNode): void {
+    if (SAFE_METHOD_NAMES.has(node.name)) {
+      this.hasSafeCall = true
+    }
+
+    if (ESCAPE_JAVASCRIPT_METHOD_NAMES.has(node.name)) {
+      this.hasEscapeJavascriptCall = true
+    }
 
-const SAFE_PATTERN = /\.to_json\b/
+    this.visitChildNodes(node)
+  }
+}
 
 class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -35,7 +62,6 @@ class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
     const typeValue = typeAttribute ? getStaticAttributeValue(typeAttribute) : null
 
     if (typeValue === "text/html") return
-
     if (!node.body || node.body.length === 0) return
 
     this.checkNodesForUnsafeOutput(node.body)
@@ -46,9 +72,21 @@ class ERBNoUnsafeScriptInterpolationVisitor extends BaseRuleVisitor {
       if (!isERBNode(child)) continue
       if (!isERBOutputNode(child)) continue
 
-      const content = child.content?.value?.trim() || ""
+      const erbContent = child as ERBContentNode
+      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,
+        )
 
-      if (SAFE_PATTERN.test(content)) continue
+        continue
+      }
 
       this.addOffense(
         "Unsafe ERB output in `<script>` tag. Use `.to_json` to safely serialize values into JavaScript.",
@@ -68,9 +106,17 @@ export class ERBNoUnsafeScriptInterpolationRule extends ParserRule {
     }
   }
 
+  get parserOptions(): Partial<ParserOptions> {
+    return {
+      prism_nodes: true,
+    }
+  }
+
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new ERBNoUnsafeScriptInterpolationVisitor(this.ruleName, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
 }

package/src/rules/html-allowed-script-type.ts

@@ -5,10 +5,10 @@ import { getTagLocalName, getAttribute, getStaticAttributeValue, hasAttributeVal
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLAttributeNode, HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
-const ALLOWED_TYPES = ["text/javascript"]
 // NOTE: Rules are not configurable for now, keep some sane defaults
 //   See https://github.com/marcoroth/herb/issues/1204
 const ALLOW_BLANK = true
+const ALLOWED_TYPES = ["text/javascript", "module", "importmap", "speculationrules"]
 
 class AllowedScriptTypeVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {

package/src/rules/index.ts

@@ -3,40 +3,45 @@ export * from "./file-utils.js"
 export * from "./string-utils.js"
 export * from "./herb-disable-comment-base.js"
 
+export * from "./actionview-no-silent-helper.js"
+export * from "./actionview-no-silent-render.js"
+
 export * from "./erb-comment-syntax.js"
 export * from "./erb-no-case-node-children.js"
-export * from "./erb-no-inline-case-conditions.js"
+export * from "./erb-no-empty-control-flow.js"
 export * from "./erb-no-conditional-open-tag.js"
 export * from "./erb-no-duplicate-branch-elements.js"
 export * from "./erb-no-empty-tags.js"
 export * from "./erb-no-extra-newline.js"
 export * from "./erb-no-extra-whitespace-inside-tags.js"
-export * from "./erb-no-output-control-flow.js"
-export * from "./erb-no-then-in-control-flow.js"
-export * from "./erb-no-silent-tag-in-attribute-name.js"
-export * from "./erb-no-trailing-whitespace.js"
-export * from "./erb-prefer-image-tag-helper.js"
-export * from "./erb-require-trailing-newline.js"
-export * from "./erb-require-whitespace-inside-tags.js"
+export * from "./erb-no-inline-case-conditions.js"
+export * from "./erb-no-instance-variables-in-partials.js"
 export * from "./erb-no-javascript-tag-helper.js"
+export * from "./erb-no-output-control-flow.js"
+export * from "./erb-no-output-in-attribute-name.js"
+export * from "./erb-no-output-in-attribute-position.js"
 export * from "./erb-no-raw-output-in-attribute-value.js"
+export * from "./erb-no-silent-statement.js"
+export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-no-statement-in-script.js"
+export * from "./erb-no-then-in-control-flow.js"
+export * from "./erb-no-trailing-whitespace.js"
 export * from "./erb-no-unsafe-js-attribute.js"
 export * from "./erb-no-unsafe-raw.js"
 export * from "./erb-no-unsafe-script-interpolation.js"
+export * from "./erb-prefer-image-tag-helper.js"
+export * from "./erb-require-trailing-newline.js"
+export * from "./erb-require-whitespace-inside-tags.js"
 export * from "./erb-right-trim.js"
-export * from "./erb-no-output-in-attribute-position.js"
-export * from "./erb-no-output-in-attribute-name.js"
-export * from "./erb-no-instance-variables-in-partials.js"
 export * from "./erb-strict-locals-comment-syntax.js"
 export * from "./erb-strict-locals-required.js"
 
-export * from "./herb-disable-comment-valid-rule-name.js"
-export * from "./herb-disable-comment-no-redundant-all.js"
-export * from "./herb-disable-comment-no-duplicate-rules.js"
-export * from "./herb-disable-comment-missing-rules.js"
 export * from "./herb-disable-comment-malformed.js"
+export * from "./herb-disable-comment-missing-rules.js"
+export * from "./herb-disable-comment-no-duplicate-rules.js"
+export * from "./herb-disable-comment-no-redundant-all.js"
 export * from "./herb-disable-comment-unnecessary.js"
+export * from "./herb-disable-comment-valid-rule-name.js"
 
 export * from "./html-allowed-script-type.js"
 export * from "./html-anchor-require-href.js"
@@ -49,8 +54,8 @@ export * from "./html-attribute-equals-spacing.js"
 export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
 export * from "./html-body-only-elements.js"
-export * from "./html-details-has-summary.js"
 export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-details-has-summary.js"
 export * from "./html-head-only-elements.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"

package/src/rules/rule-utils.ts

@@ -7,7 +7,7 @@ import {
   getValidatableStaticContent,
   getAttributeName,
   getStaticAttributeValue,
-  hasDynamicAttributeNameOnAttribute as hasDynamicAttributeName,
+  hasDynamicAttributeName,
   getCombinedAttributeNameString,
   getAttributeValueNodes,
   getAttributeValue,
@@ -27,6 +27,7 @@ import type {
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 import type * as Nodes from "@herb-tools/core"
+import type { DiagnosticTag } from "@herb-tools/core"
 import type { UnboundLintOffense, LintContext, LintSeverity, BaseAutofixContext } from "../types.js"
 
 export enum ControlFlowType {
@@ -53,7 +54,7 @@ export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -62,14 +63,15 @@ export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext
       location,
       autofixContext,
       severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 }
 
@@ -515,7 +517,7 @@ export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixCo
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -524,14 +526,15 @@ export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixCo
       location,
       autofixContext,
       severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 
   /**
@@ -578,7 +581,7 @@ export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixC
    * Helper method to create an unbound lint offense (without severity).
    * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): UnboundLintOffense<TAutofixContext> {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
@@ -587,14 +590,15 @@ export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixC
       location,
       autofixContext,
       severity,
+      tags,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity): void {
-    this.offenses.push(this.createOffense(message, location, autofixContext, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext, severity?: LintSeverity, tags?: DiagnosticTag[]): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext, severity, tags))
   }
 
   /**

package/src/rules.ts

@@ -1,9 +1,11 @@
 import type { RuleClass } from "./types.js"
 
 import { ActionViewNoSilentHelperRule } from "./rules/actionview-no-silent-helper.js"
+import { ActionViewNoSilentRenderRule } from "./rules/actionview-no-silent-render.js"
 
 import { ERBCommentSyntax } from "./rules/erb-comment-syntax.js";
 import { ERBNoCaseNodeChildrenRule } from "./rules/erb-no-case-node-children.js"
+import { ERBNoEmptyControlFlowRule } from "./rules/erb-no-empty-control-flow.js"
 import { ERBNoConditionalHTMLElementRule } from "./rules/erb-no-conditional-html-element.js"
 import { ERBNoConditionalOpenTagRule } from "./rules/erb-no-conditional-open-tag.js"
 import { ERBNoDuplicateBranchElementsRule } from "./rules/erb-no-duplicate-branch-elements.js"
@@ -18,6 +20,7 @@ import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.j
 import { ERBNoOutputInAttributeNameRule } from "./rules/erb-no-output-in-attribute-name.js"
 import { ERBNoOutputInAttributePositionRule } from "./rules/erb-no-output-in-attribute-position.js"
 import { ERBNoRawOutputInAttributeValueRule } from "./rules/erb-no-raw-output-in-attribute-value.js"
+import { ERBNoSilentStatementRule } from "./rules/erb-no-silent-statement.js"
 import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
 import { ERBNoStatementInScriptRule } from "./rules/erb-no-statement-in-script.js"
 import { ERBNoThenInControlFlowRule } from "./rules/erb-no-then-in-control-flow.js"
@@ -51,8 +54,8 @@ import { HTMLAttributeEqualsSpacingRule } from "./rules/html-attribute-equals-sp
 import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-values-require-quotes.js"
 import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-both-disabled-and-aria-disabled.js"
 import { HTMLBodyOnlyElementsRule } from "./rules/html-body-only-elements.js"
-import { HTMLDetailsHasSummaryRule } from "./rules/html-details-has-summary.js"
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
+import { HTMLDetailsHasSummaryRule } from "./rules/html-details-has-summary.js"
 import { HTMLHeadOnlyElementsRule } from "./rules/html-head-only-elements.js"
 import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
@@ -84,9 +87,11 @@ import { TurboPermanentRequireIdRule } from "./rules/turbo-permanent-require-id.
 
 export const rules: RuleClass[] = [
   ActionViewNoSilentHelperRule,
+  ActionViewNoSilentRenderRule,
 
   ERBCommentSyntax,
   ERBNoCaseNodeChildrenRule,
+  ERBNoEmptyControlFlowRule,
   ERBNoConditionalHTMLElementRule,
   ERBNoConditionalOpenTagRule,
   ERBNoDuplicateBranchElementsRule,
@@ -101,6 +106,7 @@ export const rules: RuleClass[] = [
   ERBNoOutputInAttributeNameRule,
   ERBNoOutputInAttributePositionRule,
   ERBNoRawOutputInAttributeValueRule,
+  ERBNoSilentStatementRule,
   ERBNoSilentTagInAttributeNameRule,
   ERBNoStatementInScriptRule,
   ERBNoThenInControlFlowRule,
@@ -134,8 +140,8 @@ export const rules: RuleClass[] = [
   HTMLAttributeValuesRequireQuotesRule,
   HTMLAvoidBothDisabledAndAriaDisabledRule,
   HTMLBodyOnlyElementsRule,
-  HTMLDetailsHasSummaryRule,
   HTMLBooleanAttributesNoValueRule,
+  HTMLDetailsHasSummaryRule,
   HTMLHeadOnlyElementsRule,
   HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,