tidy/

main.rs

// #t(file: rust_vec_string_field) clap-populated argument vectors must stay growable

//! Command-line entry point for the multi-language workspace linter.

#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

use std::{
    ffi::OsStr,
    process::{Command, ExitCode},
};

use clap::{Parser, Subcommand};
use tabled::Tabled;
use wowlab_common::{cli, output};
use wowlab_fs::{atomic, path::Path};
use wowlab_tidy::{Config, RuleParam, llm, runner};

#[derive(Parser)]
#[command(name = "tidy", about = "Wow Lab source code tidy checker")]
#[expect(
    clippy::struct_excessive_bools,
    reason = "independent command-line switches are represented directly as clap booleans"
)]
struct Args {
    #[command(subcommand)]
    command: Option<TidyCommand>,

    #[arg(long, short)]
    rule: Vec<String>,

    /// Auto-fix violations that have fixes available.
    #[arg(long)]
    fix: bool,

    /// Preview fixes without writing (requires --fix).
    #[arg(long, global = true)]
    dry_run: bool,

    /// Run rules, formatting, generators, and warning-denied workspace Clippy.
    #[arg(long)]
    ci: bool,

    /// Generate a tidy.toml config with all registered rules enabled.
    #[arg(long)]
    init: bool,

    /// List all registered rules with descriptions.
    #[arg(long)]
    list: bool,

    /// Parse a tidy config file, merge with registered rule metadata, and output as JSON.
    #[arg(long, value_name = "PATH")]
    parse_config: Option<String>,

    /// Show detailed info for a specific rule (description, examples).
    #[arg(long)]
    detail: Option<String>,

    /// Output all rules, details, and current violations as markdown for LLM consumption.
    #[arg(long)]
    llm: bool,

    /// Only check these crates (e.g. `--filter common --filter engine`).
    #[arg(long, short = 'F', global = true)]
    filter: Vec<String>,

    /// Report all suppression directives in the codebase.
    #[arg(long)]
    suppressions: bool,

    /// Suppress all output except violation counts (exit code still reflects pass/fail).
    #[arg(long, short, global = true)]
    quiet: bool,

    /// Only check files with uncommitted changes (staged + unstaged, via `git diff`).
    #[arg(long, short = 'd', global = true)]
    dirty: bool,

    /// Treat config warnings (missing/extra rules) as errors.
    #[arg(long)]
    strict: bool,
}

#[derive(Subcommand)]
enum TidyCommand {
    /// Remove suppression targets that no longer hide a tidy violation.
    Clean,
}

fn all_rules_meta() -> Vec<(&'static str, &'static [RuleParam])> {
    wowlab_tidy::all_rules()
        .into_iter()
        .map(|r| (r.name, r.params))
        .collect()
}

fn main() -> ExitCode {
    let args = Args::parse();
    let app = cli::boot(
        "tidy",
        env!("CARGO_PKG_VERSION"),
        args.quiet || args.llm,
        "TIDY_ROOT",
    );
    let crates_dir = app.crates_dir();
    let config_path = crates_dir.join("tidy.toml");

    if args.list {
        print_rule_list();

        return ExitCode::SUCCESS;
    }

    if let Some(ref config_path) = args.parse_config {
        return print_parsed_config(config_path);
    }

    if let Some(ref rule_name) = args.detail {
        return print_rule_detail(rule_name);
    }

    if args.init {
        return handle_init(&config_path);
    }

    let config = match load_and_validate_config(&config_path, args.strict) {
        Ok(c) => c,
        Err(code) => return code,
    };

    if matches!(args.command, Some(TidyCommand::Clean)) {
        let run_ctx = runner::RunCtx {
            rule_filter: &[],
            crate_filter: &args.filter,
            config: &config,
            root: &app.root,
            crates_dir: &crates_dir,
            quiet: args.quiet,
            dirty: args.dirty,
        };

        return runner::clean_suppressions(&run_ctx, args.dry_run);
    }

    if args.llm {
        return llm::print(&args.rule, &args.filter, &config, &app.root, &crates_dir);
    }

    if args.suppressions {
        return runner::report_suppressions(
            &args.filter,
            &config,
            &app.root,
            &crates_dir,
            args.quiet,
        );
    }

    let fix_mode = match (args.fix, args.dry_run) {
        (true, true) => runner::FixMode::DryRun,
        (true, false) => runner::FixMode::Apply,
        _ => runner::FixMode::Off,
    };

    let run_ctx = runner::RunCtx {
        rule_filter: &args.rule,
        crate_filter: &args.filter,
        config: &config,
        root: &app.root,
        crates_dir: &crates_dir,
        quiet: args.quiet,
        dirty: args.dirty,
    };

    let mut failed = !runner::run(&run_ctx, fix_mode);

    if args.ci {
        if !run_cargo_check(
            "fmt",
            &["+nightly", "fmt", "--all", "--", "--check"],
            &crates_dir,
        ) {
            failed = true;
        }

        if !run_cargo_check("codegen --check", &["codegen", "--check"], &app.root) {
            failed = true;
        }

        if !run_cargo_check("docgen --check", &["docgen", "--check"], &app.root) {
            failed = true;
        }

        if !run_cargo_check("tablegen --check", &["tablegen", "--check"], &app.root) {
            failed = true;
        }

        let clippy_target_dir =
            runner::cargo_target_dir(&app.root, &crates_dir).join("tidy-clippy");

        if !run_cargo_check_with_environment(
            "clippy",
            &[
                "clippy",
                "--workspace",
                "--all-targets",
                "--",
                "-D",
                "warnings",
            ],
            &crates_dir,
            &[
                ("CARGO_TARGET_DIR", clippy_target_dir.as_os_str()),
                ("SQLX_OFFLINE", OsStr::new("true")),
            ],
        ) {
            failed = true;
        }
    }

    if failed {
        ExitCode::FAILURE
    } else {
        ExitCode::SUCCESS
    }
}

