forge/

audit.rs

// #t(file: rust_alloc_in_loop) CLI binary, allocations are fine for readability.

//! Audit subcommand: validates spec manifests against game data.

use anyhow::{Context, Result};
use clap::Args;
use wowlab_common::{cli::workspace_root, output};
use wowlab_engine_adapter_data::LocalCsvResolver;
use wowlab_engine_application::{SpecAudit, audit_manifest};
use wowlab_engine_ports::DynDataResolver;
use wowlab_fs::{
    directory::{self, EntryKind},
    path::{Path, PathBuf},
};
use wowlab_manifest_schema::ManifestRepository;

const DATA_DIR_ENV: &str = "WOWLAB_DATA_DIR";

#[derive(Args, Debug)]
pub(crate) struct AuditArgs {
    /// Path to manifests directory.
    #[arg(long)]
    pub manifests: Option<PathBuf>,
}

pub(crate) fn run(args: &AuditArgs) -> Result<()> {
    let manifests_dir = match &args.manifests {
        Some(path) => path.clone(),
        None => find_manifests_dir().ok_or_else(|| {
            anyhow::anyhow!("could not auto-detect manifests directory, use --manifests <path>")
        })?,
    };

    let data_dir = match std::env::var(DATA_DIR_ENV) {
        Ok(dir) => PathBuf::from(dir),
        Err(_) => default_data_dir().ok_or_else(|| {
            anyhow::anyhow!(
                "could not derive the default game-data directory from the repo root (set {DATA_DIR_ENV})"
            )
        })?,
    };

    anyhow::ensure!(
        is_directory(&data_dir),
        "game-data directory '{}' does not exist (set {DATA_DIR_ENV})",
        data_dir.display(),
    );
    let resolver = LocalCsvResolver::new(data_dir.as_path());
    let resolver_dyn = DynDataResolver::from_ref(&resolver);

    output::kv("Resolver", &format!("local ({})", data_dir.display()));
    output::kv("Manifests", &manifests_dir.display().to_string());
    output::blank();

    let rt = tokio::runtime::Runtime::new().context("failed to create tokio runtime")?;

    rt.block_on(run_audit(&manifests_dir, resolver_dyn))
}

async fn run_audit(manifests_dir: &Path, resolver: &DynDataResolver<'_>) -> Result<()> {
    let repository = ManifestRepository::new(manifests_dir);
    let paths = repository.spec_paths()?;

    output::banner("Manifest Audit", &format!("{} specs", paths.len()));
    output::blank();

    let mut total_errors = 0usize;
    let mut total_warnings = 0usize;
    let mut specs_with_errors = 0usize;

    for path in &paths {
        let file_stem = repository.spec_slug(path)?;

        let manifest = repository
            .load_spec(path)
            .with_context(|| format!("failed to load {}", path.display()))?;

        let audit = audit_manifest(&file_stem, &manifest, resolver).await;

        if !audit.errors.is_empty() {
            specs_with_errors += 1;
        }

        total_errors += audit.errors.len();
        total_warnings += audit.warnings.len();

        print_spec(&audit);
    }

    print_summary(total_errors, total_warnings, specs_with_errors, paths.len());

    if total_errors > 0 {
        anyhow::bail!("{total_errors} audit errors found");
    }

    Ok(())
}

fn print_spec(audit: &SpecAudit) {
    if audit.errors.is_empty() {
        output::success(&format!(
            "{} ({} spells, {} auras)",
            audit.display_name, audit.spell_count, audit.aura_count,
        ));
    } else {
        output::error(&format!(
            "{} ({} errors)",
            audit.display_name,
            audit.errors.len(),
        ));

        for issue in &audit.errors {
            output::detail(&format!(
                "[{}] {} (id={}): {}",
                issue.category, issue.name, issue.id, issue.message,
            ));
        }
    }

    for w in &audit.warnings {
        output::warning(w);
    }
}

fn print_summary(errors: usize, warnings: usize, specs_with_errors: usize, total_specs: usize) {
    output::blank();
    output::separator();

    if errors == 0 {
        output::success(&format!(
            "All {total_specs} specs passed ({warnings} warnings)",
        ));
    } else {
        output::error(&format!(
            "{errors} errors in {specs_with_errors} specs, {warnings} warnings ({total_specs} total specs)",
        ));
    }
}

fn default_data_dir() -> Option<PathBuf> {
    workspace_root("FORGE_ROOT")
        .parent()
        .map(|root| root.join("wowlab-data"))
}

fn find_manifests_dir() -> Option<PathBuf> {
    let candidates = [
        PathBuf::from("crates/engine/manifests"),
        PathBuf::from("manifests"),
        PathBuf::from("../engine/manifests"),
    ];

    first_directory(&candidates)
}

fn first_directory(candidates: &[PathBuf]) -> Option<PathBuf> {
    candidates.iter().find(|path| is_directory(path)).cloned()
}

fn is_directory(path: &Path) -> bool {
    directory::inspect(path)
        .is_ok_and(|entry| entry.is_some_and(|entry| entry.kind() == EntryKind::Directory))
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use wowlab_fs::{directory, file, temporary::Directory};

    use super::first_directory;

    #[gtest]
    fn manifest_discovery_selects_the_first_directory_only() -> Result<()> {
        let temporary = Directory::new().or_fail()?;
        let missing = temporary.path().join("missing");
        let regular_file = temporary.path().join("manifest-file");
        let first_directory_path = temporary.path().join("first");
        let second_directory_path = temporary.path().join("second");

        file::write_text(&regular_file, "not a directory").or_fail()?;
        directory::ensure(&first_directory_path).or_fail()?;
        directory::ensure(&second_directory_path).or_fail()?;

        let candidates = [
            missing,
            regular_file,
            first_directory_path.clone(),
            second_directory_path,
        ];

        verify_that!(
            first_directory(&candidates),
            some(eq(&first_directory_path))
        )
    }
}