Rust implementation of "rescript format"

Author: cknitt

cli/rescript.js

@@ -18,7 +18,8 @@ try {
       subcommand === "build" ||
       subcommand === "watch" ||
       subcommand === "clean" ||
-      subcommand === "compiler-args"
+      subcommand === "compiler-args" ||
+      subcommand === "format"
     ) {
       child_process.execFileSync(
         rescript_exe,

rewatch/Cargo.lock

@@ -20,6 +20,7 @@ log = { version = "0.4.17" }
 notify = { version = "5.1.0", features = ["serde"] }
 notify-debouncer-mini = { version = "0.2.0" }
 rayon = "1.6.1"
+num_cpus = "1.17.0"
 regex = "1.7.1"
 serde = { version = "1.0.152", features = ["derive"] }
 serde_derive = "1.0.152"

rewatch/Cargo.toml

@@ -162,11 +162,21 @@ pub enum Command {
         #[command(flatten)]
         snapshot_output: SnapshotOutputArg,
     },
-    /// Alias to `legacy format`.
-    #[command(disable_help_flag = true)]
+    /// Formats ReScript files.
     Format {
-        #[arg(allow_hyphen_values = true, num_args = 0..)]
-        format_args: Vec<OsString>,
+        /// Read the code from stdin and print the formatted code to stdout.
+        #[arg(long)]
+        stdin: Option<String>,
+        /// Format the whole project.
+        #[arg(short = 'a', long)]
+        all: bool,
+        /// Check formatting for file or the whole project. Use `--all` to check the whole project.
+        #[arg(short = 'c', long)]
+        check: bool,
+        /// Files to format.
+        files: Vec<String>,
+        #[command(flatten)]
+        bsc_path: BscPathArg,
     },
     /// Alias to `legacy dump`.
     #[command(disable_help_flag = true)]

rewatch/src/cli.rs

@@ -0,0 +1,169 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use anyhow::{bail, Result};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::io::{self, Read, Write};
+use std::fs;
+use rayon::prelude::*;
+use num_cpus;
+
+pub fn run(
+    stdin_path: Option<String>,
+    all: bool,
+    check: bool,
+    files: Vec<String>,
+    bsc_path_arg: Option<PathBuf>,
+) -> Result<()> {
+    let bsc_exe = match bsc_path_arg {
+        Some(path) => path,
+        None => find_bsc_exe()?,
+    };
+
+    if check && stdin_path.is_some() {
+        bail!("format -stdin cannot be used with -check flag");
+    }
+
+    if all {
+        if stdin_path.is_some() || !files.is_empty() {
+            bail!("format -all can not be in use with other flags");
+        }
+        format_all(&bsc_exe, check)?;
+    } else if stdin_path.is_some() {
+        format_stdin(&bsc_exe, stdin_path.unwrap())?;
+    } else {
+        format_files(&bsc_exe, files, check)?;
+    }
+
+    Ok(())
+}
+
+fn find_bsc_exe() -> Result<PathBuf> {
+    let current_exe = std::env::current_exe()?;
+    let mut current_dir = current_exe.parent().unwrap_or_else(|| Path::new("/"));
+
+    // Traverse up to find node_modules
+    let node_modules_path = loop {
+        let potential_path = current_dir.join("node_modules");
+        if potential_path.exists() {
+            break Some(potential_path);
+        }
+        if current_dir.parent().is_none() {
+            break None;
+        }
+        current_dir = current_dir.parent().unwrap();
+    }
+    .ok_or_else(|| anyhow::anyhow!("Could not find node_modules directory"))?;
+
+    let target = format!("{}-{}", std::env::consts::OS, std::env::consts::ARCH);
+    let bsc_path = node_modules_path
+        .join("@rescript")
+        .join(target)
+        .join("bsc.exe");
+
+    if !bsc_path.exists() {
+        bail!("bsc executable not found at {}", bsc_path.display());
+    }
+    Ok(bsc_path)
+}
+
+fn format_all(bsc_exe: &Path, check: bool) -> Result<()> {
+    let output = Command::new(std::env::current_exe()?)
+        .arg("info")
+        .arg("-list-files")
+        .output()?;
+
+    if !output.status.success() {
+        io::stderr().write_all(&output.stderr)?;
+        bail!("Failed to list files");
+    }
+
+    let files_str = String::from_utf8_lossy(&output.stdout);
+    let files: Vec<String> = files_str
+        .split('\n')
+        .filter(|s| !s.trim().is_empty())
+        .map(|s| s.trim().to_string())
+        .collect();
+
+    format_files(bsc_exe, files, check)?;
+    Ok(())
+}
+
+fn format_stdin(bsc_exe: &Path, stdin_path: String) -> Result<()> {
+    let mut input = String::new();
+    io::stdin().read_to_string(&mut input)?;
+
+    let mut cmd = Command::new(bsc_exe);
+    cmd.arg("-format").arg(&stdin_path);
+    cmd.stdin(std::process::Stdio::piped());
+    cmd.stdout(std::process::Stdio::piped());
+    cmd.stderr(std::process::Stdio::piped());
+
+    let mut child = cmd.spawn()?;
+    let mut stdin = child.stdin.take().unwrap();
+    std::thread::spawn(move || {
+        stdin.write_all(input.as_bytes()).unwrap();
+    });
+
+    let output = child.wait_with_output()?;
+
+    if output.status.success() {
+        io::stdout().write_all(&output.stdout)?;
+    }
+    else {
+        io::stderr().write_all(&output.stderr)?;
+        bail!("bsc exited with an error");
+    }
+
+    Ok(())
+}
+
+fn format_files(bsc_exe: &Path, files: Vec<String>, check: bool) -> Result<()> {
+    let batch_size = 4 * num_cpus::get();
+    let incorrectly_formatted_files = AtomicUsize::new(0);
+
+    files.par_chunks(batch_size).try_for_each(|batch| {
+        batch.iter().try_for_each(|file| {
+            let mut cmd = Command::new(bsc_exe);
+            if check {
+                cmd.arg("-format").arg(file);
+            }
+            else {
+                cmd.arg("-o").arg(file).arg("-format").arg(file);
+            }
+
+            let output = cmd.output()?;
+
+            if output.status.success() {
+                if check {
+                    let original_content = fs::read_to_string(file)?;
+                    let formatted_content = String::from_utf8_lossy(&output.stdout);
+                    if original_content != formatted_content {
+                        eprintln!("[format check] {}", file);
+                        incorrectly_formatted_files.fetch_add(1, Ordering::SeqCst);
+                    }
+                }
+            }
+            else {
+                io::stderr().write_all(&output.stderr)?;
+                bail!("bsc exited with an error for file {}", file);
+            }
+            Ok(()) as Result<()>
+        })
+    })?;
+
+    let count = incorrectly_formatted_files.load(Ordering::SeqCst);
+    if count > 0 {
+        if count == 1 {
+            eprintln!("The file listed above needs formatting");
+        }
+        else {
+            eprintln!(
+                "The {} files listed above need formatting",
+                count
+            );
+        }
+        bail!("Formatting check failed");
+    }
+
+    Ok(())
+}

rewatch/src/format_cmd.rs

@@ -7,3 +7,4 @@ pub mod lock;
 pub mod queue;
 pub mod sourcedirs;
 pub mod watcher;
+pub mod format_cmd;

rewatch/src/lib.rs

@@ -7,7 +7,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use rewatch::{build, cli, cmd, lock, watcher};
+use rewatch::{build, cli, cmd, lock, watcher, format_cmd};
 
 fn main() -> Result<()> {
     let args = cli::Cli::parse();
@@ -20,7 +20,8 @@ fn main() -> Result<()> {
         .target(env_logger::fmt::Target::Stdout)
         .init();
 
-    let command = args.command.unwrap_or(cli::Command::Build(args.build_args));
+    
+    let command = args.command.unwrap_or_else(|| cli::Command::Build(args.build_args));
 
     // The 'normal run' mode will show the 'pretty' formatted progress. But if we turn off the log
     // level, we should never show that.
@@ -112,11 +113,13 @@ fn main() -> Result<()> {
             let code = build::pass_through_legacy(legacy_args);
             std::process::exit(code);
         }
-        cli::Command::Format { mut format_args } => {
-            format_args.insert(0, "format".into());
-            let code = build::pass_through_legacy(format_args);
-            std::process::exit(code);
-        }
+        cli::Command::Format {
+            stdin,
+            all,
+            check,
+            files,
+            bsc_path,
+        } => format_cmd::run(stdin, all, check, files, bsc_path.as_ref().map(|s| PathBuf::from(s.clone()))),
         cli::Command::Dump { mut dump_args } => {
             dump_args.insert(0, "dump".into());
             let code = build::pass_through_legacy(dump_args);

rewatch/src/main.rs

@@ -5,6 +5,6 @@ shopt -s extglob
 dune build @fmt --auto-promote
 
 files=$(find runtime tests -type f \( -name "*.res" -o -name "*.resi" \) ! -name "syntaxErrors*" ! -name "generated_mocha_test.res" ! -path "tests/syntax_tests*" ! -path "tests/analysis_tests/tests*" ! -path "*/node_modules/*")
-./cli/rescript-legacy.js format $files
+./cli/rescript.js format $files
 
 yarn format

scripts/format.sh

@@ -18,7 +18,7 @@ case "$(uname -s)" in
 
     echo "Checking ReScript code formatting..."
     files=$(find runtime tests -type f \( -name "*.res" -o -name "*.resi" \) ! -name "syntaxErrors*" ! -name "generated_mocha_test.res" ! -path "tests/syntax_tests*" ! -path "tests/analysis_tests/tests*" ! -path "*/node_modules/*")
-    if ./cli/rescript-legacy.js format -check $files; then
+    if ./cli/rescript.js format --check $files; then
       printf "${successGreen}✅ ReScript code formatting ok.${reset}\n"
     else
       printf "${warningYellow}⚠️ ReScript code formatting issues found. Run 'make format' to fix.${reset}\n"