@herb-tools/linter 0.7.5 → 0.8.0

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

@@ -1,11 +1,11 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, DynamicAttributeStaticValueParams } from "./rule-utils.js"
 import { IdentityPrinter } from "@herb-tools/printer"
+import { Visitor, isERBOutputNode } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, HTMLAttributeNode, ERBContentNode, LiteralNode, Node } from "@herb-tools/core"
 
-// Attributes that must not have empty values
 const RESTRICTED_ATTRIBUTES = new Set([
   'id',
   'class',
@@ -18,19 +18,15 @@ const RESTRICTED_ATTRIBUTES = new Set([
   '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
   }
@@ -42,6 +38,50 @@ function isDataAttribute(attributeName: string): boolean {
   return attributeName.startsWith('data-')
 }
 
+/**
+ * Visitor that checks if a node tree contains any output content.
+ * Output content includes:
+ * - Non-whitespace literal text (LiteralNode)
+ * - ERB output tags (<%= %>, <%== %>)
+ */
+class ContainsOutputContentVisitor extends Visitor {
+  public hasOutputContent: boolean = false
+
+  visitLiteralNode(node: LiteralNode): void {
+    if (this.hasOutputContent) return
+
+    if (node.content && node.content.trim() !== "") {
+      this.hasOutputContent = true
+
+      return
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    if (this.hasOutputContent) return
+
+    if (isERBOutputNode(node)) {
+      this.hasOutputContent = true
+
+      return
+    }
+
+    this.visitChildNodes(node)
+  }
+}
+
+
+function containsOutputContent(node: Node): boolean {
+  const visitor = new ContainsOutputContentVisitor()
+
+  visitor.visit(node)
+
+  return visitor.hasOutputContent
+}
+
+
 class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     this.checkEmptyAttribute(attributeName, attributeValue, attributeNode)
@@ -56,6 +96,9 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
     if (!isRestrictedAttribute(attributeName)) return
     if (attributeValue.trim() !== "") return
 
+    if (!attributeNode?.value) return
+    if (containsOutputContent(attributeNode.value)) return
+
     const hasExplicitValue = attributeNode.value !== null
 
     if (isDataAttribute(attributeName)) {
@@ -63,7 +106,6 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
         this.addOffense(
           `Data attribute \`${attributeName}\` should not have an empty value. Either provide a meaningful value or use \`${attributeName}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
           attributeNode.location,
-          "warning"
         )
       }
 
@@ -73,7 +115,6 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` must not be empty. Either provide a meaningful value or remove the attribute entirely.`,
       attributeNode.location,
-      "warning"
     )
   }
 }
@@ -81,7 +122,14 @@ class NoEmptyAttributesVisitor extends AttributeVisitorMixin {
 export class HTMLNoEmptyAttributesRule extends ParserRule {
   name = "html-no-empty-attributes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoEmptyAttributesVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAttributeValue, HEADING_TAGS } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, ParseResult, LiteralNode, HTMLTextNode } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
@@ -38,7 +39,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Heading element ${elementDescription} must not be empty. Provide accessible text content for screen readers and SEO.`,
         node.location,
-        "error"
       )
     }
   }
@@ -49,7 +49,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       return true
     }
 
-    // Check if all content is just whitespace or inaccessible
     let hasAccessibleContent = false
 
     for (const child of node.body) {
@@ -70,13 +69,11 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       } else if (child.type === "AST_HTML_ELEMENT_NODE") {
         const elementNode = child as HTMLElementNode
 
-        // Check if this element is accessible (not aria-hidden="true")
         if (this.isElementAccessible(elementNode)) {
           hasAccessibleContent = true
           break
         }
       } else {
-        // If there's any non-literal/non-text/non-element content (like ERB), consider it accessible
         hasAccessibleContent = true
         break
       }
@@ -98,7 +95,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   }
 
   private isElementAccessible(node: HTMLElementNode): boolean {
-    // Check if the element has aria-hidden="true"
     if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
       return true
     }
@@ -115,7 +111,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
       }
     }
 
-    // Recursively check if the element has any accessible content
     if (!node.body || node.body.length === 0) {
       return false
     }
