@herb-tools/linter 0.6.0 → 0.7.0

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, 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,101 +13,80 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
     super.visitHTMLOpenTagNode(node)
   }
 
-  private checkImgTag(node: HTMLOpenTagNode): 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
+
+      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"
-      )
+        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
+    return ""
+  }
 
-          result += literalNode.content || ""
-        }
-      }
+  private isDataUri(node: HTMLAttributeValueNode): boolean {
+    return this.getContentofFirstChild(node).startsWith("data:")
+  }
 
-      result += '"'
+  private isFullUrl(node: HTMLAttributeValueNode): boolean {
+    const content = this.getContentofFirstChild(node)
 
-      return result
-    }
-
-    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 {
+      return "expression"
     }
-
-    return "expression"
   }
 }
 

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

@@ -58,7 +58,7 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
   }
 
   private checkOpenTagWhitespace(openTag: Token, content:string):void {
-    if (content.startsWith(" ") || content.startsWith("\n")) {
+    if (content.startsWith(" ") || content.startsWith("\n")) {
       return
     }
 
@@ -70,7 +70,7 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
   }
 
   private checkCloseTagWhitespace(closeTag: Token, content:string):void {
-    if (content.endsWith(" ") || content.endsWith("\n")) {
+    if (content.endsWith(" ") || content.endsWith("\n")) {
       return
     }
 

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

@@ -1,6 +1,6 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
-import { filterLiteralNodes } from "@herb-tools/core"
+import { filterLiteralNodes } from "@herb-tools/core"
 
 import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult } from "@herb-tools/core"

package/src/rules/html-boolean-attributes-no-value.ts

@@ -1,27 +1,25 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
+import { IdentityPrinter } from "@herb-tools/printer"
 
 import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult } from "@herb-tools/core"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
-  protected checkStaticAttributeStaticValue({ attributeName, attributeNode }: StaticAttributeStaticValueParams) {
-    if (!isBooleanAttribute(attributeName)) return
-    if (!hasAttributeValue(attributeNode)) return
+  protected checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }: StaticAttributeStaticValueParams) {
+    this.checkAttribute(originalAttributeName, attributeNode)
+  }
 
-    this.addOffense(
-      `Boolean attribute \`${attributeName}\` should not have a value. Use \`${attributeName}\` instead of \`${attributeName}="${attributeName}"\`.`,
-      attributeNode.value!.location,
-      "error"
-    )
+  protected checkStaticAttributeDynamicValue({ originalAttributeName, attributeNode }: StaticAttributeDynamicValueParams) {
+    this.checkAttribute(originalAttributeName, attributeNode)
   }
 
