use std::{
collections::{HashMap, HashSet},
path::Path,
};
use cargo_metadata::{DependencyKind, MetadataCommand};
use semver::{Version, VersionReq};
use crate::{
WorkspaceMember,
errors::{ReleaseError, Result},
};
pub fn parse_workspace_members(cargo_toml: &Path) -> Result<Vec<WorkspaceMember>> {
let metadata = MetadataCommand::new()
.manifest_path(cargo_toml)
.no_deps()
.exec()?;
let root = metadata.workspace_root.as_std_path();
let members = metadata.workspace_packages();
let names: HashSet<&str> = members.iter().map(|p| p.name.as_str()).collect();
Ok(members
.iter()
.map(|p| {
let dir = p.manifest_path.parent().map_or(root, |d| d.as_std_path());
let rel = dir.strip_prefix(root).unwrap_or(dir);
let path = if rel.as_os_str().is_empty() {
".".to_owned() } else {
rel.to_string_lossy().replace('\\', "/")
};
let depends_on = p
.dependencies
.iter()
.filter(|d| matches!(d.kind, DependencyKind::Normal | DependencyKind::Build))
.filter(|d| d.path.is_some() && names.contains(d.name.as_str()))
.map(|d| d.name.clone())
.collect();
WorkspaceMember {
name: p.name.to_string(),
path,
publish: !matches!(&p.publish, Some(registries) if registries.is_empty()),
depends_on,
tag_prefix: None,
}
})
.collect())
}
pub fn ordered_members(members: &[WorkspaceMember]) -> Result<Vec<&WorkspaceMember>> {
let publish: Vec<&WorkspaceMember> = members.iter().filter(|m| m.publish).collect();
let mut ordered: Vec<&WorkspaceMember> = Vec::new();
let mut remaining: Vec<&WorkspaceMember> = publish.clone();
let mut iterations = 0;
let max = remaining.len() * remaining.len() + 1;
while !remaining.is_empty() {
iterations += 1;
if iterations > max {
return Err(ReleaseError::Message(
"circular dependency detected in workspace members".to_string(),
));
}
let mut progress = false;
remaining.retain(|member| {
let deps_satisfied = member.depends_on.iter().all(|dep| {
let is_publishable = publish.iter().any(|m| &m.name == dep);
if is_publishable {
ordered.iter().any(|m| &m.name == dep)
} else {
true
}
});
if deps_satisfied {
ordered.push(member);
progress = true;
false } else {
true }
});
if !progress {
return Err(ReleaseError::Message(
"circular dependency detected in workspace members".to_string(),
));
}
}
Ok(ordered)
}
pub fn member_versions(root: &Path) -> Result<HashMap<String, Version>> {
let metadata = MetadataCommand::new()
.manifest_path(root.join("Cargo.toml"))
.exec()?;
let mut versions = HashMap::new();
for package in &metadata.packages {
if metadata.workspace_members.contains(&package.id) {
let version = Version::parse(&package.version.to_string())?;
versions.insert(package.name.clone().to_string(), version);
}
}
Ok(versions)
}
pub fn member_requirements(
cargo_toml: &Path,
) -> Result<HashMap<String, HashMap<String, VersionReq>>> {
let metadata = MetadataCommand::new()
.manifest_path(cargo_toml)
.no_deps()
.exec()?;
let members = metadata.workspace_packages();
let names: HashSet<&str> = members.iter().map(|p| p.name.as_str()).collect();
Ok(members
.iter()
.map(|p| {
let reqs = p
.dependencies
.iter()
.filter(|d| matches!(d.kind, DependencyKind::Normal | DependencyKind::Build))
.filter(|d| names.contains(d.name.as_str()))
.map(|d| (d.name.clone(), d.req.clone()))
.collect();
(p.name.to_string(), reqs)
})
.collect())
}
#[must_use]
pub fn member_prefix<'a>(member: &'a WorkspaceMember, default: &'a str) -> &'a str {
member.tag_prefix.as_deref().unwrap_or(default)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{BumpKind, test_helpers::mock::MockBackend, workspace};
use jj_release_changelog::CommitInfo;
use std::fs;
#[test]
fn ordered_members_lib_before_cli() {
let members = vec![
WorkspaceMember {
name: "mycli".into(),
path: "cli".into(),
publish: true,
depends_on: vec!["mylib".into()],
tag_prefix: None,
},
WorkspaceMember {
name: "mylib".into(),
path: "lib".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
},
];
let ordered = ordered_members(&members).unwrap();
assert_eq!(ordered[0].name, "mylib");
assert_eq!(ordered[1].name, "mycli");
}
#[test]
fn ordered_members_no_deps_preserves_order() {
let members = vec![
WorkspaceMember {
name: "a".into(),
path: "a".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
},
WorkspaceMember {
name: "b".into(),
path: "b".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
},
];
let ordered = ordered_members(&members).unwrap();
assert_eq!(ordered[0].name, "a");
assert_eq!(ordered[1].name, "b");
}
#[test]
fn ordered_members_skips_unpublished() {
let members = vec![
WorkspaceMember {
name: "internal".into(),
path: "internal".into(),
publish: false,
depends_on: vec![],
tag_prefix: None,
},
WorkspaceMember {
name: "mylib".into(),
path: "lib".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
},
];
let ordered = ordered_members(&members).unwrap();
assert_eq!(ordered.len(), 1);
assert_eq!(ordered[0].name, "mylib");
}
#[test]
fn member_bumps_computes_per_member() {
let backend = MockBackend {
commits: vec![CommitInfo {
change_id: "abc".into(),
description: "feat: add thing".into(),
}],
..MockBackend::default()
};
let members = vec![WorkspaceMember {
name: "mylib".into(),
path: "lib".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
}];
let bumps = workspace::member_bumps(&backend, &members, "v0.1.0", None, "v").unwrap();
assert_eq!(*bumps.get("mylib").unwrap(), BumpKind::Minor);
}
#[test]
fn member_tag_name_uses_member_prefix() {
let member = WorkspaceMember {
name: "mylib".into(),
path: "lib".into(),
publish: true,
depends_on: vec![],
tag_prefix: Some("mylib-v".into()),
};
let v = Version::parse("0.5.0").unwrap();
assert_eq!(workspace::member_tag_name(&member, &v, "v"), "mylib-v0.5.0");
}
#[test]
fn member_tag_name_falls_back_to_default_prefix() {
let member = WorkspaceMember {
name: "mycli".into(),
path: "cli".into(),
publish: true,
depends_on: vec![],
tag_prefix: None,
};
let v = Version::parse("0.8.0").unwrap();
assert_eq!(workspace::member_tag_name(&member, &v, "v"), "v0.8.0");
}
#[test]
fn ordered_members_ignores_unpublished_dependencies() {
let members = vec![
WorkspaceMember {
name: "mycli".into(),
path: "cli".into(),
publish: true,
depends_on: vec!["internal-core".into()], tag_prefix: None,
},
WorkspaceMember {
name: "internal-core".into(),
path: "core".into(),
publish: false, depends_on: vec![],
tag_prefix: None,
},
];
let ordered = ordered_members(&members).unwrap();
assert_eq!(ordered.len(), 1);
assert_eq!(ordered[0].name, "mycli");
}
#[test]
fn bump_member_version_with_toml_edit() {
let dir = tempfile::tempdir().unwrap();
fs::write(
dir.path().join("Cargo.toml"),
r#"
[workspace]
members = ["lib"]
resolver = "2"
"#,
)
.unwrap();
fs::create_dir(dir.path().join("lib")).unwrap();
fs::write(
dir.path().join("lib/Cargo.toml"),
r#"[package]
name = "mylib"
version = "0.3.0"
edition = "2024"
"#,
)
.unwrap();
fs::create_dir(dir.path().join("lib/src")).unwrap();
fs::write(dir.path().join("lib/src/lib.rs"), "").unwrap();
let new_version = Version::parse("0.4.0").unwrap();
workspace::bump_member_version(dir.path(), "mylib", &new_version).unwrap();
let content = fs::read_to_string(dir.path().join("lib/Cargo.toml")).unwrap();
assert!(content.contains("\"0.4.0\""));
assert!(!content.contains("\"0.3.0\""));
}
}