@herb-tools/linter 0.7.4 → 0.8.0

package/src/rules/html-no-self-closing.ts

@@ -1,11 +1,17 @@
-import { ParserRule } from "../types.js"
-import { BaseRuleVisitor, isVoidElement } from "./rule-utils.js"
-import { getTagName } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { isVoidElement, findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { getTagName, isWhitespaceNode, Location, HTMLCloseTagNode } from "@herb-tools/core"
 
-import type { LintContext, LintOffense } from "../types.js"
-import type { HTMLOpenTagNode, HTMLElementNode, ParseResult } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, LintOffense, FullRuleConfig } from "../types.js"
+import type { Node, HTMLOpenTagNode, HTMLElementNode, SerializedToken, ParseResult } from "@herb-tools/core"
 
-class NoSelfClosingVisitor extends BaseRuleVisitor {
+interface NoSelfClosingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode>
+  tagName: string
+  isVoid: boolean
+}
+
+class NoSelfClosingVisitor extends BaseRuleVisitor<NoSelfClosingAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node) === "svg") {
       this.visit(node.open_tag)
@@ -22,20 +28,74 @@ class NoSelfClosingVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Use \`${instead}\` instead of self-closing \`<${tagName} />\` for HTML compatibility.`,
         node.location,
-        "error"
+        {
+          node,
+          tagName,
+          isVoid: isVoidElement(tagName)
+        }
       )
     }
   }
 }
 
-export class HTMLNoSelfClosingRule extends ParserRule {
+export class HTMLNoSelfClosingRule extends ParserRule<NoSelfClosingAutofixContext> {
+  static autocorrectable = true
   name = "html-no-self-closing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/views/**/*_mailer/**/*"]
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<NoSelfClosingAutofixContext>[] {
     const visitor = new NoSelfClosingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<NoSelfClosingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, tagName, isVoid } = offense.autofixContext
+    const { tag_closing } = node
+
+    if (!tag_closing) return null
+
+    tag_closing.value = ">"
+
+    if (node.children && Array.isArray(node.children)) {
+      const children = node.children as Node[]
+
+      if (children.length > 0 && isWhitespaceNode(children[children.length - 1])) {
+        node.children = children.slice(0, -1)
+      }
+    }
+
+    if (!isVoid) {
+      const parent = findParent(result.value, node as any as Node) as Mutable<HTMLElementNode> | null
+
+      if (parent && parent.type === "AST_HTML_ELEMENT_NODE") {
+        const tag_opening: SerializedToken = { type: "TOKEN_HTML_TAG_START_CLOSE", value: "</", location: Location.zero, range: [0, 0] }
+        const tag_name: SerializedToken = { type: "TOKEN_IDENTIFIER", value: tagName, location: Location.zero, range: [0, 0] }
+        const tag_closing: SerializedToken = { type: "TOKEN_HTML_TAG_END", value: ">", location: Location.zero, range: [0, 0] }
+
+        parent.close_tag = HTMLCloseTagNode.from({
+          type: "AST_HTML_CLOSE_TAG_NODE",
+          tag_opening,
+          tag_name,
+          tag_closing,
+          children: [],
+          errors: [],
+          location: Location.zero,
+        })
+      }
+    }
+
+    return result
+  }
 }

package/src/rules/html-no-space-in-tag.ts

