@herb-tools/formatter 0.4.0 → 0.4.1

package/dist/types/printer.d.ts

@@ -11,6 +11,7 @@ export declare class Printer extends Visitor {
     private source;
     private lines;
     private indentLevel;
+    private inlineMode;
     constructor(source: string, options: Required<FormatOptions>);
     print(object: Node | Token, indentLevel?: number): string;
     private push;

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.4.0",
-  "type": "module",
+  "version": "0.4.1",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/formatter%60:%20",
@@ -15,7 +14,7 @@
   "require": "./dist/index.cjs",
   "types": "./dist/types/index.d.ts",
   "bin": {
-    "herb-formatter": "bin/herb-formatter"
+    "herb-format": "bin/herb-format"
   },
   "scripts": {
     "build": "yarn clean && rollup -c rollup.config.mjs",
@@ -35,7 +34,8 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.4.0"
+    "@herb-tools/core": "0.4.1",
+    "glob": "^11.0.3"
   },
   "files": [
     "package.json",

package/src/cli.ts

@@ -1,30 +1,45 @@
-import { readFileSync } from "fs"
+import dedent from "dedent"
+import { readFileSync, writeFileSync, statSync } from "fs"
+import { glob } from "glob"
+import { join, resolve } from "path"
+
 import { Herb } from "@herb-tools/node-wasm"
 import { Formatter } from "./formatter.js"
+
 import { name, version } from "../package.json"
 
+const pluralize = (count: number, singular: string, plural: string = singular + 's'): string => {
+  return count === 1 ? singular : plural
+}
+
 export class CLI {
-  private usage = `
-  Usage: herb-formatter [file] [options]
+  private usage = dedent`
+    Usage: herb-format [file|directory] [options]
 
-  Arguments:
-    file             File to format (use '-' or omit for stdin)
+    Arguments:
+      file|directory   File to format, directory to format all **/*.html.erb files within,
+                       or '-' for stdin (omit to format all **/*.html.erb files in current directory)
 
-  Options:
-    -h, --help       show help
-    -v, --version    show version
+    Options:
+      -c, --check      check if files are formatted without modifying them
+      -h, --help       show help
+      -v, --version    show version
 
-  Examples:
-    herb-formatter templates/index.html.erb
-    cat template.html.erb | herb-formatter
-    herb-formatter - < template.html.erb
-`
+    Examples:
+      herb-format                            # Format all **/*.html.erb files in current directory
+      herb-format --check                    # Check if all **/*.html.erb files are formatted
+      herb-format templates/index.html.erb   # Format and write single file
+      herb-format --check templates/         # Check if all **/*.html.erb files in templates/ are formatted
+      cat template.html.erb | herb-format    # Format from stdin to stdout
+      herb-format - < template.html.erb      # Format from stdin to stdout
+  `
 
   async run() {
     const args = process.argv.slice(2)
 
     if (args.includes("--help") || args.includes("-h")) {
       console.log(this.usage)
+
       process.exit(0)
     }
 
@@ -34,26 +49,158 @@ export class CLI {
       if (args.includes("--version") || args.includes("-v")) {
         console.log("Versions:")
         console.log(`  ${name}@${version}, ${Herb.version}`.split(", ").join("\n  "))
+
         process.exit(0)
       }
 
-      let source: string
+      console.log("⚠️  Experimental Preview: The formatter is in early development. Please report any unexpected behavior or bugs to https://github.com/marcoroth/herb/issues")
+      console.log()
+
+      const formatter = new Formatter(Herb)
+      const isCheckMode = args.includes("--check") || args.includes("-c")
 
-      // Find the first non-flag argument (the file)
       const file = args.find(arg => !arg.startsWith("-"))
 
-      // Read from file or stdin
-      if (file && file !== "-") {
-        source = readFileSync(file, "utf-8")
+      if (!file && !process.stdin.isTTY) {
+        if (isCheckMode) {
+          console.error("Error: --check mode is not supported with stdin")
+
+          process.exit(1)
+        }
+
+        const source = await this.readStdin()
+        const result = formatter.format(source)
+        const output = result.endsWith('\n') ? result : result + '\n'
+
+        process.stdout.write(output)
+      } else if (file === "-") {
+        if (isCheckMode) {
+          console.error("Error: --check mode is not supported with stdin")
+
+          process.exit(1)
+        }
+
+        const source = await this.readStdin()
+        const result = formatter.format(source)
+        const output = result.endsWith('\n') ? result : result + '\n'
+
+        process.stdout.write(output)
+      } else if (file) {
+        try {
+          const stats = statSync(file)
+
+          if (stats.isDirectory()) {
+            const pattern = join(file, "**/*.html.erb")
+            const files = await glob(pattern)
+
+            if (files.length === 0) {
+              console.log(`No files found matching pattern: ${resolve(pattern)}`)
+              process.exit(0)
+            }
+
+            let formattedCount = 0
+            let unformattedFiles: string[] = []
+
+            for (const filePath of files) {
+              try {
+                const source = readFileSync(filePath, "utf-8")
+                const result = formatter.format(source)
+                if (result !== source) {
+                  if (isCheckMode) {
+                    unformattedFiles.push(filePath)
+                  } else {
+                    writeFileSync(filePath, result, "utf-8")
+                    console.log(`Formatted: ${filePath}`)
+                  }
+                  formattedCount++
+                }
+              } catch (error) {
+                console.error(`Error formatting ${filePath}:`, error)
+              }
+            }
+
+            if (isCheckMode) {
+              if (unformattedFiles.length > 0) {
+                console.log(`\nThe following ${pluralize(unformattedFiles.length, 'file is', 'files are')} not formatted:`)
+                unformattedFiles.forEach(file => console.log(`  ${file}`))
+                console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, found ${unformattedFiles.length} unformatted ${pluralize(unformattedFiles.length, 'file')}`)
+                process.exit(1)
+              } else {
+                console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, all files are properly formatted`)
+              }
+            } else {
+              console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, formatted ${formattedCount} ${pluralize(formattedCount, 'file')}`)
+            }
+          } else {
+            const source = readFileSync(file, "utf-8")
+            const result = formatter.format(source)
+
+            if (result !== source) {
+              if (isCheckMode) {
+                console.log(`File is not formatted: ${file}`)
+                process.exit(1)
+              } else {
+                writeFileSync(file, result, "utf-8")
+                console.log(`Formatted: ${file}`)
+              }
+            } else if (isCheckMode) {
+              console.log(`File is properly formatted: ${file}`)
+            }
+          }
+
+        } catch (error) {
+          console.error(`Error: Cannot access '${file}':`, error)
+
+          process.exit(1)
+        }
       } else {
-        source = await this.readStdin()
-      }
+        const files = await glob("**/*.html.erb")
 
-      const formatter = new Formatter(Herb)
-      const result = formatter.format(source)
-      process.stdout.write(result)
+        if (files.length === 0) {
+          console.log(`No files found matching pattern: ${resolve("**/*.html.erb")}`)
+
+          process.exit(0)
+        }
+
+        let formattedCount = 0
+        let unformattedFiles: string[] = []
+
+        for (const filePath of files) {
+          try {
+            const source = readFileSync(filePath, "utf-8")
+            const result = formatter.format(source)
+
+            if (result !== source) {
+              if (isCheckMode) {
+                unformattedFiles.push(filePath)
+              } else {
+                writeFileSync(filePath, result, "utf-8")
+                console.log(`Formatted: ${filePath}`)
+              }
+              formattedCount++
+            }
+          } catch (error) {
+            console.error(`Error formatting ${filePath}:`, error)
+          }
+        }
+
+        if (isCheckMode) {
+          if (unformattedFiles.length > 0) {
+            console.log(`\nThe following ${pluralize(unformattedFiles.length, 'file is', 'files are')} not formatted:`)
+            unformattedFiles.forEach(file => console.log(`  ${file}`))
+            console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, found ${unformattedFiles.length} unformatted ${pluralize(unformattedFiles.length, 'file')}`)
+
+            process.exit(1)
+          } else {
+            console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, all files are properly formatted`)
+          }
+        } else {
+          console.log(`\nChecked ${files.length} ${pluralize(files.length, 'file')}, formatted ${formattedCount} ${pluralize(formattedCount, 'file')}`)
+        }
+      }
     } catch (error) {
       console.error(error)
+
       process.exit(1)
     }
   }

package/src/printer.ts

@@ -67,6 +67,7 @@ export class Printer extends Visitor {
   private source: string
   private lines: string[] = []
   private indentLevel: number = 0
+  private inlineMode: boolean = false
 
   constructor(source: string, options: Required<FormatOptions>) {
     super()
@@ -143,6 +144,11 @@ export class Printer extends Visitor {
     const attributes = open.children.filter((child): child is HTMLAttributeNode =>
       child instanceof HTMLAttributeNode || (child as any).type === 'AST_HTML_ATTRIBUTE_NODE'
     )
+    const inlineNodes = open.children.filter(child =>
+      !(child instanceof HTMLAttributeNode || (child as any).type === 'AST_HTML_ATTRIBUTE_NODE') &&
+      !(child instanceof WhitespaceNode || (child as any).type === 'AST_WHITESPACE_NODE')
+    )
+
     const children = node.body.filter(
       child =>
         !(child instanceof WhitespaceNode || (child as any).type === 'AST_WHITESPACE_NODE') &&
@@ -158,7 +164,7 @@ export class Printer extends Visitor {
       return
     }
 
-    if (attributes.length === 0) {
+    if (attributes.length === 0 && inlineNodes.length === 0) {
       if (children.length === 0) {
         if (isSelfClosing) {
           this.push(indent + `<${tagName} />`)
@@ -167,6 +173,7 @@ export class Printer extends Visitor {
         } else {
           this.push(indent + `<${tagName}></${tagName}>`)
         }
+
         return
       }
 
@@ -183,16 +190,41 @@ export class Printer extends Visitor {
       return
     }
 
-    const inline = this.renderInlineOpen(tagName, attributes, isSelfClosing)
+    if (attributes.length === 0 && inlineNodes.length > 0) {
+      const inline = this.renderInlineOpen(tagName, [], isSelfClosing, inlineNodes, open.children)
+
+      if (children.length === 0) {
+        if (isSelfClosing || node.is_void) {
+          this.push(indent + inline)
+        } else {
+          this.push(indent + inline + `</${tagName}>`)
+        }
+        return
+      }
+
+      this.push(indent + inline)
+      this.withIndent(() => {
+        children.forEach(child => this.visit(child))
+      })
+
+      if (!node.is_void && !isSelfClosing) {
+        this.push(indent + `</${tagName}>`)
+      }
+
+      return
+    }
+
+    const inline = this.renderInlineOpen(tagName, attributes, isSelfClosing, inlineNodes, open.children)
     const singleAttribute = attributes[0]
     const hasEmptyValue =
       singleAttribute &&
       (singleAttribute.value instanceof HTMLAttributeValueNode || (singleAttribute.value as any)?.type === 'AST_HTML_ATTRIBUTE_VALUE_NODE') &&
       (singleAttribute.value as any)?.children.length === 0
 
-    const shouldKeepInline = attributes.length <= 3 &&
+    const shouldKeepInline = (attributes.length <= 3 &&
                             !hasEmptyValue &&
-                            inline.length + indent.length <= this.maxLineLength
+                            inline.length + indent.length <= this.maxLineLength) ||
+                            inlineNodes.length > 0
 
     if (shouldKeepInline) {
       if (children.length === 0) {
@@ -223,27 +255,38 @@ export class Printer extends Visitor {
       return
     }
 
-    this.push(indent + `<${tagName}`)
-    this.withIndent(() => {
-      attributes.forEach(attribute => {
-        this.push(this.indent() + this.renderAttribute(attribute))
-      })
-    })
+    if (inlineNodes.length > 0) {
+      this.push(indent + this.renderInlineOpen(tagName, attributes, isSelfClosing, inlineNodes, open.children))
 
-    if (isSelfClosing) {
-      this.push(indent + "/>")
-    } else if (node.is_void) {
-      this.push(indent + ">")
-    } else if (children.length === 0) {
-      this.push(indent + ">" + `</${tagName}>`)
+      if (!isSelfClosing && !node.is_void && children.length > 0) {
+        this.withIndent(() => {
+          children.forEach(child => this.visit(child))
+        })
+        this.push(indent + `</${tagName}>`)
+      }
     } else {
-      this.push(indent + ">")
-
+      this.push(indent + `<${tagName}`)
       this.withIndent(() => {
-        children.forEach(child => this.visit(child))
+        attributes.forEach(attribute => {
+          this.push(this.indent() + this.renderAttribute(attribute))
+        })
       })
 
-      this.push(indent + `</${tagName}>`)
+      if (isSelfClosing) {
+        this.push(indent + "/>")
+      } else if (node.is_void) {
+        this.push(indent + ">")
+      } else if (children.length === 0) {
+        this.push(indent + ">" + `</${tagName}>`)
+      } else {
+        this.push(indent + ">")
+
+        this.withIndent(() => {
+          children.forEach(child => this.visit(child))
+        })
+
+        this.push(indent + `</${tagName}>`)
+      }
     }
   }
 
@@ -492,18 +535,41 @@ export class Printer extends Visitor {
   }
 
   visitERBIfNode(node: ERBIfNode): void {
-    this.printERBNode(node)
+    if (this.inlineMode) {
+      const open = node.tag_opening?.value ?? ""
+      const content = node.content?.value ?? ""
+      const close = node.tag_closing?.value ?? ""
+      this.lines.push(open + content + close)
+
+      node.statements.forEach(child => {
+        if (child instanceof HTMLAttributeNode || (child as any).type === 'AST_HTML_ATTRIBUTE_NODE') {
+          this.lines.push(" " + this.renderAttribute(child as HTMLAttributeNode) + " ")
+        } else {
+          this.visit(child)
+        }
+      })
 
-    this.withIndent(() => {
-      node.statements.forEach(child => this.visit(child))
-    })
+      if (node.end_node) {
+        const endNode = node.end_node as any
+        const endOpen = endNode.tag_opening?.value ?? ""
+        const endContent = endNode.content?.value ?? ""
+        const endClose = endNode.tag_closing?.value ?? ""
+        this.lines.push(endOpen + endContent + endClose)
+      }
+    } else {
+      this.printERBNode(node)
 
-    if (node.subsequent) {
-      this.visit(node.subsequent)
-    }
+      this.withIndent(() => {
+        node.statements.forEach(child => this.visit(child))
+      })
 
-    if (node.end_node) {
-      this.printERBNode(node.end_node as any)
+      if (node.subsequent) {
+        this.visit(node.subsequent)
+      }
+
+      if (node.end_node) {
+        this.printERBNode(node.end_node as any)
+      }
     }
   }
 
@@ -601,15 +667,73 @@ export class Printer extends Visitor {
 
   // --- Utility methods ---
 
-  private renderInlineOpen(name: string, attributes: HTMLAttributeNode[], selfClose: boolean): string {
+  private renderInlineOpen(name: string, attributes: HTMLAttributeNode[], selfClose: boolean, inlineNodes: Node[] = [], allChildren: Node[] = []): string {
     const parts = attributes.map(attribute => this.renderAttribute(attribute))
 
+    if (inlineNodes.length > 0) {
+      let result = `<${name}`
+
+      if (allChildren.length > 0) {
+        const currentIndentLevel = this.indentLevel
+        this.indentLevel = 0
+        const tempLines = this.lines
+        this.lines = []
+
+        allChildren.forEach(child => {
+          if (child instanceof HTMLAttributeNode || (child as any).type === 'AST_HTML_ATTRIBUTE_NODE') {
+            this.lines.push(" " + this.renderAttribute(child as HTMLAttributeNode))
+          } else if (!(child instanceof WhitespaceNode || (child as any).type === 'AST_WHITESPACE_NODE')) {
+            const wasInlineMode = this.inlineMode
+            this.inlineMode = true
+
+            this.lines.push(" ")
+
+            this.visit(child)
+            this.inlineMode = wasInlineMode
+          }
+        })
+
+        const inlineContent = this.lines.join("")
+        this.lines = tempLines
+        this.indentLevel = currentIndentLevel
+
+        result += inlineContent
+      } else {
+        if (parts.length > 0) {
+          result += ` ${parts.join(" ")}`
+        }
+
+        const currentIndentLevel = this.indentLevel
+        this.indentLevel = 0
+        const tempLines = this.lines
+        this.lines = []
+
+        inlineNodes.forEach(node => {
+          const wasInlineMode = this.inlineMode
+          this.inlineMode = true
+          this.visit(node)
+          this.inlineMode = wasInlineMode
+        })
+
+        const inlineContent = this.lines.join("")
+        this.lines = tempLines
+        this.indentLevel = currentIndentLevel
+
+        result += inlineContent
+      }
+
+      result += selfClose ? " />" : ">"
+
+      return result
+    }
+
     return `<${name}${parts.length ? " " + parts.join(" ") : ""}${selfClose ? " /" : ""}>`
   }
 
   renderAttribute(attribute: HTMLAttributeNode): string {
     const name = (attribute.name as HTMLAttributeNameNode)!.name!.value ?? ""
     const equals = attribute.equals?.value ?? ""
+
     let value = ""
 
     if (attribute.value && (attribute.value instanceof HTMLAttributeValueNode || (attribute.value as any)?.type === 'AST_HTML_ATTRIBUTE_VALUE_NODE')) {
@@ -617,13 +741,15 @@ export class Printer extends Visitor {
       const open_quote = (attrValue.open_quote?.value ?? "")
       const close_quote = (attrValue.close_quote?.value ?? "")
       const attribute_value = attrValue.children.map((attr: any) => {
-        if (attr instanceof HTMLTextNode || (attr as any).type === 'AST_HTML_TEXT_NODE' ||
-            attr instanceof LiteralNode || (attr as any).type === 'AST_LITERAL_NODE') {
+        if (attr instanceof HTMLTextNode || (attr as any).type === 'AST_HTML_TEXT_NODE' || attr instanceof LiteralNode || (attr as any).type === 'AST_LITERAL_NODE') {
+
           return (attr as HTMLTextNode | LiteralNode).content
         } else if (attr instanceof ERBContentNode || (attr as any).type === 'AST_ERB_CONTENT_NODE') {
           const erbAttr = attr as ERBContentNode
+
           return (erbAttr.tag_opening!.value + erbAttr.content!.value + erbAttr.tag_closing!.value)
         }
+
         return ""
       }).join("")
 

package/bin/herb-formatter

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-import("../dist/herb-formatter.js")