@herb-tools/linter 0.5.0 → 0.6.1

package/src/cli/argument-parser.ts

@@ -114,11 +114,6 @@ export class ArgumentParser {
     const theme = values.theme || DEFAULT_THEME
     const pattern = this.getFilePattern(positionals)
 
-    if (positionals.length === 0) {
-      console.error("Please specify input file.")
-      process.exit(1)
-    }
-
     return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines }
   }
 

package/src/default-rules.ts

@@ -2,23 +2,33 @@ 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"
@@ -26,23 +36,33 @@ import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalizatio
 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, 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-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

@@ -1,8 +1,11 @@
+import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, findAttributeByName, getAttributes } from "./rule-utils.js"
 
-import { ParserRule } from "../types.js"
+import { ERBToRubyStringPrinter } from "@herb-tools/printer"
+import { filterNodes, ERBContentNode, LiteralNode, isNode } from "@herb-tools/core"
+
 import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLOpenTagNode, HTMLSelfCloseTagNode, HTMLAttributeValueNode, ERBContentNode, LiteralNode, ParseResult } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
 
 class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
@@ -10,106 +13,80 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
     super.visitHTMLOpenTagNode(node)
   }
 
-  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
-    this.checkImgTag(node)
-    super.visitHTMLSelfCloseTagNode(node)
-  }
-
-  private checkImgTag(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
-    const tagName = getTagName(node)
+  private checkImgTag(openTag: HTMLOpenTagNode): void {
+    const tagName = getTagName(openTag)
 
-    if (tagName !== "img") {
-      return
-    }
+    if (tagName !== "img") return
 
-    const attributes = getAttributes(node)
+    const attributes = getAttributes(openTag)
     const srcAttribute = findAttributeByName(attributes, "src")
 
-    if (!srcAttribute) {
-      return
-    }
-
-    if (!srcAttribute.value) {
-      return
-    }
+    if (!srcAttribute) return
+    if (!srcAttribute.value) return
 
-    const valueNode = srcAttribute.value as HTMLAttributeValueNode
-    const hasERBContent = this.containsERBContent(valueNode)
+    const node = srcAttribute.value
+    const hasERBContent = this.containsERBContent(node)
 
     if (hasERBContent) {
-      const suggestedExpression = this.buildSuggestedExpression(valueNode)
+      if (this.isDataUri(node)) return
 
-      this.addOffense(
-        `Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`,
-        srcAttribute.location,
-        "warning"
-      )
+      if (this.shouldFlagAsImageTagCandidate(node)) {
+        const suggestedExpression = this.buildSuggestedExpression(node)
+
+        this.addOffense(
+          `Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`,
+          srcAttribute.location,
+          "warning"
+        )
+      }
     }
   }
 
-  private containsERBContent(valueNode: HTMLAttributeValueNode): boolean {
-    if (!valueNode.children) return false
-
-    return valueNode.children.some(child => child.type === "AST_ERB_CONTENT_NODE")
+  private containsERBContent(node: HTMLAttributeValueNode): boolean {
+    return filterNodes(node.children, ERBContentNode).length > 0
   }
 
-  private buildSuggestedExpression(valueNode: HTMLAttributeValueNode): string {
-    if (!valueNode.children) return "expression"
+  private isOnlyERBContent(node: HTMLAttributeValueNode): boolean {
+    return node.children.length > 0 && node.children.length === filterNodes(node.children, ERBContentNode).length
+  }
 
-    let hasText = false
-    let hasERB = false
+  private getContentofFirstChild(node: HTMLAttributeValueNode): string {
+    if (!node.children || node.children.length === 0) return ""
 
-    for (const child of valueNode.children) {
-      if (child.type === "AST_ERB_CONTENT_NODE") {
-        hasERB = true
-      } else if (child.type === "AST_LITERAL_NODE") {
-        const literalNode = child as LiteralNode
+    const firstChild = node.children[0]
 
-        if (literalNode.content && literalNode.content.trim()) {
-          hasText = true
-        }
-      }
+    if (isNode(firstChild, LiteralNode)) {
+      return (firstChild.content || "").trim()
     }
 
-    if (hasText && hasERB) {
-      let result = '"'
-
-      for (const child of valueNode.children) {
-        if (child.type === "AST_ERB_CONTENT_NODE") {
-          const erbNode = child as ERBContentNode
-
-          result += `#{${(erbNode.content?.value || "").trim()}}`
-        } else if (child.type === "AST_LITERAL_NODE") {
-          const literalNode = child as LiteralNode
-
-          result += literalNode.content || ""
-        }
-      }
+    return ""
+  }
 
-      result += '"'
+  private isDataUri(node: HTMLAttributeValueNode): boolean {
+    return this.getContentofFirstChild(node).startsWith("data:")
+  }
 
-      return result
-    }
+  private isFullUrl(node: HTMLAttributeValueNode): boolean {
+    const content = this.getContentofFirstChild(node)
 
-    if (hasERB && !hasText) {
-      const erbNodes = valueNode.children.filter(child => child.type === "AST_ERB_CONTENT_NODE") as ERBContentNode[]
+    return content.startsWith("http://") || content.startsWith("https://")
+  }
 
-      if (erbNodes.length === 1) {
-        return (erbNodes[0].content?.value || "").trim()
-      } else if (erbNodes.length > 1) {
-        let result = '"'
+  private shouldFlagAsImageTagCandidate(node: HTMLAttributeValueNode): boolean {
+    if (this.isOnlyERBContent(node)) return true
+    if (this.isFullUrl(node)) return false
 
-        for (const erbNode of erbNodes) {
-          result += `#{${(erbNode.content?.value || "").trim()}}`
-        }
+    return true
+  }
 
-        result += '"'
+  private buildSuggestedExpression(node: HTMLAttributeValueNode): string {
+    if (!node.children) return "expression"
 
-        return result
-      }
+    try {
+      return ERBToRubyStringPrinter.print(node, { ignoreErrors: false })
+    } catch (error) {
+      return "expression"
     }
-
-    return "expression"
   }
 }
 

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,
-  ParseResult,
-} 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);
-    return visitor.offenses;
+    const visitor = new AriaAttributeMustBeValid(this.name, context)
+
+    visitor.visit(result.value)
+
+    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 { ParseResult, 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,

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

@@ -1,36 +1,22 @@
-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 { ParseResult, 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"
+    )
   }
 }
 
@@ -39,7 +25,9 @@ export class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
 
   check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AriaRoleHeadingRequiresLevel(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
 }

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

@@ -1,13 +1,13 @@
-import { AttributeVisitorMixin, VALID_ARIA_ROLES } from "./rule-utils.js"
-
 import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, VALID_ARIA_ROLES, StaticAttributeStaticValueParams } from "./rule-utils.js"
