@herb-tools/linter 0.8.6 → 0.8.8

package/src/rules/html-no-duplicate-attributes.ts

@@ -1,48 +1,163 @@
-import { ParserRule } from "../types.js"
-import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
+import { ParserRule, BaseAutofixContext } from "../types.js"
+import { ControlFlowTrackingVisitor, ControlFlowType, getAttributeName } from "./rule-utils.js"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
-import type { HTMLOpenTagNode, HTMLAttributeNode, ParseResult } from "@herb-tools/core"
+import type { HTMLOpenTagNode, HTMLAttributeNode, ParseResult, Location } from "@herb-tools/core"
 
-class NoDuplicateAttributesVisitor extends AttributeVisitorMixin {
-  private attributeNames = new Map<string, HTMLAttributeNode[]>()
+interface ControlFlowState {
+  previousBranchAttributes: Set<string>
+  previousControlFlowAttributes: Set<string>
+}
+
+interface BranchState {
+  previousBranchAttributes: Set<string>
+}
+
+class NoDuplicateAttributesVisitor extends ControlFlowTrackingVisitor<
+  BaseAutofixContext,
+  ControlFlowState,
+  BranchState
+> {
+  private tagAttributes = new Set<string>()
+  private currentBranchAttributes = new Set<string>()
+  private controlFlowAttributes = new Set<string>()
 
   visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
-    this.attributeNames.clear()
+    this.tagAttributes = new Set()
+    this.currentBranchAttributes = new Set()
+    this.controlFlowAttributes = new Set()
     super.visitHTMLOpenTagNode(node)
-    this.reportDuplicates()
   }
 
+  visitHTMLAttributeNode(node: HTMLAttributeNode): void {
+    this.checkAttribute(node)
+  }
+
+  protected onEnterControlFlow(_controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): ControlFlowState {
+    const stateToRestore: ControlFlowState = {
+      previousBranchAttributes: this.currentBranchAttributes,
+      previousControlFlowAttributes: this.controlFlowAttributes,
+    }
+
+    this.currentBranchAttributes = new Set()
+
+    if (!wasAlreadyInControlFlow) {
+      this.controlFlowAttributes = new Set()
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitControlFlow(
+    controlFlowType: ControlFlowType,
+    wasAlreadyInControlFlow: boolean,
+    stateToRestore: ControlFlowState,
+  ): void {
+    if (controlFlowType === ControlFlowType.CONDITIONAL && !wasAlreadyInControlFlow) {
+      this.controlFlowAttributes.forEach((attr) => this.tagAttributes.add(attr))
+    }
+
+    this.currentBranchAttributes = stateToRestore.previousBranchAttributes
+    this.controlFlowAttributes = stateToRestore.previousControlFlowAttributes
+  }
+
+  protected onEnterBranch(): BranchState {
+    const stateToRestore: BranchState = {
+      previousBranchAttributes: this.currentBranchAttributes,
+    }
+
+    if (this.isInControlFlow) {
+      this.currentBranchAttributes = new Set()
+    }
+
+    return stateToRestore
+  }
+
+  protected onExitBranch(_stateToRestore: BranchState): void {}
+
+  private checkAttribute(attributeNode: HTMLAttributeNode): void {
+    const identifier = getAttributeName(attributeNode)
+    if (!identifier) return
 
-  protected checkStaticAttributeStaticValue({ attributeName, attributeNode }: StaticAttributeStaticValueParams): void {
-    this.trackAttributeName(attributeName, attributeNode)
+    this.processAttributeDuplicate(identifier, attributeNode)
   }
 
-  protected checkStaticAttributeDynamicValue({ attributeName, attributeNode }: StaticAttributeDynamicValueParams): void {
-    this.trackAttributeName(attributeName, attributeNode)
+  private processAttributeDuplicate(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (!this.isInControlFlow) {
+      this.handleHTMLAttribute(identifier, attributeNode)
+      return
+    }
+
+    if (this.currentControlFlowType === ControlFlowType.LOOP) {
+      this.handleLoopAttribute(identifier, attributeNode)
+    } else {
+      this.handleConditionalAttribute(identifier, attributeNode)
+    }
+
+    this.currentBranchAttributes.add(identifier)
   }
 
-  private trackAttributeName(attributeName: string, attributeNode: HTMLAttributeNode): void {
-    if (!this.attributeNames.has(attributeName)) {
-      this.attributeNames.set(attributeName, [])
+  private handleHTMLAttribute(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.tagAttributes.has(identifier)) {
+      this.addDuplicateAttributeOffense(identifier, attributeNode.name!.location)
+    }
+
+    this.tagAttributes.add(identifier)
+  }
+
+  private handleLoopAttribute(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.currentBranchAttributes.has(identifier)) {
+      this.addSameLoopIterationOffense(identifier, attributeNode.name!.location)
+      return
+    }
+
+    if (this.tagAttributes.has(identifier)) {
+      this.addDuplicateAttributeOffense(identifier, attributeNode.name!.location)
+      return
     }
 
-    this.attributeNames.get(attributeName)!.push(attributeNode)
+    this.addLoopWillDuplicateOffense(identifier, attributeNode.name!.location)
   }
 
-  private reportDuplicates(): void {
-    for (const [attributeName, attributeNodes] of this.attributeNames) {
-      if (attributeNodes.length > 1) {
-        for (let i = 1; i < attributeNodes.length; i++) {
-          const attributeNode = attributeNodes[i]
+  private handleConditionalAttribute(identifier: string, attributeNode: HTMLAttributeNode): void {
+    if (this.currentBranchAttributes.has(identifier)) {
+      this.addSameBranchOffense(identifier, attributeNode.name!.location)
+      return
+    }
 
-          this.addOffense(
-            `Duplicate attribute \`${attributeName}\` found on tag. Remove the duplicate occurrence.`,
-            attributeNode.name!.location,
-          )
-        }
-      }
+    if (this.tagAttributes.has(identifier)) {
+      this.addDuplicateAttributeOffense(identifier, attributeNode.name!.location)
     }
+
+    this.controlFlowAttributes.add(identifier)
+  }
+
+  private addDuplicateAttributeOffense(identifier: string, location: Location): void {
+    this.addOffense(
+      `Duplicate attribute \`${identifier}\`. Browsers only use the first occurrence and ignore duplicate attributes. Remove the duplicate or merge the values.`,
+      location,
+    )
+  }
+
+  private addSameLoopIterationOffense(identifier: string, location: Location): void {
+    this.addOffense(
+      `Duplicate attribute \`${identifier}\` in same loop iteration. Each iteration will produce an element with duplicate attributes. Remove one or merge the values.`,
+      location,
+    )
+  }
+
+  private addLoopWillDuplicateOffense(identifier: string, location: Location): void {
+    this.addOffense(
+      `Attribute \`${identifier}\` inside loop will appear multiple times on this element. Use a dynamic attribute name like \`${identifier}-<%= index %>\` or move the attribute outside the loop.`,
+      location,
+    )
+  }
+
+  private addSameBranchOffense(identifier: string, location: Location): void {
+    this.addOffense(
+      `Duplicate attribute \`${identifier}\` in same branch. This branch will produce an element with duplicate attributes. Remove one or merge the values.`,
+      location,
+    )
   }
 }
 

package/src/rules/html-no-empty-headings.ts

@@ -1,31 +1,29 @@
 import { BaseRuleVisitor, getTagName, getAttributes, findAttributeByName, getAttributeValue, HEADING_TAGS } from "./rule-utils.js"
+import { isHTMLOpenTagNode, isLiteralNode, isHTMLTextNode, isHTMLElementNode } from "@herb-tools/core"
 
 import { ParserRule } from "../types.js"
 
 import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
-import type { HTMLElementNode, HTMLOpenTagNode, ParseResult, LiteralNode, HTMLTextNode } from "@herb-tools/core"
+import type { HTMLElementNode, HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node.open_tag)?.toLowerCase()
+    if (tagName === "template") return
+
     this.checkHeadingElement(node)
     super.visitHTMLElementNode(node)
   }
 
-
   private checkHeadingElement(node: HTMLElementNode): void {
-    if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
-      return
-    }
+    if (!node.open_tag) return
+    if (!isHTMLOpenTagNode(node.open_tag)) return
 
-    const openTag = node.open_tag as HTMLOpenTagNode
-    const tagName = getTagName(openTag)
-
-    if (!tagName) {
-      return
-    }
+    const tagName = getTagName(node.open_tag)
+    if (!tagName) return
 
     const isStandardHeading = HEADING_TAGS.has(tagName)
-    const isAriaHeading = this.hasHeadingRole(openTag)
+    const isAriaHeading = this.hasHeadingRole(node.open_tag)
 
     if (!isStandardHeading && !isAriaHeading) {
       return
@@ -43,7 +41,6 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
     }
   }
 
-
   private isEmptyHeading(node: HTMLElementNode): boolean {
     if (!node.body || node.body.length === 0) {
       return true
@@ -52,24 +49,13 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
     let hasAccessibleContent = false
 
     for (const child of node.body) {
-      if (child.type === "AST_LITERAL_NODE") {
-        const literalNode = child as LiteralNode
-
-        if (literalNode.content.trim().length > 0) {
+      if (isLiteralNode(child) || isHTMLTextNode(child)) {
+        if (child.content.trim().length > 0) {
           hasAccessibleContent = true
           break
         }
-      } else if (child.type === "AST_HTML_TEXT_NODE") {
-        const textNode = child as HTMLTextNode
-
-        if (textNode.content.trim().length > 0) {
-          hasAccessibleContent = true
-          break
-        }
-      } else if (child.type === "AST_HTML_ELEMENT_NODE") {
-        const elementNode = child as HTMLElementNode
-
-        if (this.isElementAccessible(elementNode)) {
+      } else if (isHTMLElementNode(child)) {
+        if (this.isElementAccessible(child)) {
           hasAccessibleContent = true
           break
         }
@@ -95,12 +81,10 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
   }
 
   private isElementAccessible(node: HTMLElementNode): boolean {
-    if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
-      return true
-    }
+    if (!node.open_tag) return true
+    if (!isHTMLOpenTagNode(node.open_tag)) return true
 
-    const openTag = node.open_tag as HTMLOpenTagNode
-    const attributes = getAttributes(openTag)
+    const attributes = getAttributes(node.open_tag)
     const ariaHiddenAttribute = findAttributeByName(attributes, "aria-hidden")
 
     if (ariaHiddenAttribute) {
@@ -116,19 +100,12 @@ class NoEmptyHeadingsVisitor extends BaseRuleVisitor {
     }
 
     for (const child of node.body) {
-      if (child.type === "AST_LITERAL_NODE") {
-        const literalNode = child as LiteralNode
-        if (literalNode.content.trim().length > 0) {
-          return true
-        }
-      } else if (child.type === "AST_HTML_TEXT_NODE") {
-        const textNode = child as HTMLTextNode
-        if (textNode.content.trim().length > 0) {
+      if (isLiteralNode(child) || isHTMLTextNode(child)) {
+        if (child.content.trim().length > 0) {
           return true
         }
-      } else if (child.type === "AST_HTML_ELEMENT_NODE") {
-        const elementNode = child as HTMLElementNode
-        if (this.isElementAccessible(elementNode)) {
+      } else if (isHTMLElementNode(child)) {
+        if (this.isElementAccessible(child)) {
           return true
         }
       } else {

package/src/rules/index.ts

@@ -1,4 +1,6 @@
 export * from "./rule-utils.js"
+export * from "./file-utils.js"
+export * from "./string-utils.js"
 export * from "./herb-disable-comment-base.js"
 
 export * from "./erb-comment-syntax.js"
@@ -12,6 +14,8 @@ export * from "./erb-prefer-image-tag-helper.js"
 export * from "./erb-require-trailing-newline.js"
 export * from "./erb-require-whitespace-inside-tags.js"
 export * from "./erb-right-trim.js"
+export * from "./erb-strict-locals-comment-syntax.js"
+export * from "./erb-strict-locals-required.js"
 
 export * from "./herb-disable-comment-valid-rule-name.js"
 export * from "./herb-disable-comment-no-redundant-all.js"

package/src/rules/string-utils.ts

@@ -0,0 +1,72 @@
+/**
+ * Checks if parentheses in a string are balanced
+ * Returns false if there are more closing parens than opening at any point
+ */
+export function hasBalancedParentheses(content: string): boolean {
+  let depth = 0
+
+  for (const char of content) {
+    if (char === "(") depth++
+    if (char === ")") depth--
+    if (depth < 0) return false
+  }
+
+  return depth === 0
+}
+
+/**
+ * Splits a string by commas at the top level only
+ * Respects nested parentheses, brackets, braces, and strings
+ *
+ * @example
+ * splitByTopLevelComma("a, b, c") // ["a", " b", " c"]
+ * splitByTopLevelComma("a, (b, c), d") // ["a", " (b, c)", " d"]
+ * splitByTopLevelComma('a, "b, c", d') // ["a", ' "b, c"', " d"]
+ */
+export function splitByTopLevelComma(str: string): string[] {
+  const result: string[] = []
+
+  let current = ""
+  let parenDepth = 0
+  let bracketDepth = 0
+  let braceDepth = 0
+  let inString = false
+  let stringChar = ""
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i]
+    const previousChar = i > 0 ? str[i - 1] : ""
+
+    if ((char === '"' || char === "'") && previousChar !== "\\") {
+      if (!inString) {
+        inString = true
+        stringChar = char
+      } else if (char === stringChar) {
+        inString = false
+      }
+    }
+
+    if (!inString) {
+      if (char === "(") parenDepth++
+      if (char === ")") parenDepth--
+      if (char === "[") bracketDepth++
+      if (char === "]") bracketDepth--
+      if (char === "{") braceDepth++
+      if (char === "}") braceDepth--
+
+      if (char === "," && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+        result.push(current)
+        current = ""
+        continue
+      }
+    }
+
+    current += char
+  }
+
+  if (current) {
+    result.push(current)
+  }
+
+  return result
+}

package/src/rules.ts

@@ -11,6 +11,8 @@ import { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper
 import { ERBRequireTrailingNewlineRule } from "./rules/erb-require-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
 import { ERBRightTrimRule } from "./rules/erb-right-trim.js"
+import { ERBStrictLocalsCommentSyntaxRule } from "./rules/erb-strict-locals-comment-syntax.js"
+import { ERBStrictLocalsRequiredRule } from "./rules/erb-strict-locals-required.js"
 
 import { HerbDisableCommentValidRuleNameRule } from "./rules/herb-disable-comment-valid-rule-name.js"
 import { HerbDisableCommentNoRedundantAllRule } from "./rules/herb-disable-comment-no-redundant-all.js"
@@ -67,6 +69,8 @@ export const rules: RuleClass[] = [
   ERBRequireTrailingNewlineRule,
   ERBRequireWhitespaceRule,
   ERBRightTrimRule,
+  ERBStrictLocalsCommentSyntaxRule,
+  ERBStrictLocalsRequiredRule,
 
   HerbDisableCommentValidRuleNameRule,
   HerbDisableCommentNoRedundantAllRule,

package/src/types.ts

@@ -85,6 +85,8 @@ export abstract class ParserRule<TAutofixContext extends BaseAutofixContext = Ba
   static type = "parser" as const
   /** Indicates whether this rule supports autofix. Defaults to false. */
   static autocorrectable = false
+  /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
+  static unsafeAutocorrectable = false
   abstract name: string
 
   get defaultConfig(): FullRuleConfig {
@@ -119,6 +121,8 @@ export abstract class LexerRule<TAutofixContext extends BaseAutofixContext = Bas
   static type = "lexer" as const
   /** Indicates whether this rule supports autofix. Defaults to false. */
   static autocorrectable = false
+  /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
+  static unsafeAutocorrectable = false
   abstract name: string
 
   get defaultConfig(): FullRuleConfig {
@@ -176,6 +180,8 @@ export abstract class SourceRule<TAutofixContext extends BaseAutofixContext = Ba
   static type = "source" as const
   /** Indicates whether this rule supports autofix. Defaults to false. */
   static autocorrectable = false
+  /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
+  static unsafeAutocorrectable = false
   abstract name: string
 
   get defaultConfig(): FullRuleConfig {