use std::cell::OnceCell;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Write as _;
use clap::Args;
use oakum::plan::aggregate::BumpFile;
use oakum::plan::{PackageId, Workspace};
use oakum::tags::{Drift, Untagged};
use semver::Version;
use super::changelog;
use super::check_report::{CheckReport, ScopeRow};
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::owned_files;
use super::repository::{self, Repository};
use super::tags::{self, CommitTags};
use super::verdict::{carry, first_line, named, LookReport, Refusal, Verdict};
use super::version::extra_file_repo_path;
use super::workflow::npm_workspace;
use super::{add, CliError};
#[derive(Debug)]
pub(super) struct TagEvaluation {
drift: Vec<Drift>,
untagged: Vec<Untagged>,
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.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
.iter()
.map(|item| PendingRelease::new(item.id().clone(), item.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)]
json: 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);
if !args.json {
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),
pins: OnceCell::new(),
};
if !args.json {
return plan.decide(&context).map(|_| ());
}
let (verdict, evaluation) = plan.look(&context);
for (_, line) in verdict.said() {
super::say_err(line);
}
let report = CheckReport::of(
&verdict,
scope.row(),
&plan.names(),
&LookPlan::check(true).names(),
);
let written = serde_json::to_string_pretty(&report)
.map_err(|err| CliError::unverified(format!("the check report could not be built: {err}")))
.and_then(|document| {
super::deliver_out(&document).map_err(|err| CliError::undelivered("report", &err))
});
match (plan.settle(verdict.error, evaluation), written) {
(Err(established), Err(undelivered)) => Err(established.recast(format!(
"{}\nalso {}: {}",
established.detail(),
undelivered.outcome(),
undelivered.detail()
))),
(settled, Ok(())) => settled.map(|_| ()),
(Ok(_), Err(undelivered)) => Err(undelivered),
}
}
#[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>,
pins: OnceCell<Result<Option<install_pin::Pins>, CliError>>,
}
impl LookContext<'_> {
fn pins(&self) -> &Result<Option<install_pin::Pins>, CliError> {
self.pins.get_or_init(|| install_pin::read_pin(self.repo))
}
}
#[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; 6] = [
INSTALL_PIN,
SCHEMA,
CHANGELOGS,
STAGING,
DROPPED_NOTES,
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| {
let (tags, unread) = evaluate_tags(context.git, context.repo, context.loaded)?;
Ok((tags, LookReport::refusing(unread)))
},
};
const INSTALL_PIN: Look = Look {
name: "install pin",
run: |context| LookReport::from_result(evaluate_install_pin(context)),
};
const SCHEMA: Look = Look {
name: "schema",
run: |context| LookReport {
lines: owned_files::schema_note(
context.repo,
context.loaded.config.names_committed_schema(),
&install_pin::standing(context.pins()),
)
.into_iter()
.collect(),
refusals: Vec::new(),
},
};
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 DROPPED_NOTES: Look = Look {
name: "notes",
run: |context| match context.strict {
Some(strict) => evaluate_dropped_notes(context, strict),
None => LookReport::from_result(Err(CliError::unverified(
"unverified: the notes look ran without a strictness decision, so it did not look",
))),
},
};
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, unread) = evaluate_tags(context.git, context.repo, context.loaded)?;
let refusals = refuse_if_pending(&tags)
.err()
.map(|error| Refusal {
error,
lines: pending_lines(
&tags,
super::release::tag_namer(
context.repo,
&context.loaded.config,
&context.loaded.workspace,
),
),
})
.into_iter()
.chain(unread)
.collect();
Ok((tags, LookReport::refusing(refusals)))
}
impl LookPlan {
fn look(&self, context: &LookContext<'_>) -> (Verdict, Option<TagEvaluation>) {
let mut reports = Vec::new();
for look in self.before {
reports.push((look.name, (look.run)(context)));
}
let evaluation = match (self.tag.run)(context) {
Ok((tags, report)) => {
reports.push((self.tag.name, report));
Some(tags)
}
Err(refusal) => {
reports.push((self.tag.name, LookReport::from_result(Err(refusal))));
None
}
};
for look in &self.after {
reports.push((look.name, (look.run)(context)));
}
(carry(reports), evaluation)
}
fn decide(&self, context: &LookContext<'_>) -> Result<TagEvaluation, CliError> {
let (verdict, evaluation) = self.look(context);
for (_, line) in verdict.said() {
super::say_err(line);
}
self.settle(verdict.error, evaluation)
}
fn settle(
&self,
error: Option<CliError>,
evaluation: Option<TagEvaluation>,
) -> Result<TagEvaluation, CliError> {
match (error, 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: Vec<&'static str>,
remote: bool,
look_names: Vec<&'static str>,
}
fn gated_looks(look_names: &[&'static str]) -> Vec<&'static str> {
[COVERAGE.name, DROPPED_NOTES.name]
.into_iter()
.filter(|name| look_names.contains(name))
.collect()
}
impl Scope {
fn row(&self) -> ScopeRow {
ScopeRow::of(
self.selected,
self.packages,
self.base.as_deref().map_err(String::as_str),
self.gating.clone(),
)
}
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: if args.strict {
gated_looks(&plan.listed_names())
} else {
Vec::new()
},
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.downcast_ref::<CliError>()
.map_or_else(|| err.to_string(), CliError::detail)
})?;
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))?;
let needing_base: Vec<&'static str> = [COVERAGE.name, DROPPED_NOTES.name]
.into_iter()
.filter(|name| self.look_names.contains(name))
.collect();
if self.base.is_err() && !needing_base.is_empty() {
write!(
f,
"; {} cannot run without a base ref",
needing_base.join(" and ")
)?;
}
if self.gating.is_empty() {
let ungated: Vec<&'static str> = needing_base
.iter()
.copied()
.filter(|_| self.base.is_ok())
.collect();
if !ungated.is_empty() {
let verb = if ungated.len() == 1 {
"reports"
} else {
"report"
};
write!(
f,
"; {} {verb} without gating (`--strict` gates)",
ungated.join(" and ")
)?;
}
}
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,
}])
}
fn evaluate_dropped_notes(context: &LookContext<'_>, strict: bool) -> LookReport {
let dropped = match dropped_note_lines(context) {
Ok(dropped) => dropped,
Err(err) => return LookReport::from_result(Err(err)),
};
if dropped.is_empty() {
return LookReport::default();
}
if !strict {
return LookReport {
lines: dropped,
refusals: Vec::new(),
};
}
LookReport::refusing(vec![Refusal {
error: CliError::new(format!(
"{} bump file note(s) would reach no changelog",
dropped.len()
)),
lines: dropped,
}])
}
fn file_drops_its_note(file: &BumpFile) -> bool {
file.entries
.iter()
.map(|(_, level)| *level)
.max()
.is_some_and(|level| changelog::note_renders_nothing(&file.note, level))
}
fn dropped_note_lines(context: &LookContext<'_>) -> Result<Vec<String>, CliError> {
let from = Some(
context
.base
.map_err(|why| CliError::unverified(format!("unverified: {why}")))?,
);
let files = load_plan_bump_files(
context.git,
context.repo,
&context.loaded.workspace,
&context.loaded.config,
from,
)
.map_err(CliError::from_boxed)?;
Ok(files
.iter()
.filter(|file| file_drops_its_note(file))
.map(|file| format!("`{}` has a heading with nothing under it", file.id))
.collect())
}
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,
pins: OnceCell::new(),
};
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,
pins: OnceCell::new(),
};
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.len()))
}
fn pending_lines(
tags: &TagEvaluation,
tag_name: impl Fn(&PackageId, &Version) -> Option<String>,
) -> 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.iter().map(|item| {
let (id, version) = (item.id(), item.version());
if item.has_section() {
format!("{id}: never released; {version} has a changelog section and no tag yet, which `oakum release` cuts")
} else {
hand_set_line(id, version, tag_name(id, version))
}
});
drift.chain(untagged).collect()
}
fn hand_set_line(id: &PackageId, version: &Version, tag: Option<String>) -> String {
let how = tag.map_or_else(String::new, |tag| format!(" (`git tag {tag} <commit>`)"));
format!(
"{id}: never released, but the manifest is {version}; tag the version you meant{how}, or run `git fetch --tags` if its tag is on a remote"
)
}
pub(super) fn refuse_hand_set_untagged<T>(
git: &Git,
repo: &Repository,
config: &LoadedConfig,
workspace: &Workspace,
bumped: &BTreeMap<PackageId, T>,
) -> Result<(), CliError> {
let mut candidates = Vec::new();
for package in workspace
.packages()
.filter(|package| bumped.contains_key(package.id()))
.filter(|package| config.tag_managed(package))
.filter(|package| !oakum::tags::is_placeholder(package.version()))
{
match changelog::has_version_section(repo.dir(), package) {
Ok(true) => {}
Ok(false) => candidates.push((package, None)),
Err(err) => candidates.push((package, Some(err))),
}
}
if candidates.is_empty() {
return Ok(());
}
let tagged = tagged_versions(git, config, workspace)?;
let tag_name = super::release::tag_namer(repo, config, workspace);
let mut hand_set = Vec::new();
let mut unread = Vec::new();
for (package, read) in candidates {
if tagged.contains_key(package.id()) {
continue;
}
match read {
None => hand_set.push(hand_set_line(
package.id(),
package.version(),
tag_name(package.id(), package.version()),
)),
Some(err) => unread.push(err.detail()),
}
}
if !hand_set.is_empty() {
let mut message = format!(
"the plan would bump past a version no tag records:\n {}",
hand_set.join("\n ")
);
for detail in &unread {
let _ = write!(message, "\n also unverified: {detail}");
}
return Err(CliError::new(message));
}
if unread.is_empty() {
Ok(())
} else {
Err(CliError::unverified(format!(
"unverified: {}",
unread.join("\n ")
)))
}
}
fn tagged_versions(
git: &Git,
config: &LoadedConfig,
workspace: &Workspace,
) -> Result<BTreeMap<PackageId, Version>, CliError> {
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);
oakum::tags::current_versions(&slices, workspace, |id| bare_candidates.contains(id))
.map_err(|err| CliError::unverified(err.to_string()))
}
fn evaluate_install_pin(context: &LookContext<'_>) -> Result<(), CliError> {
if context.loaded.config.is_default() {
return Ok(());
}
install_pin::agreement(context.pins(), npm_workspace(context.repo.path()))
}
fn evaluate_tags(
git: &Git,
repo: &Repository,
loaded: &Loaded,
) -> Result<(TagEvaluation, Vec<Refusal>), CliError> {
let _ = repo.ambient_path().map_err(CliError::from_boxed)?;
let Loaded { config, workspace } = loaded;
let _ = config.plan_intent_source()?;
let tagged = tagged_versions(git, config, workspace)?;
let (untagged, unread) = oakum::tags::untagged_pending(
workspace,
&tagged,
|package| config.tag_managed(package),
|package| changelog::has_version_section(repo.dir(), package),
);
let evaluation = TagEvaluation {
drift: oakum::tags::drift(workspace, &tagged, |package| config.tag_managed(package)),
untagged,
current: oakum::tags::tagged_current(workspace, &tagged, |package| {
config.tag_managed(package)
}),
};
Ok((evaluation, unread.into_iter().map(Refusal::bare).collect()))
}
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 base = base.map_err(|why| CliError::unverified(format!("unverified: {why}")))?;
let from = Some(base);
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 if config.generate_allowed() && files.is_empty() => format!(
"add a bump file with `oakum add --packages <package>:<level>`, or write it from conventional commits with `oakum generate --from {}` (or `none` / empty frontmatter under --strict)",
super::tags::shell_quote(base)
),
PlanIntentSource::ChangeFiles => String::from(
"add a bump file with `oakum add --packages <package>:<level>` (or `none` / empty frontmatter under --strict)",
),
PlanIntentSource::CommitsOnly => String::from(
"name the package in a conventional commit (or a path that maps to it)",
),
};
let hint = hint.as_str();
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 {
#[test]
fn nothing_refused_and_no_evaluation_is_a_look_that_did_not_happen() {
let refusal = super::LookPlan::check(false)
.settle(None, None)
.expect_err("a look that neither answered nor refused");
assert_eq!(refusal.class(), crate::cli::Outcome::Unverified);
assert!(refusal.detail().contains("tags"), "{}", refusal.detail());
}
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_ungated_clause_and_the_document_read_one_gating_set() {
let scope = |gating: Vec<&'static str>| super::Scope {
selected: 1,
packages: 1,
base: Ok(String::from("HEAD~1")),
gating,
remote: false,
look_names: Vec::from([super::COVERAGE.name, super::DROPPED_NOTES.name]),
};
let gated = scope(Vec::from([super::COVERAGE.name, super::DROPPED_NOTES.name]));
assert!(!gated.to_string().contains("without gating"), "{gated}");
assert_eq!(
serde_json::to_value(gated.row()).expect("a row")["gating"],
serde_json::json!(["coverage", "notes"])
);
let ungated = scope(Vec::new());
assert!(
ungated
.to_string()
.contains("coverage and notes report without gating"),
"{ungated}"
);
assert_eq!(
serde_json::to_value(ungated.row()).expect("a row")["gating"],
serde_json::json!([])
);
}
#[test]
fn gated_looks_names_only_the_looks_the_plan_carries() {
assert_eq!(
super::gated_looks(&super::LookPlan::check(false).listed_names()),
[super::COVERAGE.name, super::DROPPED_NOTES.name]
);
assert_eq!(
super::gated_looks(&[super::DROPPED_NOTES.name]),
[super::DROPPED_NOTES.name]
);
let gated = super::gated_looks(&[super::STAGING.name]);
assert!(gated.is_empty(), "{gated:?}");
}
#[test]
fn the_highest_level_in_a_file_decides_whether_its_note_drops() {
use oakum::plan::aggregate::BumpFile;
use oakum::plan::bump::BumpLevel;
use oakum::plan::{Ecosystem, PackageId};
let file = |entries: Vec<(&str, BumpLevel)>| BumpFile {
id: String::from("mixed.md"),
entries: entries
.into_iter()
.map(|(name, level)| (PackageId::new(Ecosystem::Cargo, name), level))
.collect(),
note: String::from("### Added\n"),
};
assert!(super::file_drops_its_note(&file(vec![
("other", BumpLevel::None),
("demo", BumpLevel::Minor),
])));
assert!(!super::file_drops_its_note(&file(vec![
("other", BumpLevel::None),
("demo", BumpLevel::None),
])));
assert!(!super::file_drops_its_note(&file(Vec::new())));
}
#[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",
"schema",
"changelogs",
"staging",
"notes",
"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}"
);
}
}