+
 import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
+import type { ParseResult } from "@herb-tools/core"
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
-  checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode,): void {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     if (attributeName !== "role") return
-    if (attributeValue === null) return
+    if (!attributeValue) return
     if (VALID_ARIA_ROLES.has(attributeValue)) return
 
     this.addOffense(

package/src/rules/html-attribute-double-quotes.ts

@@ -1,17 +1,30 @@
-import { AttributeVisitorMixin, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
-
 import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
+import { filterLiteralNodes } from "@herb-tools/core"
+
 import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
+import type { ParseResult } from "@herb-tools/core"
 
 class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
-  protected checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode): void {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams) {
     if (!hasAttributeValue(attributeNode)) return
     if (getAttributeValueQuoteType(attributeNode) !== "single") return
-    if (attributeValue?.includes('"')) return // Single quotes acceptable when value contains double quotes
+    if (attributeValue?.includes('"')) return
 
     this.addOffense(
-      `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="value"\`.`,
+      `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${attributeValue}"\`.`,
+      attributeNode.value!.location,
+      "warning"
+    )
+  }
+
+  protected checkStaticAttributeDynamicValue({ attributeName, valueNodes, attributeNode, combinedValue }: StaticAttributeDynamicValueParams) {
+    if (!hasAttributeValue(attributeNode)) return
+    if (getAttributeValueQuoteType(attributeNode) !== "single") return
+    if (filterLiteralNodes(valueNodes).some(node => node.content?.includes('"'))) return
+
+    this.addOffense(
+      `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${combinedValue}"\`.`,
       attributeNode.value!.location,
       "warning"
     )
@@ -23,7 +36,9 @@ export class HTMLAttributeDoubleQuotesRule extends ParserRule {
 
   check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
     const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
 }