use std::collections::BTreeSet;
use oakum::plan::Workspace;
use semver::Version;
use super::owned_files::PrivatePackages;
use super::quoted;
const PACKAGE: &str = "{{ package }}";
const VERSION: &str = "{{ version }}";
pub(super) fn tag_managed_count(
workspace: Option<&Workspace>,
private_packages: PrivatePackages,
) -> usize {
workspace.map_or(0, |workspace| {
workspace
.packages()
.filter(|package| package.publishable() || private_packages.tag)
.count()
})
}
const BARE: &str = "v{{ version }}";
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct ReadableTemplate(&'static str);
impl ReadableTemplate {
fn lookup(template: &str) -> Option<Self> {
READABLE
.into_iter()
.find(|shape| *shape == template)
.map(Self)
}
pub(super) const fn as_str(self) -> &'static str {
self.0
}
const fn is_bare(self) -> bool {
matches!(self.0.as_bytes(), b"v{{ version }}")
}
}
const READABLE: [&str; 4] = [
"{{ package }}@{{ version }}",
"{{ package }}/v{{ version }}",
"{{ package }}-v{{ version }}",
"v{{ version }}",
];
fn offerable(tag_managed: usize) -> Vec<ReadableTemplate> {
READABLE
.into_iter()
.map(ReadableTemplate)
.filter(|shape| !shape.is_bare() || tag_managed <= 1)
.collect()
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum TagShape {
NoTags,
Unread(String),
Derived {
template: ReadableTemplate,
skipped: Vec<String>,
},
Undecided {
why: String,
offerable: Vec<ReadableTemplate>,
},
}
fn undecided(why: String, tag_managed: usize) -> TagShape {
TagShape::Undecided {
why,
offerable: offerable(tag_managed),
}
}
pub(super) fn derive(
tags: &[String],
workspace: Option<&Workspace>,
private_packages: PrivatePackages,
) -> TagShape {
let tag_managed = tag_managed_count(workspace, private_packages);
if tags.is_empty() {
return TagShape::NoTags;
}
let names: Vec<&str> = workspace
.map(|workspace| {
workspace
.packages()
.map(|package| package.id().name.as_str())
.collect()
})
.unwrap_or_default();
let mut agreed: Option<(&str, BTreeSet<String>)> = None;
let mut skipped: Vec<&str> = Vec::new();
for tag in tags {
let found = candidates(tag, &names);
if found.is_empty() {
if !oakum::tags::looks_like_version(tag) {
skipped.push(tag);
continue;
}
return undecided(unexplained(tag), tag_managed);
}
match agreed {
None => agreed = Some((tag, found)),
Some((first, ref settled)) => {
let narrowed = settled & &found;
if narrowed.is_empty() {
return undecided(
format!("`{first}` and `{tag}` are not the same shape"),
tag_managed,
);
}
agreed = Some((first, narrowed));
}
}
}
let Some((_, agreed)) = agreed else {
return undecided(all_moving(&skipped), tag_managed);
};
let mut settled = agreed.iter();
let (Some(template), None) = (settled.next(), settled.next()) else {
return undecided(
format!(
"the existing tags fit more than one shape ({})",
quoted(&agreed)
),
tag_managed,
);
};
let skipped: Vec<String> = skipped.into_iter().map(str::to_owned).collect();
if let Some(readable) = ReadableTemplate::lookup(template) {
if readable.is_bare() && tag_managed > 1 {
return undecided(
format!(
"the existing tags are shaped `{BARE}`, which names no package; \
{tag_managed} packages are tag-managed here, so a release cannot tell \
which one such a tag belongs to"
),
tag_managed,
);
}
return TagShape::Derived {
template: readable,
skipped,
};
}
undecided(
format!("the existing tags are shaped `{template}`, which oakum does not read"),
tag_managed,
)
}
fn unexplained(tag: &str) -> String {
format!("no package name and version explain `{tag}`")
}
fn all_moving(skipped: &[&str]) -> String {
format!(
"no tag here resolves to a package and a version oakum can read ({})",
quoted(skipped)
)
}
fn candidates(tag: &str, names: &[&str]) -> BTreeSet<String> {
let mut found = BTreeSet::new();
found.extend(package_less(tag));
for name in names {
if let Some(rest) = tag.strip_prefix(name) {
found.extend(prefixed(rest));
}
}
found
}
fn package_less(tag: &str) -> Option<String> {
if let Some(rest) = tag.strip_prefix('v') {
if Version::parse(rest).is_ok() {
return Some(format!("v{VERSION}"));
}
}
Version::parse(tag).is_ok().then(|| VERSION.to_owned())
}
fn prefixed(rest: &str) -> Vec<String> {
let mut found = Vec::new();
for (index, _) in rest.char_indices().skip(1) {
let (separator, tail) = rest.split_at(index);
if separator.chars().any(char::is_alphanumeric) {
break;
}
if tail
.strip_prefix('v')
.is_some_and(|version| Version::parse(version).is_ok())
{
found.push(format!("{PACKAGE}{separator}v{VERSION}"));
}
if Version::parse(tail).is_ok() {
found.push(format!("{PACKAGE}{separator}{VERSION}"));
}
}
found
}
#[cfg(test)]
mod derivation {
use oakum::plan::{Ecosystem, Package, PackageId, ResolvesDependenciesAt, Workspace};
use semver::Version;
use super::{derive, undecided, ReadableTemplate, TagShape, READABLE};
use crate::cli::owned_files::PrivatePackages;
use crate::cli::release::default_tag_template;
#[test]
fn release_defaults_are_spelled_the_way_this_module_spells_them() {
for managed in [0, 1, 2, 3] {
assert!(
ReadableTemplate::lookup(default_tag_template(managed)).is_some(),
"`release`'s default for {managed} tag-managed package(s) \
is not one of this module's readable shapes: {}",
default_tag_template(managed)
);
}
}
fn tag_all() -> PrivatePackages {
PrivatePackages {
version: true,
tag: true,
}
}
fn workspace(names: &[&str]) -> Workspace {
let packages: Vec<Package> = names
.iter()
.map(|name| {
Package::new(
PackageId::new(Ecosystem::Cargo, *name),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
)
})
.collect();
Workspace::new(packages).expect("workspace")
}
fn shape(tags: &[&str], names: &[&str]) -> TagShape {
let tags: Vec<String> = tags.iter().map(|tag| (*tag).to_owned()).collect();
derive(&tags, Some(&workspace(names)), tag_all())
}
fn derived(tags: &[&str], names: &[&str]) -> &'static str {
match shape(tags, names) {
TagShape::Derived { template, .. } => template.as_str(),
other => panic!("expected a derived shape for {tags:?}, got {other:?}"),
}
}
fn refused(tags: &[&str], names: &[&str]) -> String {
match shape(tags, names) {
TagShape::Undecided { why, .. } => why,
other => panic!("expected a refusal for {tags:?}, got {other:?}"),
}
}
#[test]
fn every_readable_shape_derives() {
assert_eq!(
derived(
&["review-cycle@0.17.0", "prose@0.1.0"],
&["review-cycle", "prose"]
),
"{{ package }}@{{ version }}"
);
assert_eq!(
derived(&["linesmith/v0.2.0"], &["linesmith"]),
"{{ package }}/v{{ version }}"
);
assert_eq!(
derived(&["linesmith-core-v0.1.3"], &["linesmith", "linesmith-core"]),
"{{ package }}-v{{ version }}"
);
assert_eq!(derived(&["v0.1.0", "v0.2.0"], &["oakum"]), "v{{ version }}");
}
#[test]
fn a_scoped_npm_name_is_one_package_name_not_a_separator() {
let packages = vec![Package::new(
PackageId::new(Ecosystem::Npm, "@jbabin91/mui-theme"),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
Vec::new(),
)];
let workspace = Workspace::new(packages).expect("workspace");
let tags = vec![String::from("@jbabin91/mui-theme@1.4.0")];
assert_eq!(
derive(&tags, Some(&workspace), tag_all()),
TagShape::Derived {
template: ReadableTemplate::lookup("{{ package }}@{{ version }}")
.expect("readable"),
skipped: Vec::new(),
}
);
}
#[test]
fn a_prerelease_tag_derives_the_same_shape() {
assert_eq!(
derived(&["oakum@0.2.0-rc.1", "oakum@0.1.0"], &["oakum"]),
"{{ package }}@{{ version }}"
);
}
#[test]
fn a_sibling_prefix_name_does_not_explain_a_longer_package_tag() {
assert_eq!(
derived(&["linesmith-core@0.2.0"], &["linesmith", "linesmith-core"]),
"{{ package }}@{{ version }}"
);
}
#[test]
fn tags_that_disagree_derive_nothing() {
let why = refused(
&["linesmith/v0.2.0", "linesmith-core-v0.1.3"],
&["linesmith", "linesmith-core"],
);
assert_eq!(
why,
"`linesmith/v0.2.0` and `linesmith-core-v0.1.3` are not the same shape"
);
}
#[test]
fn a_moving_tag_does_not_cancel_the_shape_the_rest_agree_on() {
for tag in ["nightly", "v1", "latest", "release-2024-01-01"] {
assert_eq!(
derived(&["oakum@0.1.0", tag], &["oakum"]),
"{{ package }}@{{ version }}",
"`{tag}` should have been skipped"
);
}
}
#[test]
fn a_history_of_only_moving_tags_is_undecided_and_names_them() {
let shape = shape(&["v1", "latest"], &["oakum"]);
let TagShape::Undecided { why, .. } = &shape else {
panic!("expected Undecided, got {shape:?}");
};
assert_eq!(
why,
"no tag here resolves to a package and a version oakum can read (`v1`, `latest`)"
);
}
#[test]
fn a_version_tag_for_an_unknown_package_is_still_unexplained() {
assert_eq!(
refused(&["oakum@0.1.0", "stranger@2.0.0"], &["oakum"]),
"no package name and version explain `stranger@2.0.0`"
);
}
#[test]
fn a_disagreement_names_the_first_tag_that_was_not_skipped() {
assert_eq!(
refused(
&["latest", "linesmith/v0.2.0", "linesmith-core-v0.1.3"],
&["linesmith", "linesmith-core"]
),
"`linesmith/v0.2.0` and `linesmith-core-v0.1.3` are not the same shape"
);
}
#[test]
fn a_shape_oakum_cannot_read_back_derives_nothing() {
let why = refused(&["oakum_1.0.0", "oakum_1.1.0"], &["oakum"]);
assert_eq!(
why,
"the existing tags are shaped `{{ package }}_{{ version }}`, which oakum does not read"
);
let slash_without_v = refused(&["oakum/1.0.0"], &["oakum"]);
assert_eq!(
slash_without_v,
"the existing tags are shaped `{{ package }}/{{ version }}`, which oakum does not read"
);
}
#[test]
fn one_tag_managed_package_is_offered_the_bare_shape_too() {
let tags = vec![String::from("oakum_1.0.0"), String::from("oakum_1.1.0")];
let TagShape::Undecided { offerable, .. } =
derive(&tags, Some(&workspace(&["oakum"])), tag_all())
else {
panic!("a shape oakum cannot read derives nothing");
};
assert!(
offerable.iter().any(|shape| shape.is_bare()),
"{offerable:?}"
);
assert_eq!(offerable.len(), READABLE.len());
}
#[test]
fn a_v_prefix_and_a_v_bearing_separator_are_one_template() {
assert_eq!(
derived(&["oakum-v1.0.0"], &["oakum"]),
"{{ package }}-v{{ version }}"
);
}
#[test]
fn a_tag_two_package_names_split_differently_derives_nothing() {
let why = refused(&["oakum.@1.0.0"], &["oakum", "oakum."]);
assert_eq!(
why,
"the existing tags fit more than one shape (`{{ package }}.@{{ version }}`, `{{ package }}@{{ version }}`)"
);
}
#[test]
fn no_tags_is_not_a_refusal() {
assert_eq!(
derive(&[], Some(&workspace(&["oakum"])), tag_all()),
TagShape::NoTags
);
}
#[test]
fn without_a_workspace_only_package_less_shapes_derive() {
let bare = vec![String::from("v0.1.0")];
assert_eq!(
derive(&bare, None, tag_all()),
TagShape::Derived {
template: ReadableTemplate::lookup("v{{ version }}").expect("readable"),
skipped: Vec::new(),
}
);
let prefixed = vec![String::from("oakum@0.1.0")];
assert_eq!(
derive(&prefixed, None, tag_all()),
undecided(
String::from("no package name and version explain `oakum@0.1.0`"),
0,
)
);
}
#[test]
fn a_bare_shape_is_undecided_when_more_than_one_package_is_tag_managed() {
let tags = vec![String::from("v0.1.0"), String::from("v0.2.0")];
let single = derive(&tags, Some(&workspace(&["alpha"])), tag_all());
assert_eq!(
single,
TagShape::Derived {
template: ReadableTemplate::lookup("v{{ version }}").expect("readable"),
skipped: Vec::new(),
}
);
let TagShape::Undecided { why, offerable } =
derive(&tags, Some(&workspace(&["alpha", "beta"])), tag_all())
else {
panic!("two tag-managed packages cannot own one bare tag");
};
assert!(why.contains("names no package"), "{why}");
assert!(why.contains("2 packages are tag-managed"), "{why}");
assert!(
!offerable.iter().any(|shape| shape.is_bare()),
"a refusal naming bare as unusable cannot offer it: {offerable:?}"
);
assert_eq!(offerable.len(), READABLE.len() - 1);
}
#[test]
fn a_package_less_tag_without_the_v_derives_nothing() {
let why = refused(&["0.1.0", "0.2.0"], &["oakum"]);
assert_eq!(
why,
"the existing tags are shaped `{{ version }}`, which oakum does not read"
);
}
}