@herb-tools/linter 0.4.2 → 0.5.0

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

@@ -0,0 +1,25 @@
+import { ParserRule } from "../types.js"
+
+import type { LintOffense } from "../types.js"
+import type { ParseResult, HerbError } from "@herb-tools/core"
+
+export class ParserNoErrorsRule extends ParserRule {
+  name = "parser-no-errors"
+
+  check(result: ParseResult): LintOffense[] {
+    return result.recursiveErrors().map(error =>
+      this.herbErrorToLintOffense(error)
+    )
+  }
+
+  private herbErrorToLintOffense(error: HerbError): LintOffense {
+    return {
+      message: `${error.message} (\`${error.type}\`)`,
+      location: error.location,
+      severity: error.severity,
+      rule: this.name,
+      code: this.name,
+      source: "linter"
+    }
+  }
+}

package/src/rules/rule-utils.ts

@@ -1,5 +1,7 @@
 import {
-  Visitor
+  Visitor,
+  Position,
+  Location
 } from "@herb-tools/core"
 
 import type {
@@ -10,9 +12,11 @@ import type {
   HTMLOpenTagNode,
   HTMLSelfCloseTagNode,
   LiteralNode,
-  Location
+  LexResult,
+  Token
 } from "@herb-tools/core"
-import type { LintOffense, LintSeverity, } from "../types.js"
+import type { LintOffense, LintSeverity, LintContext } from "../types.js"
+import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
 /**
  * Base visitor class that provides common functionality for rule visitors
@@ -20,11 +24,13 @@ import type { LintOffense, LintSeverity, } from "../types.js"
 export abstract class BaseRuleVisitor extends Visitor {
   public readonly offenses: LintOffense[] = []
   protected ruleName: string
+  protected context: LintContext
 
-  constructor(ruleName: string) {
+  constructor(ruleName: string, context?: Partial<LintContext>) {
     super()
 
     this.ruleName = ruleName
+    this.context = { ...DEFAULT_LINT_CONTEXT, ...context }
   }
 
   /**
@@ -299,6 +305,22 @@ export const ARIA_ATTRIBUTES =  new Set([
   'aria-valuetext',
 ])
 
+/**
+ * Helper function to create a location at the end of the source with a 1-character range
+ */
+export function createEndOfFileLocation(source: string): Location {
+  const lines = source.split('\n')
+  const lastLineNumber = lines.length
+  const lastLine = lines[lines.length - 1]
+  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)
+}
+
 /**
  * Checks if an element is inline
  */
@@ -326,6 +348,10 @@ export function isBooleanAttribute(attributeName: string): boolean {
  * and attribute iteration logic. Provides simplified interface with extracted attribute info.
  */
 export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+  constructor(ruleName: string, context?: Partial<LintContext>) {
+    super(ruleName, context)
+  }
+
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
     this.checkAttributesOnNode(node)
     super.visitHTMLOpenTagNode(node)
@@ -383,3 +409,129 @@ export function forEachAttribute(
     }
   }
 }
