@herb-tools/formatter 0.7.4 → 0.8.0

package/src/formatter.ts

@@ -1,8 +1,13 @@
 import { FormatPrinter } from "./format-printer.js"
+
+import { isScaffoldTemplate } from "./scaffold-template-detector.js"
 import { resolveFormatOptions } from "./options.js"
 
-import type { FormatOptions } from "./options.js"
+import type { Config } from "@herb-tools/config"
+import type { RewriteContext } from "@herb-tools/rewriter"
 import type { HerbBackend, ParseResult } from "@herb-tools/core"
+import type { FormatOptions } from "./options.js"
+
 
 /**
  * Formatter uses a Herb Backend to parse the source and then
@@ -12,6 +17,37 @@ export class Formatter {
   private herb: HerbBackend
   private options: Required<FormatOptions>
 
+  /**
+   * Creates a Formatter instance from a Config object (recommended).
+   *
+   * @param herb - The Herb backend instance for parsing
+   * @param config - Optional Config instance for formatter options
+   * @param options - Additional options to override config
+   * @returns A configured Formatter instance
+   */
+  static from(
+    herb: HerbBackend,
+    config?: Config,
+    options: FormatOptions = {}
+  ): Formatter {
+    const formatterConfig = config?.formatter || {}
+
+    const mergedOptions: FormatOptions = {
+      indentWidth: options.indentWidth ?? formatterConfig.indentWidth,
+      maxLineLength: options.maxLineLength ?? formatterConfig.maxLineLength,
+      preRewriters: options.preRewriters,
+      postRewriters: options.postRewriters,
+    }
+
+    return new Formatter(herb, mergedOptions)
+  }
+
+  /**
+   * Creates a new Formatter instance.
+   *
+   * @param herb - The Herb backend instance for parsing
+   * @param options - Format options (including rewriters)
+   */
   constructor(herb: HerbBackend, options: FormatOptions = {}) {
     this.herb = herb
     this.options = resolveFormatOptions(options)
@@ -20,13 +56,49 @@ export class Formatter {
   /**
    * Format a source string, optionally overriding format options per call.
    */
-  format(source: string, options: FormatOptions = {}): string {
-    const result = this.parse(source)
+  format(source: string, options: FormatOptions = {}, filePath?: string): string {
+    let result = this.parse(source)
+
     if (result.failed) return source
+    if (isScaffoldTemplate(result)) return source
 
     const resolvedOptions = resolveFormatOptions({ ...this.options, ...options })
 
-    return new FormatPrinter(source, resolvedOptions).print(result.value)
+    let node = result.value
+
+    if (resolvedOptions.preRewriters.length > 0) {
+      const context: RewriteContext = {
+        filePath,
+        baseDir: process.cwd() // TODO: format() shouldn't depend on node internals
+      }
+
+      for (const rewriter of resolvedOptions.preRewriters) {
+        try {
+          node = rewriter.rewrite(node, context)
+        } catch (error) {
+          console.error(`Pre-format rewriter "${rewriter.name}" failed:`, error)
+        }
+      }
+    }
+
+    let formatted = new FormatPrinter(source, resolvedOptions).print(node)
+
+    if (resolvedOptions.postRewriters.length > 0) {
+      const context: RewriteContext = {
+        filePath,
+        baseDir: process.cwd() // TODO: format() shouldn't depend on node internals
+      }
+
+      for (const rewriter of resolvedOptions.postRewriters) {
+        try {
+          formatted = rewriter.rewrite(formatted, context)
+        } catch (error) {
+          console.error(`Post-format rewriter "${rewriter.name}" failed:`, error)
+        }
+      }
+    }
+
+    return formatted
   }
 
   private parse(source: string): ParseResult {

package/src/options.ts

@@ -1,14 +1,22 @@
+import type { ASTRewriter, StringRewriter } from "@herb-tools/rewriter"
+
 /**
  * Formatting options for the Herb formatter.
  *
  * indentWidth: number of spaces per indentation level.
  * maxLineLength: maximum line length before wrapping text or attributes.
+ * preRewriters: AST rewriters to run before formatting.
+ * postRewriters: String rewriters to run after formatting.
  */
 export interface FormatOptions {
   /** number of spaces per indentation level; defaults to 2 */
   indentWidth?: number
   /** maximum line length before wrapping; defaults to 80 */
   maxLineLength?: number
+  /** Pre-format rewriters (transform AST before formatting); defaults to [] */
+  preRewriters?: ASTRewriter[]
+  /** Post-format rewriters (transform string after formatting); defaults to [] */
+  postRewriters?: StringRewriter[]
 }
 
 /**
@@ -17,6 +25,8 @@ export interface FormatOptions {
 export const defaultFormatOptions: Required<FormatOptions> = {
   indentWidth: 2,
   maxLineLength: 80,
+  preRewriters: [],
+  postRewriters: [],
 }
 
 /**
@@ -30,5 +40,7 @@ export function resolveFormatOptions(
   return {
     indentWidth: options.indentWidth ?? defaultFormatOptions.indentWidth,
     maxLineLength: options.maxLineLength ?? defaultFormatOptions.maxLineLength,
+    preRewriters: options.preRewriters ?? defaultFormatOptions.preRewriters,
+    postRewriters: options.postRewriters ?? defaultFormatOptions.postRewriters,
   }
 }

package/src/scaffold-template-detector.ts

@@ -0,0 +1,33 @@
+import { Visitor } from "@herb-tools/core"
+import type { ERBContentNode, ParseResult } from "@herb-tools/core"
+
+export const isScaffoldTemplate = (result: ParseResult): boolean => {
+  const detector = new ScaffoldTemplateDetector()
+
+  detector.visit(result.value)
+
+  return detector.hasEscapedERB
+}
+
+/**
+ * Visitor that detects if the AST represents a Rails scaffold template.
+ * Scaffold templates contain escaped ERB tags (<%%= or <%%)
+ * and should not be formatted to preserve their exact structure.
+ */
+export class ScaffoldTemplateDetector extends Visitor {
+  public hasEscapedERB = false
+
+  visitERBContentNode(node: ERBContentNode): void {
+    const opening = node.tag_opening?.value
+
+    if (opening && opening.startsWith("<%%")) {
+      this.hasEscapedERB = true
+
+      return
+    }
+
+    if (this.hasEscapedERB) return
+
+    this.visitChildNodes(node)
+  }
+}

package/src/types.ts

@@ -0,0 +1,27 @@
+import type { CustomRewriterLoaderOptions } from "@herb-tools/rewriter/loader"
+
+export interface FormatterRewriterOptions extends CustomRewriterLoaderOptions {
+  /**
+   * Whether to load custom rewriters from the project
+   * Defaults to true
+   */
+  loadCustomRewriters?: boolean
+
+  /**
+   * Names of pre-format rewriters to run (in order)
+   */
+  pre?: string[]
+
+  /**
+   * Names of post-format rewriters to run (in order)
+   */
+  post?: string[]
+}
+
+export interface FormatterRewriterInfo {
+  preCount: number
+  postCount: number
+  warnings: string[]
+  preNames: string[]
+  postNames: string[]
+}