@herb-tools/linter 0.7.5 → 0.8.1

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

@@ -1,9 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
+import { isNode, getTagName, HTMLOpenTagNode } from "@herb-tools/core"
 
-import { isNode, getTagName, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLElementNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
+interface TagNameAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  tagName: string
+  correctedTagName: string
+}
 
 class XMLDeclarationChecker extends BaseRuleVisitor {
   hasXMLDeclaration: boolean = false
@@ -18,7 +24,7 @@ class XMLDeclarationChecker extends BaseRuleVisitor {
   }
 }
 
-class TagNameLowercaseVisitor extends BaseRuleVisitor {
+class TagNameLowercaseVisitor extends BaseRuleVisitor<TagNameAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node).toLowerCase() === "svg") {
       this.checkTagName(node.open_tag)
@@ -52,28 +58,53 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} tag name \`${open}${tagName}>\` should be lowercase. Use \`${open}${lowercaseTagName}>\` instead.`,
         node.tag_name!.location,
-        "error"
+        {
+          node,
+          tagName,
+          correctedTagName: lowercaseTagName
+        }
       )
     }
   }
 }
 
-export class HTMLTagNameLowercaseRule extends ParserRule {
+export class HTMLTagNameLowercaseRule extends ParserRule<TagNameAutofixContext> {
+  static autocorrectable = true
   name = "html-tag-name-lowercase"
 
-  isEnabled(result: ParseResult, context?: Partial<LintContext>): boolean {
-    if (context?.fileName?.endsWith(".xml") || context?.fileName?.endsWith(".xml.erb")) {
-      return false
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/*.xml", "**/*.xml.erb"]
     }
+  }
 
+  isEnabled(result: ParseResult, _context?: Partial<LintContext>): boolean {
     const checker = new XMLDeclarationChecker(this.name)
+
     checker.visit(result.value)
+
     return !checker.hasXMLDeclaration
   }
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<TagNameAutofixContext>[] {
     const visitor = new TagNameLowercaseVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<TagNameAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctedTagName } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctedTagName
+
+    return result
+  }
 }

package/src/rules/index.ts

@@ -1,10 +1,25 @@
 export * from "./rule-utils.js"
+export * from "./herb-disable-comment-base.js"
+
 export * from "./erb-comment-syntax.js"
+export * from "./erb-no-case-node-children.js"
 export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-extra-newline.js"
+export * from "./erb-no-extra-whitespace-inside-tags.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
-export * from "./erb-requires-trailing-newline.js"
+export * from "./erb-require-trailing-newline.js"
+export * from "./erb-require-whitespace-inside-tags.js"
+export * from "./erb-right-trim.js"
+
+export * from "./herb-disable-comment-valid-rule-name.js"
+export * from "./herb-disable-comment-no-redundant-all.js"
+export * from "./herb-disable-comment-no-duplicate-rules.js"
+export * from "./herb-disable-comment-missing-rules.js"
+export * from "./herb-disable-comment-malformed.js"
+export * from "./herb-disable-comment-unnecessary.js"
+
 export * from "./html-anchor-require-href.js"
 export * from "./html-aria-label-is-well-formatted.js"
 export * from "./html-aria-level-must-be-valid.js"
@@ -14,21 +29,26 @@ export * from "./html-attribute-double-quotes.js"
 export * from "./html-attribute-equals-spacing.js"
 export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
+export * from "./html-body-only-elements.js"
 export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-head-only-elements.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
+export * from "./html-input-require-autocomplete.js"
 export * from "./html-navigation-has-label.js"
 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-duplicate-meta-names.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"
 export * from "./html-no-self-closing.js"
+export * from "./html-no-space-in-tag.js"
 export * from "./html-no-title-attribute.js"
+export * from "./html-no-underscores-in-attribute-names.js"
 export * from "./html-tag-name-lowercase.js"
+
 export * from "./svg-tag-name-capitalization.js"
-export * from "./html-no-underscores-in-attribute-names.js"
-export * from "./erb-right-trim.js"

package/src/rules/parser-no-errors.ts

@@ -1,11 +1,18 @@
 import { ParserRule } from "../types.js"
 
