feat: call rewatch-legacy

Author: Bushuo

src/build.rs

@@ -22,6 +22,7 @@ use std::fmt;
 use std::fs::File;
 use std::io::{stdout, Write};
 use std::path::PathBuf;
+use std::process::Stdio;
 use std::time::{Duration, Instant};
 
 use self::compile::compiler_args;
@@ -506,3 +507,18 @@ pub fn build(
         }
     }
 }
+
+pub fn pass_through_legacy(args: Vec<String>) -> i32 {
+    let project_root = helpers::get_abs_path(".");
+    let workspace_root = helpers::get_workspace_root(&project_root);
+
+    let bsb_path = helpers::get_rescript_legacy(&project_root, workspace_root);
+
+    let status = std::process::Command::new(bsb_path)
+        .args(args)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status();
+
+    status.map(|s| s.code().unwrap_or(1)).unwrap_or(1)
+}

src/helpers.rs

@@ -150,6 +150,25 @@ pub fn create_path_for_path(path: &Path) {
     fs::DirBuilder::new().recursive(true).create(path).unwrap();
 }
 
+pub fn get_rescript_legacy(root_path: &str, workspace_root: Option<String>) -> String {
+    match (
+        PathBuf::from(format!("{}/node_modules/rescript/rescript-legacy", root_path)).canonicalize(),
+        workspace_root.map(|workspace_root| {
+            PathBuf::from(format!(
+                "{}/node_modules/rescript/rescript-legacy",
+                workspace_root
+            ))
+            .canonicalize()
+        }),
+    ) {
+        (Ok(path), _) => path,
+        (_, Some(Ok(path))) => path,
+        _ => panic!("Could not find rescript"),
+    }
+    .to_string_lossy()
+    .to_string()
+}
+
 pub fn get_bsc(root_path: &str, workspace_root: Option<String>) -> String {
     let subfolder = match (std::env::consts::OS, std::env::consts::ARCH) {
         ("macos", "aarch64") => "darwinarm64",

src/main.rs

@@ -15,6 +15,10 @@ enum Command {
     Watch,
     /// Clean the build artifacts
     Clean,
+    /// Format the code
+    Format,
+    /// Dump
+    Dump,
 }
 
 /// Rewatch is an alternative build system for the Rescript Compiler bsb (which uses Ninja internally). It strives
@@ -23,11 +27,12 @@ enum Command {
 #[derive(Parser, Debug)]
 #[command(version)]
 struct Args {
-    #[arg(value_enum)]
-    command: Option<Command>,
+    #[arg(value_enum, default_value_t = Command::Build)]
+    command: Command,
 
     /// The relative path to where the main rescript.json resides. IE - the root of your project.
-    folder: Option<String>,
+    #[arg(default_value = ".")]
+    folder: String,
 
     /// Filter allows for a regex to be supplied which will filter the files to be compiled. For
     /// instance, to filter out test files for compilation while doing feature work.
@@ -79,10 +84,22 @@ struct Args {
     /// A custom path to bsc
     #[arg(long)]
     bsc_path: Option<String>,
+
+    /// Use the legacy build system.
+    ///
+    /// After this flag is encountered, the rest of the command line arguments are passed to the legacy build system.
+    #[arg(long, allow_hyphen_values = true, num_args = 0..)]
+    legacy: Option<Vec<String>>,
 }
 
 fn main() -> Result<()> {
     let args = Args::parse();
+
+    if let Some(legacy_args) = args.legacy {
+        let code = build::pass_through_legacy(legacy_args);
+        std::process::exit(code);
+    }
+
     let log_level_filter = args.verbose.log_level_filter();
 
     env_logger::Builder::new()
@@ -91,8 +108,6 @@ fn main() -> Result<()> {
         .target(env_logger::fmt::Target::Stdout)
         .init();
 
-    let command = args.command.unwrap_or(Command::Build);
-    let folder = args.folder.unwrap_or(".".to_string());
     let filter = args
         .filter
         .map(|filter| Regex::new(filter.as_ref()).expect("Could not parse regex"));
@@ -112,17 +127,17 @@ fn main() -> Result<()> {
     // level, we should never show that.
     let show_progress = log_level_filter == LevelFilter::Info;
 
-    match lock::get(&folder) {
+    match lock::get(&args.folder) {
         lock::Lock::Error(ref e) => {
             println!("Could not start Rewatch: {e}");
             std::process::exit(1)
         }
-        lock::Lock::Aquired(_) => match command {
-            Command::Clean => build::clean::clean(&folder, show_progress, args.bsc_path, args.dev),
+        lock::Lock::Aquired(_) => match args.command {
+            Command::Clean => build::clean::clean(&args.folder, show_progress, args.bsc_path, args.dev),
             Command::Build => {
                 match build::build(
                     &filter,
-                    &folder,
+                    &args.folder,
                     show_progress,
                     args.no_timing,
                     args.create_sourcedirs,
@@ -145,7 +160,7 @@ fn main() -> Result<()> {
                 watcher::start(
                     &filter,
                     show_progress,
-                    &folder,
+                    &args.folder,
                     args.after_build,
                     args.create_sourcedirs,
                     args.dev,
@@ -154,6 +169,12 @@ fn main() -> Result<()> {
 
                 Ok(())
             }
+            Command::Format => {
+                todo!("Format not implemented yet");
+            }
+            Command::Dump => {
+                todo!("Dump not implemented yet");
+            }
         },
     }
 }