@herb-tools/linter 0.7.4 → 0.8.0

package/src/rules/erb-no-case-node-children.ts

@@ -0,0 +1,68 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+import { isWhitespaceNode, isLiteralNode, isHTMLTextNode, isCommentNode, isERBNode } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, ERBCaseNode, ERBCaseMatchNode, Node } from "@herb-tools/core"
+
+class ERBNoCaseNodeChildrenVisitor extends BaseRuleVisitor {
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.checkCaseNodeChildren(node, "when")
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.checkCaseNodeChildren(node, "in")
+    this.visitChildNodes(node)
+  }
+
+  private checkCaseNodeChildren(node: ERBCaseNode | ERBCaseMatchNode, type: string): void {
+    if (!node.children || node.children.length === 0) return
+
+    const caseCode = IdentityPrinter.printERBNode(node)
+    const firstCondition = node.conditions?.[0]
+    const conditionCode = firstCondition && isERBNode(firstCondition) ? IdentityPrinter.printERBNode(firstCondition) : `<% ${type} ... %>`
+
+    for (const child of node.children) {
+      if (!this.isAllowedContent(child)) {
+        const childCode = IdentityPrinter.print(child).trim()
+
+        this.addOffense(
+          `Do not place \`${childCode}\` between \`${caseCode}\` and \`${conditionCode}\`. Content here is not part of any branch and will not be rendered.`,
+          child.location,
+        )
+      }
+    }
+  }
+
+  private isAllowedContent(node: Node): boolean {
+    if (isWhitespaceNode(node)) return true
+    if (isCommentNode(node)) return true
+
+    if (isLiteralNode(node) || isHTMLTextNode(node)) {
+      return /^\s*$/.test(node.content)
+    }
+
+    return false
+  }
+}
+
+export class ERBNoCaseNodeChildrenRule extends ParserRule {
+  name = "erb-no-case-node-children"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoCaseNodeChildrenVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/erb-no-empty-tags.ts

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
@@ -17,7 +17,6 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
     this.addOffense(
       "ERB tag should not be empty. Remove empty ERB tags or add content.",
       node.location,
-      "error"
     )
   }
 }
@@ -25,7 +24,14 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
 export class ERBNoEmptyTagsRule extends ParserRule {
   name = "erb-no-empty-tags"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/erb-no-extra-newline.ts

@@ -0,0 +1,91 @@
+import { BaseSourceRuleVisitor } from "./rule-utils.js"
+import { SourceRule } from "../types.js"
+import { Location, Position } from "@herb-tools/core"
+
+import type { Node } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, FullRuleConfig } from "../types.js"
+
+interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
+  startOffset: number
+  endOffset: number
+}
+
+function positionFromOffset(source: string, offset: number): Position {
+  let line = 1
+  let column = 0
+  let currentOffset = 0
+
+  for (let i = 0; i < source.length && currentOffset < offset; i++) {
+    const char = source[i]
+    currentOffset++
+    if (char === "\n") {
+      line++
+      column = 0
+    } else {
+      column++
+    }
+  }
+
+  return new Position(line, column)
+}
+
+class ERBNoExtraNewLineVisitor extends BaseSourceRuleVisitor<ERBNoExtraNewLineAutofixContext> {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+
+    const regex = /\n{4,}/g
+
+    let match: RegExpExecArray | null
+
+    while ((match = regex.exec(source)) !== null) {
+      const startOffset = match.index + 3
+      const endOffset = match.index + match[0].length
+      const start = positionFromOffset(source, startOffset)
+      const end = positionFromOffset(source, endOffset)
+      const location = new Location(start, end)
+
+      const extraLines = match[0].length - 3
+
+      this.addOffense(
+        `Extra blank line detected. Remove ${extraLines} blank ${extraLines === 1 ? "line" : "lines"} to maintain consistent spacing (max 2 allowed).`,
+        location,
+        {
+          node: null as any as Node,
+          startOffset,
+          endOffset
+        }
+      )
+    }
+  }
+}
+
+export class ERBNoExtraNewLineRule extends SourceRule {
+  static autocorrectable = true
+  name = "erb-no-extra-newline"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(source: string, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBNoExtraNewLineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBNoExtraNewLineAutofixContext>, source: string, _context?: Partial<LintContext>): string | null {
+    if (!offense.autofixContext) return null
+
+    const { startOffset, endOffset } = offense.autofixContext
+
+    const before = source.substring(0, startOffset)
+    const after = source.substring(endOffset)
+
+    return before + after
+  }
+}

