use alloc::collections::{BTreeMap, BTreeSet};
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;
use semver::{BuildMetadata, Version};
use crate::plan::{Package, PackageId, Workspace};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Leftover {
tags: Vec<String>,
}
impl Leftover {
fn from_tags(tags: BTreeSet<String>) -> Option<Self> {
if tags.is_empty() {
None
} else {
Some(Self {
tags: tags.into_iter().collect(),
})
}
}
#[must_use]
pub fn tags(&self) -> &[String] {
&self.tags
}
}
impl fmt::Display for Leftover {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"unverified: leftover tag ambiguity: {}",
self.tags.join(", ")
)
}
}
impl core::error::Error for Leftover {}
pub fn resolve_commit_tags(
tags: &[&str],
workspace: &Workspace,
bare_candidate: impl Fn(&PackageId) -> bool,
) -> Result<BTreeMap<PackageId, Version>, Leftover> {
let mut by_package: BTreeMap<PackageId, BTreeMap<Version, BTreeSet<String>>> = BTreeMap::new();
let mut leftover = BTreeSet::new();
let mut bares = Vec::new();
for tag in tags {
match classify(tag, workspace) {
Class::Prefixed { package, version } => {
by_package
.entry(package)
.or_default()
.entry(version)
.or_default()
.insert((*tag).to_owned());
}
Class::Bare(version) => bares.push((*tag, version)),
Class::LooksLikeVersion | Class::Ambiguous => {
leftover.insert((*tag).to_owned());
}
Class::Ignore => {}
}
}
let covered_versions: BTreeSet<Version> = by_package
.iter()
.filter(|(id, _)| bare_candidate(id))
.map(|(_, versions)| versions)
.filter(|versions| versions.len() == 1)
.filter_map(|versions| versions.keys().next().cloned())
.collect();
match bare_owner(workspace, &bare_candidate) {
BareOwner::One(package) => {
for (tag, version) in bares {
by_package
.entry(package.clone())
.or_default()
.entry(version)
.or_default()
.insert(tag.to_owned());
}
}
BareOwner::Many => {
for (tag, version) in bares {
if !covered_versions.contains(&version) {
leftover.insert(tag.to_owned());
}
}
}
BareOwner::None => {
}
}
let mut attributed = BTreeMap::new();
for (package, mut versions) in by_package {
if versions.len() == 1 {
if let Some((version, _)) = versions.pop_first() {
attributed.insert(package, version);
}
} else {
leftover.extend(versions.into_values().flatten());
}
}
match Leftover::from_tags(leftover) {
None => Ok(attributed),
Some(err) => Err(err),
}
}
pub fn current_versions(
commits: &[&[&str]],
workspace: &Workspace,
bare_candidate: impl Fn(&PackageId) -> bool,
) -> Result<BTreeMap<PackageId, Version>, Leftover> {
let mut leftover = BTreeSet::new();
let mut current = BTreeMap::new();
for tags in commits {
match resolve_commit_tags(tags, workspace, &bare_candidate) {
Ok(attributed) if leftover.is_empty() => {
for (id, version) in attributed {
current
.entry(id)
.and_modify(|have: &mut Version| {
if without_build(&version) > without_build(have) {
*have = version.clone();
}
})
.or_insert(version);
}
}
Ok(_) => {}
Err(err) => leftover.extend(err.tags().iter().cloned()),
}
}
match Leftover::from_tags(leftover) {
None => Ok(current),
Some(err) => Err(err),
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Drift {
id: PackageId,
manifest: Version,
tagged: Version,
}
impl Drift {
fn new(id: PackageId, manifest: Version, tagged: Version) -> Option<Self> {
(without_build(&manifest) > without_build(&tagged)).then_some(Self {
id,
manifest,
tagged,
})
}
#[must_use]
pub fn id(&self) -> &PackageId {
&self.id
}
#[must_use]
pub fn manifest(&self) -> &Version {
&self.manifest
}
#[must_use]
pub fn tagged(&self) -> &Version {
&self.tagged
}
}
#[must_use]
pub fn drift(
workspace: &Workspace,
tagged: &BTreeMap<PackageId, Version>,
managed: impl Fn(&Package) -> bool,
) -> Vec<Drift> {
workspace
.packages()
.filter(|package| managed(package))
.filter_map(|package| {
let tagged = tagged.get(package.id())?;
Drift::new(
package.id().clone(),
package.version().clone(),
tagged.clone(),
)
})
.collect()
}
#[must_use]
pub fn tagged_current(
workspace: &Workspace,
tagged: &BTreeMap<PackageId, Version>,
managed: impl Fn(&Package) -> bool,
) -> Vec<(PackageId, Version)> {
workspace
.packages()
.filter(|package| managed(package))
.filter_map(|package| {
let tagged = tagged.get(package.id())?;
(without_build(package.version()) == without_build(tagged))
.then(|| (package.id().clone(), tagged.clone()))
})
.collect()
}
#[must_use]
pub fn untagged_ahead(
workspace: &Workspace,
tagged: &BTreeMap<PackageId, Version>,
managed: impl Fn(&Package) -> bool,
) -> Vec<(PackageId, Version)> {
workspace
.packages()
.filter(|package| managed(package))
.filter(|package| !tagged.contains_key(package.id()))
.filter(|package| without_build(package.version()) > Version::new(0, 1, 0))
.map(|package| (package.id().clone(), package.version().clone()))
.collect()
}
fn without_build(version: &Version) -> Version {
let mut version = version.clone();
version.build = BuildMetadata::EMPTY;
version
}
enum Class {
Prefixed {
package: PackageId,
version: Version,
},
Bare(Version),
LooksLikeVersion,
Ambiguous,
Ignore,
}
enum PrefixedMatch {
Unique {
package: PackageId,
version: Version,
},
Ambiguous,
}
fn classify(tag: &str, workspace: &Workspace) -> Class {
if let Some(found) = match_prefixed(tag, workspace) {
return match found {
PrefixedMatch::Unique { package, version } => Class::Prefixed { package, version },
PrefixedMatch::Ambiguous => Class::Ambiguous,
};
}
if let Some(version) = bare_version(tag) {
return Class::Bare(version);
}
if looks_like_version(tag) {
Class::LooksLikeVersion
} else {
Class::Ignore
}
}
fn match_prefixed(tag: &str, workspace: &Workspace) -> Option<PrefixedMatch> {
let mut best: Option<(&str, Version)> = None;
for package in workspace.packages() {
let name = package.id().name.as_str();
let Some(version) = prefixed_version(name, tag) else {
continue;
};
if best.as_ref().is_none_or(|(n, _)| name.len() > n.len()) {
best = Some((name, version));
}
}
let (name, version) = best?;
Some(match unique_named(workspace, name) {
Some(package) => PrefixedMatch::Unique { package, version },
None => PrefixedMatch::Ambiguous,
})
}
fn prefixed_version(name: &str, tag: &str) -> Option<Version> {
let rest = tag.strip_prefix(name)?;
rest.strip_prefix('@')
.or_else(|| rest.strip_prefix("/v"))
.or_else(|| rest.strip_prefix("-v"))
.and_then(|s| Version::parse(s).ok())
}
fn unique_named(workspace: &Workspace, name: &str) -> Option<PackageId> {
let mut matches = workspace
.packages()
.filter(|package| package.id().name == name)
.map(|package| package.id().clone());
let first = matches.next()?;
match matches.next() {
Some(_) => None,
None => Some(first),
}
}
enum BareOwner {
None,
One(PackageId),
Many,
}
fn bare_owner(workspace: &Workspace, bare_candidate: &impl Fn(&PackageId) -> bool) -> BareOwner {
let mut packages = workspace
.packages()
.map(|package| package.id().clone())
.filter(|id| bare_candidate(id));
let Some(first) = packages.next() else {
return BareOwner::None;
};
match packages.next() {
Some(_) => BareOwner::Many,
None => BareOwner::One(first),
}
}
fn bare_version(tag: &str) -> Option<Version> {
tag.strip_prefix('v').and_then(|s| Version::parse(s).ok())
}
#[must_use]
pub fn looks_like_version(tag: &str) -> bool {
if Version::parse(tag).is_ok() || bare_version(tag).is_some() {
return true;
}
if suffix_is_version(tag, "@") || suffix_is_version(tag, "/v") || suffix_is_version(tag, "-v") {
return true;
}
if let Some((_, rest)) = tag.rsplit_once('/') {
if Version::parse(rest).is_ok() {
return true;
}
}
for (i, ch) in tag.char_indices() {
if ch == '-' {
let rest = &tag[i + 1..];
if Version::parse(rest).is_ok() || bare_version(rest).is_some() {
return true;
}
}
}
false
}
fn suffix_is_version(tag: &str, marker: &str) -> bool {
tag.rsplit_once(marker)
.is_some_and(|(_, rest)| Version::parse(rest).is_ok() || bare_version(rest).is_some())
}
#[must_use]
pub fn version_from_tag(tag: &str) -> Option<Version> {
if let Ok(version) = Version::parse(tag) {
return Some(version);
}
if let Some(version) = bare_version(tag) {
return Some(version);
}
for marker in ["@", "/v"] {
if let Some((_, rest)) = tag.rsplit_once(marker) {
if let Some(version) = version_suffix(rest) {
return Some(version);
}
}
}
for (i, _) in tag.match_indices("-v") {
if let Some(version) = version_suffix(&tag[i + 2..]) {
return Some(version);
}
}
tag.rsplit_once('/')
.and_then(|(_, rest)| Version::parse(rest).ok())
}
fn version_suffix(rest: &str) -> Option<Version> {
Version::parse(rest).ok().or_else(|| bare_version(rest))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::plan::{Ecosystem, Package, ResolvesDependenciesAt};
use alloc::string::ToString;
fn cargo_workspace(names: &[&str]) -> Workspace {
workspace(Ecosystem::Cargo, names)
}
fn npm_workspace(names: &[&str]) -> Workspace {
workspace(Ecosystem::Npm, names)
}
fn workspace(ecosystem: Ecosystem, names: &[&str]) -> Workspace {
workspace_publishability(
ecosystem,
&names.iter().map(|n| (*n, true)).collect::<Vec<_>>(),
)
}
fn workspace_publishability(ecosystem: Ecosystem, packages: &[(&str, bool)]) -> Workspace {
let packages: Vec<Package> = packages
.iter()
.map(|(name, publishable)| {
Package::new(
PackageId::new(ecosystem, *name),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
*publishable,
Vec::new(),
)
})
.collect();
Workspace::new(packages).expect("workspace")
}
fn resolve(
tags: &[&str],
workspace: &Workspace,
) -> Result<BTreeMap<PackageId, Version>, Leftover> {
resolve_commit_tags(tags, workspace, |_| true)
}
fn current(
commits: &[&[&str]],
workspace: &Workspace,
) -> Result<BTreeMap<PackageId, Version>, Leftover> {
current_versions(commits, workspace, |_| true)
}
fn ver(text: &str) -> Version {
Version::parse(text).expect("version")
}
fn id(ecosystem: Ecosystem, name: &str) -> PackageId {
PackageId::new(ecosystem, name)
}
#[test]
fn version_from_tag_reads_adr_0030_shapes() {
assert_eq!(version_from_tag("v1.2.3").as_ref(), Some(&ver("1.2.3")));
assert_eq!(
version_from_tag("demo@0.10.0").as_ref(),
Some(&ver("0.10.0"))
);
assert_eq!(
version_from_tag("linesmith-core-v0.2.0").as_ref(),
Some(&ver("0.2.0"))
);
assert_eq!(
version_from_tag("linesmith/v0.2.0").as_ref(),
Some(&ver("0.2.0"))
);
assert_eq!(version_from_tag("nightly"), None);
assert!(version_from_tag("demo@0.10.0").unwrap() > version_from_tag("demo@0.9.0").unwrap());
assert_eq!(
version_from_tag("pkg-v1.0.0-v1").as_ref(),
Some(&ver("1.0.0-v1"))
);
}
#[test]
fn scoped_changeset_is_not_a_knope_split_on_slash() {
let ws = npm_workspace(&["@jbabin91/mui-theme", "tt-package-demo-2"]);
let got = resolve(&["@jbabin91/mui-theme@1.4.3"], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Npm, "@jbabin91/mui-theme")),
Some(&ver("1.4.3"))
);
assert_eq!(got.len(), 1);
}
#[test]
fn unscoped_changeset_names_the_package() {
let ws = npm_workspace(&["pr-kit", "review-cycle"]);
let got = resolve(&["pr-kit@0.1.0"], &ws).expect("ok");
assert_eq!(got.len(), 1);
assert_eq!(got.get(&id(Ecosystem::Npm, "pr-kit")), Some(&ver("0.1.0")));
}
#[test]
fn scoped_and_unscoped_changeset_tags_on_one_commit() {
let ws = npm_workspace(&["@jbabin91/mui-theme", "tt-package-demo-2"]);
let got = resolve(
&["@jbabin91/mui-theme@1.4.3", "tt-package-demo-2@1.0.0"],
&ws,
)
.expect("ok");
assert_eq!(got.len(), 2);
assert_eq!(
got.get(&id(Ecosystem::Npm, "@jbabin91/mui-theme")),
Some(&ver("1.4.3"))
);
assert_eq!(
got.get(&id(Ecosystem::Npm, "tt-package-demo-2")),
Some(&ver("1.0.0"))
);
}
#[test]
fn knope_slash_and_release_plz_hyphen_collapse() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let tags = [
"v0.2.0",
"linesmith/v0.2.0",
"linesmith-core/v0.2.0",
"linesmith-core-v0.2.0",
];
let got = resolve(&tags, &ws).expect("7219fa6");
assert_eq!(got.len(), 2);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.2.0"))
);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith-core")),
Some(&ver("0.2.0"))
);
assert!(!got.contains_key(&id(Ecosystem::Cargo, "linesmith-plugin")));
}
#[test]
fn four_hyphen_and_slash_tags_are_three_packages() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let tags = [
"linesmith-v0.1.3",
"linesmith-core-v0.1.3",
"linesmith-plugin-v0.1.3",
"linesmith-plugin/v0.1.3",
];
let got = resolve(&tags, &ws).expect("3bbde7f");
assert_eq!(got.len(), 3);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.1.3"))
);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith-core")),
Some(&ver("0.1.3"))
);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith-plugin")),
Some(&ver("0.1.3"))
);
}
#[test]
fn bare_tag_alone_in_a_multi_package_workspace_is_leftover() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let err = resolve(&["v0.1.0"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string()]);
assert!(err.to_string().contains("v0.1.0"), "{err}");
assert!(err.to_string().contains("unverified"), "{err}");
}
#[test]
fn bare_tag_assigns_when_the_workspace_has_one_package() {
let ws = npm_workspace(&["tsc-files"]);
let got = resolve(&["v0.2.3"], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Npm, "tsc-files")),
Some(&ver("0.2.3"))
);
}
#[test]
fn bare_tag_is_ignored_when_no_tag_candidate_remains() {
let ws = workspace_publishability(
Ecosystem::Cargo,
&[("probe", false), ("other-probe", false)],
);
let got = resolve_commit_tags(&["v0.1.0"], &ws, |_| false).expect("ok");
assert!(got.is_empty());
}
#[test]
fn bare_tag_assigns_when_only_one_member_is_a_tag_candidate() {
let ws =
workspace_publishability(Ecosystem::Cargo, &[("oakum", true), ("plan-no-std", false)]);
let candidates: BTreeSet<_> = ws
.packages()
.filter(|package| package.publishable())
.map(|package| package.id().clone())
.collect();
let got = resolve_commit_tags(&["v0.1.0"], &ws, |id| candidates.contains(id)).expect("ok");
assert_eq!(got.get(&id(Ecosystem::Cargo, "oakum")), Some(&ver("0.1.0")));
assert!(!got.contains_key(&id(Ecosystem::Cargo, "plan-no-std")));
}
#[test]
fn bare_tag_assigns_when_a_publishable_sibling_is_excluded_from_candidates() {
let ws = cargo_workspace(&["alpha", "beta"]);
let candidates: BTreeSet<_> = [id(Ecosystem::Cargo, "alpha")].into_iter().collect();
let got =
resolve_commit_tags(&["v0.1.0"], &ws, |pkg| candidates.contains(pkg)).expect("ok");
assert_eq!(got.get(&id(Ecosystem::Cargo, "alpha")), Some(&ver("0.1.0")));
assert!(!got.contains_key(&id(Ecosystem::Cargo, "beta")));
}
#[test]
fn bare_tag_is_leftover_when_two_tag_candidates_remain() {
let ws = workspace_publishability(
Ecosystem::Cargo,
&[("oakum", true), ("sibling", true), ("probe", false)],
);
let candidates: BTreeSet<_> = ws
.packages()
.filter(|package| package.publishable())
.map(|package| package.id().clone())
.collect();
let err = resolve_commit_tags(&["v0.1.0"], &ws, |id| candidates.contains(id))
.expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string()]);
}
#[test]
fn unmanaged_prefixed_tag_does_not_cover_a_multi_candidate_bare() {
let ws = workspace_publishability(
Ecosystem::Cargo,
&[("oakum", true), ("sibling", true), ("probe", false)],
);
let candidates: BTreeSet<_> = ws
.packages()
.filter(|package| package.publishable())
.map(|package| package.id().clone())
.collect();
let err = resolve_commit_tags(&["probe/v0.1.0", "v0.1.0"], &ws, |id| {
candidates.contains(id)
})
.expect_err("leftover");
assert!(err.tags().contains(&"v0.1.0".to_string()), "{err:?}");
}
#[test]
fn empty_tags_are_ok() {
let ws = cargo_workspace(&["linesmith"]);
let got = resolve(&[], &ws).expect("ok");
assert!(got.is_empty());
}
#[test]
fn nightly_and_v1_are_ignored() {
let ws = cargo_workspace(&["linesmith"]);
let got = resolve(&["nightly", "v1"], &ws).expect("ok");
assert!(got.is_empty());
}
#[test]
fn fifth_shape_is_leftover_not_ignored() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["linesmith/0.4.1"], &ws).expect_err("fifth");
assert_eq!(err.tags(), &["linesmith/0.4.1".to_string()]);
}
#[test]
fn unprefixed_semver_is_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["1.0.0"], &ws).expect_err("fifth");
assert_eq!(err.tags(), &["1.0.0".to_string()]);
}
#[test]
fn unknown_package_shaped_tag_is_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["other-v1.0.0"], &ws).expect_err("unknown");
assert_eq!(err.tags(), &["other-v1.0.0".to_string()]);
}
#[test]
fn same_name_in_two_ecosystems_is_leftover() {
let packages = vec![
Package::new(
PackageId::new(Ecosystem::Cargo, "shared"),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
Package::new(
PackageId::new(Ecosystem::Npm, "shared"),
Version::new(1, 0, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
];
let ws = Workspace::new(packages).expect("workspace");
let err = resolve(&["shared@1.2.3"], &ws).expect_err("polyglot");
assert_eq!(err.tags(), &["shared@1.2.3".to_string()]);
}
#[test]
fn two_versions_for_one_package_on_one_commit_are_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["linesmith/v0.2.0", "linesmith/v0.3.0"], &ws).expect_err("conflict");
assert_eq!(
err.tags(),
&[
"linesmith/v0.2.0".to_string(),
"linesmith/v0.3.0".to_string()
]
);
}
#[test]
fn longer_package_name_wins_hyphen_prefix() {
let ws = cargo_workspace(&["linesmith", "linesmith-core"]);
let got = resolve(&["linesmith-core-v0.4.1"], &ws).expect("ok");
assert_eq!(got.len(), 1);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith-core")),
Some(&ver("0.4.1"))
);
}
#[test]
fn ignored_tags_do_not_hide_a_real_release() {
let ws = cargo_workspace(&["linesmith"]);
let got = resolve(&["nightly", "linesmith/v0.4.1"], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.4.1"))
);
}
#[test]
fn prerelease_hyphen_on_an_unknown_package_is_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["other-v1.0.0-beta.1"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["other-v1.0.0-beta.1".to_string()]);
}
#[test]
fn uncovered_bare_next_to_a_prefixed_tag_is_leftover() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let err = resolve(&["linesmith/v0.2.0", "v0.1.0"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string()]);
}
#[test]
fn leftover_on_a_mixed_commit_discards_the_attributed_package() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["linesmith/v0.2.0", "other-v1.0.0"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["other-v1.0.0".to_string()]);
}
#[test]
fn ignored_tag_does_not_drop_leftover() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let err = resolve(&["nightly", "v0.1.0"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string()]);
}
#[test]
fn hyphen_and_slash_at_different_versions_are_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["linesmith/v0.2.0", "linesmith-v0.3.0"], &ws).expect_err("conflict");
assert_eq!(
err.tags(),
&[
"linesmith-v0.3.0".to_string(),
"linesmith/v0.2.0".to_string()
]
);
}
#[test]
fn two_bare_versions_in_a_one_package_workspace_are_leftover() {
let ws = npm_workspace(&["tsc-files"]);
let err = resolve(&["v0.2.3", "v0.8.4"], &ws).expect_err("conflict");
assert_eq!(err.tags(), &["v0.2.3".to_string(), "v0.8.4".to_string()]);
}
#[test]
fn prefixed_and_bare_at_different_versions_are_leftover() {
let ws = npm_workspace(&["tsc-files"]);
let err = resolve(&["tsc-files@0.2.3", "v0.8.4"], &ws).expect_err("conflict");
assert_eq!(
err.tags(),
&["tsc-files@0.2.3".to_string(), "v0.8.4".to_string()]
);
}
#[test]
fn prefixed_and_bare_at_the_same_version_collapse() {
let ws = npm_workspace(&["tsc-files"]);
let got = resolve(&["tsc-files@0.2.3", "v0.2.3"], &ws).expect("ok");
assert_eq!(got.len(), 1);
assert_eq!(
got.get(&id(Ecosystem::Npm, "tsc-files")),
Some(&ver("0.2.3"))
);
}
#[test]
fn unknown_at_and_slash_v_prereleases_are_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err =
resolve(&["other@1.0.0-beta.1", "other/v1.0.0-beta.1"], &ws).expect_err("leftover");
assert_eq!(
err.tags(),
&[
"other/v1.0.0-beta.1".to_string(),
"other@1.0.0-beta.1".to_string()
]
);
}
#[test]
fn bare_tag_in_a_polyglot_workspace_is_leftover() {
let packages = vec![
Package::new(
PackageId::new(Ecosystem::Cargo, "shared"),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
Package::new(
PackageId::new(Ecosystem::Npm, "shared"),
Version::new(1, 0, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
];
let ws = Workspace::new(packages).expect("workspace");
let err = resolve(&["v1.2.3"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v1.2.3".to_string()]);
}
#[test]
fn hyphen_without_v_on_an_unknown_package_is_leftover() {
let ws = cargo_workspace(&["linesmith"]);
let err = resolve(&["other-1.0.0"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["other-1.0.0".to_string()]);
}
#[test]
fn two_uncovered_bares_in_a_multi_package_workspace_are_leftover() {
let ws = cargo_workspace(&["linesmith", "linesmith-core", "linesmith-plugin"]);
let err = resolve(&["v0.1.0", "v0.1.1"], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string(), "v0.1.1".to_string()]);
}
fn cargo_at(name: &str, version: &str) -> Workspace {
let packages = vec![Package::new(
PackageId::new(Ecosystem::Cargo, name),
ver(version),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
)];
Workspace::new(packages).expect("workspace")
}
#[test]
fn current_versions_takes_the_max_across_commits() {
let ws = cargo_workspace(&["linesmith"]);
let got = current(&[&["linesmith/v0.1.0"], &["linesmith/v0.2.0"]], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.2.0"))
);
let got = current(&[&["linesmith/v0.2.0"], &["linesmith/v0.1.0"]], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.2.0"))
);
}
#[test]
fn current_versions_keeps_packages_from_earlier_commits() {
let ws = cargo_workspace(&["linesmith", "linesmith-core"]);
let got = current(&[&["linesmith/v0.1.0"], &["linesmith-core/v0.2.0"]], &ws).expect("ok");
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith")),
Some(&ver("0.1.0"))
);
assert_eq!(
got.get(&id(Ecosystem::Cargo, "linesmith-core")),
Some(&ver("0.2.0"))
);
}
#[test]
fn leftover_on_any_commit_is_unverified_for_the_look() {
let ws = cargo_workspace(&["linesmith", "linesmith-core"]);
let err = current(&[&["linesmith/v0.2.0"], &["v0.1.0"]], &ws).expect_err("leftover");
assert_eq!(err.tags(), &["v0.1.0".to_string()]);
}
#[test]
fn tagged_current_when_manifest_matches_the_tag() {
let ws = cargo_at("linesmith", "0.1.0");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
let got = tagged_current(&ws, &tagged, Package::publishable);
assert_eq!(got, vec![(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
}
#[test]
fn tagged_current_skips_drift() {
let ws = cargo_at("linesmith", "0.2.0");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
assert!(tagged_current(&ws, &tagged, Package::publishable).is_empty());
}
#[test]
fn tagged_current_uses_the_tagged_version_not_build_metadata() {
let ws = cargo_at("linesmith", "0.1.0+local");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
assert_eq!(
tagged_current(&ws, &tagged, Package::publishable),
vec![(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]
);
}
#[test]
fn drift_when_manifest_is_above_the_tag() {
let ws = cargo_at("linesmith", "0.2.0");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
let got = drift(&ws, &tagged, Package::publishable);
assert_eq!(got.len(), 1);
assert_eq!(got[0].id(), &id(Ecosystem::Cargo, "linesmith"));
assert_eq!(got[0].manifest(), &ver("0.2.0"));
assert_eq!(got[0].tagged(), &ver("0.1.0"));
}
#[test]
fn drift_reports_only_the_package_that_is_ahead() {
let packages = vec![
Package::new(
PackageId::new(Ecosystem::Cargo, "ahead"),
ver("0.2.0"),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
Package::new(
PackageId::new(Ecosystem::Cargo, "ok"),
ver("0.1.0"),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
];
let ws = Workspace::new(packages).expect("workspace");
let tagged = BTreeMap::from([
(id(Ecosystem::Cargo, "ahead"), ver("0.1.0")),
(id(Ecosystem::Cargo, "ok"), ver("0.1.0")),
]);
let got = drift(&ws, &tagged, Package::publishable);
assert_eq!(got.len(), 1);
assert_eq!(got[0].id(), &id(Ecosystem::Cargo, "ahead"));
assert_eq!(got[0].manifest(), &ver("0.2.0"));
assert_eq!(got[0].tagged(), &ver("0.1.0"));
}
#[test]
fn no_drift_when_manifest_matches_or_is_behind() {
let ws = cargo_at("linesmith", "0.1.0");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
assert!(drift(&ws, &tagged, Package::publishable).is_empty());
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.2.0"))]);
assert!(drift(&ws, &tagged, Package::publishable).is_empty());
}
#[test]
fn no_tag_is_not_drift() {
let ws = cargo_at("linesmith", "0.2.0");
assert!(drift(&ws, &BTreeMap::new(), Package::publishable).is_empty());
}
#[test]
fn untagged_above_0_1_0_is_ahead() {
let ws = cargo_at("linesmith", "0.2.0");
let got = untagged_ahead(&ws, &BTreeMap::new(), Package::publishable);
assert_eq!(got, vec![(id(Ecosystem::Cargo, "linesmith"), ver("0.2.0"))]);
let ws = cargo_at("linesmith", "0.1.1");
let got = untagged_ahead(&ws, &BTreeMap::new(), Package::publishable);
assert_eq!(got, vec![(id(Ecosystem::Cargo, "linesmith"), ver("0.1.1"))]);
let ws = cargo_at("linesmith", "0.1.0");
assert!(untagged_ahead(&ws, &BTreeMap::new(), Package::publishable).is_empty());
let ws = cargo_at("linesmith", "0.0.0");
assert!(untagged_ahead(&ws, &BTreeMap::new(), Package::publishable).is_empty());
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
let ws = cargo_at("linesmith", "0.2.0");
assert!(untagged_ahead(&ws, &tagged, Package::publishable).is_empty());
let packages = vec![
Package::new(
PackageId::new(Ecosystem::Cargo, "demo"),
ver("0.1.0"),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
Package::new(
PackageId::new(Ecosystem::Cargo, "other"),
ver("0.2.0"),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
),
];
let ws = Workspace::new(packages).expect("workspace");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "demo"), ver("0.1.0"))]);
assert_eq!(
untagged_ahead(&ws, &tagged, Package::publishable),
vec![(id(Ecosystem::Cargo, "other"), ver("0.2.0"))]
);
}
#[test]
fn unpublishable_package_is_not_drift() {
let packages = vec![Package::new(
PackageId::new(Ecosystem::Cargo, "priv"),
ver("0.2.0"),
ResolvesDependenciesAt::Install,
false,
Vec::new(),
)];
let ws = Workspace::new(packages).expect("workspace");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "priv"), ver("0.1.0"))]);
assert!(drift(&ws, &tagged, Package::publishable).is_empty());
assert!(untagged_ahead(&ws, &BTreeMap::new(), Package::publishable).is_empty());
}
#[test]
fn build_metadata_does_not_count_as_ahead() {
let ws = cargo_at("linesmith", "0.1.0+local");
let tagged = BTreeMap::from([(id(Ecosystem::Cargo, "linesmith"), ver("0.1.0"))]);
assert!(drift(&ws, &tagged, Package::publishable).is_empty());
}
}