@herb-tools/linter 0.4.2 → 0.5.0

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

@@ -6,34 +6,34 @@ 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
+  async format(allOffenses: ProcessedFile[]): Promise<void> {
+    if (allOffenses.length === 0) return
 
-    const groupedDiagnostics = new Map<string, Diagnostic[]>()
+    const groupedOffenses = 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, offense } of allOffenses) {
+      const offenses = groupedOffenses.get(filename) || []
+      offenses.push(offense)
+      groupedOffenses.set(filename, offenses)
     }
 
-    for (const [filename, diagnostics] of groupedDiagnostics) {
+    for (const [filename, offenses] of groupedOffenses) {
       console.log("")
-      this.formatFile(filename, diagnostics)
+      this.formatFile(filename, offenses)
     }
   }
 
-  formatFile(filename: string, diagnostics: Diagnostic[]): void {
+  formatFile(filename: string, offenses: Diagnostic[]): void {
     console.log(`${colorize(filename, "cyan")}:`)
 
-    for (const diagnostic of diagnostics) {
-      const isError = diagnostic.severity === "error"
+    for (const offense of offenses) {
+      const isError = offense.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 rule = colorize(`(${offense.code})`, "blue")
+      const locationString = `${offense.location.start.line}:${offense.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(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
     }
     console.log("")
   }

package/src/cli/output-manager.ts

@@ -0,0 +1,143 @@
+import { SummaryReporter } from "./summary-reporter.js"
+import { SimpleFormatter, DetailedFormatter, GitHubActionsFormatter, type JSONOutput } from "./formatters/index.js"
+
+import type { ThemeInput } from "@herb-tools/highlighter"
+import type { FormatOption } from "./argument-parser.js"
+import type { ProcessingResult } from "./file-processor.js"
+
+interface OutputOptions {
+  formatOption: FormatOption
+  theme: ThemeInput
+  wrapLines: boolean
+  truncateLines: boolean
+  showTiming: boolean
+  startTime: number
+  startDate: Date
+}
+
+interface LintResults extends ProcessingResult {
+  files: string[]
+}
+
+export class OutputManager {
+  private summaryReporter = new SummaryReporter()
+
+  /**
+   * Output successful lint results
+   */
+  async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
+    const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
+
+    if (options.formatOption === "github") {
+      const formatter = new GitHubActionsFormatter()
+      await formatter.format(allOffenses)
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: allOffenses.map(({ filename, offense }) => ({
+          filename,
+          message: offense.message,
+          location: offense.location.toJSON(),
+          severity: offense.severity,
+          code: offense.code,
+          source: offense.source
+        })),
+        summary: {
+          filesChecked: files.length,
+          filesWithOffenses,
+          totalErrors,
+          totalWarnings,
+          totalOffenses: totalErrors + totalWarnings,
+          ruleCount
+        },
+        timing: null,
+        completed: true,
+        clean: totalErrors === 0 && totalWarnings === 0,
+        message: null
+      }
+
+      const duration = Date.now() - options.startTime
+      output.timing = options.showTiming ? {
+        startTime: options.startDate.toISOString(),
+        duration: duration
+      } : null
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      const formatter = options.formatOption === "simple"
+        ? new SimpleFormatter()
+        : new DetailedFormatter(options.theme, options.wrapLines, options.truncateLines)
+
+      await formatter.format(allOffenses, files.length === 1)
+
+      this.summaryReporter.displayMostViolatedRules(ruleOffenses)
+      this.summaryReporter.displaySummary({
+        files,
+        totalErrors,
+        totalWarnings,
+        filesWithOffenses,
+        ruleCount,
+        startTime: options.startTime,
+        startDate: options.startDate,
+        showTiming: options.showTiming,
+        ruleOffenses
+      })
+    }
+  }
+
+  /**
+   * Output informational message (like "no files found")
+   */
+  outputInfo(message: string, options: OutputOptions): void {
+    if (options.formatOption === "github") {
+      // GitHub Actions format doesn't output anything for info messages
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: [],
+        summary: {
+          filesChecked: 0,
+          filesWithOffenses: 0,
+          totalErrors: 0,
+          totalWarnings: 0,
+          totalOffenses: 0,
+          ruleCount: 0
+        },
+        timing: null,
+        completed: false,
+        clean: null,
+        message
+      }
+
+      const duration = Date.now() - options.startTime
+      output.timing = options.showTiming ? {
+        startTime: options.startDate.toISOString(),
+        duration: duration
+      } : null
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      console.log(message)
+    }
+  }
+
+  /**
+   * Output error message
+   */
+  outputError(message: string, options: OutputOptions): void {
+    if (options.formatOption === "github") {
+      console.log(`::error::${message}`)
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: [],
+        summary: null,
+        timing: null,
+        completed: false,
+        clean: null,
+        message
+      }
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      console.error(message)
+    }
+  }
+}

package/src/cli/summary-reporter.ts

@@ -4,12 +4,12 @@ export interface SummaryData {
   files: string[]
   totalErrors: number
   totalWarnings: number
-  filesWithViolations: number
+  filesWithOffenses: number
   ruleCount: number
   startTime: number
   startDate: Date
   showTiming: boolean
-  ruleViolations: Map<string, { count: number, files: Set<string> }>
+  ruleOffenses: Map<string, { count: number, files: Set<string> }>
 }
 
 export class SummaryReporter {
@@ -18,13 +18,13 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithViolations, ruleCount, startTime, startDate, showTiming } = data
+    const { files, totalErrors, totalWarnings, filesWithOffenses, 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 labelWidth = 12 // Width for the longest label "Offenses"
     const pad = (label: string) => label.padEnd(labelWidth)
 
     // Checked summary
@@ -33,13 +33,13 @@ export class SummaryReporter {
     // Files summary (for multiple files)
     if (files.length > 1) {
       const filesChecked = files.length
-      const filesClean = filesChecked - filesWithViolations
+      const filesClean = filesChecked - filesWithOffenses
 
       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")}`
+      if (filesWithOffenses > 0) {
+        filesSummary = `${colorize(colorize(`${filesWithOffenses} with offenses`, "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
@@ -52,8 +52,8 @@ export class SummaryReporter {
       }
     }
 
-    // Violations summary with file count
-    let violationsSummary = ""
+    // Offenses summary with file count
+    let offensesSummary = ""
     const parts = []
 
     // Build the main part with errors and warnings
@@ -69,22 +69,22 @@ export class SummaryReporter {
     }
 
     if (parts.length === 0) {
-      violationsSummary = colorize(colorize("0 violations", "green"), "bold")
+      offensesSummary = colorize(colorize("0 offenses", "green"), "bold")
     } else {
-      violationsSummary = parts.join(" | ")
+      offensesSummary = parts.join(" | ")
       // Add total count and file count
       let detailText = ""
 
-      const totalViolations = totalErrors + totalWarnings
+      const totalOffenses = totalErrors + totalWarnings
 
-      if (filesWithViolations > 0) {
-        detailText = `${totalViolations} ${this.pluralize(totalViolations, "violation")} across ${filesWithViolations} ${this.pluralize(filesWithViolations, "file")}`
+      if (filesWithOffenses > 0) {
+        detailText = `${totalOffenses} ${this.pluralize(totalOffenses, "offense")} across ${filesWithOffenses} ${this.pluralize(filesWithOffenses, "file")}`
       }
 
-      violationsSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
     }
 
-    console.log(`  ${colorize(pad("Violations"), "gray")} ${violationsSummary}`)
+    console.log(`  ${colorize(pad("Offenses"), "gray")} ${offensesSummary}`)
 
     // Timing information (if enabled)
     if (showTiming) {
@@ -96,32 +96,32 @@ export class SummaryReporter {
     }
 
     // Success message for all files clean
-    if (filesWithViolations === 0 && files.length > 1) {
+    if (filesWithOffenses === 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
+  displayMostViolatedRules(ruleOffenses: Map<string, { count: number, files: Set<string> }>, limit: number = 5): void {
+    if (ruleOffenses.size === 0) return
 
-    const allRules = Array.from(ruleViolations.entries()).sort((a, b) => b[1].count - a[1].count)
+    const allRules = Array.from(ruleOffenses.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:"
+    const title = ruleOffenses.size <= limit ? "Rule offenses:" : "Most frequent rule offenses:"
     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")})`
+      const countText = `(${data.count} ${this.pluralize(data.count, "offense")} 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 remainingOffenseCount = 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"))
+      console.log(colorize(colorize(`\n  ...and ${remainingRuleCount} more ${this.pluralize(remainingRuleCount, "rule")} with ${remainingOffenseCount} ${this.pluralize(remainingOffenseCount, "offense")}`, "gray"), "dim"))
     }
   }
 }

package/src/cli.ts

@@ -1,14 +1,41 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
-import { ArgumentParser } from "./cli/argument-parser.js"
+import { ArgumentParser, type FormatOption } 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"
+import { OutputManager } from "./cli/output-manager.js"
 
 export class CLI {
   private argumentParser = new ArgumentParser()
   private fileProcessor = new FileProcessor()
-  private summaryReporter = new SummaryReporter()
+  private outputManager = new OutputManager()
+
+  private exitWithError(message: string, formatOption: FormatOption, exitCode: number = 1) {
+    this.outputManager.outputError(message, { 
+      formatOption, 
+      theme: 'auto', 
+      wrapLines: false, 
+      truncateLines: false, 
+      showTiming: false, 
+      startTime: 0, 
+      startDate: new Date() 
+    })
+    process.exit(exitCode)
+  }
+
+  private exitWithInfo(message: string, formatOption: FormatOption, exitCode: number = 0, timingData?: { startTime: number, startDate: Date, showTiming: boolean }) {
+    const outputOptions = {
+      formatOption,
+      theme: 'auto' as const,
+      wrapLines: false,
+      truncateLines: false,
+      showTiming: timingData?.showTiming ?? false,
+      startTime: timingData?.startTime ?? Date.now(),
+      startDate: timingData?.startDate ?? new Date()
+    }
+    
+    this.outputManager.outputInfo(message, outputOptions)
+    process.exit(exitCode)
+  }
 
   async run() {
     const startTime = Date.now()
@@ -16,45 +43,35 @@ export class CLI {
 
     const { pattern, formatOption, showTiming, theme, wrapLines, truncateLines } = this.argumentParser.parse(process.argv)
 
+    const outputOptions = {
+      formatOption,
+      theme,
+      wrapLines,
+      truncateLines,
+      showTiming,
+      startTime,
+      startDate
+    }
+
     try {
       await Herb.load()
 
       const files = await glob(pattern)
 
       if (files.length === 0) {
-        console.log(`No files found matching pattern: ${pattern}`)
-        process.exit(0)
+        this.exitWithInfo(`No files found matching pattern: ${pattern}`, formatOption, 0, { startTime, startDate, showTiming })
       }
 
-      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) {
+      const results = await this.fileProcessor.processFiles(files, formatOption)
+      
+      await this.outputManager.outputResults({ ...results, files }, outputOptions)
+
+      if (results.totalErrors > 0) {
         process.exit(1)
       }
 
     } catch (error) {
-      console.error(`Error:`, error)
-      process.exit(1)
+      this.exitWithError(`Error: ${error}`, formatOption)
     }
   }
 }

package/src/default-rules.ts

@@ -2,9 +2,12 @@ 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 { ERBPreferImageTagHelperRule } from "./rules/erb-prefer-image-tag-helper.js"
+import { ERBRequiresTrailingNewlineRule } from "./rules/erb-requires-trailing-newline.js"
 import { ERBRequireWhitespaceRule } from "./rules/erb-require-whitespace-inside-tags.js"
 import { HTMLAnchorRequireHrefRule } from "./rules/html-anchor-require-href.js"
 import { HTMLAriaAttributeMustBeValid } from "./rules/html-aria-attribute-must-be-valid.js"
+import { HTMLAriaLevelMustBeValidRule } from "./rules/html-aria-level-must-be-valid.js"
 import { HTMLAriaRoleHeadingRequiresLevelRule } from "./rules/html-aria-role-heading-requires-level.js"
 import { HTMLAriaRoleMustBeValidRule } from "./rules/html-aria-role-must-be-valid.js"
 import { HTMLAttributeDoubleQuotesRule } from "./rules/html-attribute-double-quotes.js"
@@ -17,14 +20,18 @@ import { HTMLNoDuplicateIdsRule } from "./rules/html-no-duplicate-ids.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"
+import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
 import { SVGTagNameCapitalizationRule } from "./rules/svg-tag-name-capitalization.js"
 
 export const defaultRules: RuleClass[] = [
   ERBNoEmptyTagsRule,
   ERBNoOutputControlFlowRule,
+  ERBPreferImageTagHelperRule,
+  ERBRequiresTrailingNewlineRule,
   ERBRequireWhitespaceRule,
   HTMLAnchorRequireHrefRule,
   HTMLAriaAttributeMustBeValid,
+  HTMLAriaLevelMustBeValidRule,
   HTMLAriaRoleHeadingRequiresLevelRule,
   HTMLAriaRoleMustBeValidRule,
   HTMLAttributeDoubleQuotesRule,
@@ -37,5 +44,6 @@ export const defaultRules: RuleClass[] = [
   HTMLNoEmptyHeadingsRule,
   HTMLNoNestedLinksRule,
   HTMLTagNameLowercaseRule,
+  ParserNoErrorsRule,
   SVGTagNameCapitalizationRule,
 ]

package/src/linter.ts

@@ -1,17 +1,20 @@
 import { defaultRules } from "./default-rules.js"
 
-import type { RuleClass, LintResult, LintOffense } from "./types.js"
-import type { DocumentNode } from "@herb-tools/core"
+import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js"
+import type { HerbBackend } from "@herb-tools/core"
 
 export class Linter {
   private rules: RuleClass[]
+  private herb: HerbBackend
   private offenses: LintOffense[]
 
   /**
    * Creates a new Linter instance.
-   * @param rules - Array of rule classes (not instances) to use. If not provided, uses default rules.
+   * @param herb - The Herb backend instance for parsing and lexing
+   * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
    */
-  constructor(rules?: RuleClass[]) {
+  constructor(herb: HerbBackend, rules?: RuleClass[]) {
+    this.herb = herb
     this.rules = rules !== undefined ? rules : this.getDefaultRules()
     this.offenses = []
   }
@@ -28,12 +31,43 @@ export class Linter {
     return this.rules.length
   }
 
-  lint(document: DocumentNode): LintResult {
+  /**
+   * Type guard to check if a rule is a LexerRule
+   */
+  private isLexerRule(rule: Rule): rule is LexerRule {
+    return (rule.constructor as any).type === "lexer"
+  }
+
+  /**
+   * Type guard to check if a rule is a SourceRule
+   */
+  private isSourceRule(rule: Rule): rule is SourceRule {
+    return (rule.constructor as any).type === "source"
+  }
+
+  /**
+   * Lint source code using Parser/AST, Lexer, and Source rules.
+   * @param source - The source code to lint
+   * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
+   */
+  lint(source: string, context?: Partial<LintContext>): LintResult {
     this.offenses = []
 
-    for (const Rule of this.rules) {
-      const rule = new Rule()
-      const ruleOffenses = rule.check(document)
+    const parseResult = this.herb.parse(source)
+    const lexResult = this.herb.lex(source)
+
+    for (const RuleClass of this.rules) {
+      const rule = new RuleClass()
+
+      let ruleOffenses: LintOffense[]
+
+      if (this.isLexerRule(rule)) {
+        ruleOffenses = (rule as LexerRule).check(lexResult, context)
+      } else if (this.isSourceRule(rule)) {
+        ruleOffenses = (rule as SourceRule).check(source, context)
+      } else {
+        ruleOffenses = (rule as ParserRule).check(parseResult, context)
+      }
 
       this.offenses.push(...ruleOffenses)
     }

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Rule, LintOffense } from "../types.js"
-import type { Node, ERBContentNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
+import type { ParseResult, ERBContentNode } from "@herb-tools/core"
 
 class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
   visitERBContentNode(node: ERBContentNode): void {
@@ -21,13 +22,13 @@ class ERBNoEmptyTagsVisitor extends BaseRuleVisitor {
   }
 }
 
-export class ERBNoEmptyTagsRule implements Rule {
+export class ERBNoEmptyTagsRule extends ParserRule {
   name = "erb-no-empty-tags"
 
-  check(node: Node): LintOffense[] {
-    const visitor = new ERBNoEmptyTagsVisitor(this.name)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoEmptyTagsVisitor(this.name, context)
 
-    visitor.visit(node)
+    visitor.visit(result.value)
 
     return visitor.offenses
   }

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

@@ -1,7 +1,8 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
 
-import type { Node, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
-import type { Rule, LintOffense } from "../types.js"
+import type { ParseResult, ERBIfNode, ERBUnlessNode, ERBElseNode, ERBEndNode } from "@herb-tools/core"
+import { ParserRule } from "../types.js"
+import type { LintOffense, LintContext } from "../types.js"
 
 class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
   visitERBIfNode(node: ERBIfNode): void {
@@ -49,12 +50,13 @@ class ERBNoOutputControlFlowRuleVisitor extends BaseRuleVisitor {
   }
 }
 
-export class ERBNoOutputControlFlowRule implements Rule {
+export class ERBNoOutputControlFlowRule extends ParserRule {
   name = "erb-no-output-control-flow"
-  check(node: Node): LintOffense[] {
-    const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name)
 
-    visitor.visit(node)
+  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+    const visitor = new ERBNoOutputControlFlowRuleVisitor(this.name, context)
+
+    visitor.visit(result.value)
 
     return visitor.offenses
   }