package/src/rules/erb-no-extra-whitespace-inside-tags.ts

@@ -0,0 +1,147 @@
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
+import { Location } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+interface ERBNoExtraWhitespaceAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+  openTag: Token
+  closeTag: Token
+  content: string
+  fixType: "after-open" | "before-close" | "after-comment-equals"
+}
+
+class ERBNoExtraWhitespaceInsideTagsVisitor extends BaseRuleVisitor<ERBNoExtraWhitespaceAutofixContext> {
+
+  visitERBNode(node: ERBNode): void {
+    const openTag = node.tag_opening
+    const closeTag = node.tag_closing
+    const { value } = node.content ?? {}
+
+    if (!openTag || !closeTag || !value) return
+
+    if (this.hasExtraLeadingWhitespace(value)) {
+      this.reportWhitespace(node, openTag, closeTag, value, "start", 0, `Remove extra whitespace after \`${openTag.value}\`.`, "after-open")
+    }
+
+    if (openTag.value === "<%#" && value.startsWith("=") && value.length > 1) {
+      const afterEquals = value.substring(1)
+
+      if (afterEquals.match(/^\s{2,}/) && !afterEquals.startsWith("  \n") && !afterEquals.startsWith("\n")) {
+        this.reportWhitespace(node, openTag, closeTag, value, "start", 1, `Remove extra whitespace after \`<%#=\`.`, "after-comment-equals")
+      }
+    }
+
+    if (this.hasExtraTrailingWhitespace(value)) {
+      this.reportWhitespace(node, openTag, closeTag, value, "end", 0, `Remove extra whitespace before \`${closeTag.value}\`.`, "before-close")
+    }
+  }
+
+  private hasExtraLeadingWhitespace(content: string): boolean {
+    return content.startsWith("  ") && !content.startsWith("  \n")
+  }
+
+  private hasExtraTrailingWhitespace(content: string): boolean {
+    return !content.includes("\n") && /\s{2,}$/.test(content)
+  }
+
+  private getWhitespaceLocation(node: ERBNode, content: string, position: "start" | "end", offset: number = 0): Location {
+    const contentLocation = node.content!.location
+
+    if (position === "start") {
+      const match = content.substring(offset).match(/^\s+/)
+      const length = match ? match[0].length : 0
+      const startColumn = contentLocation.start.column + offset
+
+      return Location.from(
+        contentLocation.start.line,
+        startColumn,
+        contentLocation.start.line,
+        startColumn + length
+      )
+    } else {
+      const match = content.match(/\s+$/)
+      const length = match ? match[0].length : 0
+
+      return Location.from(
+        contentLocation.end.line,
+        contentLocation.end.column - length,
+        contentLocation.end.line,
+        contentLocation.end.column
+      )
+    }
+  }
+
+  private reportWhitespace(
+    node: ERBNode,
+    openTag: Token,
+    closeTag: Token,
+    content: string,
+    position: "start" | "end",
+    offset: number,
+    message: string,
+    fixType: "after-open" | "before-close" | "after-comment-equals"
+  ): void {
+    const location = this.getWhitespaceLocation(node, content, position, offset)
+    this.addOffense(message, location, {
+      node,
+      openTag,
+      closeTag,
+      content,
+      fixType
+    })
+  }
+}
+
+export class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAutofixContext> {
+  static autocorrectable = true
+  name = "erb-no-extra-whitespace-inside-tags"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBNoExtraWhitespaceAutofixContext>[] {
+    const visitor = new ERBNoExtraWhitespaceInsideTagsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+
+  autofix(offense: LintOffense<ERBNoExtraWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, fixType } = offense.autofixContext
+    if (!node.content) return null
+
+    const content = node.content.value
+
+    switch (fixType) {
+      case "before-close":
+        node.content.value = content.replace(/\s{2,}$/, " ")
+        break
+
+      case "after-open":
+        node.content.value = content.replace(/^\s{2,}/, " ")
+        break
+
+      case "after-comment-equals":
+        if (content.startsWith("=")) {
+          const afterEquals = content.substring(1)
+          node.content.value = "= " + afterEquals.replace(/^\s{2,}/, "")
+        }
+
+        break
+      default:
+        return null
+    }
+
+    return result
+  }
+}