-import type { LintOffense } from "../types.js"
+import type { LintOffense, FullRuleConfig } from "../types.js"
 import type { ParseResult, HerbError } from "@herb-tools/core"
 
 export class ParserNoErrorsRule extends ParserRule {
   name = "parser-no-errors"
 
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
   check(result: ParseResult): LintOffense[] {
     return result.recursiveErrors().map(error =>
       this.herbErrorToLintOffense(error)

package/src/rules/rule-utils.ts

@@ -1,6 +1,5 @@
 import {
   Visitor,
-  Position,
   Location,
   getStaticAttributeName,
   hasDynamicAttributeName as hasNodeDynamicAttributeName,
@@ -17,6 +16,7 @@ import type {
   HTMLAttributeNameNode,
   HTMLAttributeNode,
   HTMLAttributeValueNode,
+  HTMLElementNode,
   HTMLOpenTagNode,
   LiteralNode,
   LexResult,
@@ -27,7 +27,7 @@ import type {
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 import type * as Nodes from "@herb-tools/core"
-import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js"
 
 export enum ControlFlowType {
   CONDITIONAL,
@@ -37,8 +37,8 @@ export enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export abstract class BaseRuleVisitor extends Visitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+  public readonly offenses: UnboundLintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -50,24 +50,25 @@ export abstract class BaseRuleVisitor extends Visitor {
   }
 
   /**
-   * Helper method to create a lint offense
+   * Helper method to create an unbound lint offense (without severity).
+   * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
       source: "Herb Linter",
       message,
       location,
-      severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext))
   }
 }
 
@@ -76,17 +77,18 @@ export abstract class BaseRuleVisitor extends Visitor {
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
   protected isInControlFlow: boolean = false
   protected currentControlFlowType: ControlFlowType | null = null
 
   /**
    * Handle visiting a control flow node with proper scope management
    */
-  protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void {
+  protected handleControlFlowNode(_node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void {
     const wasInControlFlow = this.isInControlFlow
     const previousControlFlowType = this.currentControlFlowType
 
@@ -170,7 +172,9 @@ export function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[] {
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export function getTagName(node: HTMLOpenTagNode): string | null {
+export function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null {
+  if (!node) return null
+
   return node.tag_name?.value.toLowerCase() || null
 }
 
@@ -374,7 +378,9 @@ export function findAttributeByName(attributes: Node[], attributeName: string):
 /**
  * Checks if a tag has a specific attribute
  */
-export function hasAttribute(node: HTMLOpenTagNode, attributeName: string): boolean {
+export function hasAttribute(node: HTMLOpenTagNode | null | undefined, attributeName: string): boolean {
+  if (!node) return false
+
   return getAttribute(node, attributeName) !== null
 }
 
@@ -577,10 +583,8 @@ export function createEndOfFileLocation(source: string): Location {
   const lastColumnNumber = lastLine.length
 
   const startColumn = lastColumnNumber > 0 ? lastColumnNumber - 1 : 0
-  const start = new Position(lastLineNumber, startColumn)
-  const end = new Position(lastLineNumber, lastColumnNumber)
 
-  return new Location(start, end)
+  return Location.from(lastLineNumber, startColumn, lastLineNumber, lastColumnNumber)
 }
 
 /**
@@ -621,7 +625,7 @@ export function isBooleanAttribute(attributeName: string): boolean {
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
   constructor(ruleName: string, context?: Partial<LintContext>) {
     super(ruleName, context)
   }
@@ -735,8 +739,8 @@ export function forEachAttribute(
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export abstract class BaseLexerRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: UnboundLintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -746,24 +750,25 @@ export abstract class BaseLexerRuleVisitor {
   }
 
   /**
-   * Helper method to create a lint offense for lexer rules
+   * Helper method to create an unbound lint offense (without severity).
+   * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
       source: "Herb Linter",
       message,
       location,
-      severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext))
   }
 
   /**
@@ -791,14 +796,13 @@ export abstract class BaseLexerRuleVisitor {
   protected visitToken(_token: Token): void {
     // Default implementation does nothing
   }
-
 }
 
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export abstract class BaseSourceRuleVisitor {
-  public readonly offenses: LintOffense[] = []
+export abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+  public readonly offenses: UnboundLintOffense<TAutofixContext>[] = []
   protected ruleName: string
   protected context: LintContext
 
@@ -808,24 +812,25 @@ export abstract class BaseSourceRuleVisitor {
   }
 
   /**
-   * Helper method to create a lint offense for source rules
+   * Helper method to create an unbound lint offense (without severity).
+   * The Linter will bind severity based on the rule's config.
    */
-  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+  protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext> {
     return {
       rule: this.ruleName,
       code: this.ruleName,
       source: "Herb Linter",
       message,
       location,
-      severity,
+      autofixContext,
     }
   }
 
   /**
    * Helper method to add an offense to the offenses array
    */
-  protected addOffense(message: string, location: Location, severity: LintSeverity = "error"): void {
-    this.offenses.push(this.createOffense(message, location, severity))
+  protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void {
+    this.offenses.push(this.createOffense(message, location, autofixContext))
   }
 
   /**
@@ -841,19 +846,222 @@ export abstract class BaseSourceRuleVisitor {
    * Override this method to implement source-level checks
    */
   protected abstract visitSource(source: string): void
+}
 
-  /**
-   * Helper method to create a location for a specific position in the source
-   */
-  protected createLocationAt(source: string, position: number): Location {
-    const beforePosition = source.substring(0, position)
-    const lines = beforePosition.split('\n')
-    const line = lines.length
-    const column = lines[lines.length - 1].length + 1
+/**
+ * Autofix utilities for applying string replacements
+ */
+
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export function locationsEqual(a: Location, b: Location): boolean {
+  return a.start.line === b.start.line &&
+         a.start.column === b.start.column &&
+         a.end.line === b.end.line &&
+         a.end.column === b.end.column
+}
+
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any {
+  const visited = new Set<any>()
+
+  function search(node: any): any {
+    if (!node || visited.has(node)) return null
+    visited.add(node)
 
-    const start = new Position(line, column)
-    const end = new Position(line, column)
+    if (node.location && locationsEqual(node.location, location)) {
+      if (!predicate || predicate(node)) {
+        return node
+      }
+    }
+
+    const propsToCheck = ['tag_opening', 'tag_closing', 'tag_name', 'name', 'equals', 'value', 'content']
+    for (const prop of propsToCheck) {
+      if (node[prop]?.location && locationsEqual(node[prop].location, location)) {
+        if (!predicate || predicate(node)) {
+          return node
+        }
+      }
+    }
 
-    return new Location(start, end)
+    if (typeof node.compactChildNodes === 'function') {
+      for (const child of node.compactChildNodes()) {
+        const found = search(child)
+        if (found) return found
+      }
+    } else {
+      if (node.children && Array.isArray(node.children)) {
+        for (const child of node.children) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+
+      if (node.body && Array.isArray(node.body)) {
+        for (const child of node.body) {
+          const found = search(child)
+          if (found) return found
+        }
+      }
+    }
+
+    return null
   }
+
+  return search(root)
+}
+
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export function findParent(root: Node, target: Node): Node | null {
+  let parentNode: Node | null = null
+
+  const search = (node: Node, _parent: Node | null = null): void => {
+    if (parentNode) return
+
+    const nodeAny = node as any
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        if (child === target) {
+          parentNode = node
+          return
+        }
+      }
+    }
+
+    const propsToCheck = ['open_tag', 'close_tag', 'body', 'name', 'value']
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (value === target) {
+        parentNode = node
+        return
+      }
+      if (Array.isArray(value) && value.includes(target)) {
+        parentNode = node
+        return
+      }
+    }
+
+    if (nodeAny.children) {
+      for (const child of nodeAny.children) {
+        search(child, node)
+        if (parentNode) return
+      }
+    }
+
+    for (const prop of propsToCheck) {
+      const value = (node as any)[prop]
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object' && 'type' in item) {
+            search(item, node)
+            if (parentNode) return
+          }
+        }
+      } else if (value && typeof value === 'object' && 'type' in value) {
+        search(value, node)
+        if (parentNode) return
+      }
+    }
+  }
+
+  search(root)
+
+  return parentNode
+}
+
+export const DOCUMENT_ONLY_TAG_NAMES = new Set<string>([
+  "html"
+])
+
+export const HTML_ONLY_TAG_NAMES = new Set<string>([
+  "head", "body"
+])
+
+export const HEAD_ONLY_TAG_NAMES = new Set<string>([
+  "base",
+  "title",
+  "style",
+  "meta",
+  "link",
+])
+
+export const HEAD_AND_BODY_TAG_NAMES = new Set<string>([
+  "script",
+  "noscript",
+  "template",
+])
+
+export function isDocumentOnlyTag(tagName: string): boolean {
+  return DOCUMENT_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHtmlOnlyTag(tagName: string): boolean {
+  return HTML_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadOnlyTag(tagName: string): boolean {
+  return HEAD_ONLY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isHeadAndBodyTag(tagName: string): boolean {
+  return HEAD_AND_BODY_TAG_NAMES.has(tagName.toLowerCase())
+}
+
+export function isBodyOnlyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    !isHeadOnlyTag(tag) &&
+    !isHeadAndBodyTag(tag)
+  )
+}
+
+export function isBodyTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isBodyOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
+}
+
+export function isHeadTag(tagName: string): boolean {
+  const tag = tagName.toLowerCase()
+
+  return (
+    !isDocumentOnlyTag(tag) &&
+    !isHtmlOnlyTag(tag) &&
+    (isHeadOnlyTag(tag) || isHeadAndBodyTag(tag))
+  )
 }

package/src/rules/svg-tag-name-capitalization.ts

@@ -1,10 +1,16 @@
+import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE } from "./rule-utils.js"
 
-import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, Mutable, FullRuleConfig } from "../types.js"
 import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core"
 
-class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
+interface SVGTagNameCapitalizationAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  currentTagName: string
+  correctCamelCase: string
+}
+
+class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor<SVGTagNameCapitalizationAutofixContext> {
   private insideSVG = false
 
   visitHTMLElementNode(node: HTMLElementNode): void {
@@ -22,6 +28,7 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       if (node.open_tag) {
         this.checkTagName(node.open_tag as HTMLOpenTagNode)
       }
+
       if (node.close_tag) {
         this.checkTagName(node.close_tag as HTMLCloseTagNode)
       }
@@ -50,18 +57,44 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,
         node.tag_name!.location,
-        "error"
+        {
+          node,
+          currentTagName: tagName,
+          correctCamelCase
+        }
       )
     }
   }
 }
 
-export class SVGTagNameCapitalizationRule extends ParserRule {
+export class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
+  static autocorrectable = true
   name = "svg-tag-name-capitalization"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<SVGTagNameCapitalizationAutofixContext>[] {
     const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctCamelCase } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctCamelCase
+
+    return result
+  }
 }