@herb-tools/linter 0.7.4 → 0.8.0

package/src/custom-rule-loader.ts

@@ -0,0 +1,189 @@
+import { pathToFileURL } from "url"
+import { glob } from "glob"
+
+import type { RuleClass } from "./types.js"
+
+export interface CustomRuleLoaderOptions {
+  /**
+   * Base directory to search for custom rules
+   * Defaults to current working directory
+   */
+  baseDir?: string
+
+  /**
+   * Glob patterns to search for custom rule files
+   * Defaults to looking in common locations
+   */
+  patterns?: string[]
+
+  /**
+   * Whether to suppress errors when loading custom rules
+   * Defaults to false
+   */
+  silent?: boolean
+}
+
+const DEFAULT_PATTERNS = [
+  ".herb/rules/**/*.mjs",
+]
+
+/**
+ * Loads custom linter rules from the user's project
+ */
+export class CustomRuleLoader {
+  private baseDir: string
+  private patterns: string[]
+  private silent: boolean
+
+  constructor(options: CustomRuleLoaderOptions = {}) {
+    this.baseDir = options.baseDir || process.cwd()
+    this.patterns = options.patterns || DEFAULT_PATTERNS
+    this.silent = options.silent || false
+  }
+
+  /**
+   * Discovers custom rule files in the project
+   */
+  async discoverRuleFiles(): Promise<string[]> {
+    const allFiles: string[] = []
+
+    for (const pattern of this.patterns) {
+      try {
+        const files = await glob(pattern, {
+          cwd: this.baseDir,
+          absolute: true,
+          nodir: true
+        })
+
+        allFiles.push(...files)
+      } catch (error) {
+        if (!this.silent) {
+          console.warn(`Warning: Failed to search pattern "${pattern}": ${error}`)
+        }
+      }
+    }
+
+    return [...new Set(allFiles)]
+  }
+
+  /**
+   * Loads a single rule file
+   */
+  async loadRuleFile(filePath: string): Promise<RuleClass[]> {
+    try {
+      const fileUrl = pathToFileURL(filePath).href
+      const cacheBustedUrl = `${fileUrl}?t=${Date.now()}`
+      const module = await import(cacheBustedUrl)
+
+      if (module.default && this.isValidRuleClass(module.default)) {
+        return [module.default]
+      }
+
+      if (!this.silent) {
+        console.warn(`Warning: No valid default export found in "${filePath}". Custom rules must use default export.`)
+      }
+
+      return []
+    } catch (error) {
+      if (!this.silent) {
+        console.error(`Error loading rule file "${filePath}": ${error}`)
+      }
+      return []
+    }
+  }
+
+  /**
+   * Type guard to check if an export is a valid rule class
+   */
+  private isValidRuleClass(value: any): value is RuleClass {
+    if (typeof value !== 'function') return false
+    if (!value.prototype) return false
+
+    const instance = new value()
+
+    return typeof instance.check === 'function' && typeof instance.name === 'string'
+  }
+
+  /**
+   * Loads all custom rules from the project
+   */
+  async loadRules(): Promise<RuleClass[]> {
+    const ruleFiles = await this.discoverRuleFiles()
+
+    if (ruleFiles.length === 0) {
+      return []
+    }
+
+    const allRules: RuleClass[] = []
+
+    for (const filePath of ruleFiles) {
+      const rules = await this.loadRuleFile(filePath)
+      allRules.push(...rules)
+    }
+
+    return allRules
+  }
+
+  /**
+   * Loads all custom rules and returns detailed information about each rule
+   */
+  async loadRulesWithInfo(): Promise<{ rules: RuleClass[], ruleInfo: Array<{ name: string, path: string }>, duplicateWarnings: string[] }> {
+    const ruleFiles = await this.discoverRuleFiles()
+
+    if (ruleFiles.length === 0) {
+      return { rules: [], ruleInfo: [], duplicateWarnings: [] }
+    }
+
+    const allRules: RuleClass[] = []
+    const ruleInfo: Array<{ name: string, path: string }> = []
+    const duplicateWarnings: string[] = []
+    const seenNames = new Map<string, string>()
+
+    for (const filePath of ruleFiles) {
+      const rules = await this.loadRuleFile(filePath)
+      for (const RuleClass of rules) {
+        const instance = new RuleClass()
+        const ruleName = instance.name
+
+        if (seenNames.has(ruleName)) {
+          const firstPath = seenNames.get(ruleName)!
+          duplicateWarnings.push(
+            `Custom rule "${ruleName}" is defined in multiple files: "${firstPath}" and "${filePath}". The later one will be used.`
+          )
+        } else {
+          seenNames.set(ruleName, filePath)
+        }
+
+        allRules.push(RuleClass)
+        ruleInfo.push({
+          name: ruleName,
+          path: filePath
+        })
+      }
+    }
+
+    return { rules: allRules, ruleInfo, duplicateWarnings }
+  }
+
+  /**
+   * Static helper to check if custom rules exist in a project
+   */
+  static async hasCustomRules(baseDir: string = process.cwd()): Promise<boolean> {
+    const loader = new CustomRuleLoader({ baseDir, silent: true })
+    const files = await loader.discoverRuleFiles()
+    return files.length > 0
+  }
+
+  /**
+   * Static helper to load custom rules and merge with default rules
+   */
+  static async loadAndMergeRules(
+    defaultRules: RuleClass[],
+    options: CustomRuleLoaderOptions = {}
+  ): Promise<RuleClass[]> {
+    const loader = new CustomRuleLoader(options)
+    const customRules = await loader.loadRules()
+
+    return [...defaultRules, ...customRules]
+  }
+}