fn load_and_validate_config(config_path: &Path, strict: bool) -> Result<Config, ExitCode> {
    let mut config = Config::load(config_path).map_err(|e| {
        output::error(&format!("tidy.toml: {e}"));
        output::blank();
        output::error("tidy.toml is required. Run `tidy --init` to generate one.");

        ExitCode::FAILURE
    })?;

    let registered = all_rules_meta();
    let (errors, warnings) = config.validate(&registered);

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

    if strict && !warnings.is_empty() {
        output::blank();
        output::error("--strict: config warnings treated as errors.");

        return Err(ExitCode::FAILURE);
    }

    if !errors.is_empty() {
        for e in &errors {
            output::error(e);
        }

        output::blank();
        output::error(
            "tidy.toml has invalid config. \
             Fix it manually or delete and run `tidy --init`.",
        );

        return Err(ExitCode::FAILURE);
    }

    if !warnings.is_empty() {
        config.backfill_defaults(&registered);
    }

    Ok(config)
}

fn handle_init(config_path: &Path) -> ExitCode {
    let meta = all_rules_meta();
    let config = Config::generate_default(&meta);

    if let Err(error) = atomic::create(config_path, config.to_toml_string()) {
        if error.is_already_exists() {
            output::error(&format!(
                "tidy.toml already exists at {}",
                config_path.display()
            ));
            output::error("Delete it first if you want to regenerate.");
        } else {
            output::error(&format!(
                "failed to write {}: {error}",
                config_path.display()
            ));
        }

        return ExitCode::FAILURE;
    }

    output::success(&format!(
        "Created {} with {} rules enabled.",
        config_path.display(),
        meta.len()
    ));

    ExitCode::SUCCESS
}

fn run_cargo_check(name: &str, cargo_args: &[&str], crates_dir: &Path) -> bool {
    run_cargo_check_with_environment(name, cargo_args, crates_dir, &[])
}

fn run_cargo_check_with_environment(
    name: &str,
    cargo_args: &[&str],
    crates_dir: &Path,
    environment: &[(&str, &OsStr)],
) -> bool {
    output::header(&format!("cargo {name}"));

    let mut command = Command::new("cargo");

    for (name, _) in std::env::vars_os() {
        if is_cargo_package_context(&name) {
            command.env_remove(name);
        }
    }

    let status = command
        .args(cargo_args)
        .current_dir(crates_dir)
        .envs(environment.iter().copied())
        .status();

    match status {
        Ok(s) if s.success() => {
            output::success(&format!("cargo {name} passed"));
            output::blank();

            true
        }
        Ok(_) => {
            output::error(&format!("cargo {name} failed"));
            output::blank();

            false
        }
        Err(e) => {
            output::error(&format!("cargo {name}: {e}"));
            output::blank();

            false
        }
    }
}

fn is_cargo_package_context(name: &OsStr) -> bool {
    let Some(name) = name.to_str() else {
        return false;
    };

    name.starts_with("CARGO_PKG_")
        || matches!(
            name,
            "CARGO_BIN_NAME"
                | "CARGO_CRATE_NAME"
                | "CARGO_MANIFEST_DIR"
                | "CARGO_MANIFEST_PATH"
                | "CARGO_PRIMARY_PACKAGE"
        )
}

fn print_rule_list() {
    let rules = wowlab_tidy::all_rules();
    let rows: Vec<RuleListRow> = rules
        .iter()
        .map(|r| {
            let params_str = r
                .params
                .iter()
                .map(|p| p.name)
                .collect::<Vec<_>>()
                .join(", ");

            RuleListRow {
                name: r.name.to_string(),
                severity: r.severity.as_str().to_string(),
                kind: r.kind.as_str().to_string(),
                fixable: if r.fixable { "yes" } else { "no" }.to_string(),
                params: params_str,
                description: r.description.to_string(),
            }
        })
        .collect();

    let fixable = rows.iter().filter(|r| r.fixable == "yes").count();

    output::detail(&format!(
        "{} rules registered ({fixable} fixable)",
        rows.len()
    ));
    output::blank();
    output::table(rows);
}

