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::{
intent_names_unmanaged, load_config, require_config, tag_managed_ids, LoadedConfig,
PlanIntentSource, ALL_PRIVATE_GUIDANCE,
};
use super::coverage;
use super::fs::{repo_path_display, stray_staging_files, stray_staging_message};
use super::git::{Git, Op};
use super::install_pin;
use super::intent::load_plan_bump_files;
use super::repository::{self, Repository};
use super::tags::{self, CommitTags};
use super::verdict::{carry, first_line, named, LookReport, Refusal};
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 plan = LookPlan::check(args.remote);
let scope = Scope::of(&git, &loaded, args, &plan);
super::say_out(&scope.to_string());
let context = LookContext {
git: &git,
repo: &repo,
loaded: &loaded,
base: scope.base.as_deref().map_err(String::as_str),
strict: Some(args.strict),
remote_lookback: Some(args.remote_lookback),
};
plan.decide(&context).map(|_| ())
}
#[derive(Clone, Copy)]
struct Look {
name: &'static str,
run: fn(&LookContext<'_>) -> LookReport,
}
struct LookContext<'a> {
git: &'a Git,
repo: &'a Repository,
loaded: &'a Loaded,
base: Result<&'a str, &'a str>,
strict: Option<bool>,
remote_lookback: Option<u32>,
}
#[derive(Clone, Copy)]
struct TagLook {
name: &'static str,
run: fn(&LookContext<'_>) -> Result<(TagEvaluation, LookReport), CliError>,
}
const BEFORE_TAGS: [Look; 1] = [MANAGEMENT];
const AFTER_TAGS: [Look; 4] = [INSTALL_PIN, CHANGELOGS, STAGING, COVERAGE];
struct LookPlan {
before: &'static [Look],
tag: TagLook,
after: Vec<Look>,
}
impl LookPlan {
fn check(remote: bool) -> Self {
Self {
before: &BEFORE_TAGS,
tag: TAGS,
after: AFTER_TAGS
.into_iter()
.chain(remote.then_some(REMOTE))
.collect(),
}
}
fn tag_drift() -> Self {
Self {
before: &[],
tag: TAGS,
after: Vec::from([INSTALL_PIN]),
}
}
fn release() -> Self {
Self {
before: &[],
tag: RELEASE_TAGS,
after: Vec::from([INSTALL_PIN, COVERAGE]),
}
}
fn names(&self) -> Vec<&'static str> {
self.before
.iter()
.map(|look| look.name)
.chain(std::iter::once(self.tag.name))
.chain(self.after.iter().map(|look| look.name))
.collect()
}
fn runs_remote(&self) -> bool {
self.names().contains(&REMOTE.name)
}
fn listed_names(&self) -> Vec<&'static str> {
self.names()
.into_iter()
.filter(|name| *name != REMOTE.name)
.collect()
}
}
const MANAGEMENT: Look = Look {
name: "management",
run: |context| evaluate_management(context.loaded),
};
const TAGS: TagLook = TagLook {
name: "tags",
run: look_tags_and_pending,
};
const RELEASE_TAGS: TagLook = TagLook {
name: "tags",
run: |context| {
Ok((
evaluate_tags(context.git, context.repo, context.loaded)?,
LookReport::default(),
))
},
};
const INSTALL_PIN: Look = Look {
name: "install pin",
run: |context| LookReport::from_result(evaluate_install_pin(context.repo, context.loaded)),
};
const CHANGELOGS: Look = Look {
name: "changelogs",
run: |context| evaluate_changelogs(context.repo, context.loaded),
};
const STAGING: Look = Look {
name: "staging",
run: |context| evaluate_staging(context.repo, context.loaded),
};
const COVERAGE: Look = Look {
name: "coverage",
run: |context| match context.strict {
Some(strict) => evaluate_coverage(
context.git,
context.repo,
context.loaded,
context.base,
strict,
),
None => LookReport::from_result(Err(CliError::unverified(
"unverified: the coverage look ran without a strictness decision, so it did not look",
))),
},
};
const REMOTE: Look = Look {
name: "remote",
run: |context| {
LookReport::from_result(match context.remote_lookback {
Some(lookback) => evaluate_remote(context.git, lookback),
None => Err(CliError::unverified(
"unverified: the remote look ran without a lookback, so it did not look",
)),
})
},
};
fn look_tags_and_pending(
context: &LookContext<'_>,
) -> Result<(TagEvaluation, LookReport), CliError> {
let tags = evaluate_tags(context.git, context.repo, context.loaded)?;
let refusals = refuse_if_pending(&tags)
.err()
.map(|error| Refusal {
error,
lines: pending_lines(&tags),
})
.into_iter()
.collect();
Ok((tags, LookReport::refusing(refusals)))
}
impl LookPlan {
fn decide(&self, context: &LookContext<'_>) -> Result<TagEvaluation, CliError> {
let mut reports = Vec::new();
for look in self.before {
reports.push((look.run)(context));
}
let evaluation = match (self.tag.run)(context) {
Ok((tags, report)) => {
reports.push(report);
Some(tags)
}
Err(refusal) => {
reports.push(LookReport::from_result(Err(refusal)));
None
}
};
for look in &self.after {
reports.push((look.run)(context));
}
let (said, verdict) = carry(reports);
for line in &said {
super::say_err(line);
}
match (verdict, evaluation) {
(Some(refusal), _) => Err(refusal),
(None, Some(tags)) => Ok(tags),
(None, None) => Err(CliError::unverified(format!(
"unverified: the `{}` look neither answered nor refused",
self.tag.name
))),
}
}
}
struct Scope {
selected: usize,
packages: usize,
base: Result<String, String>,
gating_coverage: bool,
remote: bool,
look_names: Vec<&'static str>,
}
impl Scope {
fn of(git: &Git, loaded: &Loaded, args: &CheckArgs, plan: &LookPlan) -> Self {
let Loaded { config, workspace } = loaded;
let packages = workspace.packages().count();
let selected = workspace
.packages()
.filter(|package| config.selected(&package.id().name))
.count();
debug_assert!(selected <= packages, "{selected} of {packages}");
Self {
selected,
packages,
base: resolved_base(git, args.from.as_deref()),
gating_coverage: args.strict,
remote: plan.runs_remote(),
look_names: plan.listed_names(),
}
}
}
fn resolved_base(git: &Git, from: Option<&str>) -> Result<String, String> {
let base = super::generate::resolve_from_ref(git, from).map_err(|err| err.to_string())?;
match git.predicate(Op::RefExists { reference: &base }) {
Ok(true) => Ok(base),
Ok(false) => Err(format!("git has no `{base}`")),
Err(err) => Err(err.detail()),
}
}
impl std::fmt::Display for Scope {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self {
selected, packages, ..
} = self;
write!(f, "check: {selected} of {packages} package(s) selected")?;
match &self.base {
Ok(base) => write!(f, ", diffing `{base}...HEAD`")?,
Err(why) => write!(f, "; no base ref to diff from ({})", first_line(why))?,
}
write!(f, "\ncheck: looking at {}", named(&self.look_names))?;
if self.base.is_err() {
f.write_str("; coverage cannot run without a base ref")?;
} else if !self.gating_coverage {
f.write_str("; coverage reports without gating (`--strict` gates)")?;
}
if self.remote {
return write!(f, "; looking at the {}", REMOTE.name);
}
write!(
f,
"; not looking at the {} (`--remote` asks for it)",
REMOTE.name
)
}
}
fn evaluate_staging(repo: &Repository, loaded: &Loaded) -> LookReport {
match staging_refusal(repo, loaded) {
Ok(report) => report,
Err(refusal) => LookReport::from_result(Err(refusal)),
}
}
fn staging_refusal(repo: &Repository, loaded: &Loaded) -> Result<LookReport, 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(LookReport::default());
}
Ok(LookReport::refusing(vec![Refusal {
error: CliError::unverified(format!(
"unverified: {} oakum staging file(s) left behind",
strays.len()
)),
lines: strays
.iter()
.map(|path| stray_staging_message(path))
.collect(),
}]))
}
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) -> LookReport {
let reports = match changelog::foreign_changelogs(repo.dir(), &loaded.workspace, |package| {
loaded.config.version_managed(package)
}) {
Ok(reports) => reports,
Err(err) => {
return LookReport::from_result(Err(CliError::unverified(format!("unverified: {err}"))))
}
};
if reports.is_empty() {
return LookReport::default();
}
LookReport::refusing(vec![Refusal {
error: CliError::unverified(format!(
"unverified: {} changelog(s) `oakum version` would refuse to append to",
reports.len()
)),
lines: reports,
}])
}
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 loaded = Loaded::load(&repo)?;
let context = LookContext {
git: &git,
repo: &repo,
loaded: &loaded,
base: Err("tag-drift does not diff"),
strict: None,
remote_lookback: None,
};
LookPlan::tag_drift().decide(&context).map(|_| ())
}
const NOT_STRICTLY: Option<bool> = Some(false);
pub(super) fn evaluate(
git: &Git,
repo: &Repository,
from: Option<&str>,
) -> Result<TagEvaluation, CliError> {
let loaded = Loaded::load(repo)?;
let base = resolved_base(git, from);
let context = LookContext {
git,
repo,
loaded: &loaded,
base: base.as_deref().map_err(String::as_str),
strict: NOT_STRICTLY,
remote_lookback: None,
};
LookPlan::release().decide(&context)
}
pub(super) fn selection_is_empty(config: &LoadedConfig, workspace: &Workspace) -> bool {
!workspace
.packages()
.any(|package| config.selected(&package.id().name))
}
pub(super) fn manages_nothing(config: &LoadedConfig, workspace: &Workspace) -> bool {
let mut selected = workspace
.packages()
.filter(|package| config.selected(&package.id().name))
.peekable();
if selected.peek().is_none() {
return false;
}
!selected.any(|package| config.version_managed(package) || config.tag_managed(package))
}
fn evaluate_management(loaded: &Loaded) -> LookReport {
let Loaded { config, workspace } = loaded;
if !manages_nothing(config, workspace) {
return LookReport::default();
}
LookReport::refusing(vec![Refusal {
error: CliError::unverified(String::from(
"unverified: this config manages no package on either axis",
)),
lines: vec![String::from(ALL_PRIVATE_GUIDANCE)],
}])
}
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 pending_lines(tags: &TagEvaluation) -> Vec<String> {
let drift = tags.drift.iter().map(|item| {
format!(
"{}: manifest {} is above tagged {} (local tags; run `git fetch --tags` if the remote is ahead)",
item.id(),
item.manifest(),
item.tagged()
)
});
let untagged = tags.untagged_ahead.iter().map(|(id, version)| {
format!("{id}: never released, but the manifest is {version}; tag the version you meant")
});
drift.chain(untagged).collect()
}
fn evaluate_install_pin(repo: &Repository, loaded: &Loaded) -> Result<(), CliError> {
match loaded.config.tool_version() {
Some(expected) => install_pin::verify(repo.dir(), expected),
None => Ok(()),
}
}
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;
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 intent_named_unmanaged(
config: &LoadedConfig,
workspace: &Workspace,
files: &[oakum::plan::BumpFile],
) -> Vec<PackageId> {
let mut named = BTreeSet::new();
for file in files {
for (id, _) in &file.entries {
if workspace
.get(id)
.is_some_and(|package| !config.version_managed(package))
{
named.insert(id.clone());
}
}
}
named.into_iter().collect()
}
fn evaluate_coverage(
git: &Git,
repo: &Repository,
loaded: &Loaded,
base: Result<&str, &str>,
strict: bool,
) -> LookReport {
match coverage_refusals(git, repo, loaded, base, strict) {
Ok(report) => report,
Err(refusal) => LookReport::from_result(Err(refusal)),
}
}
fn coverage_refusals(
git: &Git,
repo: &Repository,
loaded: &Loaded,
base: Result<&str, &str>,
strict: bool,
) -> Result<LookReport, CliError> {
let from = Some(base.map_err(|why| CliError::unverified(format!("unverified: {why}")))?);
let Loaded { config, workspace } = loaded;
let files =
load_plan_bump_files(git, repo, workspace, config, from).map_err(CliError::from_boxed)?;
let source = config.plan_intent_source()?;
let coverage::Uncovered {
committed:
oakum::state::Coverage {
uncovered,
unmanaged: _,
},
outside_head,
} = coverage::changed_by_standing_and_unseen(
git,
workspace,
&files,
from,
matches!(source, PlanIntentSource::ChangeFiles),
|package| config.standing(package),
)?;
let hint = match 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)"
}
};
let (unseen, unreadable_worktree) = match outside_head {
Ok(unseen) => (unseen.lines(hint), None),
Err(err) => (
Vec::new(),
Some(format!(
"the working tree could not be read, so this run looked only at commits: {}",
err.detail()
)),
),
};
let named_unmanaged = intent_named_unmanaged(config, workspace, &files);
let mut uncovered_lines = Vec::new();
for id in &uncovered {
uncovered_lines.push(format!("{id}: changed with no covering intent; {hint}"));
}
let mut unseen_lines = unseen;
unseen_lines.extend(unreadable_worktree);
let unmanaged = named_unmanaged.first().map(|id| Refusal {
error: CliError::new(intent_names_unmanaged(&id.name)),
lines: named_unmanaged
.iter()
.skip(1)
.map(|id| intent_names_unmanaged(&id.name))
.collect(),
});
let gated = strict && !uncovered.is_empty();
let (mut lines, uncovered_refusal) = if gated {
let refusal = Refusal {
error: CliError::uncovered(uncovered.len()),
lines: uncovered_lines,
};
(Vec::new(), Some(refusal))
} else {
(uncovered_lines, None)
};
lines.extend(unseen_lines);
Ok(LookReport {
lines,
refusals: [unmanaged, uncovered_refusal]
.into_iter()
.flatten()
.collect(),
})
}
fn evaluate_remote(git: &Git, remote_lookback: u32) -> Result<(), CliError> {
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(),
]
);
}
#[test]
fn release_looks_are_named() {
assert_eq!(
super::LookPlan::release().names(),
["tags", "install pin", "coverage"]
);
assert_eq!(super::NOT_STRICTLY, Some(false));
}
#[test]
fn the_announcement_names_every_look() {
let asked = super::LookPlan::check(true);
assert_eq!(asked.names().last(), Some(&super::REMOTE.name));
assert!(asked.runs_remote());
assert!(!asked.listed_names().contains(&super::REMOTE.name));
assert!(!super::LookPlan::check(false).runs_remote());
let names = super::LookPlan::check(false).names();
assert_eq!(
names,
[
"management",
"tags",
"install pin",
"changelogs",
"staging",
"coverage"
]
);
let sentence = super::named(&names);
for look in &names {
assert!(
sentence.contains(look),
"{look} is not announced: {sentence}"
);
}
assert!(sentence.ends_with("and coverage"), "{sentence}");
assert_eq!(sentence.matches(", and ").count(), 1, "{sentence}");
assert_eq!(
sentence.split(", ").count(),
names.len(),
"one item per look: {sentence}"
);
}
}