@herb-tools/linter 0.7.5 → 0.8.0

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

@@ -1,10 +1,18 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
 import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 
-class RequireWhitespaceInsideTags extends BaseRuleVisitor {
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+  openTag: Token
+  closeTag: Token
+  content: string
+  fixType: "after-open" | "before-close" | "after-comment-equals"
+}
+
+class RequireWhitespaceInsideTags extends BaseRuleVisitor<ERBRequireWhitespaceAutofixContext> {
 
   visitERBNode(node: ERBNode): void {
     const openTag = node.tag_opening
@@ -18,25 +26,37 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     const value = content.value
 
     if (openTag.value === "<%#") {
-      this.checkCommentTagWhitespace(openTag, closeTag, value)
+      this.checkCommentTagWhitespace(node, openTag, closeTag, value)
     } else {
-      this.checkOpenTagWhitespace(openTag, value)
-      this.checkCloseTagWhitespace(closeTag, value)
+      this.checkOpenTagWhitespace(node, openTag, closeTag, value)
+      this.checkCloseTagWhitespace(node, openTag, closeTag, value)
     }
   }
 
-  private checkCommentTagWhitespace(openTag: Token, closeTag: Token, content: string): void {
+  private checkCommentTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string): void {
     if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
       this.addOffense(
         `Add whitespace after \`${openTag.value}\`.`,
         openTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-open"
+        }
       )
     } else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
       this.addOffense(
         `Add whitespace after \`<%#=\`.`,
         openTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-comment-equals"
+        }
       )
     }
 
@@ -44,12 +64,18 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
       this.addOffense(
         `Add whitespace before \`${closeTag.value}\`.`,
         closeTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "before-close"
+        }
       )
     }
   }
 
-  private checkOpenTagWhitespace(openTag: Token, content:string):void {
+  private checkOpenTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.startsWith(" ") || content.startsWith("\n")) {
       return
     }
@@ -57,11 +83,17 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace after \`${openTag.value}\`.`,
       openTag.location,
-      "error"
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "after-open"
+      }
     )
   }
 
-  private checkCloseTagWhitespace(closeTag: Token, content:string):void {
+  private checkCloseTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.endsWith(" ") || content.endsWith("\n")) {
       return
     }
@@ -69,17 +101,63 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace before \`${closeTag.value}\`.`,
       closeTag.location,
-      "error"
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "before-close"
+      }
     )
   }
 }
 
-export class ERBRequireWhitespaceRule extends ParserRule {
+export class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+  static autocorrectable = true
   name = "erb-require-whitespace-inside-tags"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRequireWhitespaceAutofixContext>[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, fixType } = offense.autofixContext
+
+    if (!node.content) return null
+
+    const content = node.content.value
+
+    if (fixType === "before-close") {
+      node.content.value = content + " "
+
+      return result
+    }
+
+    if (fixType === "after-open") {
+      node.content.value = " " + content
+
+      return result
+    }
+
+    if (fixType === "after-comment-equals" && content.startsWith("=")) {
+      node.content.value = "= " + content.substring(1)
+
+      return result
+    }
+
+    return null
+  }
 }

package/src/rules/erb-right-trim.ts

@@ -1,44 +1,67 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
-import { ParserRule } from "../types.js"
-import { isERBOutputNode } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ERBNode, ParseResult } from "@herb-tools/core"
 