@@ -0,0 +1,221 @@
+import { Token, Location, WhitespaceNode } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext } from "../types.js"
+
+import { findParent, BaseRuleVisitor } from "./rule-utils.js"
+import { filterWhitespaceNodes, isWhitespaceNode, isHTMLOpenTagNode } from "@herb-tools/core"
+
+import type { ParseResult, Node, HTMLCloseTagNode, HTMLOpenTagNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, Mutable, FullRuleConfig } from "../types.js"
+
+const MESSAGES = {
+  EXTRA_SPACE_NO_SPACE: "Extra space detected where there should be no space.",
+  EXTRA_SPACE_SINGLE_SPACE: "Extra space detected where there should be a single space.",
+  EXTRA_SPACE_SINGLE_BREAK: "Extra space detected where there should be a single space or a single line break.",
+  NO_SPACE_SINGLE_SPACE: "No space detected where there should be a single space.",
+} as const
+
+interface HTMLNoSpaceInTagAutofixContext extends BaseAutofixContext {
+  node: WhitespaceNode | HTMLOpenTagNode
+  message: string
+}
+
+class HTMLNoSpaceInTagVisitor extends BaseRuleVisitor<HTMLNoSpaceInTagAutofixContext> {
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    if (node.isSingleLine) {
+      this.checkSingleLineTag(node)
+    } else {
+      this.checkMultilineTag(node)
+    }
+  }
+
+  visitHTMLCloseTagNode(node: HTMLCloseTagNode): void {
+    this.reportAllWhitespace(node.children, MESSAGES.EXTRA_SPACE_NO_SPACE)
+  }
+
+  private checkSingleLineTag(node: HTMLOpenTagNode): void {
+    const { children, tag_closing } = node
+    const isSelfClosing = tag_closing ? this.isSelfClosing(tag_closing) : false
+
+    this.checkWhitespaceInSingleLineTag(children, isSelfClosing)
+    this.checkMissingSpaceBeforeSelfClosing(node, children, isSelfClosing)
+  }
+
+  private checkWhitespaceInSingleLineTag(children: Node[], isSelfClosing: boolean): void {
+    const whitespaceNodes = filterWhitespaceNodes(children)
+
+    whitespaceNodes.forEach((whitespace) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      const isLastChild = children[children.length - 1] === whitespace
+      if (isLastChild) {
+        this.checkTrailingWhitespace(whitespace, content, isSelfClosing)
+        return
+      }
+
+      if (content.length > 1) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_SPACE })
+      }
+    })
+  }
+
+  private checkTrailingWhitespace(whitespace: WhitespaceNode, content: string, isSelfClosing: boolean): void {
+    if (isSelfClosing && content === ' ') return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private checkMissingSpaceBeforeSelfClosing(node: HTMLOpenTagNode, children: Node[], isSelfClosing: boolean): void {
+    if (!isSelfClosing) return
+
+    const lastChild = children[children.length - 1]
+    if (lastChild && isWhitespaceNode(lastChild)) return
+
+    const lastNonWhitespace = children.filter(child => !isWhitespaceNode(child)).pop()
+    const locationToReport = lastNonWhitespace?.location ?? node.tag_name?.location ?? node.location
+
+    this.addOffense(MESSAGES.NO_SPACE_SINGLE_SPACE, locationToReport, { node, message: MESSAGES.NO_SPACE_SINGLE_SPACE })
+  }
+
+  private checkMultilineTag(node: HTMLOpenTagNode): void {
+    const whitespaceNodes = filterWhitespaceNodes(node.children)
+    let previousWhitespace: WhitespaceNode | null = null
+
+    whitespaceNodes.forEach((whitespace, index) => {
+      const content = this.getWhitespaceContent(whitespace)
+      if (!content) return
+
+      if (this.hasConsecutiveNewlines(content, previousWhitespace)) {
+        this.addOffense(MESSAGES.EXTRA_SPACE_SINGLE_BREAK, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_SINGLE_BREAK })
+        previousWhitespace = whitespace
+
+        return
+      }
+
+      if (this.isNonNewlineWhitespace(content)) {
+        this.checkIndentation(whitespace, index, whitespaceNodes.length, node)
+      }
+
+      previousWhitespace = whitespace
+    })
+  }
+
+  private hasConsecutiveNewlines(content: string, previousWhitespace: WhitespaceNode | null): boolean {
+    if (content === "\n") return previousWhitespace?.value?.value === "\n"
+    if (!content.includes("\n")) return false
+
+    const newlines = content.match(/\n/g)
+
+    return (newlines?.length ?? 0) > 1
+  }
+
+  private isNonNewlineWhitespace(content: string): boolean {
+    return !content.includes("\n")
+  }
+
+  private checkIndentation(whitespace: WhitespaceNode, index: number, totalWhitespaceNodes: number, node: HTMLOpenTagNode): void {
+    const isLastWhitespace = index === totalWhitespaceNodes - 1
+    const expectedIndent = isLastWhitespace ? node.location.start.column : node.location.start.column + 2
+
+    if (whitespace.location.end.column === expectedIndent) return
+
+    this.addOffense(MESSAGES.EXTRA_SPACE_NO_SPACE, whitespace.location, { node: whitespace, message: MESSAGES.EXTRA_SPACE_NO_SPACE })
+  }
+
+  private isSelfClosing(tag_closing: Token): boolean {
+    return tag_closing?.value?.includes('/') ?? false
+  }
+
+  private getWhitespaceContent(whitespace: WhitespaceNode): string | null {
+    return whitespace.value?.value ?? null
+  }
+
+  private reportAllWhitespace(nodes: Node[] | WhitespaceNode[], message: string): void {
+    const whitespaceNodes = Array.isArray(nodes) && nodes.length > 0 && !isWhitespaceNode(nodes[0])
+      ? filterWhitespaceNodes(nodes)
+      : nodes as WhitespaceNode[]
+
+    whitespaceNodes.forEach(whitespace => {
+      this.addOffense(message, whitespace.location, { node: whitespace, message })
+    })
+  }
+}
+
+export class HTMLNoSpaceInTagRule extends ParserRule<HTMLNoSpaceInTagAutofixContext> {
+  // TODO: enable and fix autofix
+  static autocorrectable = false
+  name = "html-no-space-in-tag"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<HTMLNoSpaceInTagAutofixContext>[] {
+    const visitor = new HTMLNoSpaceInTagVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<HTMLNoSpaceInTagAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, message } = offense.autofixContext
+    if (!node) return null
+
+    if (isHTMLOpenTagNode(node)) {
+      const token = Token.from({ type: "TOKEN_WHITESPACE", value: " ", range: [0, 0], location: Location.zero })
+      const whitespace = new WhitespaceNode({ type: "AST_WHITESPACE_NODE", value: token, location: Location.zero, errors: [] })
+
+      node.children.push(whitespace)
+
+      return result
+    }
+
+    if (!isWhitespaceNode(node)) return null
+
+    const whitespaceNode = node as Mutable<WhitespaceNode>
+    if (!whitespaceNode.value) return null
+
+    switch (message) {
+      case MESSAGES.EXTRA_SPACE_NO_SPACE: {
+        let selfClosing = false
+        let beginningOfLine = false
+
+        const parent = findParent(result.value, node)
+
+        if (parent && isHTMLOpenTagNode(parent)) {
+          selfClosing = parent.tag_closing?.value === "/>"
+          beginningOfLine = node.location.start.column === 0
+        }
+
+        whitespaceNode.value.value = selfClosing && !beginningOfLine ? " " : ""
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_BREAK: {
+        if (whitespaceNode.value.value.includes("\n")) {
+          whitespaceNode.value.value = ""
+        } else {
+          whitespaceNode.value.value = " "
+        }
+
+        return result
+      }
+
+      case MESSAGES.EXTRA_SPACE_SINGLE_SPACE:
+      case MESSAGES.NO_SPACE_SINGLE_SPACE: {
+        whitespaceNode.value.value = " "
+
+        return result
+      }
+
+      default: return null
+    }
+  }
+}