package/src/rules/erb-no-output-control-flow.ts

@@ -2,7 +2,7 @@ import { BaseRuleVisitor } from "./rule-utils.js"
 
 import type { ParseResult, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 
 class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
   visitERBIfNode(node: ERBIfNode): void {
@@ -42,7 +42,6 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Control flow statements like \`${controlBlockType}\` should not be used with output tags. Use \`<% ${controlBlockType} ... %>\` instead.`,
         openTag.location,
-        "error"
       )
     }
 
@@ -53,7 +52,14 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
 export class ERBNoOutputControlFlowRule extends ParserRule {
   name = "erb-no-output-control-flow"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/erb-no-silent-tag-in-attribute-name.ts

@@ -2,7 +2,7 @@ import { ParserRule } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 import { filterERBContentNodes } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNameNode, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
@@ -14,7 +14,6 @@ class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
       this.addOffense(
         `Remove silent ERB tag from HTML attribute name. Silent ERB tags (\`${node.tag_opening?.value}\`) do not output content and should not be used in attribute names.`,
         node.location,
-        "error"
       )
     }
   }
@@ -30,7 +29,14 @@ class ERBNoSilentTagInAttributeNameVisitor extends BaseRuleVisitor {
 export class ERBNoSilentTagInAttributeNameRule extends ParserRule {
   name = "erb-no-silent-tag-in-attribute-name"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new ERBNoSilentTagInAttributeNameVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/erb-prefer-image-tag-helper.ts

@@ -4,7 +4,7 @@ import { BaseRuleVisitor, getTagName, findAttributeByName, getAttributes } from
 import { ERBToRubyStringPrinter } from "@herb-tools/printer"
 import { filterNodes, ERBContentNode, LiteralNode, isNode } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
 
 class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
@@ -36,7 +36,6 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
         this.addOffense(
           `Prefer \`image_tag\` helper over manual \`<img>\` with dynamic ERB expressions. Use \`<%= image_tag ${suggestedExpression}, alt: "..." %>\` instead.`,
           srcAttribute.location,
-          "warning"
         )
       }
     }
