@herb-tools/linter 0.6.0 → 0.7.0

package/src/rules/rule-utils.ts

@@ -26,8 +26,14 @@ import type {
 
 import { DEFAULT_LINT_CONTEXT } from "../types.js"
 
+import type * as Nodes from "@herb-tools/core"
 import type { LintOffense, LintSeverity, LintContext } from "../types.js"
 
+export enum ControlFlowType {
+  CONDITIONAL,
+  LOOP
+}
+
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
@@ -65,6 +71,95 @@ export abstract class BaseRuleVisitor extends Visitor {
   }
 }
 
+/**
+ * Mixin that adds control flow tracking capabilities to rule visitors
+ * This allows rules to track state across different control flow structures
+ * like if/else branches, loops, etc.
+ *
+ * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
+ * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
+ */
+export abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+  protected isInControlFlow: boolean = false
+  protected currentControlFlowType: ControlFlowType | null = null
+
+  /**
+   * Handle visiting a control flow node with proper scope management
+   */
+  protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void {
+    const wasInControlFlow = this.isInControlFlow
+    const previousControlFlowType = this.currentControlFlowType
+
+    this.isInControlFlow = true
+    this.currentControlFlowType = controlFlowType
+
+    const stateToRestore = this.onEnterControlFlow(controlFlowType, wasInControlFlow)
+
+    visitChildren()
+
+    this.onExitControlFlow(controlFlowType, wasInControlFlow, stateToRestore)
+
+    this.isInControlFlow = wasInControlFlow
+    this.currentControlFlowType = previousControlFlowType
+  }
+
+  /**
+   * Handle visiting a branch node (like else, when) with proper scope management
+   */
+  protected startNewBranch(visitChildren: () => void): void {
+    const stateToRestore = this.onEnterBranch()
+
+    visitChildren()
+
+    this.onExitBranch(stateToRestore)
+  }
+
+  visitERBIfNode(node: Nodes.ERBIfNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBIfNode(node))
+  }
+
+  visitERBUnlessNode(node: Nodes.ERBUnlessNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBUnlessNode(node))
+  }
+
+  visitERBCaseNode(node: Nodes.ERBCaseNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBCaseNode(node))
+  }
+
+  visitERBCaseMatchNode(node: Nodes.ERBCaseMatchNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBCaseMatchNode(node))
+  }
+
+  visitERBWhileNode(node: Nodes.ERBWhileNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBWhileNode(node))
+  }
+
+  visitERBForNode(node: Nodes.ERBForNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBForNode(node))
+  }
+
+  visitERBUntilNode(node: Nodes.ERBUntilNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.LOOP, () => super.visitERBUntilNode(node))
+  }
+
+  visitERBBlockNode(node: Nodes.ERBBlockNode): void {
+    this.handleControlFlowNode(node, ControlFlowType.CONDITIONAL, () => super.visitERBBlockNode(node))
+  }
+
+  visitERBElseNode(node: Nodes.ERBElseNode): void {
+    this.startNewBranch(() => super.visitERBElseNode(node))
+  }
+
+  visitERBWhenNode(node: Nodes.ERBWhenNode): void {
+    this.startNewBranch(() => super.visitERBWhenNode(node))
+  }
+
+  protected abstract onEnterControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): TControlFlowState
+  protected abstract onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: TControlFlowState): void
+  protected abstract onEnterBranch(): TBranchState
+  protected abstract onExitBranch(stateToRestore: TBranchState): void
+}
+
 /**
  * Gets attributes from an HTMLOpenTagNode
  */