@@ -149,7 +144,14 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
 export class HTMLNoEmptyHeadingsRule extends ParserRule {
   name = "html-no-empty-headings"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoEmptyHeadingsVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

package/src/rules/html-no-nested-links.ts

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor, getTagName } from "./rule-utils.js"
-
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
 
 class NestedLinkVisitor extends BaseRuleVisitor {
@@ -12,7 +12,6 @@ class NestedLinkVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Nested `<a>` elements are not allowed. Links cannot contain other links.",
         openTag.tag_name!.location,
-        "error"
       )
 
       return true
@@ -58,7 +57,14 @@ class NestedLinkVisitor extends BaseRuleVisitor {
 export class HTMLNoNestedLinksRule extends ParserRule {
   name = "html-no-nested-links"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NestedLinkVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult } from "@herb-tools/core"
 
 class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
@@ -14,7 +14,6 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
       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.`,
         attributeNode.location,
-        "error"
       )
     }
   }
@@ -23,7 +22,14 @@ class NoPositiveTabIndexVisitor extends AttributeVisitorMixin {
 export class HTMLNoPositiveTabIndexRule extends ParserRule {
   name = "html-no-positive-tab-index"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoPositiveTabIndexVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,11 +1,17 @@
-import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, isVoidElement } from "./rule-utils.js"
-import { getTagName } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { isVoidElement, findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { getTagName, isWhitespaceNode, Location, HTMLCloseTagNode } from "@herb-tools/core"
 
-import type { LintContext, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, LintOffense, FullRuleConfig } from "../types.js"
+import type { Node, HTMLOpenTagNode, HTMLElementNode, SerializedToken, ParseResult } from "@herb-tools/core"
 
-class NoSelfClosingVisitor extends BaseRuleVisitor {
+interface NoSelfClosingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode>
+  tagName: string
+  isVoid: boolean
+}
+
+class NoSelfClosingVisitor extends BaseRuleVisitor<NoSelfClosingAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node) === "svg") {
       this.visit(node.open_tag)
@@ -22,20 +28,74 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`,
         node.location,
-        "error"
+        {
+          node,
+          tagName,
+          isVoid: isVoidElement(tagName)
+        }
       )
     }
   }
 }
 
-export class HTMLNoSelfClosingRule extends ParserRule {
+export class HTMLNoSelfClosingRule extends ParserRule<NoSelfClosingAutofixContext> {
+  static autocorrectable = true
   name = "html-no-self-closing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/views/**/*_mailer/**/*"]
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<NoSelfClosingAutofixContext>[] {
     const visitor = new NoSelfClosingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<NoSelfClosingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, tagName, isVoid } = offense.autofixContext
+    const { tag_closing } = node
+
+    if (!tag_closing) return null
+
+    tag_closing.value = ">"
+
+    if (node.children && Array.isArray(node.children)) {
+      const children = node.children as Node[]
+
+      if (children.length > 0 && isWhitespaceNode(children[children.length - 1])) {
+        node.children = children.slice(0, -1)
+      }
+    }
+
+    if (!isVoid) {
+      const parent = findParent(result.value, node as any as Node) as Mutable<HTMLElementNode> | null
+
+      if (parent && parent.type === "AST_HTML_ELEMENT_NODE") {
+        const tag_opening: SerializedToken = { type: "TOKEN_HTML_TAG_START_CLOSE", value: "</", location: Location.zero, range: [0, 0] }
+        const tag_name: SerializedToken = { type: "TOKEN_IDENTIFIER", value: tagName, location: Location.zero, range: [0, 0] }
+        const tag_closing: SerializedToken = { type: "TOKEN_HTML_TAG_END", value: ">", location: Location.zero, range: [0, 0] }
+
+        parent.close_tag = HTMLCloseTagNode.from({
+          type: "AST_HTML_CLOSE_TAG_NODE",
+          tag_opening,
+          tag_name,
+          tag_closing,
+          children: [],
+          errors: [],
+          location: Location.zero,
+        })
+      }
+    }
+
+    return result
+  }
 }

