use std::collections::BTreeSet;
use clap::Args;
use oakum::plan::{PackageId, Workspace};
use oakum::tags::Drift;
use semver::Version;
use super::changelog;
use super::config::{load_config, require_config, tag_managed_ids, LoadedConfig, PlanIntentSource};
use super::coverage;
use super::fs::{repo_path_display, stray_staging_files, stray_staging_message};
use super::git::Git;
use super::install_pin;
use super::intent::load_plan_bump_files;
use super::repository::{self, Repository};
use super::tags::{self, CommitTags};
use super::version::extra_file_repo_path;
use super::{add, CliError};
#[derive(Debug)]
pub(super) struct TagEvaluation {
drift: Vec<Drift>,
untagged_ahead: Vec<(PackageId, Version)>,
current: Vec<(PackageId, Version)>,
}
#[derive(Clone, Debug)]
pub(super) struct PendingRelease {
id: PackageId,
version: Version,
}
impl PendingRelease {
#[must_use]
pub(super) fn new(id: PackageId, version: Version) -> Self {
Self { id, version }
}
#[must_use]
pub(super) fn id(&self) -> &PackageId {
&self.id
}
#[must_use]
pub(super) fn version(&self) -> &Version {
&self.version
}
}
impl TagEvaluation {
#[must_use]
pub(super) fn is_clean(&self) -> bool {
self.drift.is_empty() && self.untagged_ahead.is_empty()
}
#[must_use]
pub(super) fn pending(&self) -> Vec<PendingRelease> {
let mut pending: Vec<PendingRelease> = self
.drift
.iter()
.map(|item| PendingRelease::new(item.id().clone(), item.manifest().clone()))
.chain(
self.untagged_ahead
.iter()
.map(|(id, version)| PendingRelease::new(id.clone(), version.clone())),
)
.collect();
pending.sort_by(|left, right| left.id.cmp(&right.id));
pending
}
#[must_use]
pub(super) fn current(&self) -> Vec<PendingRelease> {
let mut current: Vec<PendingRelease> = self
.current
.iter()
.map(|(id, version)| PendingRelease::new(id.clone(), version.clone()))
.collect();
current.sort_by(|left, right| left.id.cmp(&right.id));
current
}
}
#[derive(Debug, Args)]
pub(super) struct CheckArgs {
#[arg(long)]
strict: bool,
#[arg(long, value_name = "REF")]
from: Option<String>,
#[arg(long)]
remote: bool,
#[arg(
long,
default_value_t = 3,
value_name = "N",
value_parser = clap::value_parser!(u32).range(1..=20),
requires = "remote"
)]
remote_lookback: u32,
}
pub(super) fn run(args: &CheckArgs) -> Result<(), CliError> {
let repo = repository::discover().map_err(CliError::from_boxed)?;
let config = load_config(&repo).map_err(CliError::from_boxed)?;
require_config(&config)?;
let loaded = Loaded::discover(&repo, config)?;
let git = Git::at_repository(&repo).map_err(CliError::from_boxed)?;
let tags = evaluate_with(
&git,
&repo,
&loaded,
args.from.as_deref(),
args.strict,
args.remote,
args.remote_lookback,
)?;
let changelogs = evaluate_changelogs(&repo, &loaded);
let staging = evaluate_staging(&repo, &loaded);
if !tags.is_clean() {
report_pending(&tags);
}
changelogs?;
staging?;
refuse_if_pending(&tags)
}
fn evaluate_staging(repo: &Repository, loaded: &Loaded) -> Result<(), CliError> {
let mut dirs: BTreeSet<String> = [String::from(".changeset"), String::from(".")].into();
for package in loaded.workspace.packages() {
let dir = package.manifest_dir();
if !dir.is_empty() {
dirs.insert(dir.to_owned());
}
for extra in loaded.config.extra_files_for(&package.id().name) {
let path = extra_file_repo_path(package, extra.path()).map_err(CliError::from_boxed)?;
let parent = path.parent().map(repo_path_display).unwrap_or_default();
dirs.insert(if parent.is_empty() {
String::from(".")
} else {
parent
});
}
}
let mut strays = Vec::new();
for sub in &dirs {
strays.extend(stray_staging_files(repo.dir(), sub).map_err(CliError::from_boxed)?);
}
if strays.is_empty() {
return Ok(());
}
for path in &strays {
eprintln!("{}", stray_staging_message(path));
}
Err(CliError::unverified(format!(
"unverified: {} oakum staging file(s) left behind",
strays.len()
)))
}
struct Loaded {
config: LoadedConfig,
workspace: Workspace,
}
impl Loaded {
fn load(repo: &Repository) -> Result<Self, CliError> {
let config = load_config(repo).map_err(CliError::from_boxed)?;
Self::discover(repo, config)
}
fn discover(repo: &Repository, config: LoadedConfig) -> Result<Self, CliError> {
let workspace = add::discover_workspace(repo).map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
Ok(Self { config, workspace })
}
}
fn evaluate_changelogs(repo: &Repository, loaded: &Loaded) -> Result<(), CliError> {
let reports = changelog::foreign_changelogs(repo.dir(), &loaded.workspace, |package| {
loaded.config.version_managed(package)
})
.map_err(|err| CliError::unverified(format!("unverified: {err}")))?;
if reports.is_empty() {
return Ok(());
}
for report in &reports {
eprintln!("{report}");
}
Err(CliError::unverified(format!(
"unverified: {} changelog(s) `oakum version` would refuse to append to",
reports.len()
)))
}
pub(super) fn run_tags_only() -> Result<(), CliError> {
let repo = repository::discover().map_err(CliError::from_boxed)?;
let git = Git::at_repository(&repo).map_err(CliError::from_boxed)?;
let tags = evaluate_tags(&git, &repo, &Loaded::load(&repo)?)?;
if !tags.is_clean() {
report_pending(&tags);
}
refuse_if_pending(&tags)
}
pub(super) fn evaluate(
git: &Git,
repo: &Repository,
from: Option<&str>,
strict: bool,
remote: bool,
remote_lookback: u32,
) -> Result<TagEvaluation, CliError> {
let loaded = Loaded::load(repo)?;
evaluate_with(git, repo, &loaded, from, strict, remote, remote_lookback)
}
fn evaluate_with(
git: &Git,
repo: &Repository,
loaded: &Loaded,
from: Option<&str>,
strict: bool,
remote: bool,
remote_lookback: u32,
) -> Result<TagEvaluation, CliError> {
let tags = evaluate_tags(git, repo, loaded)?;
evaluate_coverage(git, repo, loaded, from, strict)?;
evaluate_remote(git, remote, remote_lookback)?;
Ok(tags)
}
fn refuse_if_pending(tags: &TagEvaluation) -> Result<(), CliError> {
if tags.is_clean() {
return Ok(());
}
Err(CliError::tag_drift(
tags.drift.len() + tags.untagged_ahead.len(),
))
}
fn report_pending(tags: &TagEvaluation) {
for item in &tags.drift {
eprintln!(
"{}: manifest {} is above tagged {} (local tags; run `git fetch --tags` if the remote is ahead)",
item.id(),
item.manifest(),
item.tagged()
);
}
for (id, version) in &tags.untagged_ahead {
eprintln!("{id}: never released, but the manifest is {version}; tag the version you meant");
}
}
fn evaluate_tags(git: &Git, repo: &Repository, loaded: &Loaded) -> Result<TagEvaluation, CliError> {
let _ = repo.ambient_path().map_err(CliError::from_boxed)?;
let Loaded { config, workspace } = loaded;
if let Some(expected) = config.tool_version() {
install_pin::verify(repo.dir(), expected)?;
}
let _ = config.plan_intent_source()?;
let groups = tags::reachable_tags(git)?;
let owned: Vec<Vec<&str>> = groups
.iter()
.map(CommitTags::tags)
.map(|tags| tags.iter().map(String::as_str).collect())
.collect();
let slices: Vec<&[&str]> = owned.iter().map(Vec::as_slice).collect();
let bare_candidates = tag_managed_ids(workspace, config);
let tagged =
oakum::tags::current_versions(&slices, workspace, |id| bare_candidates.contains(id))
.map_err(|err| CliError::unverified(err.to_string()))?;
Ok(TagEvaluation {
drift: oakum::tags::drift(workspace, &tagged, |package| config.tag_managed(package)),
untagged_ahead: oakum::tags::untagged_ahead(workspace, &tagged, |package| {
config.tag_managed(package)
}),
current: oakum::tags::tagged_current(workspace, &tagged, |package| {
config.tag_managed(package)
}),
})
}
fn evaluate_coverage(
git: &Git,
repo: &Repository,
loaded: &Loaded,
from: Option<&str>,
strict: bool,
) -> Result<(), CliError> {
let Loaded { config, workspace } = loaded;
let files =
load_plan_bump_files(git, repo, workspace, config, from).map_err(CliError::from_boxed)?;
let uncovered = coverage::uncovered_packages(git, workspace, &files, from, |package| {
config.version_managed(package)
})?;
if uncovered.is_empty() {
return Ok(());
}
let hint = match config.plan_intent_source()? {
PlanIntentSource::ChangeFiles => {
"add a bump file (or `none` / empty frontmatter under --strict)"
}
PlanIntentSource::CommitsOnly => {
"name the package in a conventional commit (or a path that maps to it)"
}
};
for id in &uncovered {
eprintln!("{id}: changed with no covering intent; {hint}");
}
if strict {
return Err(CliError::uncovered(uncovered.len()));
}
Ok(())
}
fn evaluate_remote(git: &Git, remote: bool, remote_lookback: u32) -> Result<(), CliError> {
if !remote {
return Ok(());
}
let Some(remote) = tags::first_remote(git)? else {
return Err(CliError::unverified(
"unverified: --remote set but this repository has no remotes",
));
};
let advertised = tags::remote_tag_names(git, &remote)?;
let local = tags::reachable_tags(git)?;
let local_names: BTreeSet<String> = local.iter().flat_map(CommitTags::tags).cloned().collect();
if local_names.is_empty() {
if advertised.is_empty() {
return Ok(());
}
return Err(CliError::unverified(format!(
"unverified: remote {remote:?} advertises tags but none are reachable locally; \
run `git fetch --tags -- {remote}` (a prior fetch --no-tags leaves no local tagOpt to detect)"
)));
}
let lookback = remote_lookback as usize;
let missing: Vec<String> = newest_local_tags(&local_names, lookback)
.into_iter()
.filter(|name| !advertised.contains(name))
.collect();
if missing.is_empty() {
return Ok(());
}
Err(CliError::unverified(format!(
"unverified: newest local tags missing from remote {remote:?}: {}; \
push the tags (`git push --tags -- {remote}`) or confirm the remote did not drop them",
missing.join(", ")
)))
}
fn newest_local_tags(local: &BTreeSet<String>, n: usize) -> Vec<String> {
let mut tags: Vec<String> = local.iter().cloned().collect();
tags.sort_by(|left, right| compare_tag_names(left, right));
let skip = tags.len().saturating_sub(n);
tags.into_iter().skip(skip).collect()
}
fn compare_tag_names(left: &str, right: &str) -> std::cmp::Ordering {
match (tag_version(left), tag_version(right)) {
(Some(left), Some(right)) => left.cmp(&right),
(Some(_), None) => std::cmp::Ordering::Greater,
(None, Some(_)) => std::cmp::Ordering::Less,
(None, None) => left.cmp(right),
}
}
fn tag_version(name: &str) -> Option<semver::Version> {
oakum::tags::version_from_tag(name)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn newest_local_tags_orders_changeset_and_hyphen_shapes() {
let names = BTreeSet::from([
"demo@0.9.0".into(),
"demo@0.10.0".into(),
"demo-v0.11.0".into(),
"other/v0.8.0".into(),
]);
assert_eq!(
newest_local_tags(&names, 3),
vec![
"demo@0.9.0".to_string(),
"demo@0.10.0".to_string(),
"demo-v0.11.0".to_string(),
]
);
}
#[test]
fn newest_local_tags_keeps_hyphen_prerelease_starting_with_v() {
let names = BTreeSet::from([
"demo@0.9.0".into(),
"demo@0.10.0".into(),
"demo-v1.0.0-v1".into(),
"other/v0.8.0".into(),
]);
assert_eq!(
newest_local_tags(&names, 3),
vec![
"demo@0.9.0".to_string(),
"demo@0.10.0".to_string(),
"demo-v1.0.0-v1".to_string(),
]
);
}
}