pets_tools 0.2.0

MusKitty multi-repo source management CLI — one command to clone, build, test, push, and publish 9 independent crate repositories
//! repos.toml parsing and data structures.

use serde::Deserialize;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::{Path, PathBuf};

/// Top-level configuration deserialized from repos.toml.
#[derive(Debug, Deserialize)]
pub struct ConfigFile {
    pub project: ProjectMeta,
    pub main_repo: MainRepo,
    #[serde(default)]
    pub repos: Vec<Repo>,
}

#[derive(Debug, Deserialize)]
pub struct ProjectMeta {
    pub name: String,
    pub root: PathBuf,
    #[serde(default)]
    pub crates_dir: Option<PathBuf>,
    /// npm-style user-defined scripts, executed via `pets run`.
    #[serde(default)]
    pub commands: BTreeMap<String, String>,
    /// Project-wide WPT defaults (runner, baseline dir).
    #[serde(default)]
    pub wpt: Option<WptConfig>,
}

#[derive(Debug, Deserialize)]
pub struct MainRepo {
    pub name: String,
    pub dir: PathBuf,
    pub url: String,
    #[serde(default)]
    pub upstream: Option<String>,
    pub token_key: String,
}

#[derive(Debug, Clone, Deserialize)]
pub struct Repo {
    pub name: String,
    pub dir: String,
    pub url: String,
    #[serde(default)]
    pub deps: Vec<String>,
    #[serde(default)]
    pub dev_deps: Vec<String>,
    #[serde(default = "default_msrv")]
    pub msrv: String,
    #[serde(default = "default_token_key")]
    pub token_key: String,
    /// Repo-level user-defined scripts, executed via `pets run --repo <name>`.
    #[serde(default)]
    pub commands: BTreeMap<String, String>,
    /// Repo-level WPT config (suites, runner override, baseline).
    #[serde(default)]
    pub wpt: Option<WptConfig>,
}

/// WPT (Web Platform Tests) configuration for a project or repo.
#[derive(Debug, Clone, Deserialize)]
pub struct WptConfig {
    /// Test suites to run (passed to the runner via `WPT_SUITE`).
    #[serde(default)]
    pub suites: Vec<String>,
    /// Command that runs a WPT suite. Defaults to `cargo test --test wpt`.
    #[serde(default)]
    pub runner: Option<String>,
    /// Baseline file path. For a repo this overrides `baseline_dir/<repo>.toml`;
    /// for a project it sets the baseline directory.
    #[serde(default)]
    pub baseline: Option<PathBuf>,
}

fn default_msrv() -> String {
    "1.85".into()
}

fn default_token_key() -> String {
    "crates".into()
}

/// Fully resolved, validated configuration.
#[derive(Debug)]
pub struct Config {
    pub project_name: String,
    pub root: PathBuf,
    pub crates_dir: PathBuf,
    pub main_repo: ResolvedMainRepo,
    /// All crate repos (does not include main).
    pub repos: Vec<ResolvedRepo>,
    /// Lookup: crate name → index in `repos`.
    pub index: HashMap<String, usize>,
    /// Project-level user-defined scripts (npm-style).
    pub commands: BTreeMap<String, String>,
    /// Project-wide WPT defaults.
    pub wpt: Option<WptConfig>,
    /// Directory holding baseline files, resolved from `project.wpt.baseline`
    /// or defaulting to `<root>/wpt/expected`.
    pub baseline_dir: PathBuf,
}

#[derive(Debug)]
pub struct ResolvedMainRepo {
    pub name: String,
    pub dir: PathBuf,
    pub url: String,
    pub upstream: Option<String>,
    #[allow(dead_code)]
    pub token_key: String,
}

#[derive(Debug, Clone)]
pub struct ResolvedRepo {
    pub name: String,
    pub abs_dir: PathBuf,
    pub url: String,
    pub deps: Vec<String>,
    pub dev_deps: Vec<String>,
    #[allow(dead_code)]
    pub msrv: String,
    #[allow(dead_code)]
    pub token_key: String,
    /// Repo-level user-defined scripts.
    pub commands: BTreeMap<String, String>,
    /// Repo-level WPT config.
    pub wpt: Option<WptConfig>,
}

impl Config {
    /// Load and validate repos.toml from `path`.
    pub fn load(path: &Path) -> Result<Self, String> {
        let content = std::fs::read_to_string(path)
            .map_err(|e| format!("cannot read {}: {}", path.display(), e))?;
        Self::parse(&content).map_err(|e| format!("{}: {}", path.display(), e))
    }

