//github.com/ Build using Rewatch

Build,

//github.com/ Build, then start a watcher

Watch,

//github.com/ Clean the build artifacts

Clean,

#[arg(value_enum)]

command: Option<Command>,

//github.com/ The relative path to where the main rescript.json resides. IE - the root of your project.

folder: Option<String>,

//github.com/ Filter allows for a regex to be supplied which will filter the files to be compiled. For

//github.com/ instance, to filter out test files for compilation while doing feature work.

#[arg(short, long)]

filter: Option<String>,

//github.com/ This allows one to pass an additional command to the watcher, which allows it to run when

//github.com/ finished. For instance, to play a sound when done compiling, or to run a test suite.

//github.com/ NOTE - You may need to add '--color=always' to your subcommand in case you want to output

//github.com/ colour as well

#[arg(short, long)]

after_build: Option<String>,

// Disable timing on the output

#[arg(short, long, default_value = "false", num_args = 0..=1)]

no_timing: bool,

//github.com/ Verbosity:

//github.com/ -v -> Debug

//github.com/ -vv -> Trace

//github.com/ -q -> Warn

//github.com/ -qq -> Error

//github.com/ -qqq -> Off.

//github.com/ Default (/ no argument given): 'info'

#[command(flatten)]

verbose: clap_verbosity_flag::Verbosity<InfoLevel>,

//github.com/ This creates a source_dirs.json file at the root of the monorepo, which is needed when you

//github.com/ want to use Reanalyze

#[arg(short, long, default_value_t = false, num_args = 0..=1)]

create_sourcedirs: bool,

//github.com/ This prints the compiler arguments. It expects the path to a rescript.json file.

//github.com/ This also requires --bsc-path and --rescript-version to be present

#[arg(long)]

compiler_args: Option<String>,

//github.com/ This is the flag to also compile development dependencies

//github.com/ It's important to know that we currently do not discern between project src, and

//github.com/ dependencies. So enabling this flag will enable building _all_ development dependencies of

//github.com/ _all_ packages

#[arg(long, default_value_t = false, num_args = 0..=1)]

dev: bool,

//github.com/ To be used in conjunction with compiler_args

#[arg(long)]

rescript_version: Option<String>,

//github.com/ A custom path to bsc

#[arg(long)]

bsc_path: Option<String>,

let args = Args::parse();

let log_level_filter = args.verbose.log_level_filter();

env_logger::Builder::new()

.format(|buf, record| writeln!(buf, "{}:\n{}", record.level(), record.args()))

.filter_level(log_level_filter)

.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"));

match args.compiler_args {

None => (),

Some(path) => {

println!(

"{}",

build::get_compiler_args(&path, args.rescript_version, args.bsc_path, args.dev)?

);

std::process::exit(0);

}

}

// The 'normal run' mode will show the 'pretty' formatted progress. But if we turn off the log

// level, we should never show that.

let show_progress = log_level_filter == LevelFilter::Info;

match lock::get(&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),

Command::Build => {

match build::build(

&filter,

&folder,

show_progress,

args.no_timing,

args.create_sourcedirs,

args.bsc_path,

args.dev,

) {

Err(e) => {

println!("{e}");

std::process::exit(1)

}

Ok(_) => {

if let Some(args_after_build) = args.after_build {

cmd::run(args_after_build)

}

std::process::exit(0)

}

};

}

Command::Watch => {

watcher::start(

&filter,

show_progress,

&folder,

args.after_build,

args.create_sourcedirs,

args.dev,

args.bsc_path,

);

Ok(())

}

},

}