-  protected checkStaticAttributeDynamicValue({ attributeName, attributeNode, combinedValue }: StaticAttributeDynamicValueParams) {
+  private checkAttribute(attributeName: string, attributeNode: HTMLAttributeNode) {
     if (!isBooleanAttribute(attributeName)) return
     if (!hasAttributeValue(attributeNode)) return
 
     this.addOffense(
-      `Boolean attribute \`${attributeName}\` should not have a value. Use \`${attributeName}\` instead of \`${attributeName}="${combinedValue}"\`.`,
+      `Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
       attributeNode.value!.location,
       "error"
     )

package/src/rules/html-no-duplicate-ids.ts

@@ -1,29 +1,203 @@
 import { ParserRule } from "../types"
-import { AttributeVisitorMixin, StaticAttributeStaticValueParams } from "./rule-utils"
+import { ControlFlowTrackingVisitor, ControlFlowType } from "./rule-utils"
+import { LiteralNode } from "@herb-tools/core"
+import { Printer, IdentityPrinter } from "@herb-tools/printer"
 
-import type { ParseResult } from "@herb-tools/core"
+import { hasERBOutput, getValidatableStaticContent, isEffectivelyStatic, isNode, getStaticAttributeName, isERBOutputNode } from "@herb-tools/core"
+
+import type { ParseResult, HTMLAttributeNode, ERBContentNode } from "@herb-tools/core"
 import type { LintOffense, LintContext } from "../types"
 
-class NoDuplicateIdsVisitor extends AttributeVisitorMixin {
+interface ControlFlowState {
+  previousBranchIds: Set<string>
+  previousControlFlowIds: Set<string>
+}
+
+interface BranchState {
+  previousBranchIds: Set<string>
+}
+
+class OutputPrinter extends Printer {
+  visitLiteralNode(node: LiteralNode) {
+    this.write(IdentityPrinter.print(node))
+  }
+
+  visitERBContentNode(node: ERBContentNode) {
+    if (isERBOutputNode(node)) {
+      this.write(IdentityPrinter.print(node))
+    }
+  }
+}
+
+class NoDuplicateIdsVisitor extends ControlFlowTrackingVisitor<ControlFlowState, BranchState> {
   private documentIds: Set<string> = new Set<string>()
+  private currentBranchIds: Set<string> = new Set<string>()
+  private controlFlowIds: Set<string> = new Set<string>()
+
+  visitHTMLAttributeNode(node: HTMLAttributeNode): void {
+    this.checkAttribute(node)
+  }
+
+  protected onEnterControlFlow(_controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): ControlFlowState {
+    const stateToRestore: ControlFlowState = {
+      previousBranchIds: this.currentBranchIds,
+      previousControlFlowIds: this.controlFlowIds
+    }
 
-  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
-    if (attributeName.toLowerCase() !== "id") return
-    if (!attributeValue) return
+    this.currentBranchIds = new Set<string>()
 
-    const id = attributeValue.trim()
+    if (!wasAlreadyInControlFlow) {
+      this.controlFlowIds = new Set<string>()
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: ControlFlowState): void {
+    if (controlFlowType === ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+      this.controlFlowIds.forEach(id => this.documentIds.add(id))
+    }
 
-    if (this.documentIds.has(id)) {
-      this.addOffense(
-        `Duplicate ID \`${id}\` found. IDs must be unique within a document.`,
-        attributeNode.location,
-        "error"
-      )
+    this.currentBranchIds = stateToRestore.previousBranchIds
+    this.controlFlowIds = stateToRestore.previousControlFlowIds
+  }
+
+  protected onEnterBranch(): BranchState {
+    const stateToRestore: BranchState = {
+      previousBranchIds: this.currentBranchIds
+    }
+
+    if (this.isInControlFlow) {
+      this.currentBranchIds = new Set<string>()
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitBranch(_stateToRestore: BranchState): void {}
+
+  private checkAttribute(attributeNode: HTMLAttributeNode): void {
+    if (!this.isIdAttribute(attributeNode)) return
+
+    const idValue = this.extractIdValue(attributeNode)
+
+    if (!idValue) return
+    if (this.isWhitespaceOnlyId(idValue.identifier)) return
+
+    this.processIdDuplicate(idValue, attributeNode)
+  }
+
+  private isIdAttribute(attributeNode: HTMLAttributeNode): boolean {
+    if (!attributeNode.name?.children || !attributeNode.value) return false
+
+    return getStaticAttributeName(attributeNode.name) === "id"
+  }
+
+  private extractIdValue(attributeNode: HTMLAttributeNode): { identifier: string; shouldTrackDuplicates: boolean } | null {
+    const valueNodes = attributeNode.value?.children || []
+
+    if (hasERBOutput(valueNodes) && this.isInControlFlow && this.currentControlFlowType === ControlFlowType.LOOP) {
+      return null
+    }
 
+    const identifier = isEffectivelyStatic(valueNodes) ? getValidatableStaticContent(valueNodes) : OutputPrinter.print(valueNodes)
+    if (!identifier) return null
+
+    return { identifier, shouldTrackDuplicates: true }
+  }
+
+  private isWhitespaceOnlyId(identifier: string): boolean {
+    return identifier !== '' && identifier.trim() === ''
+  }
+
+  private processIdDuplicate(idValue: { identifier: string; shouldTrackDuplicates: boolean }, attributeNode: HTMLAttributeNode): void {
+    const { identifier, shouldTrackDuplicates } = idValue
+
+    if (!shouldTrackDuplicates) return
+
+    if (this.isInControlFlow) {
+      this.handleControlFlowId(identifier, attributeNode)
+    } else {
+      this.handleGlobalId(identifier, attributeNode)
+    }
+  }
+
+  private handleControlFlowId(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.currentControlFlowType === ControlFlowType.LOOP) {
+      this.handleLoopId(identifier, attributeNode)
+    } else {
+      this.handleConditionalId(identifier, attributeNode)
+    }
+
+    this.currentBranchIds.add(identifier)
+  }
+
+  private handleLoopId(identifier: string, attributeNode: HTMLAttributeNode): void {
+    const isStaticId = this.isStaticId(attributeNode)
+
+    if (isStaticId) {
+      this.addDuplicateIdOffense(identifier, attributeNode.location)
+      return
+    }
+
+    if (this.currentBranchIds.has(identifier)) {
+      this.addSameLoopIterationOffense(identifier, attributeNode.location)
+    }
+  }
+
+  private handleConditionalId(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.currentBranchIds.has(identifier)) {
+      this.addSameBranchOffense(identifier, attributeNode.location)
+      return
+    }
+
+    if (this.documentIds.has(identifier)) {
+      this.addDuplicateIdOffense(identifier, attributeNode.location)
+      return
+    }
+
+    this.controlFlowIds.add(identifier)
+  }
+
+  private handleGlobalId(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.documentIds.has(identifier)) {
+      this.addDuplicateIdOffense(identifier, attributeNode.location)
       return
     }
 
-    this.documentIds.add(id)
+    this.documentIds.add(identifier)
+  }
+
+  private isStaticId(attributeNode: HTMLAttributeNode): boolean {
+    const valueNodes = attributeNode.value!.children
+    const isCompletelyStatic = valueNodes.every(child => isNode(child, LiteralNode))
+    const isEffectivelyStaticValue = isEffectivelyStatic(valueNodes)
+
+    return isCompletelyStatic || isEffectivelyStaticValue
+  }
+
+  private addDuplicateIdOffense(identifier: string, location: any): void {
+    this.addOffense(
+      `Duplicate ID \`${identifier}\` found. IDs must be unique within a document.`,
+      location,
+      "error"
+    )
+  }
+
+  private addSameLoopIterationOffense(identifier: string, location: any): void {
+    this.addOffense(
+      `Duplicate ID \`${identifier}\` found within the same loop iteration. IDs must be unique within the same loop iteration.`,
+      location,
+      "error"
+    )
+  }
+
+  private addSameBranchOffense(identifier: string, location: any): void {
+    this.addOffense(
+      `Duplicate ID \`${identifier}\` found within the same control flow branch. IDs must be unique within the same control flow branch.`,
+      location,
+      "error"
+    )
   }
 }
 

