main.rs

use anyhow::Result;
use console::Term;
use log::LevelFilter;
use std::{io::Write, path::Path};

use rescript::{
    build, cli, cmd, format,
    lock::{LockKind, drop_lock, get_lock_or_exit},
    watcher,
};

fn main() -> Result<()> {
    let cli = cli::parse_with_default().unwrap_or_else(|err| err.exit());

    let log_level_filter = cli.verbose.log_level_filter();

    let stdout_logger = 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)
        .build();

    let stderr_logger = env_logger::Builder::new()
        .format(|buf, record| writeln!(buf, "{}:\n{}", record.level(), record.args()))
        .filter_level(log_level_filter)
        .target(env_logger::fmt::Target::Stderr)
        .build();

    log::set_max_level(log_level_filter);
    log::set_boxed_logger(Box::new(SplitLogger {
        stdout: stdout_logger,
        stderr: stderr_logger,
    }))
    .expect("Failed to initialize logger");

    let is_tty: bool = Term::stdout().is_term() && Term::stderr().is_term();
    let plain_output = !is_tty;

    // Show progress messages (e.g. "Finished compilation") as long as logging is at Info level
    // or more verbose. This way `-v` and `-vv` add debug output without suppressing progress.
    let show_progress = log_level_filter >= LevelFilter::Info;

    match cli.command {
        cli::Command::CompilerArgs { path } => {
            println!("{}", build::get_compiler_args(Path::new(&path))?);
            std::process::exit(0);
        }
        cli::Command::Build(build_args) => {
            match build::build(
                &build_args.filter,
                Path::new(&build_args.folder as &str),
                show_progress,
                build_args.no_timing,
                true, // create_sourcedirs is now always enabled
                plain_output,
                (*build_args.warn_error).clone(),
                build_args.prod,
            ) {
                Err(e) => {
                    eprintln!("{:#}", e);
                    std::process::exit(1)
                }
                Ok(_) => {
                    if let Some(args_after_build) = (*build_args.after_build).clone() {
                        cmd::run(args_after_build)
                    }
                    std::process::exit(0)
                }
            };
        }
        cli::Command::Watch(watch_args) => {
            let _lock = get_lock_or_exit(LockKind::Watch, &watch_args.folder);

            match watcher::start(
                &watch_args.filter,
                show_progress,
                &watch_args.folder,
                (*watch_args.after_build).clone(),
                true, // create_sourcedirs is now always enabled
                plain_output,
                (*watch_args.warn_error).clone(),
                watch_args.clear_screen,
                watch_args.prod,
            ) {
                Err(e) => {
                    eprintln!("{:#}", e);
                    std::process::exit(1)
                }
                Ok(_) => Ok(()),
            }
        }
        cli::Command::Clean { folder, prod } => {
            let _lock = get_lock_or_exit(LockKind::Build, &folder);
            let result = build::clean::clean(Path::new(&folder as &str), show_progress, plain_output, prod);
            let _lock = drop_lock(LockKind::Build, &folder);

            result
        }
        cli::Command::Format { stdin, check, files } => format::format(stdin, check, files),
    }
}

struct SplitLogger {
    stdout: env_logger::Logger,
    stderr: env_logger::Logger,
}

impl log::Log for SplitLogger {
    fn enabled(&self, metadata: &log::Metadata) -> bool {
        self.stdout.enabled(metadata) || self.stderr.enabled(metadata)
    }

    fn log(&self, record: &log::Record) {
        match record.level() {
            log::Level::Error | log::Level::Warn => self.stderr.log(record),
            _ => self.stdout.log(record),
        }
    }

    fn flush(&self) {
        self.stdout.flush();
        self.stderr.flush();
    }
}