@herb-tools/linter 0.4.0

package/src/cli/argument-parser.ts

@@ -0,0 +1,125 @@
+import dedent from "dedent"
+
+import { parseArgs } from "util"
+import { statSync } from "fs"
+import { join } from "path"
+
+import { Herb } from "@herb-tools/node-wasm"
+
+import { THEME_NAMES, DEFAULT_THEME } from "@herb-tools/highlighter"
+import type { ThemeInput } from "@herb-tools/highlighter"
+
+import { name, version } from "../../package.json"
+
+export interface ParsedArguments {
+  pattern: string
+  formatOption: 'simple' | 'detailed'
+  showTiming: boolean
+  theme: ThemeInput
+  wrapLines: boolean
+  truncateLines: boolean
+}
+
+export class ArgumentParser {
+  private readonly usage = dedent`
+    Usage: herb-lint [file|glob-pattern|directory] [options]
+
+    Arguments:
+      file             Single file to lint
+      glob-pattern     Files to lint (defaults to **/*.html.erb)
+      directory        Directory to lint (automatically appends **/*.html.erb)
+
+    Options:
+      -h, --help       show help
+      -v, --version    show version
+      --format         output format (simple|detailed) [default: detailed]
+      --simple         use simple output format (shortcut for --format simple)
+      --theme          syntax highlighting theme (${THEME_NAMES.join('|')}) or path to custom theme file [default: ${DEFAULT_THEME}]
+      --no-color       disable colored output
+      --no-timing      hide timing information
+      --no-wrap-lines  disable line wrapping
+      --truncate-lines enable line truncation (mutually exclusive with line wrapping)
+  `
+
+  parse(argv: string[]): ParsedArguments {
+    const { values, positionals } = parseArgs({
+      args: argv.slice(2),
+      options: {
+        help: { type: 'boolean', short: 'h' },
+        version: { type: 'boolean', short: 'v' },
+        format: { type: 'string' },
+        simple: { type: 'boolean' },
+        theme: { type: 'string' },
+        'no-color': { type: 'boolean' },
+        'no-timing': { type: 'boolean' },
+        'no-wrap-lines': { type: 'boolean' },
+        'truncate-lines': { type: 'boolean' }
+      },
+      allowPositionals: true
+    })
+
+    if (values.help) {
+      console.log(this.usage)
+      process.exit(0)
+    }
+
+    if (values.version) {
+      console.log("Versions:")
+      console.log(`  ${name}@${version}, ${Herb.version}`.split(", ").join("\n  "))
+      process.exit(0)
+    }
+
+    let formatOption: 'simple' | 'detailed' = 'detailed'
+    if (values.format && (values.format === "detailed" || values.format === "simple")) {
+      formatOption = values.format
+    }
+
+    if (values.simple) {
+      formatOption = "simple"
+    }
+
+    if (values['no-color']) {
+      process.env.NO_COLOR = "1"
+    }
+
+    const showTiming = !values['no-timing']
+
+    let wrapLines = !values['no-wrap-lines']
+    let truncateLines = false
+
+    if (values['truncate-lines']) {
+      truncateLines = true
+      wrapLines = false
+    }
+
+    if (!values['no-wrap-lines'] && values['truncate-lines']) {
+      console.error("Error: Line wrapping and --truncate-lines cannot be used together. Use --no-wrap-lines with --truncate-lines.")
+      process.exit(1)
+    }
+
+    const theme = values.theme || DEFAULT_THEME
+    const pattern = this.getFilePattern(positionals)
+
+    if (positionals.length === 0) {
+      console.error("Please specify input file.")
+      process.exit(1)
+    }
+
+    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines }
+  }
+
+  private getFilePattern(positionals: string[]): string {
+    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html.erb"
+
+    try {
+      const stat = statSync(pattern)
+      if (stat.isDirectory()) {
+        pattern = join(pattern, "**/*.html.erb")
+      }
+    } catch {
+      // Not a file/directory, treat as glob pattern
+    }
+
+    return pattern
+  }
+}

package/src/cli/file-processor.ts

