use serde::Deserialize;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::{Path, PathBuf};
#[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>,
#[serde(default)]
pub commands: BTreeMap<String, String>,
#[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,
#[serde(default)]
pub commands: BTreeMap<String, String>,
#[serde(default)]
pub wpt: Option<WptConfig>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct WptConfig {
#[serde(default)]
pub suites: Vec<String>,
#[serde(default)]
pub runner: Option<String>,
#[serde(default)]
pub baseline: Option<PathBuf>,
}
fn default_msrv() -> String {
"1.85".into()
}
fn default_token_key() -> String {
"crates".into()
}
#[derive(Debug)]
pub struct Config {
pub project_name: String,
pub root: PathBuf,
pub crates_dir: PathBuf,
pub main_repo: ResolvedMainRepo,
pub repos: Vec<ResolvedRepo>,
pub index: HashMap<String, usize>,
pub commands: BTreeMap<String, String>,
pub wpt: Option<WptConfig>,
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,
pub commands: BTreeMap<String, String>,
pub wpt: Option<WptConfig>,
}
impl Config {
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))
}
pub fn parse(content: &str) -> Result<Self, String> {
let cf: ConfigFile = toml::from_str(content).map_err(|e| format!("parse error: {}", e))?;
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"));
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);
}
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,
})
}
pub fn repo_by_name(&self, name: &str) -> Option<&ResolvedRepo> {
self.index.get(name).map(|&i| &self.repos[i])
}
#[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")
);
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"));
}
}