package/src/rules/html-no-empty-attributes.ts

@@ -0,0 +1,75 @@
+import { ParserRule } from "../types.js"
+import { AttributeVisitorMixin, StaticAttributeStaticValueParams, DynamicAttributeStaticValueParams } from "./rule-utils.js"
+
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult } from "@herb-tools/core"
+
+// Attributes that must not have empty values
+const RESTRICTED_ATTRIBUTES = new Set([
+  'id',
+  'class',
+  'name',
+  'for',
+  'src',
+  'href',
+  'title',
+  'data',
+  'role'
+])
+
+// Check if attribute name matches any restricted patterns
+function isRestrictedAttribute(attributeName: string): boolean {
+  // Check direct matches
+  if (RESTRICTED_ATTRIBUTES.has(attributeName)) {
+    return true
+  }
+
+  // Check for data-* attributes
+  if (attributeName.startsWith('data-')) {
+    return true
+  }
+
+  // Check for aria-* attributes
+  if (attributeName.startsWith('aria-')) {
+    return true
+  }
+
+  return false
+}
+
+class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
+    if (!isRestrictedAttribute(attributeName)) return
+    if (attributeValue.trim() !== "") return
+
+    this.addOffense(
+      `Attribute \`${attributeName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`,
+      attributeNode.name!.location,
+      "warning"
+    )
+  }
+
+  protected checkDynamicAttributeStaticValue({ combinedName, attributeValue, attributeNode }: DynamicAttributeStaticValueParams): void {
+    const name = (combinedName || "").toLowerCase()
+    if (!isRestrictedAttribute(name)) return
+    if (attributeValue.trim() !== "") return
+
+    this.addOffense(
+      `Attribute \`${combinedName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`,
+      attributeNode.name!.location,
+      "warning"
+    )
+  }
+}
+
+export class HTMLNoEmptyAttributesRule extends ParserRule {
+  name = "html-no-empty-attributes"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new NoEmptyAttributesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-no-positive-tab-index.ts

@@ -12,7 +12,7 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
 
     if (!isNaN(tabIndexValue) && tabIndexValue > 0) {
       this.addOffense(
-        `Do not use positive \`tabindex\` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use \`tabindex="0"\` to make an element focusable or \`tabindex=\"-1\"\` to remove it from the tab sequence.`,
+        `Do not use positive \`tabindex\` values as they are error prone and can severely disrupt navigation experience for keyboard users. Use \`tabindex="0"\` to make an element focusable or \`tabindex="-1"\` to remove it from the tab sequence.`,
         attributeNode.location,
         "error"
       )

package/src/rules/html-no-self-closing.ts

@@ -1,25 +1,30 @@
 import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, getTagName, isVoidElement } from "./rule-utils.js"
+import { BaseRuleVisitor, isVoidElement } from "./rule-utils.js"
+import { getTagName } from "@herb-tools/core"
 
 import type { LintContext, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NoSelfClosingVisitor extends BaseRuleVisitor {
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (getTagName(node) === "svg") {
+      this.visit(node.open_tag)
+    } else {
+      this.visitChildNodes(node)
+    }
+  }
+
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
     if (node.tag_closing?.value === "/>") {
       const tagName = getTagName(node)
-
-      const shouldBeVoid = tagName ? isVoidElement(tagName) : false
-      const instead = shouldBeVoid ? `Use \`<${tagName}>\` instead.` : `Use \`<${tagName}></${tagName}>\` instead.`
+      const instead = isVoidElement(tagName) ? `<${tagName}>` : `<${tagName}></${tagName}>`
 
       this.addOffense(
-        `Self-closing syntax \`<${tagName} />\` is not allowed in HTML. ${instead}`,
+        `Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`,
         node.location,
         "error"
       )
     }
-
-    super.visitHTMLOpenTagNode(node)
   }
 }
 