package/src/herb-disable-comment-utils.ts

@@ -0,0 +1,175 @@
+/**
+ * Utilities for parsing herb:disable comments
+ */
+
+/**
+ * Information about a single rule name in a herb:disable comment
+ */
+export interface HerbDisableRuleName {
+  /** The rule name */
+  name: string
+  /** The starting offset of this rule name within the content/line */
+  offset: number
+  /** The length of the rule name */
+  length: number
+}
+
+/**
+ * Result of parsing a herb:disable comment
+ */
+export interface HerbDisableComment {
+  /** The full matched string */
+  match: string
+  /** Array of rule names specified in the comment */
+  ruleNames: string[]
+  /** Array of rule name information with positions */
+  ruleNameDetails: HerbDisableRuleName[]
+  /** The original rules string (e.g., "rule1, rule2") */
+  rulesString: string
+}
+
+/**
+ * Prefix for herb:disable comments
+ */
+const HERB_DISABLE_PREFIX = "herb:disable"
+
+/**
+ * Parse a herb:disable comment from ERB comment content.
+ * Use this when you have the content inside <%# ... %> (e.g., from ERBContentNode.content.value)
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableContent("herb:disable rule1, rule2")
+ * // { match: "herb:disable rule1, rule2", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export function parseHerbDisableContent(content: string): HerbDisableComment | null {
+  const trimmed = content.trim()
+
+  if (!trimmed.startsWith(HERB_DISABLE_PREFIX)) return null
+
+  const afterPrefix = trimmed.substring(HERB_DISABLE_PREFIX.length).trimStart()
+  if (afterPrefix.length === 0) return null
+
+  const rulesString = afterPrefix.trimEnd()
+  const ruleNames = rulesString.split(',').map(name => name.trim())
+
+  if (ruleNames.some(name => name.length === 0)) return null
+  if (ruleNames.length === 0) return null
+
+  const herbDisablePrefix = content.indexOf(HERB_DISABLE_PREFIX)
+  const searchStart = herbDisablePrefix + HERB_DISABLE_PREFIX.length
+  const rulesStringOffset = content.indexOf(rulesString, searchStart)
+
+  const ruleNameDetails: HerbDisableRuleName[] = []
+
+  let currentOffset = 0
+
+  for (const ruleName of ruleNames) {
+    const ruleOffset = rulesString.indexOf(ruleName, currentOffset)
+
+    ruleNameDetails.push({
+      name: ruleName,
+      offset: rulesStringOffset + ruleOffset,
+      length: ruleName.length
+    })
+
+    currentOffset = ruleOffset + ruleName.length
+  }
+
+  return {
+    match: trimmed,
+    ruleNames,
+    ruleNameDetails,
+    rulesString
+  }
+}
+
+/**
+ * Parse a herb:disable comment from a full source line.
+ * Use this when you have a complete line that may contain <%# herb:disable ... %>
+ *
+ * @param line - The source line that may contain a herb:disable comment
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableLine("<div>test</div> <%# herb:disable rule1, rule2 %>")
+ * // { match: "<%# herb:disable rule1, rule2 %>", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export function parseHerbDisableLine(line: string): HerbDisableComment | null {
+  const startTag = "<%#"
+  const endTag = "%>"
+
+  const startIndex = line.indexOf(startTag)
+  if (startIndex === -1) return null
+
+  const endIndex = line.indexOf(endTag, startIndex)
+  if (endIndex === -1) return null
+
+  const content = line.substring(startIndex + startTag.length, endIndex).trim()
+
+  if (!content.startsWith(HERB_DISABLE_PREFIX)) return null
+
+  const afterPrefix = content.substring(HERB_DISABLE_PREFIX.length).trimStart()
+  if (afterPrefix.length === 0) return null
+
+  const rulesString = afterPrefix.trimEnd()
+  const ruleNames = rulesString.split(',').map(name => name.trim())
+
+  if (ruleNames.some(name => name.length === 0)) return null
+  if (ruleNames.length === 0) return null
+
+  const herbDisablePrefix = line.indexOf(HERB_DISABLE_PREFIX)
+  const searchStart = herbDisablePrefix + HERB_DISABLE_PREFIX.length
+  const rulesStringOffset = line.indexOf(rulesString, searchStart)
+
+  const ruleNameDetails: HerbDisableRuleName[] = []
+
+  let currentOffset = 0
+
+  for (const ruleName of ruleNames) {
+    const ruleOffset = rulesString.indexOf(ruleName, currentOffset)
+
+    ruleNameDetails.push({
+      name: ruleName,
+      offset: rulesStringOffset + ruleOffset,
+      length: ruleName.length
+    })
+
+    currentOffset = ruleOffset + ruleName.length
+  }
+
+  const fullMatch = line.substring(startIndex, endIndex + endTag.length)
+
+  return {
+    match: fullMatch,
+    ruleNames,
+    ruleNameDetails,
+    rulesString
+  }
+}
+
+/**
+ * Check if an ERB comment content contains a herb:disable directive.
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns true if the content contains a herb:disable directive
+ */
+export function isHerbDisableContent(content: string): boolean {
+  return parseHerbDisableContent(content) !== null
+}
+
+/**
+ * Check if a source line contains a herb:disable comment.
+ *
+ * @param line - The source line
+ * @returns true if the line contains a herb:disable comment
+ */
+export function isHerbDisableLine(line: string): boolean {
+  return parseHerbDisableLine(line) !== null
+}

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from "./linter.js"
 export * from "./rules/index.js"
 export * from "./types.js"
+
+export { rules } from "./rules.js"