use git_conventional::Commit;
use semver::{BuildMetadata, Prerelease, Version};
use crate::errors::{ReleaseError, Result};
use crate::jj::JjBackend;
#[derive(Debug, Clone)]
pub struct CommitInfo {
pub change_id: String,
pub description: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum BumpKind {
None,
Patch,
Minor,
Major,
}
pub(crate) fn find_trigger(
backend: &dyn JjBackend,
trigger: &str,
since: &str,
) -> Result<Option<String>> {
let commits = backend
.log_commits(&format!("{since}..@"))
.map_err(|_| ReleaseError::Message("scanning for trigger commit".into()))?;
for c in commits {
if c.description.contains(trigger) {
return Ok(Some(c.change_id));
}
}
Ok(None)
}
pub fn latest_version_tag(backend: &dyn JjBackend, prefix: &str) -> Result<Option<Tag>> {
let raw_tags = backend.list_tags()?;
let tags: Vec<Tag> = raw_tags
.into_iter()
.filter_map(|name| {
let stripped = name.strip_prefix(prefix)?;
let version = Version::parse(stripped).ok()?;
Some(Tag { name, version })
})
.collect();
Ok(highest_semver_tag(&tags).cloned())
}
#[must_use]
pub(crate) fn compute_bump(commits: &[CommitInfo]) -> BumpKind {
let mut bump = BumpKind::None;
for commit in commits {
let kind = classify(&commit.description);
if kind > bump {
bump = kind;
}
if bump == BumpKind::Major {
break;
}
}
bump
}
pub fn resolve_bump(force: Option<&String>, commits: &[CommitInfo]) -> Result<BumpKind> {
if let Some(force) = force {
return match force.as_str() {
"major" => Ok(BumpKind::Major),
"minor" => Ok(BumpKind::Minor),
"patch" => Ok(BumpKind::Patch),
other => {
return Err(ReleaseError::Message(format!(
"unknown bump.force value {other:?}: must be major/minor/patch"
)));
}
};
}
Ok(compute_bump(commits))
}
fn classify(description: &str) -> BumpKind {
if let Ok(conv) = Commit::parse(description) {
if conv.breaking() {
return BumpKind::Major;
}
return match conv.type_().as_str() {
"feat" => BumpKind::Minor,
"fix" | "perf" | "refactor" => BumpKind::Patch,
_ => BumpKind::None,
};
}
BumpKind::None
}
#[must_use]
pub fn apply_bump(current: &Version, bump: BumpKind) -> Version {
let mut next = current.clone();
match bump {
BumpKind::Major => {
next.major += 1;
next.minor = 0;
next.patch = 0;
}
BumpKind::Minor => {
next.minor += 1;
next.patch = 0;
}
BumpKind::Patch => {
next.patch += 1;
}
BumpKind::None => {}
}
next.pre = Prerelease::EMPTY;
next.build = BuildMetadata::EMPTY;
next
}
#[derive(Debug, Clone)]
pub struct Tag {
pub name: String,
pub version: Version,
}
#[must_use]
pub(crate) fn highest_semver_tag(tags: &[Tag]) -> Option<&Tag> {
tags.iter().max_by(|a, b| a.version.cmp(&b.version))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test_helpers::mock::MockBackend;
#[test]
fn latest_version_tag_finds_highest() {
let backend = MockBackend {
tags: vec!["v0.1.0".into(), "v0.3.0".into(), "v0.2.0".into()],
..MockBackend::default()
};
let result = latest_version_tag(&backend, "v").unwrap();
assert_eq!(result.unwrap().name, "v0.3.0");
}
#[test]
fn latest_version_tag_ignores_non_semver() {
let backend = MockBackend {
tags: vec![
"latest".into(),
"abc123".into(),
"v0.2.0".into(),
"def456".into(),
],
..MockBackend::default()
};
let result = latest_version_tag(&backend, "v").unwrap();
assert_eq!(result.unwrap().name, "v0.2.0");
}
#[test]
fn latest_version_tag_empty_returns_none() {
let backend = MockBackend {
tags: vec![],
..MockBackend::default()
};
let result = latest_version_tag(&backend, "v").unwrap();
assert!(result.is_none());
}
fn bump(msg: &str) -> BumpKind {
classify(msg)
}
#[test]
fn conventional_feat_is_minor() {
assert_eq!(bump("feat: add wallpaper cycling"), BumpKind::Minor);
}
#[test]
fn conventional_fix_is_patch() {
assert_eq!(bump("fix: prevent crash on empty dir"), BumpKind::Patch);
}
#[test]
fn breaking_bang_is_major() {
assert_eq!(bump("feat!: redesign IPC protocol"), BumpKind::Major);
}
#[test]
fn breaking_footer_is_major() {
assert_eq!(
bump("refactor: change socket path\n\nBREAKING CHANGE: moved from /tmp to /run"),
BumpKind::Major
);
}
#[test]
fn chore_is_none() {
assert_eq!(bump("chore: bump deps"), BumpKind::None);
}
#[test]
fn non_conventional_is_none() {
assert_eq!(bump("did some stuff"), BumpKind::None);
}
#[test]
fn apply_minor_bump() {
let v = Version::parse("1.2.3").unwrap();
assert_eq!(
apply_bump(&v, BumpKind::Minor),
Version::parse("1.3.0").unwrap()
);
}
#[test]
fn apply_major_bump() {
let v = Version::parse("1.2.3").unwrap();
assert_eq!(
apply_bump(&v, BumpKind::Major),
Version::parse("2.0.0").unwrap()
);
}
#[test]
fn compute_bump_takes_commits_directly() {
let commits = vec![
CommitInfo {
change_id: "abc".into(),
description: "feat: add thing".into(),
},
CommitInfo {
change_id: "def".into(),
description: "fix: patch thing".into(),
},
];
assert_eq!(compute_bump(&commits), BumpKind::Minor);
}
#[test]
fn highest_semver_tag_picks_correct_version() {
let tags = vec![
Tag {
name: "v0.1.0".into(),
version: Version::parse("0.1.0").unwrap(),
},
Tag {
name: "v0.3.0".into(),
version: Version::parse("0.3.0").unwrap(),
},
Tag {
name: "v0.2.0".into(),
version: Version::parse("0.2.0").unwrap(),
},
];
let latest = highest_semver_tag(&tags).unwrap();
assert_eq!(latest.name, "v0.3.0");
}
#[test]
fn highest_semver_tag_empty_returns_none() {
assert!(highest_semver_tag(&[]).is_none());
}
#[test]
fn find_trigger_only_scans_since_last_tag() {
let backend = MockBackend {
commits: vec![CommitInfo {
change_id: "abc".into(),
description: "Release: please".into(),
}],
..MockBackend::default()
};
find_trigger(&backend, "Release: please", "v0.1.0").unwrap();
assert_eq!(backend.calls.borrow()[0], "v0.1.0..@");
}
#[test]
fn resolve_bump_force_major() {
let commits = vec![CommitInfo {
change_id: "abc".into(),
description: "fix: small thing".into(),
}];
assert_eq!(
resolve_bump(Some(&"major".to_owned()), &commits).unwrap(),
BumpKind::Major
);
}
#[test]
fn resolve_bump_force_overrides_commits() {
let commits = vec![CommitInfo {
change_id: "abc".into(),
description: "fix: small thing".into(),
}];
assert_eq!(
resolve_bump(Some(&"minor".to_owned()), &commits).unwrap(),
BumpKind::Minor
);
}
#[test]
fn resolve_bump_auto_from_commits() {
let commits = vec![CommitInfo {
change_id: "abc".into(),
description: "feat: new thing".into(),
}];
assert_eq!(resolve_bump(None, &commits).unwrap(), BumpKind::Minor);
}
#[test]
fn resolve_bump_unknown_force_errors() {
assert!(resolve_bump(Some(&"banana".to_owned()), &[]).is_err());
}
#[test]
fn log_commits_for_path_uses_path_filter() {
let backend = MockBackend {
commits: vec![CommitInfo {
change_id: "abc".into(),
description: "feat: change lib".into(),
}],
..MockBackend::default()
};
let commits = backend.log_commits_for_path("root()..@", "lib").unwrap();
assert_eq!(commits.len(), 1);
assert_eq!(backend.calls.borrow()[0], "root()..@");
}
}