es_fluent_cli/commands/

common.rs

use crate::core::{CliError, CrateInfo, GenerateResult, GenerationAction, WorkspaceInfo};
use crate::utils::{count_ftl_resources, filter_crates_by_package, partition_by_lib_rs, ui};
use clap::Args;
use colored::Colorize as _;
use std::path::PathBuf;
use std::time::Instant;

#[derive(Args, Clone, Debug)]
pub struct WorkspaceArgs {
    /// Path to the crate or workspace root (defaults to current directory).
    #[arg(short, long)]
    pub path: Option<PathBuf>,
    /// Package name to filter (if in a workspace, only process this package).
    #[arg(short = 'P', long)]
    pub package: Option<String>,
}

/// Common arguments for locale-based processing commands.
///
/// Used by format, check, and sync commands.
#[derive(Args, Clone, Debug)]
pub struct LocaleProcessingArgs {
    /// Process all locales, not just the fallback language.
    #[arg(long)]
    pub all: bool,

    /// Dry run - show what would change without making changes.
    #[arg(long)]
    pub dry_run: bool,
}

/// Represents a resolved set of crates for a command to operate on.
#[derive(Clone, Debug)]
pub struct WorkspaceCrates {
    /// The user-supplied (or default) root path.
    pub path: PathBuf,
    /// Workspace information (root dir, target dir, all crates).
    pub workspace_info: WorkspaceInfo,
    /// All crates discovered (after optional package filtering).
    pub crates: Vec<CrateInfo>,
    /// Crates that are eligible for operations (contain `lib.rs`).
    pub valid: Vec<CrateInfo>,
    /// Crates that were skipped (missing `lib.rs`).
    pub skipped: Vec<CrateInfo>,
}

impl WorkspaceCrates {
    /// Discover crates for a command, applying the common filtering and partitioning logic.
    pub fn discover(args: WorkspaceArgs) -> Result<Self, CliError> {
        use crate::utils::discover_workspace;

        let path = args.path.unwrap_or_else(|| PathBuf::from("."));
        let workspace_info = discover_workspace(&path)?;
        let crates = filter_crates_by_package(workspace_info.crates.clone(), args.package.as_ref());
        let (valid_refs, skipped_refs) = partition_by_lib_rs(&crates);
        let valid = valid_refs.into_iter().cloned().collect();
        let skipped = skipped_refs.into_iter().cloned().collect();

        Ok(Self {
            path,
            workspace_info,
            crates,
            valid,
            skipped,
        })
    }

    /// Print a standardized discovery summary, including skipped crates.
    ///
    /// Returns `false` when no crates were discovered to allow early-exit flows.
    pub fn print_discovery(&self, header: impl Fn()) -> bool {
        header();

        if self.crates.is_empty() {
            ui::print_discovered(&[]);
            return false;
        }

        ui::print_discovered(&self.crates);

        for krate in &self.skipped {
            ui::print_missing_lib_rs(&krate.name);
        }

        true
    }
}

/// Read the changed status from the runner crate's result.json file.
///
/// Returns `true` if the file indicates changes were made, `false` otherwise.
fn read_changed_status(temp_dir: &std::path::Path, crate_name: &str) -> bool {
    let result_json_path = es_fluent_derive_core::get_metadata_result_path(temp_dir, crate_name);

    if !result_json_path.exists() {
        return false;
    }

    match std::fs::read_to_string(&result_json_path) {
        Ok(json_str) => match serde_json::from_str::<serde_json::Value>(&json_str) {
            Ok(json) => json["changed"].as_bool().unwrap_or(false),
            Err(_) => false,
        },
        Err(_) => false,
    }
}

