add autofix

Author: markokajzer

javascript/packages/linter/docs/rules/erb-space-indentation.md

@@ -24,6 +24,10 @@ Detects indentation with tabs. Consistent use of spaces for indentation improves
 </div>
 ```
 
+## Autofix
+
+This rule is autocorrectable. Each tab character in leading whitespace is replaced with spaces based on the configured `indentWidth` (default: 2).
+
 ## References
 
 - [Shopify/erb_lint - `SpaceIndentation`](https://github.com/Shopify/erb_lint/blob/main/lib/erb_lint/linters/space_indentation.rb)

javascript/packages/linter/src/linter.ts

@@ -368,7 +368,8 @@ export class Linter {
     context = {
       ...context,
       validRuleNames: this.getAvailableRules().map(ruleClass => ruleClass.ruleName),
-      ignoredOffensesByLine
+      ignoredOffensesByLine,
+      indentWidth: context?.indentWidth ?? this.config?.formatter?.indentWidth
     }
 
     const regularRules = this.rules.filter(ruleClass => ruleClass.ruleName !== "herb-disable-comment-unnecessary")
@@ -481,6 +482,12 @@ export class Linter {
    */
   autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[], options?: { includeUnsafe?: boolean }): AutofixResult {
     const includeUnsafe = options?.includeUnsafe ?? false
+
+    context = {
+      ...context,
+      indentWidth: context?.indentWidth ?? this.config?.formatter?.indentWidth
+    }
+
     const lintResult = offensesToFix ? { offenses: offensesToFix } : this.lint(source, context)
 
     const parserOffenses: LintOffense[] = []

javascript/packages/linter/src/rules/erb-space-indentation.ts

@@ -2,7 +2,7 @@ import { Location } from "@herb-tools/core"
 
 import { BaseSourceRuleVisitor, positionFromOffset } from "./rule-utils.js"
 import { SourceRule } from "../types.js"
-import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 
 const START_BLANKS = /^[^\S\n]*\t[^\S\n]*/
 
@@ -31,6 +31,7 @@ class ERBSpaceIndentationVisitor extends BaseSourceRuleVisitor {
 }
 
 export class ERBSpaceIndentationRule extends SourceRule {
+  static autocorrectable = true
   static ruleName = "erb-space-indentation"
 
   get defaultConfig(): FullRuleConfig {
@@ -47,4 +48,21 @@ export class ERBSpaceIndentationRule extends SourceRule {
 
     return visitor.offenses
   }
+
+  autofix(_offense: LintOffense, source: string, context?: Partial<LintContext>): string | null {
+    const indentWidth = context?.indentWidth ?? 2
+    const lines = source.split("\n")
+    const result = lines.map((line) => {
+      const match = line.match(START_BLANKS)
+
+      if (match) {
+        const replaced = match[0].replace(/\t/g, " ".repeat(indentWidth))
+        return replaced + line.substring(match[0].length)
+      }
+
+      return line
+    })
+
+    return result.join("\n")
+  }
 }

javascript/packages/linter/src/types.ts

@@ -216,6 +216,7 @@ export interface LintContext {
   validRuleNames: string[] | undefined
   ignoredOffensesByLine: Map<number, Set<string>> | undefined
   ignoreDisableComments: boolean | undefined
+  indentWidth: number | undefined
 }
 
 /**
@@ -225,7 +226,8 @@ export const DEFAULT_LINT_CONTEXT: LintContext = {
   fileName: undefined,
   validRuleNames: undefined,
   ignoredOffensesByLine: undefined,
-  ignoreDisableComments: undefined
+  ignoreDisableComments: undefined,
+  indentWidth: undefined
 } as const
 
 export abstract class SourceRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {

javascript/packages/linter/test/autofix/erb-space-indentation.autofix.test.ts

@@ -0,0 +1,124 @@
+import { describe, test, expect, beforeAll } from "vitest"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Config } from "@herb-tools/config"
+import { Linter } from "../../src/linter.js"
+
+import { ERBSpaceIndentationRule } from "../../src/rules/erb-space-indentation.js"
+
+describe("erb-space-indentation autofix", () => {
+  beforeAll(async () => {
+    await Herb.load()
+  })
+
+  test("replaces tab indentation with spaces", () => {
+    const input = "\tthis is a line\n\tanother line\n"
+    const expected = "  this is a line\n  another line\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("replaces multiple tab indentation with spaces", () => {
+    const input = "\t\tthis is a line\n"
+    const expected = "    this is a line\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("replaces tabs in mixed indentation", () => {
+    const input = "  \t    this is a line\n  \t  another line\n"
+    const expected = "        this is a line\n      another line\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("ignores space-only indentation", () => {
+    const input = "   this is a line\n   another line\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("ignores lines without indentation", () => {
+    const input = "this is a line\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("ignores tabs in the middle of a line", () => {
+    const input = "hello\tworld\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(input)
+    expect(result.fixed).toHaveLength(0)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("handles HTML content with tab indentation", () => {
+    const input = "<div>\n\t<p>hello</p>\n</div>\n"
+    const expected = "<div>\n  <p>hello</p>\n</div>\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(1)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("uses custom indentWidth from autofix context", () => {
+    const input = "\tthis is a line\n\t\tindented twice\n"
+    const expected = "    this is a line\n        indented twice\n"
+
+    const linter = new Linter(Herb, [ERBSpaceIndentationRule])
+    const result = linter.autofix(input, { indentWidth: 4 })
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+
+  test("defaults to indentWidth from formatter config", () => {
+    const input = "\tthis is a line\n\t\tindented twice\n"
+    const expected = "    this is a line\n        indented twice\n"
+
+    const config = Config.fromObject({
+      formatter: {
+        indentWidth: 4
+      }
+    })
+
+    const linter = Linter.from(Herb, config)
+    const result = linter.autofix(input)
+
+    expect(result.source).toBe(expected)
+    expect(result.fixed).toHaveLength(2)
+    expect(result.unfixed).toHaveLength(0)
+  })
+})

javascript/packages/linter/test/rules/erb-space-indentation.test.ts

@@ -6,41 +6,41 @@ import { createLinterTest } from "../helpers/linter-test-helper.js"
 const { expectNoOffenses, expectError, assertOffenses } = createLinterTest(ERBSpaceIndentationRule)
 
 describe("ERBSpaceIndentationRule", () => {
-  test("no indentation present", () => {
+  test("ignores empty lines", () => {
+    expectNoOffenses("\n\n\n")
+  })
+
+  test("passes when no indentation", () => {
     expectNoOffenses("this is a line")
   })
 
-  test("space indentation present", () => {
+  test("passes when space indentation", () => {
     expectNoOffenses("   this is a line\n   another line\n")
   })
 
-  test("tab indentation", () => {
+  test("fails with tab indentation", () => {
     expectError("Indent with spaces instead of tabs.", [1])
     expectError("Indent with spaces instead of tabs.", [2])
+
     assertOffenses("\t\tthis is a line\n\t\tanother line\n")
   })
 
-  test("tab and spaces indentation", () => {
+  test("handles mixed indentation", () => {
     expectError("Indent with spaces instead of tabs.", [1])
     expectError("Indent with spaces instead of tabs.", [2])
+
     assertOffenses("  \t    this is a line\n  \t  another line\n")
   })
 
-  test("mixed content with tabs", () => {
+  test("handles html template with tabs", () => {
     expectError("Indent with spaces instead of tabs.", [2])
-    assertOffenses("<div>\n\t<p>hello</p>\n</div>\n")
-  })
-
-  test("tabs only at start of line", () => {
-    expectNoOffenses("hello\tworld\n")
-  })
 
-  test("empty lines are fine", () => {
-    expectNoOffenses("\n\n\n")
+    assertOffenses("<div>\n\t<p>hello</p>\n</div>\n")
   })
 
-  test("ERB content with tab indentation", () => {
+  test("fails ERB content with tab indentation", () => {
     expectError("Indent with spaces instead of tabs.", [2])
+
     assertOffenses("<div>\n\t<%= hello %>\n</div>\n")
   })
 })