@@ -0,0 +1,86 @@
+import { readFileSync } from "fs"
+import { resolve } from "path"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "../linter.js"
+import { colorize } from "@herb-tools/highlighter"
+import type { Diagnostic } from "@herb-tools/core"
+
+export interface ProcessedFile {
+  filename: string
+  diagnostic: Diagnostic
+  content: string
+}
+
+export interface ProcessingResult {
+  totalErrors: number
+  totalWarnings: number
+  filesWithIssues: number
+  ruleCount: number
+  allDiagnostics: ProcessedFile[]
+  ruleViolations: Map<string, { count: number, files: Set<string> }>
+}
+
+export class FileProcessor {
+  private linter: Linter | null = null
+
+  async processFiles(files: string[]): Promise<ProcessingResult> {
+    let totalErrors = 0
+    let totalWarnings = 0
+    let filesWithIssues = 0
+    let ruleCount = 0
+    const allDiagnostics: ProcessedFile[] = []
+    const ruleViolations = new Map<string, { count: number, files: Set<string> }>()
+
+    for (const filename of files) {
+      const filePath = resolve(filename)
+      const content = readFileSync(filePath, "utf-8")
+
+      const parseResult = Herb.parse(content)
+
+      if (parseResult.errors.length > 0) {
+        console.error(`${colorize(filename, "cyan")} - ${colorize("Parse errors:", "brightRed")}`)
+
+        for (const error of parseResult.errors) {
+          console.error(`  ${colorize("✗", "brightRed")} ${error.message}`)
+        }
+
+        totalErrors++
+        filesWithIssues++
+        continue
+      }
+
+      if (!this.linter) {
+        this.linter = new Linter()
+      }
+
+      const lintResult = this.linter.lint(parseResult.value)
+
+      // Get rule count on first file
+      if (ruleCount === 0) {
+        ruleCount = this.linter.getRuleCount()
+      }
+
+      if (lintResult.offenses.length === 0) {
+        if (files.length === 1) {
+          console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
+        }
+      } else {
+        // Collect messages for later display
+        for (const offense of lintResult.offenses) {
+          allDiagnostics.push({ filename, diagnostic: offense, content })
+
+          const ruleData = ruleViolations.get(offense.rule) || { count: 0, files: new Set() }
+          ruleData.count++
+          ruleData.files.add(filename)
+          ruleViolations.set(offense.rule, ruleData)
+        }
+
+        totalErrors += lintResult.errors
+        totalWarnings += lintResult.warnings
+        filesWithIssues++
+      }
+    }
+
+    return { totalErrors, totalWarnings, filesWithIssues, ruleCount, allDiagnostics, ruleViolations }
+  }
+}

package/src/cli/formatters/base-formatter.ts

@@ -0,0 +1,11 @@
+import type { Diagnostic } from "@herb-tools/core"
+import type { ProcessedFile } from "../file-processor.js"
+
+export abstract class BaseFormatter {
+  abstract format(
+    allDiagnostics: ProcessedFile[],
+    isSingleFile?: boolean
+  ): Promise<void>
+
+  abstract formatFile(filename: string, diagnostics: Diagnostic[]): void
+}

package/src/cli/formatters/detailed-formatter.ts

