xianyun_cli/

hooks.rs

//! The `caproni` root command's `Before`/`After` hook equivalents.
//!
//! Ported from `cmd/factory.go`'s `createBeforeHook`/`createAfterHook`.
//! `urfave/cli/v3`'s `Before` hook runs once before any subcommand's
//! `Action`, resolving the effective config file path and installing a
//! logger; `clap` has no direct equivalent (there is no single "before
//! dispatch" callback slot on a derived `Parser`), so this module exposes
//! the same two concerns as plain functions that [`super::commands::dispatch`]
//! calls explicitly before matching on the subcommand.
//!
//! Deviation from Go: [`before_hook`] covers only config-file resolution
//! (exactly what `TestBeforeHook` asserts on), not logger setup. Go's
//! `createBeforeHook` closure does both in one step, but that closure is
//! only ever invoked once per real process. This port's `before_hook` is
//! unit-tested directly (see `tests/factory.rs`), and
//! `xianyun_executor::logging`'s `tracing::Dispatch` can only be
//! installed as the process-wide default once -- calling it from
//! `before_hook` would make the second in-process test call fail. Logger
//! initialization is therefore split out into [`init_logging`], which
//! `dispatch()` calls once per real invocation and which tolerates being
//! called more than once (by ignoring the "already set" error) rather
//! than panicking, so it stays safe to call from tests too.

use xianyun_core::config::global::{GlobalConfig, find_config_file};
use xianyun_executor::logging::cliflags::LoggingArgs;

use crate::Cli;

/// Checks the `CAPRONI_NO_CACHE` compatibility alias for `--no-cache`/
/// `XIANYUN_NO_CACHE` (which `clap`'s `env` attribute on `Cli::no_cache`
/// already handles natively -- `clap` only supports one env var name per
/// arg, so the alias is checked here instead). Any non-empty value
/// counts as set, matching `clap`'s own bool-env-var truthiness for this
/// arg.
fn caproni_no_cache_alias_set() -> bool {
    std::env::var("CAPRONI_NO_CACHE").is_ok_and(|v| !v.is_empty())
}

/// Ported from `shouldLoadConfig`.
///
/// `command_name` is `None` when no subcommand has been resolved yet
/// (mirrors Go's `args == nil` case, which always loads); `Some("")` is
/// unreachable in this port since `clap` requires a subcommand, but is
/// accepted for parity with Go's skip list.
#[must_use]
pub fn should_load_config(command_name: Option<&str>) -> bool {
    match command_name {
        None => true,
        Some(name) => !matches!(name, "" | "h" | "help" | "version"),
    }
}

/// Ported from `createBeforeHook`'s config-resolution half: if no
/// `--config-file` was given explicitly and the resolved subcommand needs
/// one, searches parent directories for `caproni.yaml`
/// ([`find_config_file`]).
///
/// # Errors
///
/// Returns an error if config-file discovery fails (no `--config-file`
/// given, and no `caproni.yaml` found in any parent directory).
pub fn before_hook(cli: &Cli, command_name: Option<&str>) -> anyhow::Result<GlobalConfig> {
    let mut global_config = GlobalConfig::new(None);
    global_config.no_caching = cli.no_cache || caproni_no_cache_alias_set();

    if let Some(path) = &cli.config_file {
        global_config.config_file.clone_from(path);
    } else if should_load_config(command_name) {
        global_config.config_file =
            find_config_file().map_err(|err| anyhow::anyhow!("finding config file: {err}"))?;
    }

    Ok(global_config)
}

/// Builds [`LoggingArgs`] from the top-level `--log-*`/`--debug` flags
/// stored on [`Cli`], filling in `LoggingArgs`'s own defaults for any
/// flag the user didn't pass (mirroring `clap`'s `default_value`
/// handling for a struct that isn't `#[command(flatten)]`d into `Cli`
/// directly -- see `PORT_NOTES.md` for why `Cli`'s logging flags are
/// plain `Option<...>` fields instead).
fn logging_args_from_cli(cli: &Cli) -> LoggingArgs {
    let defaults = LoggingArgs::default();

    LoggingArgs {
        log_format: cli.log_format.clone().unwrap_or(defaults.log_format),
        log_level: cli.log_level.clone().unwrap_or(defaults.log_level),
        log_color: cli
            .log_color
            .map(|c| c.to_string())
            .unwrap_or(defaults.log_color),
        log_output: cli.log_output.clone().unwrap_or(defaults.log_output),
        log_source: cli.log_source,
        debug: cli.debug,
    }
}

/// Resolves `Cli`'s `--log-*`/`--debug` flags into a
/// [`logging::Config`](xianyun_executor::logging::Config), without
/// installing anything. Shared by [`init_logging`] (which builds the
/// process-wide default dispatcher from it) and `commands::run`, which
/// needs the same resolved config to build a second, TUI-routed
/// dispatcher scoped to its reloader tasks -- see that module's doc
/// comment on `build_reloader_run_fn` for why a *second* dispatch is
/// needed at all (in short: `tracing`'s global default is set-once,
/// unlike Go's freely-reassignable `slog.SetDefault`, so routing output
/// through the log-filter TUI for `run`'s lifetime only is a scoped
/// override, not a global swap).
///
/// # Errors
///
/// Returns an error if the logging configuration itself is invalid
/// (unparseable `--log-level`/`--log-color`).
pub(crate) fn resolve_logging_config(
    cli: &Cli,
) -> anyhow::Result<xianyun_executor::logging::Config> {
    let logging_args = logging_args_from_cli(cli);

    xianyun_executor::logging::cliflags::parse_config(&logging_args)
        .map_err(|err| anyhow::anyhow!("parsing logging config: {err}"))
}

/// Ported from `createBeforeHook`'s logger-setup half. Installs a
/// `tracing` dispatcher built from `Cli`'s logging flags as the
/// process-wide default.
///
/// Tolerates being called more than once per process (each call after
/// the first is a silent no-op) rather than erroring or panicking, since
/// `tracing::dispatcher::set_global_default` can only succeed once --
/// this keeps the function safe to call from tests that run multiple
/// commands in the same process.
///
/// # Errors
///
/// Returns an error if the logging configuration itself is invalid
/// (unparseable `--log-level`/`--log-color`) or the configured output
/// can't be opened.
pub fn init_logging(cli: &Cli) -> anyhow::Result<()> {
    let config = resolve_logging_config(cli)?;

    let (dispatch, _writer) = xianyun_executor::logging::new_logger(&config)
        .map_err(|err| anyhow::anyhow!("creating logger: {err}"))?;

    // Ignore "a global default trace dispatcher has already been set":
    // see the doc comment above for why this must be tolerated.
    let _ = tracing::dispatcher::set_global_default(dispatch);

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn should_load_config_matches_go_skip_list() {
        assert!(should_load_config(None));
        assert!(should_load_config(Some("up")));
        assert!(!should_load_config(Some("")));
        assert!(!should_load_config(Some("h")));
        assert!(!should_load_config(Some("help")));
        assert!(!should_load_config(Some("version")));
    }
}