@herb-tools/linter 0.4.0

package/src/rules/html-no-nested-links.ts

@@ -0,0 +1,65 @@
+import { BaseRuleVisitor, getTagName } from "./rule-utils.js"
+
+import type { Rule, LintOffense } from "../types.js"
+import type { HTMLOpenTagNode, HTMLElementNode, Node } from "@herb-tools/core"
+
+class NestedLinkVisitor extends BaseRuleVisitor {
+  private linkStack: HTMLOpenTagNode[] = []
+
+  private checkNestedLink(openTag: HTMLOpenTagNode): boolean {
+    if (this.linkStack.length > 0) {
+      this.addOffense(
+        "Nested `<a>` elements are not allowed. Links cannot contain other links.",
+        openTag.tag_name!.location,
+        "error"
+      )
+
+      return true
+    }
+
+    return false
+  }
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (!node.open_tag || node.open_tag.type !== "AST_HTML_OPEN_TAG_NODE") {
+      super.visitHTMLElementNode(node)
+      return
+    }
+
+    const openTag = node.open_tag as HTMLOpenTagNode
+    const tagName = getTagName(openTag)
+
+    if (tagName !== "a") {
+      super.visitHTMLElementNode(node)
+      return
+    }
+
+    // If we're already inside a link, this is a nested link
+    this.checkNestedLink(openTag)
+
+    this.linkStack.push(openTag)
+    super.visitHTMLElementNode(node)
+    this.linkStack.pop()
+  }
+
+  // Handle self-closing <a> tags (though they're not valid HTML, they might exist)
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    const tagName = getTagName(node)
+
+    if (tagName === "a" && node.is_void) {
+      this.checkNestedLink(node)
+    }
+
+    super.visitHTMLOpenTagNode(node)
+  }
+}
+
+export class HTMLNoNestedLinksRule implements Rule {
+  name = "html-no-nested-links"
+
+  check(node: Node): LintOffense[] {
+    const visitor = new NestedLinkVisitor(this.name)
+    visitor.visit(node)
+    return visitor.offenses
+  }
+}

package/src/rules/html-tag-name-lowercase.ts

@@ -0,0 +1,50 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { Rule, LintOffense } from "../types.js"
+import type { HTMLOpenTagNode, HTMLCloseTagNode, HTMLSelfCloseTagNode, Node } from "@herb-tools/core"
+
+class TagNameLowercaseVisitor extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkTagName(node)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
+    this.checkTagName(node)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
+    this.checkTagName(node)
+    this.visitChildNodes(node)
+  }
+
+  private checkTagName(node: HTMLOpenTagNode | HTMLCloseTagNode | HTMLSelfCloseTagNode): void {
+    const tagName = node.tag_name?.value
+    if (!tagName) return
+
+    if (tagName !== tagName.toLowerCase()) {
+      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} tag name \`${tagName}\` should be lowercase. Use \`${tagName.toLowerCase()}\` instead.`,
+        node.tag_name!.location,
+        "error"
+      )
+    }
+  }
+}
+
+export class HTMLTagNameLowercaseRule implements Rule {
+  name = "html-tag-name-lowercase"
+
+  check(node: Node): LintOffense[] {
+    const visitor = new TagNameLowercaseVisitor(this.name)
+    visitor.visit(node)
+    return visitor.offenses
+  }
+}

package/src/rules/index.ts

@@ -0,0 +1,12 @@
+export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-output-control-flow.js"
+export * from "./html-anchor-require-href.js"
+export * from "./html-attribute-double-quotes.js"
+export * from "./html-attribute-values-require-quotes.js"
+export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-img-require-alt.js"
+export * from "./html-no-block-inside-inline.js"
+export * from "./html-no-duplicate-attributes.js"
+export * from "./html-no-empty-headings.js"
+export * from "./html-no-nested-links.js"
+export * from "./html-tag-name-lowercase.js"

package/src/rules/rule-utils.ts

