@herb-tools/linter 0.8.9 → 0.9.0

package/src/linter.ts

@@ -1,16 +1,19 @@
-import { Location } from "@herb-tools/core"
-import { IdentityPrinter } from "@herb-tools/printer"
 import picomatch from "picomatch"
 
+import { Location } from "@herb-tools/core"
+import { IdentityPrinter, IndentPrinter } from "@herb-tools/printer"
+
 import { rules } from "./rules.js"
 import { findNodeByLocation } from "./rules/rule-utils.js"
 import { parseHerbDisableLine } from "./herb-disable-comment-utils.js"
 import { hasLinterIgnoreDirective } from "./linter-ignore.js"
+import { ParseCache } from "./parse-cache.js"
 
 import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
+
 import { DEFAULT_RULE_CONFIG } from "./types.js"
 
-import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js"
+import type { RuleClass, ParserRuleClass, LexerRuleClass, SourceRuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js"
 import type { ParseResult, LexResult, HerbBackend } from "@herb-tools/core"
 import type { RuleConfig, Config } from "@herb-tools/config"
 
@@ -45,9 +48,10 @@ export interface LinterOptions {
 }
 
 export class Linter {
-  protected rules: RuleClass[]
+  public rules: RuleClass[]
   protected allAvailableRules: RuleClass[]
   protected herb: HerbBackend
+  protected parseCache: ParseCache
   protected offenses: LintOffense[]
   protected config?: Config
 
@@ -81,6 +85,7 @@ export class Linter {
    */
   constructor(herb: HerbBackend, rules?: RuleClass[], config?: Config, allAvailableRules?: RuleClass[]) {
     this.herb = herb
+    this.parseCache = new ParseCache(herb)
     this.config = config
     this.rules = rules !== undefined ? rules : this.getDefaultRules()
     this.allAvailableRules = allAvailableRules !== undefined ? allAvailableRules : this.rules
@@ -104,10 +109,9 @@ export class Linter {
   ): RuleClass[] {
     return allRules.filter(ruleClass => {
       const instance = new ruleClass()
-      const ruleName = instance.name
 
       const defaultEnabled = instance.defaultConfig?.enabled ?? DEFAULT_RULE_CONFIG.enabled
-      const userRuleConfig = userRulesConfig?.[ruleName]
+      const userRuleConfig = userRulesConfig?.[ruleClass.ruleName]
 
       if (userRuleConfig !== undefined) {
         return userRuleConfig.enabled !== false
@@ -156,18 +160,29 @@ export class Linter {
     return this.rules.length
   }
 
+  protected findRuleClass(ruleName: string): RuleClass | undefined {
+    return this.rules.find(ruleClass => ruleClass.ruleName === ruleName)
+  }
+
+  /**
+   * Type guard to check if a rule class is a LexerRule class
+   */
+  protected isLexerRuleClass(ruleClass: RuleClass): ruleClass is LexerRuleClass {
+    return ruleClass.type === "lexer"
+  }
+
   /**
-   * Type guard to check if a rule is a LexerRule
+   * Type guard to check if a rule class is a SourceRule class
    */
-  protected isLexerRule(rule: Rule): rule is LexerRule {
-    return (rule.constructor as any).type === "lexer"
+  protected isSourceRuleClass(ruleClass: RuleClass): ruleClass is SourceRuleClass {
+    return ruleClass.type === "source"
   }
 
   /**
-   * Type guard to check if a rule is a SourceRule
+   * Type guard to check if a rule class is a ParserRule class
    */
-  protected isSourceRule(rule: Rule): rule is SourceRule {
-    return (rule.constructor as any).type === "source"
+  protected isParserRuleClass(ruleClass: RuleClass): ruleClass is ParserRuleClass {
+    return ruleClass.type === "parser" || ruleClass.type === undefined
   }
 
   /**
@@ -175,19 +190,22 @@ export class Linter {
    * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
    */
   private executeRule(
+    ruleClass: RuleClass,
     rule: Rule,
     parseResult: ParseResult,
     lexResult: LexResult,
     source: string,
     context?: Partial<LintContext>
   ): UnboundLintOffense[] {
+    const ruleName = rule.ruleName
+
     if (this.config && context?.fileName) {
-      if (!this.config.isRuleEnabledForPath(rule.name, context.fileName)) {
+      if (!this.config.isRuleEnabledForPath(ruleName, context.fileName)) {
         return []
       }
     }
 
-    if (context?.fileName && !this.config?.linter?.rules?.[rule.name]?.exclude) {
+    if (context?.fileName && !this.config?.linter?.rules?.[ruleName]?.exclude) {
       const defaultExclude = rule.defaultConfig?.exclude ?? DEFAULT_RULE_CONFIG.exclude
 
       if (defaultExclude && defaultExclude.length > 0) {
@@ -202,34 +220,40 @@ export class Linter {
     let isEnabled = true
     let ruleOffenses: UnboundLintOffense[]
 
-    if (this.isLexerRule(rule)) {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(lexResult, context)
+    if (this.isLexerRuleClass(ruleClass)) {
+      const lexerRule = rule as LexerRule
+
+      if (lexerRule.isEnabled) {
+        isEnabled = lexerRule.isEnabled(lexResult, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as LexerRule).check(lexResult, context)
+        ruleOffenses = lexerRule.check(lexResult, context)
       } else {
         ruleOffenses = []
       }
 
-    } else if (this.isSourceRule(rule)) {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(source, context)
+    } else if (this.isSourceRuleClass(ruleClass)) {
+      const sourceRule = rule as SourceRule
+
+      if (sourceRule.isEnabled) {
+        isEnabled = sourceRule.isEnabled(source, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as SourceRule).check(source, context)
+        ruleOffenses = sourceRule.check(source, context)
       } else {
         ruleOffenses = []
       }
     } else {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(parseResult, context)
+      const parserRule = rule as ParserRule
+
+      if (parserRule.isEnabled) {
+        isEnabled = parserRule.isEnabled(parseResult, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as ParserRule).check(parseResult, context)
+        ruleOffenses = parserRule.check(parseResult, context)
       } else {
         ruleOffenses = []
       }
@@ -303,7 +327,7 @@ export class Linter {
     let ignoredCount = 0
     let wouldBeIgnoredCount = 0
 
-    const parseResult = this.herb.parse(source, { track_whitespace: true })
+    const parseResult = this.parseCache.get(source)
 
     // Check for file-level ignore directive using visitor
     if (hasLinterIgnoreDirective(parseResult)) {
@@ -323,22 +347,13 @@ export class Linter {
     const herbDisableCache = new Map<number, string[]>()
 
     if (hasParserErrors) {
-      const hasParserRule = this.rules.find(RuleClass => (new RuleClass()).name === "parser-no-errors")
+      const hasParserRule = this.findRuleClass("parser-no-errors")
 
       if (hasParserRule) {
         const rule = new ParserNoErrorsRule()
         const offenses = rule.check(parseResult)
         this.offenses.push(...offenses)
       }
-
-      return {
-        offenses: this.offenses,
-        errors: this.offenses.filter(o => o.severity === "error").length,
-        warnings: this.offenses.filter(o => o.severity === "warning").length,
-        info: this.offenses.filter(o => o.severity === "info").length,
-        hints: this.offenses.filter(o => o.severity === "hint").length,
-        ignored: 0
-      }
     }
 
     for (let i = 0; i < sourceLines.length; i++) {
@@ -352,24 +367,31 @@ export class Linter {
 
     context = {
       ...context,
-      validRuleNames: this.getAvailableRules().map(RuleClass => new RuleClass().name),
+      validRuleNames: this.getAvailableRules().map(ruleClass => ruleClass.ruleName),
       ignoredOffensesByLine
     }
 
-    const regularRules = this.rules.filter(RuleClass => {
-      const rule = new RuleClass()
+    const regularRules = this.rules.filter(ruleClass => ruleClass.ruleName !== "herb-disable-comment-unnecessary")
 
-      return rule.name !== "herb-disable-comment-unnecessary"
-    })
+    for (const ruleClass of regularRules) {
+      const rule = new ruleClass()
+      const parserOptions = this.isParserRuleClass(ruleClass) ? (rule as ParserRule).parserOptions : {}
+      const parseResult = this.parseCache.get(source, parserOptions)
+
+      // Skip parser rules whose parse result has errors (parser-no-errors handled above)
+      // Skip lexer/source rules when the default parse has errors
+      if (this.isParserRuleClass(ruleClass)) {
+        if (parseResult.recursiveErrors().length > 0) continue
+      } else if (hasParserErrors) {
+        continue
+      }
 
-    for (const RuleClass of regularRules) {
-      const rule = new RuleClass()
-      const unboundOffenses = this.executeRule(rule, parseResult, lexResult, source, context)
-      const boundOffenses = this.bindSeverity(unboundOffenses, rule.name)
+      const unboundOffenses = this.executeRule(ruleClass, rule, parseResult, lexResult, source, context)
+      const boundOffenses = this.bindSeverity(unboundOffenses, ruleClass.ruleName)
 
       const { kept, ignored, wouldBeIgnored } = this.filterOffenses(
         boundOffenses,
-        rule.name,
+        ruleClass.ruleName,
         ignoredOffensesByLine,
         herbDisableCache,
         context?.ignoreDisableComments
@@ -380,16 +402,13 @@ export class Linter {
       this.offenses.push(...kept)
     }
 
-    const unnecessaryRuleClass = this.rules.find(RuleClass => {
-      const rule = new RuleClass()
-
-      return rule.name === "herb-disable-comment-unnecessary"
-    })
+    const unnecessaryRuleClass = this.findRuleClass("herb-disable-comment-unnecessary")
 
     if (unnecessaryRuleClass) {
       const unnecessaryRule = new unnecessaryRuleClass() as ParserRule
+      const parseResult = this.parseCache.get(source, unnecessaryRule.parserOptions)
       const unboundOffenses = unnecessaryRule.check(parseResult, context)
-      const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRule.name)
+      const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRuleClass.ruleName)
 
       this.offenses.push(...boundOffenses)
     }
@@ -429,19 +448,16 @@ export class Linter {
    * @returns Array of offenses with severity bound
    */
   protected bindSeverity(unboundOffenses: UnboundLintOffense[], ruleName: string): LintOffense[] {
-    const RuleClass = this.rules.find(rule => {
-      const instance = new rule()
-      return instance.name === ruleName
-    })
+    const ruleClass = this.findRuleClass(ruleName)
 
-    if (!RuleClass) {
+    if (!ruleClass) {
       return unboundOffenses.map(offense => ({
         ...offense,
         severity: "error" as const
       }))
     }
 
-    const ruleInstance = new RuleClass()
+    const ruleInstance = new ruleClass()
     const defaultSeverity = ruleInstance.defaultConfig?.severity ?? DEFAULT_RULE_CONFIG.severity
 
     const userRuleConfig = this.config?.linter?.rules?.[ruleName]
@@ -449,7 +465,7 @@ export class Linter {
 
     return unboundOffenses.map(offense => ({
       ...offense,
-      severity
+      severity: offense.severity ?? severity
     }))
   }
 
@@ -472,17 +488,13 @@ export class Linter {
     const sourceOffenses: LintOffense[] = []
 
     for (const offense of lintResult.offenses) {
-      const RuleClass = this.rules.find(rule => {
-        const instance = new rule()
-
-        return instance.name === offense.rule
-      })
+      const ruleClass = this.findRuleClass(offense.rule)
 
-      if (!RuleClass) continue
+      if (!ruleClass) continue
 
-      if ((RuleClass as any).type === "lexer") {
+      if (this.isLexerRuleClass(ruleClass)) {
         lexerOffenses.push(offense)
-      } else if ((RuleClass as any).type === "source") {
+      } else if (this.isSourceRuleClass(ruleClass)) {
         sourceOffenses.push(offense)
       } else {
         parserOffenses.push(offense)
@@ -494,19 +506,20 @@ export class Linter {
     const unfixed: LintOffense[] = []
 
     if (parserOffenses.length > 0) {
-      const parseResult = this.herb.parse(currentSource, { track_whitespace: true })
+      const parseResult = this.parseCache.get(currentSource)
+      let needsReindent = false
 
       for (const offense of parserOffenses) {
-        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+        const ruleClass = this.findRuleClass(offense.rule)
 
-        if (!RuleClass) {
+        if (!ruleClass) {
           unfixed.push(offense)
 
           continue
         }
 
-        const rule = new RuleClass() as ParserRule
-        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
+        const rule = new ruleClass() as ParserRule
+        const isUnsafe = (ruleClass as any).unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
@@ -543,14 +556,21 @@ export class Linter {
 
         if (fixedResult) {
           fixed.push(offense)
+
+          if (this.isParserRuleClass(ruleClass) && ruleClass.reindentAfterAutofix === true) {
+            needsReindent = true
+          }
         } else {
           unfixed.push(offense)
         }
       }
 
       if (fixed.length > 0) {
-        const printer = new IdentityPrinter()
-        currentSource = printer.print(parseResult.value)
+        if (needsReindent) {
+          currentSource = new IndentPrinter().print(parseResult.value)
+        } else {
+          currentSource = new IdentityPrinter().print(parseResult.value)
+        }
       }
     }
 
@@ -564,15 +584,15 @@ export class Linter {
       })
 
       for (const offense of sortedSourceOffenses) {
-        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+        const ruleClass = this.findRuleClass(offense.rule)
 
-        if (!RuleClass) {
+        if (!ruleClass) {
           unfixed.push(offense)
           continue
         }
 
-        const rule = new RuleClass() as SourceRule
-        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
+        const rule = new ruleClass() as SourceRule
+        const isUnsafe = (ruleClass as any).unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
@@ -602,4 +622,3 @@ export class Linter {
     }
   }
 }
-

package/src/parse-cache.ts

@@ -0,0 +1,39 @@
+import { DEFAULT_PARSER_OPTIONS } from "@herb-tools/core"
+import { DEFAULT_LINTER_PARSER_OPTIONS } from "./types.js"
+
+import type { ParseResult, HerbBackend, ParserOptions } from "@herb-tools/core"
+
+export class ParseCache {
+  private herb: HerbBackend
+  private cache = new Map<string, ParseResult>()
+
+  constructor(herb: HerbBackend) {
+    this.herb = herb
+  }
+
+  get(source: string, parserOptions: Partial<ParserOptions> = {}): ParseResult {
+    const effectiveOptions = this.resolveOptions(parserOptions)
+    const key = source + JSON.stringify(effectiveOptions)
+
+    let result = this.cache.get(key)
+
+    if (!result) {
+      result = this.herb.parse(source, effectiveOptions)
+      this.cache.set(key, result)
+    }
+
+    return result
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+
+  resolveOptions(parserOptions: Partial<ParserOptions>): ParserOptions {
+    return {
+      ...DEFAULT_PARSER_OPTIONS,
+      ...DEFAULT_LINTER_PARSER_OPTIONS,
+      ...parserOptions
+    }
+  }
+}

package/src/rules/actionview-no-silent-helper.ts

@@ -0,0 +1,58 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { isERBOpenTagNode, isERBOutputNode } from "@herb-tools/core"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, HTMLElementNode, ParserOptions } from "@herb-tools/core"
+
+class ActionViewNoSilentHelperVisitor extends BaseRuleVisitor {
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    this.checkActionViewHelper(node)
+    super.visitHTMLElementNode(node)
+  }
+
+  private checkActionViewHelper(node: HTMLElementNode): void {
+    if (!node.element_source || node.element_source === "HTML") return
+    if (!isERBOpenTagNode(node.open_tag)) return
+    if (isERBOutputNode(node.open_tag)) return
+
+    const tagOpening = node.open_tag.tag_opening?.value
+
+    if (!tagOpening) return
+
+    const helperName = node.element_source.includes("#")
+      ? node.element_source.split("#").pop()
+      : node.element_source
+
+    this.addOffense(
+      `Avoid using \`${tagOpening} %>\` with \`${helperName}\`. Use \`<%= %>\` to ensure the helper's output is rendered.`,
+      node.open_tag.location,
+    )
+  }
+}
+
+export class ActionViewNoSilentHelperRule extends ParserRule {
+  static ruleName = "actionview-no-silent-helper"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  get parserOptions(): Partial<ParserOptions> {
+    return {
+      track_whitespace: true,
+      action_view_helpers: true,
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ActionViewNoSilentHelperVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-comment-syntax.ts

@@ -34,7 +34,7 @@ class ERBCommentSyntaxVisitor extends BaseRuleVisitor<ERBCommentSyntaxAutofixCon
 
 export class ERBCommentSyntax extends ParserRule<ERBCommentSyntaxAutofixContext> {
   static autocorrectable = true
-  name = "erb-comment-syntax"
+  static ruleName = "erb-comment-syntax"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -44,7 +44,7 @@ export class ERBCommentSyntax extends ParserRule<ERBCommentSyntaxAutofixContext>
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBCommentSyntaxAutofixContext>[] {
-    const visitor = new ERBCommentSyntaxVisitor(this.name, context)
+    const visitor = new ERBCommentSyntaxVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/erb-no-case-node-children.ts

@@ -49,7 +49,7 @@ class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
 }
 
 export class ERBNoCaseNodeChildrenRule extends ParserRule {
-  name = "erb-no-case-node-children"
+  static ruleName = "erb-no-case-node-children"
 
   get defaultConfig(): FullRuleConfig {
     return {
@@ -59,7 +59,7 @@ export class ERBNoCaseNodeChildrenRule extends ParserRule {
   }
 
   check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
-    const visitor = new ERBNoCaseNodeChildrenVisitor(this.name, context)
+    const visitor = new ERBNoCaseNodeChildrenVisitor(this.ruleName, context)
 
     visitor.visit(result.value)
 

package/src/rules/erb-no-conditional-html-element.ts

@@ -0,0 +1,53 @@
+import dedent from "dedent"
+
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { ParseResult, HTMLConditionalElementNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+class ERBNoConditionalHTMLElementRuleVisitor extends BaseRuleVisitor {
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void {
+    const tagName = node.tag_name?.value || "element"
+    const condition = node.condition || "condition"
+
+    const suggestion = dedent`
+      Consider using a \`capture\` block instead:
+
+        <% content = capture do %>
+          ... your content here ...
+        <% end %>
+
+        <%= ${condition} ? content_tag(:${tagName}, content) : content %>
+    `
+
+    this.addOffense(
+      dedent`
+        Avoid opening and closing \`<${tagName}>\` tags in separate conditional blocks with the same condition. \
+        This pattern is difficult to read and maintain. ${suggestion}
+      `,
+      node.location,
+    )
+
+    this.visitChildNodes(node)
+  }
+}
+
+export class ERBNoConditionalHTMLElementRule extends ParserRule {
+  static ruleName = "erb-no-conditional-html-element"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoConditionalHTMLElementRuleVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-no-conditional-open-tag.ts

@@ -0,0 +1,37 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { ParseResult, HTMLConditionalOpenTagNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+class ERBNoConditionalOpenTagRuleVisitor extends BaseRuleVisitor {
+  visitHTMLConditionalOpenTagNode(node: HTMLConditionalOpenTagNode): void {
+    const tagName = node.tag_name?.value || "element"
+
+    this.addOffense(
+      `Avoid using ERB conditionals to split the open and closing tag of \`<${tagName}>\` element.`,
+      node.location,
+    )
+
+    this.visitChildNodes(node)
+  }
+}
+
+export class ERBNoConditionalOpenTagRule extends ParserRule {
+  static ruleName = "erb-no-conditional-open-tag"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoConditionalOpenTagRuleVisitor(this.ruleName, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}