package/src/rules/html-no-underscores-in-attribute-names.ts

@@ -0,0 +1,58 @@
+import { ParserRule } from "../types.js"
+import {
+  AttributeVisitorMixin,
+  StaticAttributeStaticValueParams,
+  StaticAttributeDynamicValueParams,
+  DynamicAttributeStaticValueParams,
+  DynamicAttributeDynamicValueParams
+} from "./rule-utils.js"
+import { getStaticContentFromNodes } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+import type { LintContext, LintOffense } from "../types.js"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
+
+class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
+  protected checkStaticAttributeStaticValue({ attributeName, attributeNode }: StaticAttributeStaticValueParams): void {
+    this.check(attributeName, attributeNode)
+  }
+
+  protected checkStaticAttributeDynamicValue({ attributeName, attributeNode }: StaticAttributeDynamicValueParams): void {
+    this.check(attributeName, attributeNode)
+  }
+
+  protected checkDynamicAttributeStaticValue({ nameNodes, attributeNode }: DynamicAttributeStaticValueParams) {
+    const attributeName = getStaticContentFromNodes(nameNodes)
+
+    this.check(attributeName, attributeNode)
+  }
+
+  protected checkDynamicAttributeDynamicValue({ nameNodes, attributeNode }: DynamicAttributeDynamicValueParams) {
+    const attributeName = getStaticContentFromNodes(nameNodes)
+
+    this.check(attributeName, attributeNode)
+  }
+
+  private check(attributeName: string | null, attributeNode: HTMLAttributeNode): void {
+    if (!attributeName) return
+
+    if (attributeName.includes("_")) {
+      this.addOffense(
+        `Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`,
+        attributeNode.value!.location,
+        "warning"
+      )
+    }
+  }
+}
+
+export class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
+  name = "html-no-underscores-in-attribute-names"
+
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-tag-name-lowercase.ts

@@ -36,7 +36,7 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
     this.checkTagName(node)
   }
 
-  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode | null): void {
+  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode | null): void {
     if (!node) return
 
     const tagName = getTagName(node)

package/src/rules/index.ts

@@ -1,3 +1,4 @@
+export * from "./rule-utils.js"
 export * from "./erb-no-empty-tags.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
@@ -20,6 +21,7 @@ export * from "./html-no-aria-hidden-on-focusable.js"
 export * from "./html-no-block-inside-inline.js"
 export * from "./html-no-duplicate-attributes.js"
 export * from "./html-no-duplicate-ids.js"
+export * from "./html-no-empty-attributes.js"
 export * from "./html-no-empty-headings.js"
 export * from "./html-no-nested-links.js"
 export * from "./html-no-positive-tab-index.js"
@@ -27,3 +29,4 @@ export * from "./html-no-self-closing.js"
 export * from "./html-no-title-attribute.js"
 export * from "./html-tag-name-lowercase.js"
 export * from "./svg-tag-name-capitalization.js"
+export * from "./html-no-underscores-in-attribute-names.js"