@herb-tools/linter 0.4.1 → 0.4.3

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 }
   }
 
   /**
@@ -188,6 +194,53 @@ export const HTML_BOOLEAN_ATTRIBUTES = new Set([
 
 export const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"])
 
+/**
+ * SVG elements that use camelCase naming
+ */
+export const SVG_CAMEL_CASE_ELEMENTS = new Set([
+  "animateMotion",
+  "animateTransform",
+  "clipPath",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "foreignObject",
+  "glyphRef",
+  "linearGradient",
+  "radialGradient",
+  "textPath"
+])
+
+/**
+ * Mapping from lowercase SVG element names to their correct camelCase versions
+ * Generated dynamically from SVG_CAMEL_CASE_ELEMENTS
+ */
+export const SVG_LOWERCASE_TO_CAMELCASE = new Map(
+  Array.from(SVG_CAMEL_CASE_ELEMENTS).map(element => [element.toLowerCase(), element])
+)
+
 export const VALID_ARIA_ROLES = new Set([
   "banner", "complementary", "contentinfo", "form", "main", "navigation", "region", "search",
   "article", "cell", "columnheader", "definition", "directory", "document", "feed", "figure",
@@ -252,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
  */
@@ -279,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)
@@ -336,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

@@ -0,0 +1,74 @@
+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 { HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+
+class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
+  private insideSVG = false
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = node.tag_name?.value
+
+    if (tagName && ["svg"].includes(tagName.toLowerCase())) {
+      const wasInsideSVG = this.insideSVG
+      this.insideSVG = true
+      this.visitChildNodes(node)
+      this.insideSVG = wasInsideSVG
+      return
+    }
+
+    if (this.insideSVG) {
+      if (node.open_tag) {
+        this.checkTagName(node.open_tag as HTMLOpenTagNode)
+      }
+      if (node.close_tag) {
+        this.checkTagName(node.close_tag as HTMLCloseTagNode)
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
+    if (this.insideSVG) {
+      this.checkTagName(node)
+    }
+    this.visitChildNodes(node)
+  }
+
+  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode | HTMLSelfCloseTagNode): void {
+    const tagName = node.tag_name?.value
+
+    if (!tagName) return
+
+    if (SVG_CAMEL_CASE_ELEMENTS.has(tagName)) return
+
+    const lowercaseTagName = tagName.toLowerCase()
+    const correctCamelCase = SVG_LOWERCASE_TO_CAMELCASE.get(lowercaseTagName)
+
+    if (correctCamelCase && tagName !== correctCamelCase) {
+      let type: string = node.type
+
+      if (node.type == "AST_HTML_OPEN_TAG_NODE") type = "Opening"
+      if (node.type == "AST_HTML_CLOSE_TAG_NODE") type = "Closing"
+      if (node.type == "AST_HTML_SELF_CLOSE_TAG_NODE") type = "Self-closing"
+
+      this.addOffense(
+        `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,
+        node.tag_name!.location,
+        "error"
+      )
+    }
+  }
+}
+
+export class SVGTagNameCapitalizationRule extends ParserRule {
+  name = "svg-tag-name-capitalization"
+
+  check(node: Node, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new SVGTagNameCapitalizationVisitor(this.name, context)
+    visitor.visit(node)
+    return visitor.offenses
+  }
+}

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Node, Diagnostic } from "@herb-tools/core"
+import { Node, Diagnostic, LexResult } from "@herb-tools/core"
 import type { defaultRules } from "./default-rules.js"
 
 export type LintSeverity = "error" | "warning"
@@ -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(node: Node, 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