#[derive(Tabled)]
#[tabled(crate = "tabled")]
struct RuleListRow {
    #[tabled(rename = "Rule")]
    name: String,
    #[tabled(rename = "Severity")]
    severity: String,
    #[tabled(rename = "Type")]
    kind: String,
    #[tabled(rename = "Fixable")]
    fixable: String,
    #[tabled(rename = "Params")]
    params: String,
    #[tabled(rename = "Description")]
    description: String,
}

fn print_parsed_config(config_path: &str) -> ExitCode {
    let config = match Config::load(Path::new(config_path)) {
        Ok(c) => c,
        Err(e) => {
            output::error(&e.to_string());

            return ExitCode::FAILURE;
        }
    };

    let rules = wowlab_tidy::all_rules();
    let entries = config.resolved_rules(&rules);

    let json = match serde_json::to_string(&entries) {
        Ok(json) => json,
        Err(error) => {
            output::error(&format!("failed to serialize config: {error}"));

            return ExitCode::FAILURE;
        }
    };

    println!("{json}");

    ExitCode::SUCCESS
}

fn print_rule_detail(name: &str) -> ExitCode {
    use wowlab_tidy::ParamDefault;

    let rules = wowlab_tidy::all_rules();
    let found = rules.into_iter().find(|r| r.name == name);

    let Some(d) = found else {
        output::error(&format!("unknown rule: {name}"));
        output::blank();
        let meta = all_rules_meta();

        for (n, _) in &meta {
            output::detail(n);
        }

        return ExitCode::FAILURE;
    };

    output::header(name);
    output::kv("type", d.kind.as_str());
    output::kv("severity", d.severity.as_str());
    output::kv("fixable", if d.fixable { "yes" } else { "no" });
    output::kv("description", d.description);

    if !d.params.is_empty() {
        output::blank();
        output::subheader("parameters");

        for p in d.params {
            let type_str = match p.param_type {
                wowlab_tidy::ParamType::Int => "i64",
                wowlab_tidy::ParamType::StringArray => "[String]",
            };
            let default_str = match &p.default {
                ParamDefault::Int(d) => d.to_string(),
                ParamDefault::StringArray(d) => format!("{d:?}"),
            };

            output::kv(p.name, &format!("{type_str}, default = {default_str}"));
        }
    }

    output::blank();
    output::detail(d.justification);
    output::blank();

    let examples = d.examples;

    if examples.is_empty() {
        output::detail("no examples defined");
    } else {
        let bad: Vec<_> = examples.iter().filter(|e| !e.pass).collect();
        let good: Vec<_> = examples.iter().filter(|e| e.pass).collect();

        if !bad.is_empty() {
            output::subheader(&format!(
                "bad ({} example{})",
                bad.len(),
                if bad.len() == 1 { "" } else { "s" }
            ));
            output::blank();

            for (i, ex) in bad.iter().enumerate() {
                let label = if ex.label.is_empty() {
                    "fail"
                } else {
                    ex.label
                };

                output::error(&format!("{}. {label}", i + 1));

                for line in ex.code.lines() {
                    output::detail(&format!("  {line}"));
                }

                output::blank();
            }
        }

        if !good.is_empty() {
            output::subheader(&format!(
                "good ({} example{})",
                good.len(),
                if good.len() == 1 { "" } else { "s" }
            ));
            output::blank();

            for (i, ex) in good.iter().enumerate() {
                let label = if ex.label.is_empty() {
                    "pass"
                } else {
                    ex.label
                };

                output::success(&format!("{}. {label}", i + 1));

                for line in ex.code.lines() {
                    output::detail(&format!("  {line}"));
                }

                output::blank();
            }
        }
    }

    ExitCode::SUCCESS
}

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

    use super::*;

    #[gtest]
    fn nested_cargo_drops_only_parent_package_context() -> Result<()> {
        verify_true!(is_cargo_package_context(OsStr::new("CARGO_MANIFEST_DIR")))?;
        verify_true!(is_cargo_package_context(OsStr::new("CARGO_PKG_VERSION")))?;
        verify_true!(is_cargo_package_context(OsStr::new(
            "CARGO_PRIMARY_PACKAGE"
        )))?;
        verify_false!(is_cargo_package_context(OsStr::new("CARGO_HOME")))?;

        verify_false!(is_cargo_package_context(OsStr::new("CARGO_MAKEFLAGS")))
    }

    #[gtest]
    fn init_creates_a_complete_config_without_overwriting_it() -> Result<()> {
        let temporary = Directory::new().or_fail()?;
        let path = temporary.path().join("tidy.toml");

        verify_eq!(handle_init(&path), ExitCode::SUCCESS)?;
        let initial = file::read_text(&path).or_fail()?;

        Config::load(&path).or_fail()?;

        verify_eq!(handle_init(&path), ExitCode::FAILURE)?;
        verify_eq!(file::read_text(&path).or_fail()?, initial)?;

        verify_that!(directory::entries(temporary.path()).or_fail()?, len(eq(1)))
    }
}