wip: maybe there is a better solution

Author: Bushuo

src/main.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use clap::{Parser, ValueEnum};
+use clap::{arg, Arg, ArgAction, Args, FromArgMatches, Parser, ValueEnum};
 use clap_verbosity_flag::InfoLevel;
 use log::LevelFilter;
 use regex::Regex;
@@ -15,19 +15,24 @@ 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
 /// to deliver consistent and faster builds in monorepo setups with multiple packages, where the
 /// default build system fails to pick up changed interfaces across multiple packages.
 #[derive(Parser, Debug)]
 #[command(version)]
-struct Args {
-    #[arg(value_enum)]
-    command: Option<Command>,
+struct DerivedArgs {
+    #[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.
@@ -82,7 +87,33 @@ struct Args {
 }
 
 fn main() -> Result<()> {
-    let args = Args::parse();
+    let legacy = clap::Command::new("rewatch")
+        .disable_help_flag(true)
+        .disable_version_flag(true)
+        .arg(
+            arg!(-l - -legacy ... "Use the legacy build system")
+                .global(true)
+                .action(ArgAction::SetTrue),
+        )
+        .defer(|cmd| {
+            cmd.arg(arg!([cmd] ... "commands and args for the legacy build system").trailing_var_arg(true))
+        });
+
+    let legacy_matches = legacy.get_matches();
+
+    if legacy_matches.get_flag("legacy") {
+        let s = std::env::args().collect::<Vec<String>>().join(" ");
+
+        println!("Using legacy build system");
+        println!("Running: {s}");
+        std::process::exit(0);
+    }
+
+    let matches = DerivedArgs::augment_args(clap::Command::new("rewatch")).get_matches();
+    let args = DerivedArgs::from_arg_matches(&matches)
+        .map_err(|err| err.exit())
+        .unwrap();
+
     let log_level_filter = args.verbose.log_level_filter();
 
     env_logger::Builder::new()
@@ -91,8 +122,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 +141,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),
+        lock::Lock::Aquired(_) => match args.command {
+            Command::Clean => build::clean::clean(&args.folder, show_progress, args.bsc_path),
             Command::Build => {
                 match build::build(
                     &filter,
-                    &folder,
+                    &args.folder,
                     show_progress,
                     args.no_timing,
                     args.create_sourcedirs,
@@ -145,14 +174,20 @@ fn main() -> Result<()> {
                 watcher::start(
                     &filter,
                     show_progress,
-                    &folder,
+                    &args.folder,
                     args.after_build,
                     args.create_sourcedirs,
                     args.dev,
                 );
 
                 Ok(())
             }
+            Command::Format => {
+                todo!("Format not implemented yet");
+            }
+            Command::Dump => {
+                todo!("Dump not implemented yet");
+            }
         },
     }
 }