@@ -83,11 +178,13 @@ export function getTagName(node: HTMLOpenTagNode): string | null {
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
  * Returns null if the attribute name contains dynamic content (ERB)
  */
-export function getAttributeName(attributeNode: HTMLAttributeNode): string | null {
+export function getAttributeName(attributeNode: HTMLAttributeNode, lowercase = true): string | null {
   if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
     const nameNode = attributeNode.name as HTMLAttributeNameNode
     const staticName = getStaticAttributeName(nameNode)
 
+    if (!lowercase) return staticName
+
     return staticName ? staticName.toLowerCase() : null
   }
 
@@ -190,7 +287,7 @@ export function getStaticAttributeValueContent(attributeNode: HTMLAttributeNode)
  * Gets the attribute value content from an HTMLAttributeValueNode
  */
 export function getAttributeValue(attributeNode: HTMLAttributeNode): string | null {
-  const valueNode: HTMLAttributeValueNode | null = attributeNode.value as HTMLAttributeValueNode
+  const valueNode: HTMLAttributeValueNode | null = attributeNode.value as HTMLAttributeValueNode
 
   if (valueNode === null) return null
 
@@ -284,7 +381,7 @@ export function hasAttribute(node: HTMLOpenTagNode, attributeName: string): bool
 /**
  * Checks if a tag has a specific attribute
  */
-export function getAttribute(node: HTMLOpenTagNode, attributeName: string): HTMLAttributeNode | null {
+export function getAttribute(node: HTMLOpenTagNode, attributeName: string): HTMLAttributeNode | null {
   const attributes = getAttributes(node)
 
   return findAttributeByName(attributes, attributeName)
@@ -389,6 +486,7 @@ export interface StaticAttributeStaticValueParams {
   attributeName: string
   attributeValue: string
   attributeNode: HTMLAttributeNode
+  originalAttributeName: string
   parentNode: HTMLOpenTagNode
 }
 
@@ -396,6 +494,7 @@ export interface StaticAttributeDynamicValueParams {
   attributeName: string
   valueNodes: Node[]
   attributeNode: HTMLAttributeNode
+  originalAttributeName: string
   parentNode: HTMLOpenTagNode
   combinedValue?: string | null
 }
@@ -535,6 +634,7 @@ export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
   private checkAttributesOnNode(node: HTMLOpenTagNode): void {
     forEachAttribute(node, (attributeNode) => {
       const staticAttributeName = getAttributeName(attributeNode)
+      const originalAttributeName = getAttributeName(attributeNode, false) || ""
       const isDynamicName = hasDynamicAttributeName(attributeNode)
       const staticAttributeValue = getStaticAttributeValue(attributeNode)
       const valueNodes = getAttributeValueNodes(attributeNode)
@@ -546,16 +646,17 @@ export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
           attributeName: staticAttributeName,
           attributeValue: staticAttributeValue,
           attributeNode,
+          originalAttributeName,
           parentNode: node
         })
       } else if (staticAttributeName && isEffectivelyStaticValue && !hasOutputERB) {
         const validatableContent = getValidatableStaticContent(valueNodes) || ""
 
-        this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, parentNode: node })
+        this.checkStaticAttributeStaticValue({ attributeName: staticAttributeName, attributeValue: validatableContent, attributeNode, originalAttributeName, parentNode: node })
       } else if (staticAttributeName && hasOutputERB) {
         const combinedValue = getAttributeValue(attributeNode)
 
-        this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, combinedValue })
+        this.checkStaticAttributeDynamicValue({ attributeName: staticAttributeName, valueNodes, attributeNode, parentNode: node, originalAttributeName, combinedValue })
       } else if (isDynamicName && staticAttributeValue !== null) {
         const nameNode = attributeNode.name as HTMLAttributeNameNode
         const nameNodes = nameNode.children || []
@@ -576,28 +677,28 @@ export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
   /**
    * Static attribute name with static value: class="container"
    */
-  protected checkStaticAttributeStaticValue(params: StaticAttributeStaticValueParams): void {
+  protected checkStaticAttributeStaticValue(_params: StaticAttributeStaticValueParams): void {
     // Default implementation does nothing
   }
 
   /**
    * Static attribute name with dynamic value: class="<%= css_class %>"
    */
-  protected checkStaticAttributeDynamicValue(params: StaticAttributeDynamicValueParams): void {
+  protected checkStaticAttributeDynamicValue(_params: StaticAttributeDynamicValueParams): void {
     // Default implementation does nothing
   }
 
   /**
    * Dynamic attribute name with static value: data-<%= key %>="foo"
    */
-  protected checkDynamicAttributeStaticValue(params: DynamicAttributeStaticValueParams): void {
+  protected checkDynamicAttributeStaticValue(_params: DynamicAttributeStaticValueParams): void {
     // Default implementation does nothing
   }
 
   /**
    * Dynamic attribute name with dynamic value: data-<%= key %>="<%= value %>"
    */
-  protected checkDynamicAttributeDynamicValue(params: DynamicAttributeDynamicValueParams): void {
+  protected checkDynamicAttributeDynamicValue(_params: DynamicAttributeDynamicValueParams): void {
     // Default implementation does nothing
   }
 }

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

@@ -44,8 +44,8 @@ class SVGTagNameCapitalizationVisitor extends BaseRuleVisitor {
     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_OPEN_TAG_NODE") type = "Opening"
+      if (node.type === "AST_HTML_CLOSE_TAG_NODE") type = "Closing"
 
       this.addOffense(
         `${type} SVG tag name \`${tagName}\` should use proper capitalization. Use \`${correctCamelCase}\` instead.`,