@@ -93,7 +92,14 @@ class ERBPreferImageTagHelperVisitor extends BaseRuleVisitor {
 export class ERBPreferImageTagHelperRule extends ParserRule {
   name = "erb-prefer-image-tag-helper"
 
-  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 ERBPreferImageTagHelperVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

package/src/rules/erb-require-trailing-newline.ts

@@ -0,0 +1,47 @@
+import { SourceRule } from "../types.js"
+import { BaseSourceRuleVisitor, createEndOfFileLocation } from "./rule-utils.js"
+
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+
+class ERBRequireTrailingNewlineVisitor extends BaseSourceRuleVisitor {
+  protected visitSource(source: string): void {
+    if (source.length === 0) return
+    if (!this.context.fileName) return
+
+    if (!source.endsWith('\n')) {
+      this.addOffense(
+        "File must end with trailing newline.",
+        createEndOfFileLocation(source),
+      )
+    } else if (source.endsWith('\n\n')) {
+      this.addOffense(
+        "File must end with exactly one trailing newline.",
+        createEndOfFileLocation(source),
+      )
+    }
+  }
+}
+
+export class ERBRequireTrailingNewlineRule extends SourceRule {
+  static autocorrectable = true
+  name = "erb-require-trailing-newline"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(source: string, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new ERBRequireTrailingNewlineVisitor(this.name, context)
+
+    visitor.visit(source)
+
+    return visitor.offenses
+  }
+
+  autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null {
+    return source.trimEnd() + "\n"
+  }
+}

package/src/rules/erb-require-whitespace-inside-tags.ts

@@ -1,20 +1,20 @@
-import type { ParseResult, Token, Node } from "@herb-tools/core"
-import { isERBNode } from "@herb-tools/core";
-import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-class RequireWhitespaceInsideTags extends BaseRuleVisitor {
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 
-  visitChildNodes(node: Node): void {
-    this.checkWhitespace(node)
-    super.visitChildNodes(node)
-  }
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+  node: Mutable<ERBNode>
+  openTag: Token
+  closeTag: Token
+  content: string
+  fixType: "after-open" | "before-close" | "after-comment-equals"
+}
 
-  private checkWhitespace(node: Node): void {
-    if (!isERBNode(node)) {
-      return
-    }
+class RequireWhitespaceInsideTags extends BaseRuleVisitor<ERBRequireWhitespaceAutofixContext> {
+
+  visitERBNode(node: ERBNode): void {
     const openTag = node.tag_opening
     const closeTag = node.tag_closing
     const content = node.content
@@ -26,25 +26,37 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     const value = content.value
 
     if (openTag.value === "<%#") {
-      this.checkCommentTagWhitespace(openTag, closeTag, value)
+      this.checkCommentTagWhitespace(node, openTag, closeTag, value)
     } else {
-      this.checkOpenTagWhitespace(openTag, value)
-      this.checkCloseTagWhitespace(closeTag, value)
+      this.checkOpenTagWhitespace(node, openTag, closeTag, value)
+      this.checkCloseTagWhitespace(node, openTag, closeTag, value)
     }
   }
 
-  private checkCommentTagWhitespace(openTag: Token, closeTag: Token, content: string): void {
+  private checkCommentTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string): void {
     if (!content.startsWith(" ") && !content.startsWith("\n") && !content.startsWith("=")) {
       this.addOffense(
         `Add whitespace after \`${openTag.value}\`.`,
         openTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-open"
+        }
       )
     } else if (content.startsWith("=") && content.length > 1 && !content[1].match(/\s/)) {
       this.addOffense(
         `Add whitespace after \`<%#=\`.`,
         openTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "after-comment-equals"
+        }
       )
     }
 
@@ -52,12 +64,18 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
       this.addOffense(
         `Add whitespace before \`${closeTag.value}\`.`,
         closeTag.location,
-        "error"
+        {
+          node,
+          openTag,
+          closeTag,
+          content,
+          fixType: "before-close"
+        }
       )
     }
   }
 
-  private checkOpenTagWhitespace(openTag: Token, content:string):void {
+  private checkOpenTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.startsWith(" ") || content.startsWith("\n")) {
       return
     }
@@ -65,11 +83,17 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace after \`${openTag.value}\`.`,
       openTag.location,
-      "error"
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "after-open"
+      }
     )
   }
 
-  private checkCloseTagWhitespace(closeTag: Token, content:string):void {
+  private checkCloseTagWhitespace(node: ERBNode, openTag: Token, closeTag: Token, content: string):void {
     if (content.endsWith(" ") || content.endsWith("\n")) {
       return
     }
@@ -77,17 +101,63 @@ class RequireWhitespaceInsideTags extends BaseRuleVisitor {
     this.addOffense(
       `Add whitespace before \`${closeTag.value}\`.`,
       closeTag.location,
-      "error"
+      {
+        node,
+        openTag,
+        closeTag,
+        content,
+        fixType: "before-close"
+      }
     )
   }
 }
 
-export class ERBRequireWhitespaceRule extends ParserRule {
+export class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+  static autocorrectable = true
   name = "erb-require-whitespace-inside-tags"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRequireWhitespaceAutofixContext>[] {
     const visitor = new RequireWhitespaceInsideTags(this.name, context)
+
     visitor.visit(result.value)
+
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node, fixType } = offense.autofixContext
+
+    if (!node.content) return null
+
+    const content = node.content.value
+
+    if (fixType === "before-close") {
+      node.content.value = content + " "
+
+      return result
+    }
+
+    if (fixType === "after-open") {
+      node.content.value = " " + content
+
+      return result
+    }
+
+    if (fixType === "after-comment-equals" && content.startsWith("=")) {
+      node.content.value = "= " + content.substring(1)
+
+      return result
+    }
+
+    return null
+  }
 }