-class ERBRightTrimVisitor extends BaseRuleVisitor {
+interface ERBRightTrimAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+}
+
+class ERBRightTrimVisitor extends BaseRuleVisitor<ERBRightTrimAutofixContext> {
   visitERBNode(node: ERBNode): void {
     if (!node.tag_closing) return
 
     const trimClosing = node.tag_closing.value
 
-    if (trimClosing !== "=%>" && trimClosing !== "-%>") return
-
-    if (!isERBOutputNode(node)) {
-      this.addOffense(
-        `Right-trimming with \`${trimClosing}\` has no effect on non-output ERB tags. Use \`%>\` instead`,
-        node.tag_closing.location
-      )
-
-      return
-    }
+    if (trimClosing !== "=%>") return
 
-    if (trimClosing === "=%>") {
-      this.addOffense(
-        "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines",
-        node.tag_closing.location
-      )
-    }
+    this.addOffense(
+      "Use `-%>` instead of `=%>` for right-trimming. The `=%>` syntax is obscure and not well-supported in most ERB engines.",
+      node.tag_closing.location,
+      { node }
+    )
   }
 }
 
-export class ERBRightTrimRule extends ParserRule {
+export class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+  static autocorrectable = true
   name = "erb-right-trim"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRightTrimAutofixContext>[] {
     const visitor = new ERBRightTrimVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    if (!node.tag_closing) return null
+
+    const closing = node.tag_closing
+
+    if (closing.value === "=%>") {
+      closing.value = "-%>"
+      return result
+    }
+
+    if (closing.value === "-%>") {
+      closing.value = "%>"
+      return result
+    }
+
+    return null
+  }
 }

package/src/rules/herb-disable-comment-base.ts

@@ -0,0 +1,76 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ERBContentNode, Location } from "@herb-tools/core"
+
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { LintContext } from "../types.js"
+import type { HerbDisableComment, HerbDisableRuleName } from "../herb-disable-comment-utils.js"
+
+/**
+ * Base visitor class for herb:disable comment validation rules.
+ * Handles common patterns like checking ERB comments and parsing herb:disable content.
+ */
+export abstract class HerbDisableCommentBaseVisitor extends BaseRuleVisitor {
+  constructor(ruleName: string, context?: Partial<LintContext>) {
+    super(ruleName, context)
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    if (node.tag_opening?.value !== "<%#") return
+
+    const content = node.content?.value
+    if (!content) return
+
+    this.checkHerbDisableComment(node, content)
+  }
+
+  /**
+   * Override this method to implement rule-specific logic.
+   * This is called for every ERB comment node.
+   */
+  protected abstract checkHerbDisableComment(node: ERBContentNode, content: string): void
+
+  /**
+   * Helper to create a precise location for a specific rule name within the comment.
+   * Returns null if content location is not available.
+   */
+  protected createRuleNameLocation(node: ERBContentNode, ruleDetail: HerbDisableRuleName): Location | null {
+    const contentLocation = node.content?.location
+    if (!contentLocation) return null
+
+    const startLine = contentLocation.start.line
+    const startColumn = contentLocation.start.column + ruleDetail.offset
+
+    return Location.from(
+      startLine,
+      startColumn,
+      startLine,
+      startColumn + ruleDetail.length
+    )
+  }
+
+  /**
+   * Helper to add an offense with a fallback to node location if precise location unavailable.
+   */
+  protected addOffenseWithFallback(message: string, preciseLocation: Location | null, node: ERBContentNode): void {
+    this.addOffense(message, preciseLocation || node.location)
+  }
+}
+
+/**
+ * Base visitor for rules that need to process parsed herb:disable comments.
+ * Only calls the abstract method if the content successfully parses as a herb:disable comment.
+ */
+export abstract class HerbDisableCommentParsedVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const herbDisable = parseHerbDisableContent(content)
+    if (!herbDisable) return
+
+    this.checkParsedHerbDisable(node, content, herbDisable)
+  }
+
+  /**
+   * Override this method to implement rule-specific logic for parsed herb:disable comments.
+   */
+  protected abstract checkParsedHerbDisable(node: ERBContentNode, content: string, herbDisable: HerbDisableComment): void
+}

package/src/rules/herb-disable-comment-malformed.ts