@@ -0,0 +1,74 @@
+import { colorize, Highlighter, type ThemeInput, DEFAULT_THEME } from "@herb-tools/highlighter"
+
+import { BaseFormatter } from "./base-formatter.js"
+
+import type { Diagnostic } from "@herb-tools/core"
+import type { ProcessedFile } from "../file-processor.js"
+
+export class DetailedFormatter extends BaseFormatter {
+  private highlighter: Highlighter | null = null
+  private theme: ThemeInput
+  private wrapLines: boolean
+  private truncateLines: boolean
+
+  constructor(theme: ThemeInput = DEFAULT_THEME, wrapLines: boolean = true, truncateLines: boolean = false) {
+    super()
+    this.theme = theme
+    this.wrapLines = wrapLines
+    this.truncateLines = truncateLines
+  }
+
+  async format(allDiagnostics: ProcessedFile[], isSingleFile: boolean = false): Promise<void> {
+    if (allDiagnostics.length === 0) return
+
+    if (!this.highlighter) {
+      this.highlighter = new Highlighter(this.theme)
+      await this.highlighter.initialize()
+    }
+
+    if (isSingleFile) {
+      // For single file, use inline diagnostics with syntax highlighting
+      const { filename, content } = allDiagnostics[0]
+      const diagnostics = allDiagnostics.map(item => item.diagnostic)
+
+      const highlighted = this.highlighter.highlight(filename, content, {
+        diagnostics: diagnostics,
+        splitDiagnostics: true, // Use split mode to show each diagnostic separately
+        contextLines: 2,
+        wrapLines: this.wrapLines,
+        truncateLines: this.truncateLines
+      })
+
+      console.log(`\n${highlighted}`)
+    } else {
+      // For multiple files, show individual diagnostics with syntax highlighting
+      const totalMessageCount = allDiagnostics.length
+
+      for (let i = 0; i < allDiagnostics.length; i++) {
+        const { filename, diagnostic, content } = allDiagnostics[i]
+        const formatted = this.highlighter.highlightDiagnostic(filename, diagnostic, content, { 
+          contextLines: 2, 
+          wrapLines: this.wrapLines,
+          truncateLines: this.truncateLines
+        })
+        console.log(`\n${formatted}`)
+
+        const width = process.stdout.columns || 80
+        const progressText = `[${i + 1}/${totalMessageCount}]`
+        const rightPadding = 16
+        const separatorLength = Math.max(0, width - progressText.length - 1 - rightPadding)
+        const separator = '⎯'
+        const leftSeparator = colorize(separator.repeat(separatorLength), "gray")
+        const rightSeparator = colorize(separator.repeat(4), "gray")
+        const progress = colorize(progressText, "gray")
+
+        console.log(colorize(`${leftSeparator}  ${progress}`, "dim") + colorize(` ${rightSeparator}\n`, "dim"))
+      }
+    }
+  }
+
+  formatFile(_filename: string, _diagnostics: Diagnostic[]): void {
+    // Not used in detailed formatter
+    throw new Error("formatFile is not implemented for DetailedFormatter")
+  }
+}

package/src/cli/formatters/index.ts

@@ -0,0 +1,3 @@
+export { BaseFormatter } from "./base-formatter.js"
+export { SimpleFormatter } from "./simple-formatter.js"
+export { DetailedFormatter } from "./detailed-formatter.js"

package/src/cli/formatters/simple-formatter.ts

