use std::{collections::HashMap, path::Path};
use semver::{Version, VersionReq};
use crate::{
BumpKind, Config, ManifestBackend, MemberPlan, PreparedRelease, ReleasePlan, UnifiedPlan,
Versioning, WorkspaceConfig, bump, commits, detect, errors::Result, jj::JjBackend, publish,
workspace,
};
pub fn prepare_release(
backend: &dyn JjBackend,
manifest: &dyn ManifestBackend,
config: &Config,
root: &Path,
) -> Result<Option<PreparedRelease>> {
backend.check_identity()?;
let since = release_since(backend, config)?;
if commits::find_trigger(backend, &config.release.trigger, &since)?.is_none() {
return Ok(None);
}
plan_since(backend, manifest, config, root, since)
}
pub fn plan_release(
backend: &dyn JjBackend,
manifest: &dyn ManifestBackend,
config: &Config,
root: &Path,
) -> Result<Option<PreparedRelease>> {
let since = release_since(backend, config)?;
plan_since(backend, manifest, config, root, since)
}
pub(super) fn release_since(backend: &dyn JjBackend, config: &Config) -> Result<String> {
independent_workspace(config).map_or_else(
|| resolve_since(backend, config),
|ws| independent_since(backend, config, ws),
)
}
fn plan_since(
backend: &dyn JjBackend,
manifest: &dyn ManifestBackend,
config: &Config,
root: &Path,
since: String,
) -> Result<Option<PreparedRelease>> {
if let Some(ws) = independent_workspace(config) {
let commits = backend.log_commits(&format!("{since}..@"))?;
let members = plan_member_versions(backend, config, ws, root)?;
if !members.values().any(MemberPlan::is_released) {
return Ok(None);
}
return Ok(Some(PreparedRelease {
since,
commits,
plan: ReleasePlan::Independent(members),
}));
}
let is_first_release = since == "root()";
let current_version = manifest.read_version(root)?;
let latest_tag = commits::latest_version_tag(backend, &config.release.tag_prefix)?;
let baseline_version = if is_first_release {
current_version.clone()
} else {
latest_tag
.as_ref()
.map_or_else(|| current_version.clone(), |t| t.version.clone())
};
let commits = backend.log_commits(&format!("{since}..@"))?;
let mut bump = commits::resolve_bump(config.bump.force.as_deref(), &commits)?;
if config.bump.force.is_none() {
bump = commits::initial_development_bump(
bump,
&baseline_version,
config.bump.features_bump_patch_before_1_0,
);
}
if !is_first_release {
bump = upgrade_for_breaking_changes(config, root, ¤t_version, bump)?;
}
let next_version = if is_first_release {
current_version.clone()
} else {
bump::next_version(
latest_tag.as_ref().map(|t| &t.version),
¤t_version,
bump,
)
};
let next_version = apply_channel(backend, config, &config.release.tag_prefix, next_version)?;
let tag_name = config.tag_name(&next_version);
Ok(Some(PreparedRelease {
since,
commits,
plan: ReleasePlan::Unified(UnifiedPlan {
current_version,
baseline_version,
next_version,
tag_name,
bump,
}),
}))
}
fn apply_channel(
backend: &dyn JjBackend,
config: &Config,
prefix: &str,
next: Version,
) -> Result<Version> {
let Some(channel) = config.bump.pre.as_deref() else {
return Ok(next);
};
let tags = commits::version_tags(backend, prefix, "tags()")?;
commits::next_prerelease(&next, channel, &tags)
}
fn independent_since(
backend: &dyn JjBackend,
config: &Config,
ws: &WorkspaceConfig,
) -> Result<String> {
let tags = backend.list_tags("tags() & ::@")?;
Ok(ws
.members
.iter()
.filter_map(|m| {
let prefix = m
.tag_prefix
.as_deref()
.unwrap_or(&config.release.tag_prefix);
tags.iter()
.filter_map(|t| Some((t, Version::parse(t.strip_prefix(prefix)?).ok()?)))
.max_by(|a, b| a.1.cmp(&b.1))
.map(|(t, _)| t.clone())
})
.max_by_key(|t| backend.commit_date(t).unwrap_or_default())
.unwrap_or_else(|| "root()".to_owned()))
}
#[must_use]
pub fn independent_workspace(config: &Config) -> Option<&WorkspaceConfig> {
config
.workspace
.as_ref()
.filter(|ws| ws.enabled && matches!(ws.versioning, Versioning::Independent))
}
fn upgrade_for_breaking_changes(
config: &Config,
root: &Path,
current: &Version,
bump: BumpKind,
) -> Result<BumpKind> {
let enabled = config.publish.cargo
&& config.publish.semver_checks
&& detect::tool_available("cargo-semver-checks");
let may_upgrade = current.major >= 1 || config.publish.semver_checks_upgrade_major;
if !enabled || !may_upgrade || bump >= BumpKind::Major {
return Ok(bump);
}
eprintln!("→ Running cargo-semver-checks...");
if publish::run_semver_checks(root)? {
eprintln!(
"warning: cargo-semver-checks detected API breaking changes, upgrading bump to Major"
);
return Ok(BumpKind::Major);
}
Ok(bump)
}
fn plan_member_versions(
backend: &dyn JjBackend,
config: &Config,
ws: &WorkspaceConfig,
root: &Path,
) -> Result<HashMap<String, MemberPlan>> {
let versions = workspace::member_versions(root)?;
let bumps = workspace::member_bumps(
backend,
&ws.members,
"root()",
config.bump.force.as_deref(),
&config.release.tag_prefix,
)?;
let mut plans = HashMap::new();
for member in &ws.members {
let current = versions
.get(&member.name)
.cloned()
.unwrap_or_else(|| Version::new(0, 0, 0));
let first_release =
workspace::member_since(backend, member, &config.release.tag_prefix, "root()")?
== "root()";
let next = if first_release {
Some(current.clone())
} else {
let bump = bumps.get(&member.name).copied().unwrap_or(BumpKind::None);
let bump = if config.bump.force.is_none() {
commits::initial_development_bump(
bump,
¤t,
config.bump.features_bump_patch_before_1_0,
)
} else {
bump
};
(bump != BumpKind::None).then(|| commits::apply_bump(¤t, bump))
};
let next = match next {
Some(next) => apply_channel(
backend,
config,
workspace::member_prefix(member, &config.release.tag_prefix),
next,
)?,
None => current.clone(),
};
plans.insert(
member.name.clone(),
MemberPlan {
current,
next,
first_release,
propagated: false,
updated_deps: Vec::new(),
},
);
}
let reqs = workspace::member_requirements(&root.join("Cargo.toml"))?;
propagate_dependency_bumps(backend, config, ws, &reqs, &mut plans)?;
Ok(plans)
}
pub(super) fn resolve_since(backend: &dyn JjBackend, config: &Config) -> Result<String> {
if let Some(tag) = commits::latest_version_tag(backend, &config.release.tag_prefix)? {
return Ok(tag.name);
}
eprintln!("hint: no version tag found. Entering First Release mode (starting from root).");
Ok("root()".to_owned())
}
fn propagate_dependency_bumps(
backend: &dyn JjBackend,
config: &Config,
ws: &WorkspaceConfig,
reqs: &HashMap<String, HashMap<String, VersionReq>>,
plans: &mut HashMap<String, MemberPlan>,
) -> Result<()> {
for member in workspace::ordered_members(&ws.members)? {
let Some(member_reqs) = reqs.get(&member.name) else {
continue;
};
let mut outdated: Vec<String> = member_reqs
.iter()
.filter(|(dep, req)| {
plans
.get(*dep)
.is_some_and(|p| p.is_released() && !req.matches(&p.next))
})
.map(|(dep, _)| dep.clone())
.collect();
if outdated.is_empty() {
continue;
}
outdated.sort();
let Some(plan) = plans.get_mut(&member.name) else {
continue;
};
if !plan.is_released() {
let next = commits::apply_bump(&plan.current, BumpKind::Patch);
let prefix = workspace::member_prefix(member, &config.release.tag_prefix);
plan.next = apply_channel(backend, config, prefix, next)?;
plan.propagated = true;
}
plan.updated_deps = outdated;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::{cell::RefCell, path::Path};
use crate::{PublishBackend, WorkspaceMember};
use semver::Version;
use crate::{
config,
errors::{ReleaseError, Result},
manifest,
pipeline::validate,
test_helpers::mock::MockBackend,
};
use jj_release_changelog::CommitInfo;
struct MockManifest {
version: Version,
}
impl manifest::ManifestBackend for MockManifest {
fn read_version(&self, _root: &Path) -> Result<Version> {
Ok(self.version.clone())
}
fn write_version(&self, _root: &Path, _version: &Version) -> Result<()> {
Ok(())
}
}
struct MockPublisher(bool);
impl PublishBackend for MockPublisher {
fn check(&self, _root: &Path) -> Result<()> {
if self.0 {
return Err(ReleaseError::Message("mock failure".to_string()));
}
Ok(())
}
fn publish(&self, _root: &Path, _flags: &[String]) -> Result<()> {
Ok(())
}
}
#[test]
fn prepare_release_computes_correct_next_version() {
let backend = MockBackend {
tags: vec!["v0.1.0".into()],
commits: vec![
CommitInfo {
change_id: "abc".into(),
description: "Release: please".into(),
},
CommitInfo {
change_id: "def".into(),
description: "feat: add thing".into(),
},
],
calls: RefCell::new(vec![]),
};
let manifest = MockManifest {
version: Version::parse("0.1.0").unwrap(),
};
let config = config::Config::default();
let prepared = prepare_release(&backend, &manifest, &config, Path::new("/tmp"))
.unwrap()
.expect("a release should be pending");
let plan = prepared
.unified()
.expect("default config should give a unified plan");
assert_eq!(plan.next_version, Version::parse("0.2.0").unwrap());
assert_eq!(plan.tag_name, "v0.2.0");
}
#[test]
fn prepare_release_returns_none_when_no_trigger() {
let backend = MockBackend {
tags: vec!["v0.0.0".into()],
commits: vec![CommitInfo {
change_id: "abc".into(),
description: "feat: add thing".into(),
}],
calls: RefCell::new(vec![]),
};
let manifest = MockManifest {
version: Version::parse("0.0.0").unwrap(),
};
let config = Config::default();
let prepared = prepare_release(&backend, &manifest, &config, Path::new("/tmp")).unwrap();
assert!(prepared.is_none());
}
#[test]
fn semver_checks_defaults_to_true() {
let cfg = Config::default();
assert!(cfg.publish.semver_checks);
}
#[test]
fn parse_semver_checks_config() {
let raw = r"
[publish]
semver_checks = false
";
let cfg: Config = toml::from_str(raw).unwrap();
assert!(!cfg.publish.semver_checks);
}
#[test]
fn check_publish_success() {
let publisher = MockPublisher(false);
assert_eq!(
validate::check_publish(&publisher, Path::new("/tmp")),
Ok("dry-run passed".to_owned())
);
}
#[test]
fn check_publish_failure() {
let publisher = MockPublisher(true);
assert_eq!(
validate::check_publish(&publisher, Path::new("/tmp")),
Err("mock failure".to_owned())
);
}
fn member(name: &str, deps: &[&str]) -> WorkspaceMember {
WorkspaceMember {
name: name.into(),
path: format!("crates/{name}"),
depends_on: deps.iter().map(|d| (*d).to_owned()).collect(),
..Default::default()
}
}
fn plan(current: &str, next: &str) -> MemberPlan {
MemberPlan {
current: Version::parse(current).unwrap(),
next: Version::parse(next).unwrap(),
first_release: false,
propagated: false,
updated_deps: Vec::new(),
}
}
fn reqs(entries: &[(&str, &str, &str)]) -> HashMap<String, HashMap<String, VersionReq>> {
let mut out: HashMap<String, HashMap<String, VersionReq>> = HashMap::new();
for (dependent, dep, req) in entries {
out.entry((*dependent).to_owned())
.or_default()
.insert((*dep).to_owned(), VersionReq::parse(req).unwrap());
}
out
}
fn ws() -> WorkspaceConfig {
WorkspaceConfig {
enabled: true,
versioning: Versioning::Independent,
members: vec![
member("globset", &[]),
member("ignore", &["globset"]),
member("ripgrep", &["ignore"]),
],
}
}
fn propagate(
reqs: &HashMap<String, HashMap<String, VersionReq>>,
plans: &mut HashMap<String, MemberPlan>,
) {
let backend = MockBackend::default();
propagate_dependency_bumps(&backend, &Config::default(), &ws(), reqs, plans).unwrap();
}
#[test]
fn breaking_bump_releases_direct_dependents() {
let reqs = reqs(&[
("ignore", "globset", "0.4.21"),
("ripgrep", "ignore", "0.4.34"),
]);
let mut plans = HashMap::from([
("globset".to_owned(), plan("0.4.21", "0.5.0")),
("ignore".to_owned(), plan("0.4.34", "0.4.34")),
("ripgrep".to_owned(), plan("15.2.0", "15.2.0")),
]);
propagate(&reqs, &mut plans);
let ignore = &plans["ignore"];
assert_eq!(ignore.next, Version::new(0, 4, 35));
assert!(ignore.propagated);
assert_eq!(ignore.updated_deps, ["globset"]);
assert!(!plans["ripgrep"].is_released());
}
#[test]
fn compatible_bump_does_not_propagate() {
let reqs = reqs(&[("ignore", "globset", "0.4.21")]);
let mut plans = HashMap::from([
("globset".to_owned(), plan("0.4.21", "0.4.22")),
("ignore".to_owned(), plan("0.4.34", "0.4.34")),
("ripgrep".to_owned(), plan("15.2.0", "15.2.0")),
]);
propagate(&reqs, &mut plans);
assert!(!plans["ignore"].is_released());
}
#[test]
fn exact_pin_cascades() {
let reqs = reqs(&[
("ignore", "globset", "0.4.21"),
("ripgrep", "ignore", "=0.4.34"),
]);
let mut plans = HashMap::from([
("globset".to_owned(), plan("0.4.21", "0.5.0")),
("ignore".to_owned(), plan("0.4.34", "0.4.34")),
("ripgrep".to_owned(), plan("15.2.0", "15.2.0")),
]);
propagate(&reqs, &mut plans);
assert!(plans["ignore"].propagated);
assert!(plans["ripgrep"].propagated);
assert_eq!(plans["ripgrep"].next, Version::new(15, 2, 1));
}
#[test]
fn own_bump_is_kept() {
let reqs = reqs(&[("ignore", "globset", "0.4.21")]);
let mut plans = HashMap::from([
("globset".to_owned(), plan("0.4.21", "0.5.0")),
("ignore".to_owned(), plan("0.4.34", "0.5.0")), ("ripgrep".to_owned(), plan("15.2.0", "15.2.0")),
]);
propagate(&reqs, &mut plans);
let ignore = &plans["ignore"];
assert_eq!(ignore.next, Version::new(0, 5, 0));
assert!(!ignore.propagated);
assert_eq!(ignore.updated_deps, ["globset"]);
}
#[test]
fn pre_release_dependency_propagates_on_the_same_channel() {
let reqs = reqs(&[("ignore", "globset", "0.4.21")]);
let mut plans = HashMap::from([
("globset".to_owned(), plan("0.4.21", "0.5.0-rc.1")),
("ignore".to_owned(), plan("0.4.34", "0.4.34")),
("ripgrep".to_owned(), plan("15.2.0", "15.2.0")),
]);
let config = Config {
bump: config::BumpConfig {
pre: Some("rc".into()),
..Default::default()
},
..Default::default()
};
propagate_dependency_bumps(&MockBackend::default(), &config, &ws(), &reqs, &mut plans)
.unwrap();
let ignore = &plans["ignore"];
assert_eq!(ignore.next, Version::parse("0.4.35-rc.1").unwrap());
assert!(ignore.propagated);
}
}