@herb-tools/linter 0.4.3 → 0.6.0

package/src/cli.ts

@@ -1,14 +1,41 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
-import { ArgumentParser } from "./cli/argument-parser.js"
+import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
-import { SimpleFormatter, DetailedFormatter } from "./cli/formatters/index.js"
-import { SummaryReporter } from "./cli/summary-reporter.js"
+import { OutputManager } from "./cli/output-manager.js"
 
 export class CLI {
   private argumentParser = new ArgumentParser()
   private fileProcessor = new FileProcessor()
-  private summaryReporter = new SummaryReporter()
+  private outputManager = new OutputManager()
+
+  private exitWithError(message: string, formatOption: FormatOption, exitCode: number = 1) {
+    this.outputManager.outputError(message, { 
+      formatOption, 
+      theme: 'auto', 
+      wrapLines: false, 
+      truncateLines: false, 
+      showTiming: false, 
+      startTime: 0, 
+      startDate: new Date() 
+    })
+    process.exit(exitCode)
+  }
+
+  private exitWithInfo(message: string, formatOption: FormatOption, exitCode: number = 0, timingData?: { startTime: number, startDate: Date, showTiming: boolean }) {
+    const outputOptions = {
+      formatOption,
+      theme: 'auto' as const,
+      wrapLines: false,
+      truncateLines: false,
+      showTiming: timingData?.showTiming ?? false,
+      startTime: timingData?.startTime ?? Date.now(),
+      startDate: timingData?.startDate ?? new Date()
+    }
+    
+    this.outputManager.outputInfo(message, outputOptions)
+    process.exit(exitCode)
+  }
 
   async run() {
     const startTime = Date.now()
@@ -16,45 +43,35 @@ export class CLI {
 
     const { pattern, formatOption, showTiming, theme, wrapLines, truncateLines } = this.argumentParser.parse(process.argv)
 
+    const outputOptions = {
+      formatOption,
+      theme,
+      wrapLines,
+      truncateLines,
+      showTiming,
+      startTime,
+      startDate
+    }
+
     try {
       await Herb.load()
 
       const files = await glob(pattern)
 
       if (files.length === 0) {
-        console.log(`No files found matching pattern: ${pattern}`)
-        process.exit(0)
+        this.exitWithInfo(`No files found matching pattern: ${pattern}`, formatOption, 0, { startTime, startDate, showTiming })
       }
 
-      const results = await this.fileProcessor.processFiles(files)
-      const { totalErrors, totalWarnings, filesWithIssues, ruleCount, allDiagnostics, ruleViolations } = results
-
-      const formatter = formatOption === 'simple'
-        ? new SimpleFormatter()
-        : new DetailedFormatter(theme, wrapLines, truncateLines)
-
-      await formatter.format(allDiagnostics, files.length === 1)
-
-      this.summaryReporter.displayMostViolatedRules(ruleViolations)
-      this.summaryReporter.displaySummary({
-        files,
-        totalErrors,
-        totalWarnings,
-        filesWithViolations: filesWithIssues,
-        ruleCount,
-        startTime,
-        startDate,
-        showTiming,
-        ruleViolations
-      })
-
-      if (totalErrors > 0) {
+      const results = await this.fileProcessor.processFiles(files, formatOption)
+      
+      await this.outputManager.outputResults({ ...results, files }, outputOptions)
+
+      if (results.totalErrors > 0) {
         process.exit(1)
       }
 
     } catch (error) {
-      console.error(`Error:`, error)
-      process.exit(1)
+      this.exitWithError(`Error: ${error}`, formatOption)
     }
   }
 }

package/src/default-rules.ts

@@ -2,46 +2,68 @@ import type { RuleClass } from "./types.js"
 
 import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
 import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
+import { ERBNoSilentTagInAttributeNameRule } from "./rules/erb-no-silent-tag-in-attribute-name.js"
 import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
 import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
 import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
 import { HTMLAriaAttributeMustBeValid } from "./rules/html-aria-attribute-must-be-valid.js"
+import { HTMLAriaLabelIsWellFormattedRule } from "./rules/html-aria-label-is-well-formatted.js"
 import { HTMLAriaLevelMustBeValidRule } from "./rules/html-aria-level-must-be-valid.js"
 import { HTMLAriaRoleHeadingRequiresLevelRule } from "./rules/html-aria-role-heading-requires-level.js"
 import { HTMLAriaRoleMustBeValidRule } from "./rules/html-aria-role-must-be-valid.js"
 import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quotes.js"
+import { HTMLAttributeEqualsSpacingRule } from "./rules/html-attribute-equals-spacing.js"
 import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-values-require-quotes.js"
+import { HTMLAvoidBothDisabledAndAriaDisabledRule } from "./rules/html-avoid-both-disabled-and-aria-disabled.js"
 import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
+import { HTMLIframeHasTitleRule } from "./rules/html-iframe-has-title.js"
 import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
+import { HTMLNavigationHasLabelRule } from "./rules/html-navigation-has-label.js"
+import { HTMLNoAriaHiddenOnFocusableRule } from "./rules/html-no-aria-hidden-on-focusable.js"
 // import { HTMLNoBlockInsideInlineRule } from "./rules/html-no-block-inside-inline.js"
 import { HTMLNoDuplicateAttributesRule } from "./rules/html-no-duplicate-attributes.js"
 import { HTMLNoDuplicateIdsRule } from "./rules/html-no-duplicate-ids.js"
 import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
 import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
+import { HTMLNoPositiveTabIndexRule } from "./rules/html-no-positive-tab-index.js"
+import { HTMLNoSelfClosingRule } from "./rules/html-no-self-closing.js"
+import { HTMLNoTitleAttributeRule } from "./rules/html-no-title-attribute.js"
 import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
+import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
 
 export const defaultRules: RuleClass[] = [
   ERBNoEmptyTagsRule,
   ERBNoOutputControlFlowRule,
+  ERBNoSilentTagInAttributeNameRule,
   ERBPreferImageTagHelperRule,
   ERBRequiresTrailingNewlineRule,
   ERBRequireWhitespaceRule,
   HTMLAnchorRequireHrefRule,
   HTMLAriaAttributeMustBeValid,
+  HTMLAriaLabelIsWellFormattedRule,
   HTMLAriaLevelMustBeValidRule,
   HTMLAriaRoleHeadingRequiresLevelRule,
   HTMLAriaRoleMustBeValidRule,
   HTMLAttributeDoubleQuotesRule,
+  HTMLAttributeEqualsSpacingRule,
   HTMLAttributeValuesRequireQuotesRule,
+  HTMLAvoidBothDisabledAndAriaDisabledRule,
   HTMLBooleanAttributesNoValueRule,
+  HTMLIframeHasTitleRule,
   HTMLImgRequireAltRule,
+  HTMLNavigationHasLabelRule,
+  HTMLNoAriaHiddenOnFocusableRule,
   // HTMLNoBlockInsideInlineRule,
   HTMLNoDuplicateAttributesRule,
   HTMLNoDuplicateIdsRule,
   HTMLNoEmptyHeadingsRule,
   HTMLNoNestedLinksRule,
+  HTMLNoPositiveTabIndexRule,
+  HTMLNoSelfClosingRule,
+  HTMLNoTitleAttributeRule,
   HTMLTagNameLowercaseRule,
+  ParserNoErrorsRule,
   SVGTagNameCapitalizationRule,
 ]

package/src/linter.ts

@@ -53,20 +53,46 @@ export class Linter {
   lint(source: string, context?: Partial<LintContext>): LintResult {
     this.offenses = []
 
-    const parseResult = this.herb.parse(source)
+    const parseResult = this.herb.parse(source, { track_whitespace: true })
     const lexResult = this.herb.lex(source)
 
     for (const RuleClass of this.rules) {
       const rule = new RuleClass()
 
+      let isEnabled = true
       let ruleOffenses: LintOffense[]
 
       if (this.isLexerRule(rule)) {
-        ruleOffenses = (rule as LexerRule).check(lexResult, context)
+        if (rule.isEnabled) {
+          isEnabled = rule.isEnabled(lexResult, context)
+        }
+
+        if (isEnabled) {
+          ruleOffenses = (rule as LexerRule).check(lexResult, context)
+        } else {
+          ruleOffenses = []
+        }
+
       } else if (this.isSourceRule(rule)) {
-        ruleOffenses = (rule as SourceRule).check(source, context)
+        if (rule.isEnabled) {
+          isEnabled = rule.isEnabled(source, context)
+        }
+
+        if (isEnabled) {
+          ruleOffenses = (rule as SourceRule).check(source, context)
+        } else {
+          ruleOffenses = []
+        }
       } else {
-        ruleOffenses = (rule as ParserRule).check(parseResult.value, context)
+        if (rule.isEnabled) {
+          isEnabled = rule.isEnabled(parseResult, context)
+        }
+
+        if (isEnabled) {
+          ruleOffenses = (rule as ParserRule).check(parseResult, context)
+        } else {
+          ruleOffenses = []
+        }
       }
 
       this.offenses.push(...ruleOffenses)

package/src/rules/erb-no-empty-tags.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, ERBContentNode } from "@herb-tools/core"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
   visitERBContentNode(node: ERBContentNode): void {
@@ -25,10 +25,10 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
 export class ERBNoEmptyTagsRule extends ParserRule {
   name = "erb-no-empty-tags"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -1,6 +1,6 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Node, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
+import type { ParseResult, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
 
@@ -53,10 +53,10 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
 export class ERBNoOutputControlFlowRule extends ParserRule {
   name = "erb-no-output-control-flow"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/erb-no-silent-tag-in-attribute-name.ts

@@ -0,0 +1,40 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { filterERBContentNodes } from "@herb-tools/core"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNameNode, ERBContentNode } from "@herb-tools/core"
+
+class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
+  visitHTMLAttributeNameNode(node: HTMLAttributeNameNode): void {
+    const erbNodes = filterERBContentNodes(node.children)
+    const silentNodes = erbNodes.filter(this.isSilentERBTag)
+
+    for (const node of silentNodes) {
+      this.addOffense(
+        `Remove silent ERB tag from HTML attribute name. Silent ERB tags (\`${node.tag_opening?.value}\`) do not output content and should not be used in attribute names.`,
+        node.location,
+        "error"
+      )
+    }
+  }
+
+  // TODO: might be worth to extract
+  private isSilentERBTag(node: ERBContentNode): boolean {
+    const silentTags = ["<%", "<%-", "<%#"]
+
+    return silentTags.includes(node.tag_opening?.value || "")
+  }
+}
+
+export class ERBNoSilentTagInAttributeNameRule extends ParserRule {
+  name = "erb-no-silent-tag-in-attribute-name"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoSilentTagInAttributeNameVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-prefer-image-tag-helper.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, findAttributeByName, getAttributes } from
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, ParseResult } from "@herb-tools/core"
 
 class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -10,12 +10,7 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
     super.visitHTMLOpenTagNode(node)
   }
 
-  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
-    this.checkImgTag(node)
-    super.visitHTMLSelfCloseTagNode(node)
-  }
-
-  private checkImgTag(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+  private checkImgTag(node: HTMLOpenTagNode): void {
     const tagName = getTagName(node)
 
     if (tagName !== "img") {
@@ -116,9 +111,9 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
 export class ERBPreferImageTagHelperRule extends ParserRule {
   name = "erb-prefer-image-tag-helper"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBPreferImageTagHelperVisitor(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/erb-require-whitespace-inside-tags.ts

@@ -1,4 +1,4 @@
-import type { Node, Token } from "@herb-tools/core"
+import type { ParseResult, Token, Node } from "@herb-tools/core"
 import { isERBNode } from "@herb-tools/core";
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
@@ -85,9 +85,9 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
 export class ERBRequireWhitespaceRule extends ParserRule {
   name = "erb-require-whitespace-inside-tags"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
-    visitor.visit(node)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/rules/erb-requires-trailing-newline.ts

@@ -21,7 +21,9 @@ export class ERBRequiresTrailingNewlineRule extends SourceRule {
 
   check(source: string, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new ERBRequiresTrailingNewlineVisitor(this.name, context)
+
     visitor.visit(source)
+
     return visitor.offenses
   }
 }

package/src/rules/html-anchor-require-href.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, Node } from "@herb-tools/core"
+import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class AnchorRechireHrefVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -30,10 +30,10 @@ class AnchorRechireHrefVisitor extends BaseRuleVisitor {
 export class HTMLAnchorRequireHrefRule extends ParserRule {
   name = "html-anchor-require-href"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AnchorRechireHrefVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/html-aria-attribute-must-be-valid.ts

@@ -1,42 +1,38 @@
-import {
-  ARIA_ATTRIBUTES,
-  AttributeVisitorMixin,
-} from "./rule-utils.js";
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type {
-  HTMLAttributeNode,
-  HTMLOpenTagNode,
-  HTMLSelfCloseTagNode,
-  Node,
-} from "@herb-tools/core";
+import { ParserRule } from "../types.js"
+import { ARIA_ATTRIBUTES, AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class AriaAttributeMustBeValid extends AttributeVisitorMixin {
-  checkAttribute(
-    attributeName: string,
-    _attributeValue: string | null,
-    attributeNode: HTMLAttributeNode,
-    _parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode,
-  ): void {
-    if (!attributeName.startsWith("aria-")) return;
-
-    if (!ARIA_ATTRIBUTES.has(attributeName)){
-      this.offenses.push({
-        message: `The attribute \`${attributeName}\` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.`,
-        severity: "error",
-        location: attributeNode.location,
-        rule: this.ruleName,
-      });
-    }
+  protected checkStaticAttributeStaticValue({ attributeName, attributeNode }: StaticAttributeStaticValueParams) {
+    this.check(attributeName, attributeNode)
+  }
+
+  protected checkStaticAttributeDynamicValue({ attributeName, attributeNode }: StaticAttributeDynamicValueParams) {
+    this.check(attributeName, attributeNode)
+  }
+
+  private check(attributeName: string, attributeNode: HTMLAttributeNode) {
+    if (!attributeName.startsWith("aria-")) return
+    if (ARIA_ATTRIBUTES.has(attributeName)) return
+
+    this.addOffense(
+      `The attribute \`${attributeName}\` is not a valid ARIA attribute. ARIA attributes must match the WAI-ARIA specification.`,
+      attributeNode.location,
+      "error"
+    )
   }
 }
 
 export class HTMLAriaAttributeMustBeValid extends ParserRule {
-  name = "html-aria-attribute-must-be-valid";
+  name = "html-aria-attribute-must-be-valid"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaAttributeMustBeValid(this.name, context)
+
+    visitor.visit(result.value)
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
-    const visitor = new AriaAttributeMustBeValid(this.name, context);
-    visitor.visit(node);
-    return visitor.offenses;
+    return visitor.offenses
   }
 }

package/src/rules/html-aria-label-is-well-formatted.ts

@@ -0,0 +1,59 @@
+import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, StaticAttributeStaticValueParams } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult } from "@herb-tools/core"
+
+class AriaLabelIsWellFormattedVisitor extends AttributeVisitorMixin {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
+    if (attributeName !== "aria-label") return
+
+    if (attributeValue.match(/[\r\n]+/) || attributeValue.match(/
|
|
|
/i)) {
+      this.addOffense(
+        "The `aria-label` attribute value text should not contain line breaks. Use concise, single-line descriptions.",
+        attributeNode.location,
+        "error"
+      )
+
+      return
+    }
+
+    if (this.looksLikeId(attributeValue)) {
+      this.addOffense(
+        "The `aria-label` attribute value should not be formatted like an ID. Use natural, sentence-case text instead.",
+        attributeNode.location,
+        "error"
+      )
+
+      return
+    }
+
+    if (attributeValue.match(/^[a-z]/)) {
+      this.addOffense(
+        "The `aria-label` attribute value text should be formatted like visual text. Use sentence case (capitalize the first letter).",
+        attributeNode.location,
+        "error"
+      )
+    }
+  }
+
+  private looksLikeId(text: string): boolean {
+    return (
+      text.includes('_') ||
+      text.includes('-') ||
+      /^[a-z]+([A-Z][a-z]*)*$/.test(text)
+    ) && !text.includes(' ')
+  }
+}
+
+export class HTMLAriaLabelIsWellFormattedRule extends ParserRule {
+  name = "html-aria-label-is-well-formatted"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new AriaLabelIsWellFormattedVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-aria-level-must-be-valid.ts

@@ -1,15 +1,48 @@
-import { AttributeVisitorMixin } from "./rule-utils.js"
 import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
+import { getValidatableStaticContent, hasERBOutput, filterLiteralNodes, filterERBContentNodes, isERBOutputNode } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
-  protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode, _parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams) {
     if (attributeName !== "aria-level") return
-    if (attributeValue !== null && attributeValue.includes("<%")) return
 
-    if (attributeValue === null || attributeValue === "") {
+    this.validateAriaLevel(attributeValue, attributeNode)
+  }
+
+  protected checkStaticAttributeDynamicValue({ attributeName, valueNodes, attributeNode }: StaticAttributeDynamicValueParams) {
+    if (attributeName !== "aria-level") return
+
+    const validatableContent = getValidatableStaticContent(valueNodes)
+
+    if (validatableContent !== null) {
+      this.validateAriaLevel(validatableContent, attributeNode)
+      return
+    }
+
+    if (!hasERBOutput(valueNodes)) return
+
+    const literalNodes = filterLiteralNodes(valueNodes)
+    const erbOutputNodes = filterERBContentNodes(valueNodes).filter(isERBOutputNode)
+
+    if (literalNodes.length > 0 && erbOutputNodes.length > 0) {
+      const staticPart = literalNodes.map(node => node.content).join("")
+
+      // TODO: this can be cleaned up using @herb-tools/printer
+      const erbPart = erbOutputNodes[0]
+      const erbText = `${erbPart.tag_opening?.value || ""}${erbPart.content?.value || ""}${erbPart.tag_closing?.value || ""}`
+
+      this.addOffense(
+        `The \`aria-level\` attribute must be an integer between 1 and 6, got \`${staticPart}\` and the ERB expression \`${erbText}\`.`,
+        attributeNode.location,
+      )
+    }
+  }
+
+  private validateAriaLevel(attributeValue: string, attributeNode: HTMLAttributeNode): void {
+    if (!attributeValue || attributeValue === "") {
       this.addOffense(
         `The \`aria-level\` attribute must be an integer between 1 and 6, got an empty value.`,
         attributeNode.location,
@@ -32,10 +65,10 @@ class HTMLAriaLevelMustBeValidVisitor extends AttributeVisitorMixin {
 export class HTMLAriaLevelMustBeValidRule extends ParserRule {
   name = "html-aria-level-must-be-valid"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new HTMLAriaLevelMustBeValidVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

package/src/rules/html-aria-role-heading-requires-level.ts

@@ -1,45 +1,33 @@
-import { AttributeVisitorMixin, getAttributeName, getAttributes } from "./rule-utils.js"
-
 import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, getAttributeName, getAttributes, StaticAttributeStaticValueParams } from "./rule-utils.js"
+
 import type { LintOffense, LintContext } from "../types.js"
-import type { Node, HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode } from "@herb-tools/core"
+import type { ParseResult } from "@herb-tools/core"
 
 class AriaRoleHeadingRequiresLevel extends AttributeVisitorMixin {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode, parentNode }: StaticAttributeStaticValueParams): void {
+    if (!(attributeName === "role" && attributeValue === "heading")) return
+
+    const ariaLevelAttributes = getAttributes(parentNode).find(attribute => getAttributeName(attribute) === "aria-level")
 
-  // We want to check 2 attributes here:
-  // 1. role="heading"
-  // 2. aria-level (which must be present if role="heading")
-  checkAttribute(
-    attributeName: string,
-    attributeValue: string | null,
-    attributeNode: HTMLAttributeNode,
-    parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode
-  ): void {
-
-    if (!(attributeName === "role" && attributeValue === "heading")) {
-      return
-    }
-
-    const allAttributes = getAttributes(parentNode)
-
-    // If we have a role="heading", we must check for aria-level
-    const ariaLevelAttr = allAttributes.find(attr => getAttributeName(attr) === "aria-level")
-    if (!ariaLevelAttr) {
-      this.addOffense(
-        `Element with \`role="heading"\` must have an \`aria-level\` attribute.`,
-        attributeNode.location,
-        "error"
-      )
-    }
+    if (ariaLevelAttributes) return
+
+    this.addOffense(
+      `Element with \`role="heading"\` must have an \`aria-level\` attribute.`,
+      attributeNode.location,
+      "error"
+    )
   }
 }
 
 export class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
   name = "html-aria-role-heading-requires-level"
 
-  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
-    visitor.visit(node)
+
+    visitor.visit(result.value)
+
     return visitor.offenses
   }
 }