build.rs

use std::collections::HashSet;
use std::fs;
use std::path::Path;

/// Reserve a larger main-thread stack for Windows targets.
///
/// Clap + the full command graph can exceed the default 1 MiB Windows stack
/// during process startup, so `rtk.exe --version`, `--help`, and the hook entry
/// points need the headroom to start reliably without ad-hoc RUSTFLAGS.
///
/// Two things here are deliberately keyed off the **target**, not the host:
/// `CARGO_CFG_TARGET_OS` (a `#[cfg(windows)]` here would describe the machine
/// running the build, so cross-compiling to Windows from Linux would silently
/// skip the flag), and the flag syntax itself — `link.exe` takes `/STACK:`
/// while the MinGW `ld` behind `x86_64-pc-windows-gnu` only understands
/// `--stack`, and feeding it `/STACK:` makes it look for a file by that name.
/// Only `msvc` needs its own spelling: `gnu` (gnullvm reports it too) links
/// through a gcc or clang driver that takes `-Wl,--stack`, and that is also what
/// an environment the match does not name gets.
fn set_windows_stack_size() {
    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
        return;
    }
    const STACK_BYTES: usize = 8 * 1024 * 1024;
    let arg = match std::env::var("CARGO_CFG_TARGET_ENV").as_deref() {
        Ok("msvc") => format!("/STACK:{STACK_BYTES}"),
        _ => format!("-Wl,--stack,{STACK_BYTES}"),
    };
    println!("cargo:rustc-link-arg={arg}");
}

fn main() {
    set_windows_stack_size();

    check_cmds_modules_declared();

    let filters_dir = Path::new("src/filters");
    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR must be set by Cargo");
    let dest = Path::new(&out_dir).join("builtin_filters.toml");

    // Rebuild when any file in src/filters/ changes
    println!("cargo:rerun-if-changed=src/filters");

    let mut files: Vec<_> = fs::read_dir(filters_dir)
        .expect("src/filters/ directory must exist")
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "toml"))
        .collect();

    // Sort alphabetically for deterministic filter ordering
    files.sort_by_key(|e| e.file_name());

    let mut combined = String::from("schema_version = 1\n\n");

    for entry in &files {
        let content = fs::read_to_string(entry.path())
            .unwrap_or_else(|e| panic!("Failed to read {:?}: {}", entry.path(), e));
        combined.push_str(&format!(
            "# --- {} ---\n",
            entry.file_name().to_string_lossy()
        ));
        combined.push_str(&content);
        combined.push_str("\n\n");
    }

    // Validate: parse the combined TOML to catch errors at build time
    let parsed: toml::Value = combined.parse().unwrap_or_else(|e| {
        panic!(
            "TOML validation failed for combined filters:\n{}\n\nCheck src/filters/*.toml files",
            e
        )
    });

    // Detect duplicate filter names across files
    if let Some(filters) = parsed.get("filters").and_then(|f| f.as_table()) {
        let mut seen: HashSet<String> = HashSet::new();
        for key in filters.keys() {
            if !seen.insert(key.clone()) {
                panic!(
                    "Duplicate filter name '{}' found across src/filters/*.toml files",
                    key
                );
            }
        }
    }

    fs::write(&dest, combined).expect("Failed to write combined builtin_filters.toml");
}

/// Every `.rs` under `src/cmds/<ecosystem>/` must be declared in that folder's
/// `mod.rs`. An undeclared file is not part of the crate: it is never compiled,
/// never linted, and its tests never run, all without any diagnostic.
fn check_cmds_modules_declared() {
    println!("cargo:rerun-if-changed=src/cmds");

    let cmds = Path::new("src/cmds");
    let ecosystems = fs::read_dir(cmds).expect("src/cmds/ directory must exist");

    for ecosystem in ecosystems {
        let dir = ecosystem.expect("failed to read src/cmds/ entry").path();
        let mod_rs = dir.join("mod.rs");
        if !dir.is_dir() || !mod_rs.exists() {
            continue;
        }

        let declared = fs::read_to_string(&mod_rs)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", mod_rs.display(), e));

        let entries = fs::read_dir(&dir)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", dir.display(), e));

        for entry in entries {
            let path = entry.expect("failed to read directory entry").path();
            if path.extension().is_none_or(|ext| ext != "rs") {
                continue;
            }
            let stem = path
                .file_stem()
                .expect("a .rs path always has a stem")
                .to_string_lossy()
                .to_string();
            if stem == "mod" {
                continue;
            }
            if !declared.contains(&format!("mod {stem};")) {
                panic!(
                    "{} is not declared in {}.\n\
                     Add `pub mod {};` there, keeping the list alphabetical.\n\
                     An undeclared module is never compiled, linted, or tested.",
                    path.display(),
                    mod_rs.display(),
                    stem
                );
            }
        }
    }
}