@herb-tools/formatter 0.4.0 → 0.4.2

package/dist/types/printer.d.ts

@@ -11,6 +11,8 @@ export declare class Printer extends Visitor {
     private source;
     private lines;
     private indentLevel;
+    private inlineMode;
+    private isInComplexNesting;
     constructor(source: string, options: Required<FormatOptions>);
     print(object: Node | Token, indentLevel?: number): string;
     private push;
@@ -52,4 +54,17 @@ export declare class Printer extends Visitor {
     private visitERBGeneric;
     private renderInlineOpen;
     renderAttribute(attribute: HTMLAttributeNode): string;
+    /**
+     * Try to render children inline if they are simple enough.
+     * Returns the inline string if possible, null otherwise.
+     */
+    private tryRenderInline;
+    /**
+     * Calculate the maximum nesting depth in a subtree of nodes.
+     */
+    private getMaxNestingDepth;
+    /**
+     * Render an HTML element's content inline (without the wrapping tags).
+     */
+    private renderElementInline;
 }

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.4.0",
-  "type": "module",
+  "version": "0.4.2",
   "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.2",
+    "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,163 @@ 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)
+                const output = result.endsWith('\n') ? result : result + '\n'
+
+                if (output !== source) {
+                  if (isCheckMode) {
+                    unformattedFiles.push(filePath)
+                  } else {
+                    writeFileSync(filePath, output, "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)
+            const output = result.endsWith('\n') ? result : result + '\n'
+
+            if (output !== source) {
+              if (isCheckMode) {
+                console.log(`File is not formatted: ${file}`)
+                process.exit(1)
+              } else {
+                writeFileSync(file, output, "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)
+            const output = result.endsWith('\n') ? result : result + '\n'
+
+            if (output !== source) {
+              if (isCheckMode) {
+                unformattedFiles.push(filePath)
+              } else {
+                writeFileSync(filePath, output, "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)
     }
   }