/// Run generation-like work using the monolithic temp crate approach.
///
/// This prepares a single temp crate at workspace root that links all workspace crates,
/// then runs the binary for each crate. Much faster on subsequent runs.
///
/// If `force_run` is true, the staleness check is skipped and the runner is always rebuilt.
pub fn parallel_generate(
    workspace: &WorkspaceInfo,
    crates: &[CrateInfo],
    action: &GenerationAction,
    force_run: bool,
) -> Vec<GenerateResult> {
    use crate::generation::{generate_for_crate_monolithic, prepare_monolithic_runner_crate};

    // Prepare the monolithic temp crate once upfront
    if let Err(e) = prepare_monolithic_runner_crate(workspace) {
        // If preparation fails, return error results for all crates
        return crates
            .iter()
            .map(|k| {
                GenerateResult::failure(k.name.clone(), std::time::Duration::ZERO, e.to_string())
            })
            .collect();
    }

    let pb = ui::create_progress_bar(crates.len() as u64, "Processing crates...");

    // Process sequentially since they share the same binary
    // (parallel could cause contention on first build)
    crates
        .iter()
        .map(|krate| {
            let start = Instant::now();
            let result = generate_for_crate_monolithic(krate, workspace, action, force_run);
            let duration = start.elapsed();

            pb.inc(1);

            let resource_count = result
                .as_ref()
                .ok()
                .map(|_| count_ftl_resources(&krate.ftl_output_dir, &krate.name))
                .unwrap_or(0);

            match result {
                Ok(output) => {
                    // For monolithic, result.json is at workspace root
                    let temp_dir =
                        es_fluent_derive_core::get_es_fluent_temp_dir(&workspace.root_dir);
                    let changed = read_changed_status(&temp_dir, &krate.name);

                    let output_opt = if output.is_empty() {
                        None
                    } else {
                        Some(output.to_string())
                    };

                    GenerateResult::success(
                        krate.name.clone(),
                        duration,
                        resource_count,
                        output_opt,
                        changed,
                    )
                },
                Err(e) => GenerateResult::failure(krate.name.clone(), duration, e.to_string()),
            }
        })
        .collect()
}

/// Render a list of `GenerateResult`s with custom success/error handlers.
///
/// Returns `true` when any errors were encountered.
pub fn render_generation_results(
    results: &[GenerateResult],
    on_success: impl Fn(&GenerateResult),
    on_error: impl Fn(&GenerateResult),
) -> bool {
    let mut has_errors = false;

    for result in results {
        if result.error.is_some() {
            has_errors = true;
            on_error(result);
        } else {
            on_success(result);
        }
    }

    has_errors
}

#[derive(Clone, Copy, Debug)]
pub enum GenerationVerb {
    Generate,
    Clean,
}

impl GenerationVerb {
    fn dry_run_label(self) -> &'static str {
        match self {
            GenerationVerb::Generate => "would be generated in",
            GenerationVerb::Clean => "would be cleaned in",
        }
    }

    fn print_changed(self, result: &GenerateResult) {
        match self {
            GenerationVerb::Generate => {
                ui::print_generated(&result.name, result.duration, result.resource_count);
            },
            GenerationVerb::Clean => {
                ui::print_cleaned(&result.name, result.duration, result.resource_count);
            },
        }
    }
}

/// Render generation-like results with the standard dry-run output.
///
/// Returns `true` when any errors were encountered.
pub fn render_generation_results_with_dry_run(
    results: &[GenerateResult],
    dry_run: bool,
    verb: GenerationVerb,
) -> bool {
    render_generation_results(
        results,
        |result| {
            if dry_run {
                if let Some(output) = &result.output {
                    print!("{}", output);
                } else if result.changed {
                    println!(
                        "{} {} ({} resources)",
                        format!("{} {}", result.name, verb.dry_run_label()).yellow(),
                        ui::format_duration(result.duration).green(),
                        result.resource_count.to_string().cyan()
                    );
                } else {
                    println!("{} {}", "Unchanged:".dimmed(), result.name.bold());
                }
            } else if result.changed {
                verb.print_changed(result);
            } else {
                println!("{} {}", "Unchanged:".dimmed(), result.name.bold());
            }
        },
        |result| ui::print_generation_error(&result.name, result.error.as_ref().unwrap()),
    )
}