package/src/rules/html-no-title-attribute.ts

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class NoTitleAttributeVisitor extends BaseRuleVisitor {
@@ -23,7 +23,6 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
       this.addOffense(
         "The `title` attribute should never be used as it is inaccessible for several groups of users. Use `aria-label` or `aria-describedby` instead. Exceptions are provided for `<iframe>` and `<link>` elements.",
         node.tag_name!.location,
-        "error"
       )
     }
   }
@@ -32,7 +31,14 @@ class NoTitleAttributeVisitor extends BaseRuleVisitor {
 export class HTMLNoTitleAttributeRule extends ParserRule {
   name = "html-no-title-attribute"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: false,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new NoTitleAttributeVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/html-no-underscores-in-attribute-names.ts

@@ -6,9 +6,11 @@ import {
   DynamicAttributeStaticValueParams,
   DynamicAttributeDynamicValueParams
 } from "./rule-utils.js"
+
 import { getStaticContentFromNodes } from "@herb-tools/core"
 import { IdentityPrinter } from "@herb-tools/printer"
-import type { LintContext, LintOffense } from "../types.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
 class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
@@ -38,8 +40,7 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
     if (attributeName.includes("_")) {
       this.addOffense(
         `Attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not contain underscores. Use hyphens (-) instead.`,
-        attributeNode.value!.location,
-        "warning"
+        attributeNode.name?.location ?? attributeNode.location,
       )
     }
   }
@@ -48,7 +49,14 @@ class HTMLNoUnderscoresInAttributeNamesVisitor extends AttributeVisitorMixin {
 export class HTMLNoUnderscoresInAttributeNamesRule extends ParserRule {
   name = "html-no-underscores-in-attribute-names"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new HTMLNoUnderscoresInAttributeNamesVisitor(this.name, context)
 
     visitor.visit(result.value)

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

@@ -1,9 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
+import { isNode, getTagName, HTMLOpenTagNode } from "@herb-tools/core"
 
-import { isNode, getTagName, HTMLElementNode, HTMLOpenTagNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLElementNode, HTMLCloseTagNode, ParseResult, XMLDeclarationNode, Node } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
+interface TagNameAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>
+  tagName: string
+  correctedTagName: string
+}
 
 class XMLDeclarationChecker extends BaseRuleVisitor {
   hasXMLDeclaration: boolean = false
@@ -18,7 +24,7 @@ class XMLDeclarationChecker extends BaseRuleVisitor {
   }
 }
 
-class TagNameLowercaseVisitor extends BaseRuleVisitor {
+class TagNameLowercaseVisitor extends BaseRuleVisitor<TagNameAutofixContext> {
   visitHTMLElementNode(node: HTMLElementNode): void {
     if (getTagName(node).toLowerCase() === "svg") {
       this.checkTagName(node.open_tag)
@@ -52,28 +58,53 @@ class TagNameLowercaseVisitor extends BaseRuleVisitor {
       this.addOffense(
         `${type} tag name \`${open}${tagName}>\` should be lowercase. Use \`${open}${lowercaseTagName}>\` instead.`,
         node.tag_name!.location,
-        "error"
+        {
+          node,
+          tagName,
+          correctedTagName: lowercaseTagName
+        }
       )
     }
   }
 }
 
-export class HTMLTagNameLowercaseRule extends ParserRule {
+export class HTMLTagNameLowercaseRule extends ParserRule<TagNameAutofixContext> {
+  static autocorrectable = true
   name = "html-tag-name-lowercase"
 
-  isEnabled(result: ParseResult, context?: Partial<LintContext>): boolean {
-    if (context?.fileName?.endsWith(".xml") || context?.fileName?.endsWith(".xml.erb")) {
-      return false
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/*.xml", "**/*.xml.erb"]
     }
+  }
 
+  isEnabled(result: ParseResult, _context?: Partial<LintContext>): boolean {
     const checker = new XMLDeclarationChecker(this.name)
+
     checker.visit(result.value)
+
     return !checker.hasXMLDeclaration
   }
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<TagNameAutofixContext>[] {
     const visitor = new TagNameLowercaseVisitor(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<TagNameAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { tag_name }, correctedTagName } = offense.autofixContext
+
+    if (!tag_name) return null
+
+    tag_name.value = correctedTagName
+
+    return result
+  }
 }

package/src/rules/index.ts

@@ -1,9 +1,25 @@
 export * from "./rule-utils.js"
+export * from "./herb-disable-comment-base.js"
+
+export * from "./erb-comment-syntax.js"
+export * from "./erb-no-case-node-children.js"
 export * from "./erb-no-empty-tags.js"
+export * from "./erb-no-extra-newline.js"
+export * from "./erb-no-extra-whitespace-inside-tags.js"
 export * from "./erb-no-output-control-flow.js"
 export * from "./erb-no-silent-tag-in-attribute-name.js"
 export * from "./erb-prefer-image-tag-helper.js"
-export * from "./erb-requires-trailing-newline.js"
+export * from "./erb-require-trailing-newline.js"
+export * from "./erb-require-whitespace-inside-tags.js"
+export * from "./erb-right-trim.js"
+
+export * from "./herb-disable-comment-valid-rule-name.js"
+export * from "./herb-disable-comment-no-redundant-all.js"
+export * from "./herb-disable-comment-no-duplicate-rules.js"
+export * from "./herb-disable-comment-missing-rules.js"
+export * from "./herb-disable-comment-malformed.js"
+export * from "./herb-disable-comment-unnecessary.js"
+
 export * from "./html-anchor-require-href.js"
 export * from "./html-aria-label-is-well-formatted.js"
 export * from "./html-aria-level-must-be-valid.js"
@@ -13,20 +29,26 @@ export * from "./html-attribute-double-quotes.js"
 export * from "./html-attribute-equals-spacing.js"
 export * from "./html-attribute-values-require-quotes.js"
 export * from "./html-avoid-both-disabled-and-aria-disabled.js"
+export * from "./html-body-only-elements.js"
 export * from "./html-boolean-attributes-no-value.js"
+export * from "./html-head-only-elements.js"
 export * from "./html-iframe-has-title.js"
 export * from "./html-img-require-alt.js"
+export * from "./html-input-require-autocomplete.js"
 export * from "./html-navigation-has-label.js"
 export * from "./html-no-aria-hidden-on-focusable.js"
 export * from "./html-no-block-inside-inline.js"
 export * from "./html-no-duplicate-attributes.js"
 export * from "./html-no-duplicate-ids.js"
+export * from "./html-no-duplicate-meta-names.js"
 export * from "./html-no-empty-attributes.js"
 export * from "./html-no-empty-headings.js"
 export * from "./html-no-nested-links.js"
 export * from "./html-no-positive-tab-index.js"
 export * from "./html-no-self-closing.js"
+export * from "./html-no-space-in-tag.js"
 export * from "./html-no-title-attribute.js"
+export * from "./html-no-underscores-in-attribute-names.js"
 export * from "./html-tag-name-lowercase.js"
+
 export * from "./svg-tag-name-capitalization.js"
-export * from "./html-no-underscores-in-attribute-names.js"

package/src/rules/parser-no-errors.ts

@@ -1,11 +1,18 @@
 import { ParserRule } from "../types.js"
 
-import type { LintOffense } from "../types.js"
+import type { LintOffense, FullRuleConfig } from "../types.js"
 import type { ParseResult, HerbError } from "@herb-tools/core"
 
 export class ParserNoErrorsRule extends ParserRule {
   name = "parser-no-errors"
 
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
   check(result: ParseResult): LintOffense[] {
     return result.recursiveErrors().map(error =>
       this.herbErrorToLintOffense(error)