@@ -0,0 +1,40 @@
+import { colorize } from "@herb-tools/highlighter"
+
+import { BaseFormatter } from "./base-formatter.js"
+
+import type { Diagnostic } from "@herb-tools/core"
+import type { ProcessedFile } from "../file-processor.js"
+
+export class SimpleFormatter extends BaseFormatter {
+  async format(allDiagnostics: ProcessedFile[]): Promise<void> {
+    if (allDiagnostics.length === 0) return
+
+    const groupedDiagnostics = new Map<string, Diagnostic[]>()
+
+    for (const { filename, diagnostic } of allDiagnostics) {
+      const diagnostics = groupedDiagnostics.get(filename) || []
+      diagnostics.push(diagnostic)
+      groupedDiagnostics.set(filename, diagnostics)
+    }
+
+    for (const [filename, diagnostics] of groupedDiagnostics) {
+      console.log("")
+      this.formatFile(filename, diagnostics)
+    }
+  }
+
+  formatFile(filename: string, diagnostics: Diagnostic[]): void {
+    console.log(`${colorize(filename, "cyan")}:`)
+
+    for (const diagnostic of diagnostics) {
+      const isError = diagnostic.severity === "error"
+      const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
+      const rule = colorize(`(${diagnostic.code})`, "blue")
+      const locationString = `${diagnostic.location.start.line}:${diagnostic.location.start.column}`
+      const paddedLocation = locationString.padEnd(4) // Pad to 4 characters for alignment
+
+      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${diagnostic.message} ${rule}`)
+    }
+    console.log("")
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,4 @@
+export { ArgumentParser } from "./argument-parser.js"
+export { FileProcessor } from "./file-processor.js"
+export { SummaryReporter } from "./summary-reporter.js"
+export * from "./formatters/index.js"

package/src/cli/summary-reporter.ts

@@ -0,0 +1,127 @@
+import { colorize } from "@herb-tools/highlighter"
+
+export interface SummaryData {
+  files: string[]
+  totalErrors: number
+  totalWarnings: number
+  filesWithViolations: number
+  ruleCount: number
+  startTime: number
+  startDate: Date
+  showTiming: boolean
+  ruleViolations: Map<string, { count: number, files: Set<string> }>
+}
+
+export class SummaryReporter {
+  private pluralize(count: number, singular: string, plural?: string): string {
+    return count === 1 ? singular : (plural || `${singular}s`)
+  }
+
+  displaySummary(data: SummaryData): void {
+    const { files, totalErrors, totalWarnings, filesWithViolations, ruleCount, startTime, startDate, showTiming } = data
+
+    console.log("\n")
+    console.log(` ${colorize("Summary:", "bold")}`)
+
+    // Calculate padding for alignment
+    const labelWidth = 12 // Width for the longest label "Violations"
+    const pad = (label: string) => label.padEnd(labelWidth)
+
+    // Checked summary
+    console.log(`  ${colorize(pad("Checked"), "gray")} ${colorize(`${files.length} ${this.pluralize(files.length, "file")}`, "cyan")}`)
+
+    // Files summary (for multiple files)
+    if (files.length > 1) {
+      const filesChecked = files.length
+      const filesClean = filesChecked - filesWithViolations
+
+      let filesSummary = ""
+      let shouldDim = false
+
+      if (filesWithViolations > 0) {
+        filesSummary = `${colorize(colorize(`${filesWithViolations} with violations`, "brightRed"), "bold")} | ${colorize(colorize(`${filesClean} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
+      } else {
+        filesSummary = `${colorize(colorize(`${filesChecked} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
+        shouldDim = true
+      }
+
+      if (shouldDim) {
+        console.log(colorize(`  ${colorize(pad("Files"), "gray")} ${filesSummary}`, "dim"))
+      } else {
+        console.log(`  ${colorize(pad("Files"), "gray")} ${filesSummary}`)
+      }
+    }
+
+    // Violations summary with file count
+    let violationsSummary = ""
+    const parts = []
+
+    // Build the main part with errors and warnings
+    if (totalErrors > 0) {
+      parts.push(colorize(colorize(`${totalErrors} ${this.pluralize(totalErrors, "error")}`, "brightRed"), "bold"))
+    }
+
+    if (totalWarnings > 0) {
+      parts.push(colorize(colorize(`${totalWarnings} ${this.pluralize(totalWarnings, "warning")}`, "brightYellow"), "bold"))
+    } else if (totalErrors > 0) {
+      // Show 0 warnings when there are errors but no warnings
+      parts.push(colorize(colorize(`${totalWarnings} ${this.pluralize(totalWarnings, "warning")}`, "green"), "bold"))
+    }
+
+    if (parts.length === 0) {
+      violationsSummary = colorize(colorize("0 violations", "green"), "bold")
+    } else {
+      violationsSummary = parts.join(" | ")
+      // Add total count and file count
+      let detailText = ""
+
+      const totalViolations = totalErrors + totalWarnings
+
+      if (filesWithViolations > 0) {
+        detailText = `${totalViolations} ${this.pluralize(totalViolations, "violation")} across ${filesWithViolations} ${this.pluralize(filesWithViolations, "file")}`
+      }
+
+      violationsSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+    }
+
+    console.log(`  ${colorize(pad("Violations"), "gray")} ${violationsSummary}`)
+
+    // Timing information (if enabled)
+    if (showTiming) {
+      const duration = Date.now() - startTime
+      const timeString = startDate.toTimeString().split(' ')[0] // HH:MM:SS format
+
+      console.log(`  ${colorize(pad("Start at"), "gray")} ${colorize(timeString, "cyan")}`)
+      console.log(`  ${colorize(pad("Duration"), "gray")} ${colorize(`${duration}ms`, "cyan")} ${colorize(colorize(`(${ruleCount} ${this.pluralize(ruleCount, "rule")})`, "gray"), "dim")}`)
+    }
+
+    // Success message for all files clean
+    if (filesWithViolations === 0 && files.length > 1) {
+      console.log("")
+      console.log(` ${colorize("✓", "brightGreen")} ${colorize("All files are clean!", "green")}`)
+    }
+  }
+
+  displayMostViolatedRules(ruleViolations: Map<string, { count: number, files: Set<string> }>, limit: number = 5): void {
+    if (ruleViolations.size === 0) return
+
+    const allRules = Array.from(ruleViolations.entries()).sort((a, b) => b[1].count - a[1].count)
+    const displayedRules = allRules.slice(0, limit)
+    const remainingRules = allRules.slice(limit)
+
+    const title = ruleViolations.size <= limit ? "Rule violations:" : "Most violated rules:"
+    console.log(` ${colorize(title, "bold")}`)
+
+    for (const [rule, data] of displayedRules) {
+      const fileCount = data.files.size
+      const countText = `(${data.count} ${this.pluralize(data.count, "violation")} in ${fileCount} ${this.pluralize(fileCount, "file")})`
+      console.log(`  ${colorize(rule, "gray")} ${colorize(colorize(countText, "gray"), "dim")}`)
+    }
+
+    if (remainingRules.length > 0) {
+      const remainingViolationCount = remainingRules.reduce((sum, [_, data]) => sum + data.count, 0)
+      const remainingRuleCount = remainingRules.length
+      console.log(colorize(colorize(`\n  ...and ${remainingRuleCount} more ${this.pluralize(remainingRuleCount, "rule")} with ${remainingViolationCount} ${this.pluralize(remainingViolationCount, "violation")}`, "gray"), "dim"))
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,60 @@
+import { glob } from "glob"
+import { Herb } from "@herb-tools/node-wasm"
+import { ArgumentParser } from "./cli/argument-parser.js"
+import { FileProcessor } from "./cli/file-processor.js"
+import { SimpleFormatter, DetailedFormatter } from "./cli/formatters/index.js"
+import { SummaryReporter } from "./cli/summary-reporter.js"
+
+export class CLI {
+  private argumentParser = new ArgumentParser()
+  private fileProcessor = new FileProcessor()
+  private summaryReporter = new SummaryReporter()
+
+  async run() {
+    const startTime = Date.now()
+    const startDate = new Date()
+
+    const { pattern, formatOption, showTiming, theme, wrapLines, truncateLines } = this.argumentParser.parse(process.argv)
+
+    try {
+      await Herb.load()
+
+      const files = await glob(pattern)
+
+      if (files.length === 0) {
+        console.log(`No files found matching pattern: ${pattern}`)
+        process.exit(0)
+      }
+
+      const results = await this.fileProcessor.processFiles(files)
+      const { totalErrors, totalWarnings, filesWithIssues, ruleCount, allDiagnostics, ruleViolations } = results
+
+      const formatter = formatOption === 'simple'
+        ? new SimpleFormatter()
+        : new DetailedFormatter(theme, wrapLines, truncateLines)
+
+      await formatter.format(allDiagnostics, files.length === 1)
+
+      this.summaryReporter.displayMostViolatedRules(ruleViolations)
+      this.summaryReporter.displaySummary({
+        files,
+        totalErrors,
+        totalWarnings,
+        filesWithViolations: filesWithIssues,
+        ruleCount,
+        startTime,
+        startDate,
+        showTiming,
+        ruleViolations
+      })
+
+      if (totalErrors > 0) {
+        process.exit(1)
+      }
+
+    } catch (error) {
+      console.error(`Error:`, error)
+      process.exit(1)
+    }
+  }
+}

package/src/default-rules.ts

@@ -0,0 +1,33 @@
+import type { RuleClass } from "./types.js"
+
+import { ERBNoEmptyTagsRule } from "./rules/erb-no-empty-tags.js"
+import { ERBNoOutputControlFlowRule } from "./rules/erb-no-output-control-flow.js"
+import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
+import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
+import { HTMLAriaRoleHeadingRequiresLevelRule } from "./rules/html-aria-role-heading-requires-level.js"
+import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quotes.js"
+import { HTMLAttributeValuesRequireQuotesRule } from "./rules/html-attribute-values-require-quotes.js"
+import { HTMLBooleanAttributesNoValueRule } from "./rules/html-boolean-attributes-no-value.js"
+import { HTMLImgRequireAltRule } from "./rules/html-img-require-alt.js"
+import { HTMLNoBlockInsideInlineRule } from "./rules/html-no-block-inside-inline.js"
+import { HTMLNoDuplicateAttributesRule } from "./rules/html-no-duplicate-attributes.js"
+import { HTMLNoEmptyHeadingsRule } from "./rules/html-no-empty-headings.js"
+import { HTMLNoNestedLinksRule } from "./rules/html-no-nested-links.js"
+import { HTMLTagNameLowercaseRule } from "./rules/html-tag-name-lowercase.js"
+
+export const defaultRules: RuleClass[] = [
+  ERBNoEmptyTagsRule,
+  ERBNoOutputControlFlowRule,
+  ERBRequireWhitespaceRule,
+  HTMLAnchorRequireHrefRule,
+  HTMLAriaRoleHeadingRequiresLevelRule,
+  HTMLAttributeDoubleQuotesRule,
+  HTMLAttributeValuesRequireQuotesRule,
+  HTMLBooleanAttributesNoValueRule,
+  HTMLImgRequireAltRule,
+  HTMLNoBlockInsideInlineRule,
+  HTMLNoDuplicateAttributesRule,
+  HTMLNoEmptyHeadingsRule,
+  HTMLNoNestedLinksRule,
+  HTMLTagNameLowercaseRule,
+]

package/src/herb-lint.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { CLI } from "./cli.js"
+
+const cli = new CLI()
+cli.run()

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./linter.js"
+export * from "./rules/index.js"
+export * from "./types.js"

package/src/linter.ts

@@ -0,0 +1,50 @@
+import { defaultRules } from "./default-rules.js"
+
+import type { RuleClass, LintResult, LintOffense } from "./types.js"
+import type { DocumentNode } from "@herb-tools/core"
+
+export class Linter {
+  private rules: RuleClass[]
+  private offenses: LintOffense[]
+
+  /**
+   * Creates a new Linter instance.
+   * @param rules - Array of rule classes (not instances) to use. If not provided, uses default rules.
+   */
+  constructor(rules?: RuleClass[]) {
+    this.rules = rules !== undefined ? rules : this.getDefaultRules()
+    this.offenses = []
+  }
+
+  /**
+   * Returns the default set of rule classes used by the linter.
+   * @returns Array of rule classes
+   */
+  private getDefaultRules(): RuleClass[] {
+    return defaultRules
+  }
+
+  getRuleCount(): number {
+    return this.rules.length
+  }
+
+  lint(document: DocumentNode): LintResult {
+    this.offenses = []
+
+    for (const Rule of this.rules) {
+      const rule = new Rule()
+      const ruleOffenses = rule.check(document)
+
+      this.offenses.push(...ruleOffenses)
+    }
+
+    const errors = this.offenses.filter(offense => offense.severity === "error").length
+    const warnings = this.offenses.filter(offense => offense.severity === "warning").length
+
+    return {
+      offenses: this.offenses,
+      errors,
+      warnings
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+import { BaseRuleVisitor } from "./rule-utils.js"
+
+import type { Rule, LintOffense } from "../types.js"
+import type { Node, ERBContentNode } from "@herb-tools/core"
+
+class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
+  visitERBContentNode(node: ERBContentNode): void {
+    this.visitChildNodes(node)
+
+    const { content, tag_closing } = node
+
+    if (!content) return
+    if (tag_closing?.value === "") return
+    if (content.value.trim().length > 0) return
+
+    this.addOffense(
+      "ERB tag should not be empty. Remove empty ERB tags or add content.",
+      node.location,
+      "error"
+    )
+  }
+}
+
+export class ERBNoEmptyTagsRule implements Rule {
+  name = "erb-no-empty-tags"
+
+  check(node: Node): LintOffense[] {
+    const visitor = new ERBNoEmptyTagsVisitor(this.name)
+
+    visitor.visit(node)
+
+    return visitor.offenses
+  }
+}