@herb-tools/linter 0.8.6 → 0.8.8

package/src/cli.ts

@@ -1,9 +1,9 @@
-import { glob } from "glob"
+import { glob } from "tinyglobby"
 import { Herb } from "@herb-tools/node-wasm"
 import { Config, addHerbExtensionRecommendation, getExtensionsJsonRelativePath } from "@herb-tools/config"
 
 import { existsSync, statSync } from "fs"
-import { dirname, resolve, relative } from "path"
+import { resolve, relative } from "path"
 
 import { ArgumentParser } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
@@ -66,9 +66,9 @@ export class CLI {
     }
   }
 
-  protected adjustPattern(pattern: string | undefined, configGlobPattern: string): string {
+  protected adjustPattern(pattern: string | undefined, configGlobPatterns: string[]): string {
     if (!pattern) {
-      return configGlobPattern
+      return configGlobPatterns.length === 1 ? configGlobPatterns[0] : `{${configGlobPatterns.join(',')}}`
     }
 
     const resolvedPattern = resolve(pattern)
@@ -77,7 +77,15 @@ export class CLI {
       const stats = statSync(resolvedPattern)
 
       if (stats.isDirectory()) {
-        return configGlobPattern
+        const relativeDir = relative(this.projectPath, resolvedPattern)
+
+        if (relativeDir) {
+          const scopedPatterns = configGlobPatterns.map(pattern => `${relativeDir}/${pattern}`)
+
+          return scopedPatterns.length === 1 ? scopedPatterns[0] : `{${scopedPatterns.join(',')}}`
+        }
+
+        return configGlobPatterns.length === 1 ? configGlobPatterns[0] : `{${configGlobPatterns.join(',')}}`
       } else if (stats.isFile()) {
         return relative(this.projectPath, resolvedPattern)
       }
@@ -96,10 +104,11 @@ export class CLI {
     }
 
     const filesConfig = config.getFilesConfigForTool('linter')
-    const configGlobPattern = filesConfig.include && filesConfig.include.length > 0
-      ? (filesConfig.include.length === 1 ? filesConfig.include[0] : `{${filesConfig.include.join(',')}}`)
-      : '**/*.html.erb'
-    const adjustedPattern = this.adjustPattern(pattern, configGlobPattern)
+    const configGlobPatterns = filesConfig.include && filesConfig.include.length > 0
+      ? filesConfig.include
+      : ['**/*.html.erb']
+
+    const adjustedPattern = this.adjustPattern(pattern, configGlobPatterns)
 
     let files = await glob(adjustedPattern, {
       cwd: this.projectPath,
@@ -135,7 +144,7 @@ export class CLI {
     const startTime = Date.now()
     const startDate = new Date()
 
-    let { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, ignoreDisableComments, force, init, loadCustomRules } = this.argumentParser.parse(process.argv)
+    let { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, fixUnsafe, ignoreDisableComments, force, init, loadCustomRules, failLevel } = this.argumentParser.parse(process.argv)
 
     this.determineProjectPath(patterns)
 
@@ -239,6 +248,7 @@ export class CLI {
         projectPath: this.projectPath,
         pattern: patterns.join(' '),
         fix,
+        fixUnsafe,
         ignoreDisableComments,
         linterConfig,
         config: processingConfig,
@@ -250,7 +260,20 @@ export class CLI {
       await this.outputManager.outputResults({ ...results, files }, outputOptions)
       await this.afterProcess(results, outputOptions)
 
-      if (results.totalErrors > 0) {
+      const effectiveFailLevel = failLevel || linterConfig.failLevel
+
+      const errors = results.totalErrors > 0
+      const warnings = results.totalWarnings > 0
+      const info = results.totalInfo > 0
+      const hints = results.totalHints > 0
+
+      const shouldFailOnWarnings = effectiveFailLevel === "warning" && warnings
+      const shouldFailOnInfo = effectiveFailLevel === "info" && (warnings || info)
+      const shouldFailOnHints = effectiveFailLevel === "hint" && (warnings || info || hints)
+
+      const shouldFail = errors || shouldFailOnWarnings || shouldFailOnInfo || shouldFailOnHints
+
+      if (shouldFail) {
         process.exit(1)
       }
 

package/src/custom-rule-loader.ts

@@ -1,5 +1,5 @@
 import { pathToFileURL } from "url"
-import { glob } from "glob"
+import { glob } from "tinyglobby"
 
 import type { RuleClass } from "./types.js"
 
@@ -52,7 +52,7 @@ export class CustomRuleLoader {
         const files = await glob(pattern, {
           cwd: this.baseDir,
           absolute: true,
-          nodir: true
+          onlyFiles: true
         })
 
         allFiles.push(...files)

package/src/linter.ts

@@ -1,6 +1,6 @@
 import { Location } from "@herb-tools/core"
 import { IdentityPrinter } from "@herb-tools/printer"
-import { minimatch } from "minimatch"
+import picomatch from "picomatch"
 
 import { rules } from "./rules.js"
 import { findNodeByLocation } from "./rules/rule-utils.js"
@@ -191,7 +191,7 @@ export class Linter {
       const defaultExclude = rule.defaultConfig?.exclude ?? DEFAULT_RULE_CONFIG.exclude
 
       if (defaultExclude && defaultExclude.length > 0) {
-        const isExcluded = defaultExclude.some((pattern: string) => minimatch(context.fileName!, pattern))
+        const isExcluded = defaultExclude.some(pattern => picomatch.isMatch(context.fileName!, pattern))
 
         if (isExcluded) {
           return []
@@ -459,9 +459,12 @@ export class Linter {
    * @param source - The source code to fix
    * @param context - Optional context for linting (e.g., fileName)
    * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+   * @param options - Options for autofix behavior
+   * @param options.includeUnsafe - If true, also apply unsafe fixes (rules with unsafeAutocorrectable = true)
    * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
    */
-  autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult {
+  autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[], options?: { includeUnsafe?: boolean }): AutofixResult {
+    const includeUnsafe = options?.includeUnsafe ?? false
     const lintResult = offensesToFix ? { offenses: offensesToFix } : this.lint(source, context)
 
     const parserOffenses: LintOffense[] = []
@@ -503,6 +506,7 @@ export class Linter {
         }
 
         const rule = new RuleClass() as ParserRule
+        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
@@ -510,6 +514,12 @@ export class Linter {
           continue
         }
 
+        if (isUnsafe && !includeUnsafe) {
+          unfixed.push(offense)
+
+          continue
+        }
+
         if (offense.autofixContext) {
           const originalNodeType = offense.autofixContext.node.type
           const location: Location = offense.autofixContext.node.location ? Location.from(offense.autofixContext.node.location) : offense.location
@@ -562,12 +572,18 @@ export class Linter {
         }
 
         const rule = new RuleClass() as SourceRule
+        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
           continue
         }
 
+        if (isUnsafe && !includeUnsafe) {
+          unfixed.push(offense)
+          continue
+        }
+
         const correctedSource = rule.autofix(offense, currentSource, context)
 
         if (correctedSource) {

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

@@ -0,0 +1,274 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import { isPartialFile } from "./file-utils.js"
+import { hasBalancedParentheses, splitByTopLevelComma } from "./string-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
+
+export const STRICT_LOCALS_PATTERN = /^locals:\s*\([^)]*\)\s*$/
+
+function isValidStrictLocalsFormat(content: string): boolean {
+  return STRICT_LOCALS_PATTERN.test(content)
+}
+
+function extractERBCommentContent(content: string): string {
+  return content.trim()
+}
+
+function extractRubyCommentContent(content: string): string | null {
+  const match = content.match(/^\s*#\s*(.*)$/)
+
+  return match ? match[1].trim() : null
+}
+
+function extractLocalsRemainder(content: string): string | null {
+  const match = content.match(/^locals?\b(.*)$/)
+
+  return match ? match[1] : null
+}
+
+function looksLikeLocalsDeclaration(content: string): boolean {
+  return /^locals?\b/.test(content) && /[(:)]/.test(content)
+}
+
+function hasLocalsLikeSyntax(remainder: string): boolean {
+  return /[(:)]/.test(remainder)
+}
+
+function detectLocalsWithoutColon(content: string): boolean {
+  return /^locals?\(/.test(content)
+}
+
+function detectSingularLocal(content: string): boolean {
+  return /^local:/.test(content)
+}
+
+function detectMissingColonBeforeParens(content: string): boolean {
+  return /^locals\s+\(/.test(content)
+}
+
+function detectMissingParentheses(content: string): boolean {
+  return /^locals:\s*[^(]/.test(content)
+}
+
+function detectEmptyLocalsWithoutParens(content: string): boolean {
+  return /^locals:\s*$/.test(content)
+}
+
+function validateCommaUsage(inner: string): string | null {
+  if (inner.startsWith(",") || inner.endsWith(",") || /,,/.test(inner)) {
+    return "Unexpected comma in `locals:` parameters."
+  }
+
+  return null
+}
+
+function validateBlockArgument(param: string): string | null {
+  if (param.startsWith("&")) {
+    return `Block argument \`${param}\` is not allowed. Strict locals only support keyword arguments.`
+  }
+
+  return null
+}
+
+function validateSplatArgument(param: string): string | null {
+  if (param.startsWith("*") && !param.startsWith("**")) {
+    return `Splat argument \`${param}\` is not allowed. Strict locals only support keyword arguments.`
+  }
+
+  return null
+}
+
+function validateDoubleSplatArgument(param: string): string | null {
+  if (param.startsWith("**")) {
+    if (/^\*\*\w+$/.test(param)) {
+      return null // Valid double-splat
+    }
+
+    return `Invalid double-splat syntax \`${param}\`. Use \`**name\` format (e.g., \`**attributes\`).`
+  }
+
+  return null
+}
+
+function validateKeywordArgument(param: string): string | null {
+  if (!/^\w+:\s*/.test(param)) {
+    if (/^\w+$/.test(param)) {
+      return `Positional argument \`${param}\` is not allowed. Use keyword argument format: \`${param}:\`.`
+    }
+
+    return `Invalid parameter \`${param}\`. Use keyword argument format: \`name:\` or \`name: default\`.`
+  }
+
+  return null
+}
+
+function validateParameter(param: string): string | null {
+  const trimmed = param.trim()
+
+  if (!trimmed) return null
+
+  return (
+    validateBlockArgument(trimmed) ||
+    validateSplatArgument(trimmed) ||
+    validateDoubleSplatArgument(trimmed) ||
+    (trimmed.startsWith("**") ? null : validateKeywordArgument(trimmed))
+  )
+}
+
+function validateLocalsSignature(paramsContent: string): string | null {
+  const match = paramsContent.match(/^\s*\(([\s\S]*)\)\s*$/)
+  if (!match) return null
+
+  const inner = match[1].trim()
+  if (!inner) return null // Empty locals is valid: locals: ()
+
+  const commaError = validateCommaUsage(inner)
+  if (commaError) return commaError
+
+  const params = splitByTopLevelComma(inner)
+
+  for (const param of params) {
+    const error = validateParameter(param)
+    if (error) return error
+  }
+
+  return null
+}
+
+class ERBStrictLocalsCommentSyntaxVisitor extends BaseRuleVisitor {
+  private seenStrictLocalsComment: boolean = false
+  private firstStrictLocalsLocation: { line: number; column: number } | null = null
+
+  visitERBContentNode(node: ERBContentNode): void {
+    const openingTag = node.tag_opening?.value
+    const content = node.content?.value
+
+    if (!content) return
+
+    const commentContent = this.extractCommentContent(openingTag, content, node)
+    if (!commentContent) return
+
+    const remainder = extractLocalsRemainder(commentContent)
+    if (!remainder || !hasLocalsLikeSyntax(remainder)) return
+
+    this.validateLocalsComment(commentContent, node)
+  }
+
+  private extractCommentContent(openingTag: string | undefined, content: string, node: ERBContentNode): string | null {
+    if (openingTag === "<%#") {
+      return extractERBCommentContent(content)
+    }
+
+    if (openingTag === "<%" || openingTag === "<%-") {
+      const rubyComment = extractRubyCommentContent(content)
+
+      if (rubyComment && looksLikeLocalsDeclaration(rubyComment)) {
+        this.addOffense(`Use \`<%#\` instead of \`${openingTag} #\` for strict locals comments. Only ERB comment syntax is recognized by Rails.`, node.location)
+      }
+    }
+
+    return null
+  }
+
+  private validateLocalsComment(commentContent: string, node: ERBContentNode): void {
+    this.checkPartialFile(node)
+
+    if (!hasBalancedParentheses(commentContent)) {
+      this.addOffense("Unbalanced parentheses in `locals:` comment. Ensure all opening parentheses have matching closing parentheses.", node.location)
+      return
+    }
+
+    if (isValidStrictLocalsFormat(commentContent)) {
+      this.handleValidFormat(commentContent, node)
+      return
+    }
+
+    this.handleInvalidFormat(commentContent, node)
+  }
+
+  private checkPartialFile(node: ERBContentNode): void {
+    const isPartial = isPartialFile(this.context.fileName)
+
+    if (isPartial === false) {
+      this.addOffense("Strict locals (`locals:`) only work in partials (files starting with `_`). This declaration will be ignored.", node.location)
+    }
+  }
+
+  private handleValidFormat(commentContent: string, node: ERBContentNode): void {
+    if (this.seenStrictLocalsComment) {
+      this.addOffense(
+        `Duplicate \`locals:\` declaration. Only one \`locals:\` comment is allowed per partial (first declaration at line ${this.firstStrictLocalsLocation?.line}).`,
+        node.location
+      )
+
+      return
+    }
+
+    this.seenStrictLocalsComment = true
+    this.firstStrictLocalsLocation = {
+      line: node.location.start.line,
+      column: node.location.start.column
+    }
+
+    const paramsMatch = commentContent.match(/^locals:\s*(\([\s\S]*\))\s*$/)
+
+    if (paramsMatch) {
+      const error = validateLocalsSignature(paramsMatch[1])
+
+      if (error) {
+        this.addOffense(error, node.location)
+      }
+    }
+  }
+
+  private handleInvalidFormat(commentContent: string, node: ERBContentNode): void {
+    if (detectLocalsWithoutColon(commentContent)) {
+      this.addOffense("Use `locals:` with a colon, not `locals()`. Correct format: `<%# locals: (...) %>`.", node.location)
+      return
+    }
+
+    if (detectSingularLocal(commentContent)) {
+      this.addOffense("Use `locals:` (plural), not `local:`.", node.location)
+      return
+    }
+
+    if (detectMissingColonBeforeParens(commentContent)) {
+      this.addOffense("Use `locals:` with a colon before the parentheses, not `locals (`.", node.location)
+      return
+    }
+
+    if (detectMissingParentheses(commentContent)) {
+      this.addOffense("Wrap parameters in parentheses: `locals: (name:)` or `locals: (name: default)`.", node.location)
+      return
+    }
+
+    if (detectEmptyLocalsWithoutParens(commentContent)) {
+      this.addOffense("Add parameters after `locals:`. Use `locals: (name:)` or `locals: ()` for no locals.", node.location)
+      return
+    }
+
+    this.addOffense("Invalid `locals:` syntax. Use format: `locals: (name:, option: default)`.", node.location)
+  }
+}
+
+export class ERBStrictLocalsCommentSyntaxRule extends ParserRule {
+  name = "erb-strict-locals-comment-syntax"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBStrictLocalsCommentSyntaxVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-strict-locals-required.ts

@@ -0,0 +1,52 @@
+import { SourceRule } from "../types.js"
+import { Location } from "@herb-tools/core"
+import { BaseSourceRuleVisitor } from "./rule-utils.js"
+
+import { isPartialFile } from "./file-utils.js"
+
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+function hasStrictLocals(source: string): boolean {
+  return source.includes("<%# locals:") || source.includes("<%#locals:")
+}
+
+class ERBStrictLocalsRequiredVisitor extends BaseSourceRuleVisitor {
+  protected visitSource(source: string): void {
+    const isPartial = isPartialFile(this.context.fileName)
+
+    if (isPartial !== true) return
+    if (hasStrictLocals(source)) return
+
+    const firstLineLength = source.indexOf("\n") === -1 ? source.length : source.indexOf("\n")
+    const location = Location.from(1, 0, 1, firstLineLength)
+
+    this.addOffense(
+      "Partial is missing a strict locals declaration. Add `<%# locals: (...) %>` at the top of the file.",
+      location
+    )
+  }
+}
+
+export class ERBStrictLocalsRequiredRule extends SourceRule {
+  static unsafeAutocorrectable = true
+  name = "erb-strict-locals-required"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error",
+    }
+  }
+
+  check(source: string, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBStrictLocalsRequiredVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null {
+    return `<%# locals: () %>\n\n${source}`
+  }
+}

package/src/rules/file-utils.ts

@@ -0,0 +1,23 @@
+/**
+ * File path and naming utilities for linter rules
+ */
+
+/**
+ * Extracts the basename (filename) from a file path
+ * Works with both forward slashes and backslashes
+ */
+export function getBasename(filePath: string): string {
+  const lastSlash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"))
+
+  return lastSlash === -1 ? filePath : filePath.slice(lastSlash + 1)
+}
+
+/**
+ * Checks if a file is a Rails partial (filename starts with `_`)
+ * Returns null if fileName is undefined (unknown context)
+ */
+export function isPartialFile(fileName: string | undefined): boolean | null {
+  if (!fileName) return null
+
+  return getBasename(fileName).startsWith("_")
+}

package/src/rules/html-head-only-elements.ts

@@ -23,6 +23,7 @@ class HeadOnlyElementsVisitor extends BaseRuleVisitor {
     if (!this.insideBody) return
     if (!isHeadOnlyTag(tagName)) return
     if (tagName === "title" && this.insideSVG) return
+    if (tagName === "style" && this.insideSVG) return
     if (tagName === "meta" && this.hasItempropAttribute(node)) return
 
     this.addOffense(