@@ -0,0 +1,66 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentBaseVisitor } from "./herb-disable-comment-base.js"
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+class HerbDisableCommentMalformedVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const trimmed = content.trim()
+    const looksLikeHerbDisable = trimmed.startsWith("herb:disable")
+    if (!looksLikeHerbDisable) return
+
+    if (trimmed.length > "herb:disable".length) {
+      const charAfterPrefix = trimmed["herb:disable".length]
+
+      if (charAfterPrefix !== ' ' && charAfterPrefix !== '\t' && charAfterPrefix !== '\n') {
+        this.addOffense(
+          "`herb:disable` comment is missing a space after `herb:disable`. Add a space before the rule names.",
+          node.location,
+        )
+
+        return
+      }
+    }
+
+    const afterPrefix = trimmed.substring("herb:disable".length).trim()
+    if (afterPrefix.length === 0) return
+
+    const parsed = parseHerbDisableContent(content)
+    if (parsed !== null) return
+
+    let message = "`herb:disable` comment is malformed."
+
+    const rulesString = afterPrefix.trim()
+
+    if (rulesString.endsWith(',')) {
+      message = "`herb:disable` comment has a trailing comma. Remove the trailing comma."
+    } else if (rulesString.includes(',,') || rulesString.match(/,\s*,/)) {
+      message = "`herb:disable` comment has consecutive commas. Remove extra commas."
+    } else if (rulesString.startsWith(',')) {
+      message = "`herb:disable` comment starts with a comma. Remove the leading comma."
+    }
+
+    this.addOffense(message, node.location)
+  }
+}
+
+export class HerbDisableCommentMalformedRule extends ParserRule {
+  name = "herb-disable-comment-malformed"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentMalformedVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-missing-rules.ts

@@ -0,0 +1,41 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentBaseVisitor } from "./herb-disable-comment-base.js"
+
+import { parseHerbDisableContent } from "../herb-disable-comment-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+class HerbDisableCommentMissingRulesVisitor extends HerbDisableCommentBaseVisitor {
+  protected checkHerbDisableComment(node: ERBContentNode, content: string): void {
+    const herbDisable = parseHerbDisableContent(content)
+    if (herbDisable) return
+
+    const emptyFormat = /^\s*herb:disable\s*$/
+    if (!emptyFormat.test(content)) return
+
+    this.addOffense(
+      `\`herb:disable\` comment is missing rule names. Specify \`all\` or list specific rules to disable.`,
+      node.location,
+    )
+  }
+}
+
+export class HerbDisableCommentMissingRulesRule extends ParserRule {
+  name = "herb-disable-comment-missing-rules"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentMissingRulesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-no-duplicate-rules.ts

@@ -0,0 +1,46 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentNoDuplicateRulesVisitor extends HerbDisableCommentParsedVisitor {
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    const seenRules = new Map<string, number>()
+
+    herbDisable.ruleNameDetails.forEach((ruleDetail, index) => {
+      const firstIndex = seenRules.get(ruleDetail.name)
+
+      if (firstIndex !== undefined) {
+        const location = this.createRuleNameLocation(node, ruleDetail)
+        const message = `Duplicate rule \`${ruleDetail.name}\` in \`herb:disable\` comment. Remove the duplicate.`
+
+        this.addOffenseWithFallback(message, location, node)
+
+        return
+      }
+
+      seenRules.set(ruleDetail.name, index)
+    })
+  }
+}
+
+export class HerbDisableCommentNoDuplicateRulesRule extends ParserRule {
+  name = "herb-disable-comment-no-duplicate-rules"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentNoDuplicateRulesVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-no-redundant-all.ts

@@ -0,0 +1,40 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentNoRedundantAllVisitor extends HerbDisableCommentParsedVisitor {
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    if (!herbDisable.ruleNames.includes("all")) return
+    if (herbDisable.ruleNames.length <= 1) return
+
+    const allDetail = herbDisable.ruleNameDetails.find(detail => detail.name === "all")
+    if (!allDetail) return
+
+    const location = this.createRuleNameLocation(node, allDetail)
+    const message = `Using \`all\` with specific rules is redundant. Use \`herb:disable all\` by itself or list only specific rules.`
+
+    this.addOffenseWithFallback(message, location, node)
+  }
+}
+
+export class HerbDisableCommentNoRedundantAllRule extends ParserRule {
+  name = "herb-disable-comment-no-redundant-all"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HerbDisableCommentNoRedundantAllVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/herb-disable-comment-unnecessary.ts

@@ -0,0 +1,103 @@
+import { ParserRule } from "../types.js"
+import { HerbDisableCommentParsedVisitor } from "./herb-disable-comment-base.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+import type { HerbDisableComment } from "../herb-disable-comment-utils.js"
+
+class HerbDisableCommentUnnecessaryVisitor extends HerbDisableCommentParsedVisitor {
+  private ignoredOffensesByLine: Map<number, Set<string>>
+  private validRuleNames: Set<string>
+
+  constructor(ruleName: string, ignoredOffensesByLine: Map<number, Set<string>>, validRuleNames: string[], context?: Partial<LintContext>) {
+    super(ruleName, context)
+
+    this.ignoredOffensesByLine = ignoredOffensesByLine
+    this.validRuleNames = new Set([...validRuleNames, "all"])
+  }
+
+  protected checkParsedHerbDisable(node: ERBContentNode, _content: string, herbDisable: HerbDisableComment): void {
+    const line = node.location.start.line
+    const usedRuleNames = this.ignoredOffensesByLine.get(line) || new Set<string>()
+
+    if (herbDisable.ruleNames.includes("all")) {
+      if (herbDisable.ruleNames.length > 1) return
+      if (usedRuleNames.size > 0) return
+
+      this.addOffense(
+        `No offenses to disable on this line. Remove the \`herb:disable all\` comment.`,
+        node.location,
+      )
+
+      return
+    }
+
+    const unnecessaryRules = herbDisable.ruleNameDetails.filter(
+      detail => this.validRuleNames.has(detail.name) && !usedRuleNames.has(detail.name)
+    )
+
+    if (unnecessaryRules.length === 0) return
+
+    const validRuleCount = herbDisable.ruleNames.filter(name => this.validRuleNames.has(name)).length
+
+    if (unnecessaryRules.length === validRuleCount) {
+      if (unnecessaryRules.length === 1) {
+        const ruleName = unnecessaryRules[0].name
+
+        this.addOffense(
+          `No offenses from \`${ruleName}\` on this line. Remove the \`herb:disable\` comment.`,
+          node.location,
+        )
+
+        return
+      }
+
+      const unnecessaryRuleNames = unnecessaryRules.map(rule => `\`${rule.name}\``).join(", ")
+
+      this.addOffense(
+        `No offenses from rules ${unnecessaryRuleNames} on this line. Remove them from the \`herb:disable\` comment.`,
+        node.location,
+      )
+
+      return
+    }
+
+    for (const unnecessaryRule of unnecessaryRules) {
+      const location = this.createRuleNameLocation(node, unnecessaryRule)
+      const message = `No offenses from \`${unnecessaryRule.name}\` on this line. Remove it from the \`herb:disable\` comment.`
+
+      this.addOffenseWithFallback(message, location, node)
+    }
+  }
+}
+
+export class HerbDisableCommentUnnecessaryRule extends ParserRule {
+  name = "herb-disable-comment-unnecessary"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const validRuleNames = context?.validRuleNames
+    const ignoredOffensesByLine = context?.ignoredOffensesByLine
+
+    if (!validRuleNames) return []
+    if (validRuleNames.length === 0) return []
+    if (!ignoredOffensesByLine) return []
+
+    const visitor = new HerbDisableCommentUnnecessaryVisitor(
+      this.name,
+      ignoredOffensesByLine,
+      validRuleNames,
+      context
+    )
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}