package/src/rules/html-no-space-in-tag.ts

@@ -0,0 +1,221 @@
+import { Token, Location, WhitespaceNode } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext } from "../types.js"
+
+import { findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { filterWhitespaceNodes, isWhitespaceNode, isHTMLOpenTagNode } from "@herb-tools/core"
+
+import type { ParseResult, Node, HTMLCloseTagNode, HTMLOpenTagNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, Mutable, FullRuleConfig } from "../types.js"
+
+const MESSAGES = {
+  EXTRA_SPACE_NO_SPACE: "Extra space detected where there should be no space.",
+  EXTRA_SPACE_SINGLE_SPACE: "Extra space detected where there should be a single space.",
+  EXTRA_SPACE_SINGLE_BREAK: "Extra space detected where there should be a single space or a single line break.",
+  NO_SPACE_SINGLE_SPACE: "No space detected where there should be a single space.",
+} as const
+
+interface HTMLNoSpaceInTagAutofixContext extends BaseAutofixContext {
+  node: WhitespaceNode | HTMLOpenTagNode
+  message: string
+}
+
+class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor<HTMLNoSpaceInTagAutofixContext> {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    if (node.isSingleLine) {
+      this.checkSingleLineTag(node)
+    } else {
+      this.checkMultilineTag(node)
+    }
+  }
+
+  visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
+    this.reportAllWhitespace(node.children, MESSAGES.EXTRA_SPACE_NO_SPACE)
+  }
+
+  private checkSingleLineTag(node: HTMLOpenTagNode): void {
+    const { children, tag_closing } = node
+    const isSelfClosing = tag_closing ? this.isSelfClosing(tag_closing) : false
+
+    this.checkWhitespaceInSingleLineTag(children, isSelfClosing)
+    this.checkMissingSpaceBeforeSelfClosing(node, children, isSelfClosing)
+  }
+
+  private checkWhitespaceInSingleLineTag(children: Node[], isSelfClosing: boolean): void {
+    const whitespaceNodes = filterWhitespaceNodes(children)
+
+    whitespaceNodes.forEach((whitespace) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      const isLastChild = children[children.length - 1] === whitespace
+      if (isLastChild) {
+        this.checkTrailingWhitespace(whitespace, content, isSelfClosing)
+        return
+      }
+
+      if (content.length > 1) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_SPACE })
+      }
+    })
+  }
+
+  private checkTrailingWhitespace(whitespace: WhitespaceNode, content: string, isSelfClosing: boolean): void {
+    if (isSelfClosing && content === ' ') return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private checkMissingSpaceBeforeSelfClosing(node: HTMLOpenTagNode, children: Node[], isSelfClosing: boolean): void {
+    if (!isSelfClosing) return
+
+    const lastChild = children[children.length - 1]
+    if (lastChild && isWhitespaceNode(lastChild)) return
+
+    const lastNonWhitespace = children.filter(child => !isWhitespaceNode(child)).pop()
+    const locationToReport = lastNonWhitespace?.location ?? node.tag_name?.location ?? node.location
+
+    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport, { node, message: MESSAGES.NO_SPACE_SINGLE_SPACE })
+  }
+
+  private checkMultilineTag(node: HTMLOpenTagNode): void {
+    const whitespaceNodes = filterWhitespaceNodes(node.children)
+    let previousWhitespace: WhitespaceNode | null = null
+
+    whitespaceNodes.forEach((whitespace, index) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      if (this.hasConsecutiveNewlines(content, previousWhitespace)) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_BREAK })
+        previousWhitespace = whitespace
+
+        return
+      }
+
+      if (this.isNonNewlineWhitespace(content)) {
+        this.checkIndentation(whitespace, index, whitespaceNodes.length, node)
+      }
+
+      previousWhitespace = whitespace
+    })
+  }
+
+  private hasConsecutiveNewlines(content: string, previousWhitespace: WhitespaceNode | null): boolean {
+    if (content === "\n") return previousWhitespace?.value?.value === "\n"
+    if (!content.includes("\n")) return false
+
+    const newlines = content.match(/\n/g)
+
+    return (newlines?.length ?? 0) > 1
+  }
+
+  private isNonNewlineWhitespace(content: string): boolean {
+    return !content.includes("\n")
+  }
+
+  private checkIndentation(whitespace: WhitespaceNode, index: number, totalWhitespaceNodes: number, node: HTMLOpenTagNode): void {
+    const isLastWhitespace = index === totalWhitespaceNodes - 1
+    const expectedIndent = isLastWhitespace ? node.location.start.column : node.location.start.column + 2
+
+    if (whitespace.location.end.column === expectedIndent) return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private isSelfClosing(tag_closing: Token): boolean {
+    return tag_closing?.value?.includes('/') ?? false
+  }
+
+  private getWhitespaceContent(whitespace: WhitespaceNode): string | null {
+    return whitespace.value?.value ?? null
+  }
+
+  private reportAllWhitespace(nodes: Node[] | WhitespaceNode[], message: string): void {
+    const whitespaceNodes = Array.isArray(nodes) && nodes.length > 0 && !isWhitespaceNode(nodes[0])
+      ? filterWhitespaceNodes(nodes)
+      : nodes as WhitespaceNode[]
+
+    whitespaceNodes.forEach(whitespace => {
+      this.addOffense(message, whitespace.location, { node: whitespace, message })
+    })
+  }
+}
+
+export class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
+  // TODO: enable and fix autofix
+  static autocorrectable = false
+  name = "html-no-space-in-tag"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<HTMLNoSpaceInTagAutofixContext>[] {
+    const visitor = new HTMLNoSpaceInTagVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<HTMLNoSpaceInTagAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, message } = offense.autofixContext
+    if (!node) return null
+
+    if (isHTMLOpenTagNode(node)) {
+      const token = Token.from({ type: "TOKEN_WHITESPACE", value: " ", range: [0, 0], location: Location.zero })
+      const whitespace = new WhitespaceNode({ type: "AST_WHITESPACE_NODE", value: token, location: Location.zero, errors: [] })
+
+      node.children.push(whitespace)
+
+      return result
+    }
+
+    if (!isWhitespaceNode(node)) return null
+
+    const whitespaceNode = node as Mutable<WhitespaceNode>
+    if (!whitespaceNode.value) return null
+
+    switch (message) {
+      case MESSAGES.EXTRA_SPACE_NO_SPACE: {
+        let selfClosing = false
+        let beginningOfLine = false
+
+        const parent = findParent(result.value, node)
+
+        if (parent && isHTMLOpenTagNode(parent)) {
+          selfClosing = parent.tag_closing?.value === "/>"
+          beginningOfLine = node.location.start.column === 0
+        }
+
+        whitespaceNode.value.value = selfClosing && !beginningOfLine ? " " : ""
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_BREAK: {
+        if (whitespaceNode.value.value.includes("\n")) {
+          whitespaceNode.value.value = ""
+        } else {
+          whitespaceNode.value.value = " "
+        }
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_SPACE:
+      case MESSAGES.NO_SPACE_SINGLE_SPACE: {
+        whitespaceNode.value.value = " "
+
+        return result
+      }
+
+      default: return null
+    }
+  }
+}

package/src/rules/html-no-title-attribute.ts

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class NoTitleAttributeVisitor extends BaseRuleVisitor {
@@ -23,7 +23,6 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
       this.addOffense(
         "The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.",
         node.tag_name!.location,
-        "error"
       )
     }
   }
@@ -32,7 +31,14 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
 export class HTMLNoTitleAttributeRule extends ParserRule {
   name = "html-no-title-attribute"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoTitleAttributeVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -6,9 +6,11 @@ import {
   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 { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
@@ -38,8 +40,7 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
     if (attributeName.includes("_")) {
       this.addOffense(
         `Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`,
-        attributeNode.value!.location,
-        "warning"
+        attributeNode.name?.location ?? attributeNode.location,
       )
     }
   }
@@ -48,7 +49,14 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
 export class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
   name = "html-no-underscores-in-attribute-names"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.name, context)
 
     visitor.visit(result.value)