+
+/**
+ * Base lexer visitor class that provides common functionality for lexer-based rule visitors
+ */
+export abstract class BaseLexerRuleVisitor {
+  public readonly offenses: LintOffense[] = []
+  protected ruleName: string
+  protected context: LintContext
+
+  constructor(ruleName: string, context?: Partial<LintContext>) {
+    this.ruleName = ruleName
+    this.context = { ...DEFAULT_LINT_CONTEXT, ...context }
+  }
+
+  /**
+   * Helper method to create a lint offense for lexer rules
+   */
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+    return {
+      rule: this.ruleName,
+      code: this.ruleName,
+      source: "Herb Linter",
+      message,
+      location,
+      severity,
+    }
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * Main entry point for lexer rule visitors
+   * @param lexResult - The lexer result containing tokens and source
+   */
+  visit(lexResult: LexResult): void {
+    this.visitTokens(lexResult.value.tokens)
+  }
+
+  /**
+   * Visit all tokens
+   * Override this method to implement token-level checks
+   */
+  protected visitTokens(tokens: Token[]): void {
+    for (const token of tokens) {
+      this.visitToken(token)
+    }
+  }
+
+  /**
+   * Visit individual tokens
+   * Override this method to implement per-token checks
+   */
+  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[] = []
+  protected ruleName: string
+  protected context: LintContext
+
+  constructor(ruleName: string, context?: Partial<LintContext>) {
+    this.ruleName = ruleName
+    this.context = { ...DEFAULT_LINT_CONTEXT, ...context }
+  }
+
+  /**
+   * Helper method to create a lint offense for source rules
+   */
+  protected createOffense(message: string, location: Location, severity: LintSeverity = "error"): LintOffense {
+    return {
+      rule: this.ruleName as any, // Type assertion for compatibility
+      code: this.ruleName,
+      source: "Herb Linter",
+      message,
+      location,
+      severity,
+    }
+  }
+
+  /**
+   * 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))
+  }
+
+  /**
+   * Main entry point for source rule visitors
+   * @param source - The raw source code
+   */
+  visit(source: string): void {
+    this.visitSource(source)
+  }
+
+  /**
+   * Visit the source code directly
+   * 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
+
+    const start = new Position(line, column)
+    const end = new Position(line, column)
+
+    return new Location(start, end)
+  }
+}

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor, SVG_CAMEL_CASE_ELEMENTS, SVG_LOWERCASE_TO_CAMELCASE } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, ParseResult } from "@herb-tools/core"
 
 class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
   private insideSVG = false
@@ -62,12 +63,12 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
   }
 }
 
-export class SVGTagNameCapitalizationRule implements Rule {
+export class SVGTagNameCapitalizationRule extends ParserRule {
   name = "svg-tag-name-capitalization"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new SVGTagNameCapitalizationVisitor(this.name)
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+    visitor.visit(result.value)
     return visitor.offenses
   }
 }

package/src/types.ts

@@ -1,7 +1,7 @@
-import { Node, Diagnostic } from "@herb-tools/core"
+import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core"
 import type { defaultRules } from "./default-rules.js"
 
-export type LintSeverity = "error" | "warning"
+export type LintSeverity = "error" | "warning" | "info" | "hint"
 
 /**
  * Automatically inferred union type of all available linter rule names.
@@ -20,13 +20,67 @@ export interface LintResult {
   warnings: number
 }
 
-export interface Rule {
-  name: string
-  check(node: Node): LintOffense[]
+export abstract class ParserRule {
+  static type = "parser" as const
+  abstract name: string
+  abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[]
+}
+
+export abstract class LexerRule {
+  static type = "lexer" as const
+  abstract name: string
+  abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[]
+}
+
+export interface LexerRuleConstructor {
+  type: "lexer"
+  new (): LexerRule
+}
+
+/**
+ * Complete lint context with all properties defined.
+ * Use Partial<LintContext> when passing context to rules.
+ */
+export interface LintContext {
+  fileName: string | undefined
 }
 
 /**
- * Type representing a rule class constructor.
+ * Default context object with all keys defined but set to undefined
+ */
+export const DEFAULT_LINT_CONTEXT: LintContext = {
+  fileName: undefined
+} as const
+
+export abstract class SourceRule {
+  static type = "source" as const
+  abstract name: string
+  abstract check(source: string, context?: Partial<LintContext>): LintOffense[]
+}
+
+export interface SourceRuleConstructor {
+  type: "source"
+  new (): SourceRule
+}
+
+/**
+ * Type representing a parser/AST rule class constructor.
  * The Linter accepts rule classes rather than instances for better performance and memory usage.
+ * Parser rules are the default and don't require static properties.
+ */
+export type ParserRuleClass = (new () => ParserRule) & {
+  type?: "parser"
+}
+
+export type LexerRuleClass = LexerRuleConstructor
+export type SourceRuleClass = SourceRuleConstructor
+
+/**
+ * Union type for any rule instance (Parser/AST, Lexer, or Source)
+ */
+export type Rule = ParserRule | LexerRule | SourceRule
+
+/**
+ * Union type for any rule class (Parser/AST, Lexer, or Source)
  */
-export type RuleClass = new () => Rule
+export type RuleClass = ParserRuleClass | LexerRuleClass | SourceRuleClass