    /// Parse and validate repos.toml content (no filesystem access).
    pub fn parse(content: &str) -> Result<Self, String> {
        let cf: ConfigFile = toml::from_str(content).map_err(|e| format!("parse error: {}", e))?;

        // Validate project name
        if cf.project.name.is_empty() {
            return Err("[project].name must not be empty".into());
        }

        let crates_dir = cf
            .project
            .crates_dir
            .unwrap_or_else(|| cf.project.root.join("crates"));

        // Create name→index mapping and validate
        let mut index = HashMap::new();
        for (i, repo) in cf.repos.iter().enumerate() {
            if index.contains_key(&repo.name) {
                return Err(format!("duplicate repo name: {}", repo.name));
            }
            index.insert(repo.name.clone(), i);
        }

        // Validate deps reference existing repos
        let names: HashSet<&str> = cf.repos.iter().map(|r| r.name.as_str()).collect();
        for repo in &cf.repos {
            for dep in &repo.deps {
                if !names.contains(dep.as_str()) {
                    return Err(format!(
                        "repo '{}' depends on '{}', which is not in repos.toml",
                        repo.name, dep
                    ));
                }
            }
            for dep in &repo.dev_deps {
                if !names.contains(dep.as_str()) {
                    return Err(format!(
                        "repo '{}' has dev-dep '{}', which is not in repos.toml",
                        repo.name, dep
                    ));
                }
            }
        }

        let project_root = cf.project.root.clone();
        let baseline_dir = cf
            .project
            .wpt
            .as_ref()
            .and_then(|w| w.baseline.clone())
            .map(|b| {
                if b.is_absolute() {
                    b
                } else {
                    project_root.join(b)
                }
            })
            .unwrap_or_else(|| project_root.join("wpt").join("expected"));

        Ok(Self {
            project_name: cf.project.name.clone(),
            root: cf.project.root,
            crates_dir,
            main_repo: ResolvedMainRepo {
                name: cf.main_repo.name,
                dir: cf.main_repo.dir,
                url: cf.main_repo.url,
                upstream: cf.main_repo.upstream,
                token_key: cf.main_repo.token_key,
            },
            repos: cf
                .repos
                .into_iter()
                .map(|r| ResolvedRepo {
                    abs_dir: project_root.join(&r.dir),
                    name: r.name,
                    url: r.url,
                    deps: r.deps,
                    dev_deps: r.dev_deps,
                    msrv: r.msrv,
                    token_key: r.token_key,
                    commands: r.commands,
                    wpt: r.wpt,
                })
                .collect(),
            index,
            commands: cf.project.commands.clone(),
            wpt: cf.project.wpt.clone(),
            baseline_dir,
        })
    }

    /// Look up a resolved repo by name.
    pub fn repo_by_name(&self, name: &str) -> Option<&ResolvedRepo> {
        self.index.get(name).map(|&i| &self.repos[i])
    }

    /// All repo dirs (main + crates) that exist for scanning.
    #[allow(dead_code)]
    pub fn all_dirs(&self) -> impl Iterator<Item = (&str, &Path)> {
        let main = ("main", self.main_repo.dir.as_path());
        let crates = self
            .repos
            .iter()
            .map(|r| (r.name.as_str(), r.abs_dir.as_path()));
        std::iter::once(main).chain(crates)
    }
}

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

    fn base_toml() -> String {
        r#"
[project]
name = "MusKitty"
root = "/proj"
crates_dir = "/proj/crates"

[main_repo]
name = "MusKitty"
dir = "/proj"
url = "https://github.com/Ink-dark/MusKitty.git"
token_key = "main"

[[repos]]
name = "muskitty-dom"
dir = "crates/muskitty-dom"
url = "https://github.com/muskitty-dev/muskitty-dom.git"
"#
        .to_string()
    }

    #[test]
    fn parses_minimal_config() {
        let cfg = Config::parse(&base_toml()).unwrap();
        assert_eq!(cfg.project_name, "MusKitty");
        assert_eq!(cfg.repos.len(), 1);
        assert_eq!(cfg.repos[0].name, "muskitty-dom");
        assert_eq!(
            cfg.repos[0].abs_dir,
            PathBuf::from("/proj/crates/muskitty-dom")
        );
        // Defaults for optional sections.
        assert!(cfg.commands.is_empty());
        assert!(cfg.wpt.is_none());
        assert_eq!(cfg.baseline_dir, PathBuf::from("/proj/wpt/expected"));
    }

    #[test]
    fn parses_commands_and_wpt() {
        let toml = r#"
[project]
name = "P"
root = "/p"

[project.commands]
docs = "cargo doc --no-deps"
bench = "cargo bench"

[project.wpt]
runner = "cargo test --test wpt"
baseline = "wpt/baseline"

[main_repo]
name = "M"
dir = "/p"
url = "u"
token_key = "main"

[[repos]]
name = "r1"
dir = "crates/r1"
url = "u"
commands = { bench = "cargo bench" }
wpt = { suites = ["html5lib"] }
"#;
        let cfg = Config::parse(toml).unwrap();
        assert_eq!(cfg.commands.len(), 2);
        assert_eq!(
            cfg.commands.get("docs").map(String::as_str),
            Some("cargo doc --no-deps")
        );
        assert!(cfg.wpt.is_some());
        assert_eq!(cfg.baseline_dir, PathBuf::from("/p/wpt/baseline"));

        let r = &cfg.repos[0];
        assert_eq!(
            r.commands.get("bench").map(String::as_str),
            Some("cargo bench")
        );
        assert_eq!(r.wpt.as_ref().unwrap().suites, vec!["html5lib"]);
    }

    #[test]
    fn empty_project_name_rejected() {
        let toml = r#"
[project]
name = ""
root = "/p"

[main_repo]
name = "M"
dir = "/p"
url = "u"
token_key = "main"
"#;
        assert!(Config::parse(toml).is_err());
    }

    #[test]
    fn duplicate_repo_name_rejected() {
        let toml = r#"
[project]
name = "P"
root = "/p"

[main_repo]
name = "M"
dir = "/p"
url = "u"
token_key = "main"

[[repos]]
name = "r1"
dir = "crates/r1"
url = "u"

[[repos]]
name = "r1"
dir = "crates/r2"
url = "u"
"#;
        let err = Config::parse(toml).unwrap_err();
        assert!(err.contains("duplicate repo name: r1"));
    }

    #[test]
    fn dep_on_missing_repo_rejected() {
        let toml = r#"
[project]
name = "P"
root = "/p"

[main_repo]
name = "M"
dir = "/p"
url = "u"
token_key = "main"

[[repos]]
name = "r1"
dir = "crates/r1"
url = "u"
deps = ["ghost"]
"#;
        let err = Config::parse(toml).unwrap_err();
        assert!(err.contains("ghost"));
    }
}