@@ -0,0 +1,257 @@
+import {
+  Visitor
+} from "@herb-tools/core"
+
+import type { 
+  ERBNode, 
+  HTMLAttributeNameNode,
+  HTMLAttributeNode, 
+  HTMLAttributeValueNode, 
+  HTMLOpenTagNode, 
+  HTMLSelfCloseTagNode, 
+  LiteralNode, 
+  Location, 
+  Node 
+} from "@herb-tools/core"
+import type { LintOffense, LintSeverity, } from "../types.js"
+
+/**
+ * Base visitor class that provides common functionality for rule visitors
+ */
+export abstract class BaseRuleVisitor extends Visitor {
+  public readonly offenses: LintOffense[] = []
+  protected ruleName: string
+
+  constructor(ruleName: string) {
+    super()
+
+    this.ruleName = ruleName
+  }
+
+  /**
+   * Helper method to create a lint offense
+   */
+  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))
+  }
+}
+
+/**
+ * Gets attributes from either an HTMLOpenTagNode or HTMLSelfCloseTagNode
+ */
+export function getAttributes(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): any[] {
+  return node.type === "AST_HTML_SELF_CLOSE_TAG_NODE"
+    ? (node as HTMLSelfCloseTagNode).attributes
+    : (node as HTMLOpenTagNode).children
+}
+
+/**
+ * Gets the tag name from an HTML tag node (lowercased)
+ */
+export function getTagName(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): string | null {
+  return node.tag_name?.value.toLowerCase() || null
+}
+
+/**
+ * Gets the attribute name from an HTMLAttributeNode (lowercased)
+ */
+export function getAttributeName(attributeNode: HTMLAttributeNode): string | null {
+  if (attributeNode.name?.type === "AST_HTML_ATTRIBUTE_NAME_NODE") {
+    const nameNode = attributeNode.name as HTMLAttributeNameNode
+
+    return nameNode.name?.value.toLowerCase() || null
+  }
+
+  return null
+}
+
+/**
+ * Gets the attribute value content from an HTMLAttributeValueNode
+ */
+export function getAttributeValue(attributeNode: HTMLAttributeNode): string | null {
+  if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
+    const valueNode = attributeNode.value as HTMLAttributeValueNode
+
+    if (valueNode.children && valueNode.children.length > 0) {
+      return valueNode.children
+        .filter(child => child.type === "AST_LITERAL_NODE")
+        .map(child => (child as LiteralNode).content)
+        .join("")
+    }
+  }
+
+  return null
+}
+
+/**
+ * Checks if an attribute has a value
+ */
+export function hasAttributeValue(attributeNode: HTMLAttributeNode): boolean {
+  return attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE"
+}
+
+/**
+ * Gets the quote type used for an attribute value
+ */
+export function getAttributeValueQuoteType(attributeNode: HTMLAttributeNode): "single" | "double" | "none" | null {
+  if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
+    const valueNode = attributeNode.value as HTMLAttributeValueNode
+    if (valueNode.quoted && valueNode.open_quote) {
+      return valueNode.open_quote.value === '"' ? "double" : "single"
+    }
+
+    return "none"
+  }
+
+  return null
+}
+
+/**
+ * Finds an attribute by name in a list of attributes
+ */
+export function findAttributeByName(attributes: any[], attributeName: string): HTMLAttributeNode | null {
+  for (const child of attributes) {
+    if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
+      const attributeNode = child as HTMLAttributeNode
+      const name = getAttributeName(attributeNode)
+      if (name === attributeName.toLowerCase()) {
+        return attributeNode
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Checks if a tag has a specific attribute
+ */
+export function hasAttribute(node: HTMLOpenTagNode | HTMLSelfCloseTagNode, attributeName: string): boolean {
+  const attributes = getAttributes(node)
+  return findAttributeByName(attributes, attributeName) !== null
+}
+
+/**
+ * Common HTML element categorization
+ */
+export const HTML_INLINE_ELEMENTS = new Set([
+  "a", "abbr", "acronym", "b", "bdo", "big", "br", "button", "cite", "code",
+  "dfn", "em", "i", "img", "input", "kbd", "label", "map", "object", "output",
+  "q", "samp", "script", "select", "small", "span", "strong", "sub", "sup",
+  "textarea", "time", "tt", "var"
+])
+
+export const HTML_BLOCK_ELEMENTS = new Set([
+  "address", "article", "aside", "blockquote", "canvas", "dd", "div", "dl",
+  "dt", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2",
+  "h3", "h4", "h5", "h6", "header", "hr", "li", "main", "nav", "noscript",
+  "ol", "p", "pre", "section", "table", "tfoot", "ul", "video"
+])
+
+export const HTML_BOOLEAN_ATTRIBUTES = new Set([
+  "autofocus", "autoplay", "checked", "controls", "defer", "disabled", "hidden",
+  "loop", "multiple", "muted", "readonly", "required", "reversed", "selected",
+  "open", "default", "formnovalidate", "novalidate", "itemscope", "scoped",
+  "seamless", "allowfullscreen", "async", "compact", "declare", "nohref",
+  "noresize", "noshade", "nowrap", "sortable", "truespeed", "typemustmatch"
+])
+
+export const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"])
+
+/**
+ * Checks if an element is inline
+ */
+export function isInlineElement(tagName: string): boolean {
+  return HTML_INLINE_ELEMENTS.has(tagName.toLowerCase())
+}
+
+/**
+ * Checks if an element is block-level
+ */
+export function isBlockElement(tagName: string): boolean {
+  return HTML_BLOCK_ELEMENTS.has(tagName.toLowerCase())
+}
+
+/**
+ * Checks if an attribute is a boolean attribute
+ */
+export function isBooleanAttribute(attributeName: string): boolean {
+  return HTML_BOOLEAN_ATTRIBUTES.has(attributeName.toLowerCase())
+}
+
+/**
+ * Abstract base class for rules that need to check individual attributes on HTML tags
+ * Eliminates duplication of visitHTMLOpenTagNode/visitHTMLSelfCloseTagNode patterns
+ * and attribute iteration logic. Provides simplified interface with extracted attribute info.
+ */
+export abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkAttributesOnNode(node)
+    super.visitHTMLOpenTagNode(node)
+  }
+
+  visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void {
+    this.checkAttributesOnNode(node)
+    super.visitHTMLSelfCloseTagNode(node)
+  }
+
+  private checkAttributesOnNode(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): void {
+    forEachAttribute(node, (attributeNode) => {
+      const attributeName = getAttributeName(attributeNode)
+      const attributeValue = getAttributeValue(attributeNode)
+
+      if (attributeName) {
+        this.checkAttribute(attributeName, attributeValue, attributeNode, node)
+      }
+    })
+  }
+
+  protected abstract checkAttribute(
+    attributeName: string,
+    attributeValue: string | null,
+    attributeNode: HTMLAttributeNode,
+    parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode
+  ): void
+}
+
+/**
+ * Checks if an attribute value is quoted
+ */
+export function isAttributeValueQuoted(attributeNode: HTMLAttributeNode): boolean {
+  if (attributeNode.value?.type === "AST_HTML_ATTRIBUTE_VALUE_NODE") {
+    const valueNode = attributeNode.value as HTMLAttributeValueNode
+
+    return !!valueNode.quoted
+  }
+
+  return false
+}
+
+/**
+ * Iterates over all attributes of a tag node, calling the callback for each attribute
+ */
+export function forEachAttribute(
+  node: HTMLOpenTagNode | HTMLSelfCloseTagNode,
+  callback: (attributeNode: HTMLAttributeNode) => void
+): void {
+  const attributes = getAttributes(node)
+
+  for (const child of attributes) {
+    if (child.type === "AST_HTML_ATTRIBUTE_NODE") {
+      callback(child as HTMLAttributeNode)
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+import { Node, Diagnostic } from "@herb-tools/core"
+import type { defaultRules } from "./default-rules.js"
+
+export type LintSeverity = "error" | "warning"
+
+/**
+ * Automatically inferred union type of all available linter rule names.
+ * This type extracts the 'name' property from each rule class instance.
+ */
+export type LinterRule = InstanceType<typeof defaultRules[number]>['name']
+
+export interface LintOffense extends Diagnostic {
+  rule: LinterRule
+  severity: LintSeverity
+}
+
+export interface LintResult {
+  offenses: LintOffense[]
+  errors: number
+  warnings: number
+}
+
+export interface Rule {
+  name: string
+  check(node: Node): LintOffense[]
+}
+
+/**
+ * Type representing a rule class constructor.
+ * The Linter accepts rule classes rather than instances for better performance and memory usage.
+ */
+export type RuleClass = new () => Rule