use std::cell::OnceCell;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt::Write as _;
use std::path::{Path, PathBuf};
use clap::Args;
use oakum::plan::aggregate::BumpFile;
use oakum::plan::{Package, PackageId, Workspace};
use oakum::state::{ChangedPackage, HandSet, RetiredPackage};
use oakum::tags::{Behind, Drift, Untagged};
use semver::Version;
use serde::Serialize;
use super::changelog::{self, EntryRefusal};
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::{self, BranchBumpFiles, Covering};
use super::fs::{link_staging_dir, repo_path_display, stray_staging_files, stray_staging_message};
use super::git::{Git, Op};
use super::install_pin;
use super::intent::{load_coverage_intent, load_plan_bump_files, PlanIntent};
use super::lockfiles;
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::workspace::discover_validated;
use super::CliError;
#[derive(Debug)]
pub(super) struct TagEvaluation {
drift: Vec<Drift>,
hand_set_drift: BTreeSet<PackageId>,
behind: Vec<Behind>,
untagged: Vec<Untagged>,
current: Vec<(PackageId, Version)>,
retired: Vec<RetiredPackage>,
}
#[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)]
#[expect(
clippy::struct_excessive_bools,
reason = "each is an independent command-line switch"
)]
pub(super) struct CheckArgs {
#[arg(long)]
strict: bool,
#[arg(long, value_name = "REF", help = super::FROM_PLAN)]
from: Option<String>,
#[arg(long, value_name = "PATH")]
notes_file: Option<PathBuf>,
#[arg(long)]
remote: bool,
#[arg(long)]
json: bool,
#[arg(long, conflicts_with = "json")]
explain: 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()?;
let git = Git::at_repository(&repo)?.offline();
refuse_treeless(&git)?;
let config = load_config(&repo)?;
require_config(&config)?;
let loaded = Loaded::discover(&repo, config)?;
let plan = LookPlan::check(
Gate::of(args.strict),
args.remote.then_some(args.remote_lookback),
);
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),
from: args.from.as_deref(),
notes_file: args.notes_file.as_deref(),
pins: OnceCell::new(),
};
let (verdict, evaluation) = plan.look(&context);
for (_, line) in verdict.said() {
super::say_err(line);
}
if !args.json {
for line in verdict
.changed(COVERAGE)
.map(super::reasons::summary_lines)
.unwrap_or_default()
{
super::say_out(&line);
}
let settled = plan.settle(verdict.error(), evaluation).map(|_| ());
if !args.explain {
return settled;
}
return match (
settled,
super::release_state::explain(&git, &repo, &loaded.config, args.from.as_deref()),
) {
(settled, Ok(explain)) => {
super::say_out(&explain_lines(&explain));
settled
}
(Err(refused), Err(_)) => {
super::say_out("explain: not traced, check refused above");
Err(refused)
}
(Ok(()), Err(unexplained)) => Err(unexplained),
};
}
let report = CheckReport::of(
&verdict,
scope.row(),
&plan.names(),
&LookPlan::check(Gate::Reports, Some(args.remote_lookback)).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),
}
}
fn refuse_treeless(git: &Git) -> Result<(), CliError> {
let Ok(Some(stdout)) = git.optional_text(Op::PartialCloneFilters) else {
return Ok(());
};
match treeless(&stdout) {
Some(refusal) => Err(CliError::unverified(refusal)),
None => Ok(()),
}
}
fn treeless(stdout: &str) -> Option<String> {
stdout.split('\0').find_map(|entry| {
let (key, filter) = entry.trim_start_matches('\n').split_once('\n')?;
(!keeps_history(filter)).then(|| refusal(key, filter))
})
}
fn refusal(key: &str, filter: &str) -> String {
let remote = key
.strip_prefix("remote.")
.and_then(|rest| rest.strip_suffix(".partialclonefilter"))
.unwrap_or(key);
format!(
"unverified: this clone fetches `{remote}` with `--filter={filter}`, which leaves out more than file contents, and `check` would fetch what its history reads need; bring them in and keep them with `git fetch --refetch --filter=blob:none {}` and `git config {} blob:none`; in CI, check out with no filter",
tags::shell_quote(remote),
tags::shell_quote(key),
)
}
fn keeps_history(filter: &str) -> bool {
let Some(parts) = filter.strip_prefix("combine:") else {
return filter == "blob:none"
|| filter.starts_with("blob:limit=")
|| filter.starts_with("sparse:oid=");
};
parts
.split('+')
.all(|part| percent_decoded(part).is_some_and(|part| keeps_history(&part)))
}
fn percent_decoded(text: &str) -> Option<String> {
let mut bytes = Vec::with_capacity(text.len());
let mut rest = text.as_bytes();
while let Some((&byte, tail)) = rest.split_first() {
if byte == b'%' {
let hex = std::str::from_utf8(tail.get(..2)?).ok()?;
bytes.push(u8::from_str_radix(hex, 16).ok()?);
rest = &tail[2..];
} else {
bytes.push(byte);
rest = tail;
}
}
String::from_utf8(bytes).ok()
}
fn explain_lines(explain: &oakum::plan::Explain) -> String {
if explain.is_empty() {
return String::from("explain: no package is planned to bump");
}
let mut lines = String::from("explain:");
for entry in explain.entries() {
lines.push_str("\n ");
lines.push_str(&entry.to_string());
}
lines
}
#[derive(Clone, Copy)]
struct Look {
name: &'static str,
run: Run,
}
#[derive(Clone, Copy)]
enum Run {
Plain(fn(&LookContext<'_>) -> LookReport),
Gated(fn(&LookContext<'_>, bool) -> LookReport, Gate),
Remote {
lookback: u32,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Gate {
Reports,
Blocks,
}
impl Gate {
fn of(strict: bool) -> Self {
if strict {
Self::Blocks
} else {
Self::Reports
}
}
}
impl Look {
fn perform(&self, context: &LookContext<'_>) -> LookReport {
match self.run {
Run::Plain(run) => run(context),
Run::Gated(run, gate) => run(context, gate == Gate::Blocks),
Run::Remote { lookback } => {
LookReport::from_result(evaluate_remote(context.git, lookback))
}
}
}
fn blocks(&self) -> bool {
matches!(self.run, Run::Gated(_, Gate::Blocks))
}
}
struct LookContext<'a> {
git: &'a Git,
repo: &'a Repository,
loaded: &'a Loaded,
base: Result<&'a str, &'a str>,
from: Option<&'a str>,
notes_file: Option<&'a Path>,
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];
struct LookPlan {
before: &'static [Look],
tag: TagLook,
after: Vec<Look>,
}
impl LookPlan {
fn check(gate: Gate, remote_lookback: Option<u32>) -> Self {
Self {
before: &BEFORE_TAGS,
tag: TAGS,
after: [
INSTALL_PIN,
SCHEMA,
CHANGELOGS,
STAGING,
LOCKFILES,
notes_look(gate),
coverage_look(gate),
]
.into_iter()
.chain(remote_lookback.map(remote_look))
.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_look(Gate::Reports)]),
}
}
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)
}
fn listed_names(&self) -> Vec<&'static str> {
self.names()
.into_iter()
.filter(|name| *name != REMOTE)
.collect()
}
}
const MANAGEMENT: Look = Look {
name: "management",
run: Run::Plain(|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: Run::Plain(|context| LookReport::from_result(evaluate_install_pin(context))),
};
const SCHEMA: Look = Look {
name: "schema",
run: Run::Plain(|context| {
let standing = install_pin::standing(context.pins());
LookReport {
lines: owned_files::schema_note(
context.repo,
context.loaded.config.names_committed_schema(),
&standing,
)
.into_iter()
.chain(owned_files::readme_note(context.repo, &standing))
.collect(),
..LookReport::default()
}
}),
};
const CHANGELOGS: Look = Look {
name: "changelogs",
run: Run::Plain(evaluate_changelogs),
};
const STAGING: Look = Look {
name: "staging",
run: Run::Plain(|context| evaluate_staging(context.repo, context.loaded)),
};
const LOCKFILES: Look = Look {
name: "lockfiles",
run: Run::Plain(|context| {
lockfiles::evaluate_pnpm_lock(context.repo, &context.loaded.workspace)
}),
};
const DROPPED_NOTES: &str = "notes";
const COVERAGE: &str = "coverage";
const REMOTE: &str = "remote";
fn notes_look(gate: Gate) -> Look {
Look {
name: DROPPED_NOTES,
run: Run::Gated(evaluate_dropped_notes, gate),
}
}
fn coverage_look(gate: Gate) -> Look {
Look {
name: COVERAGE,
run: Run::Gated(
|context, strict| {
evaluate_coverage(
context.git,
context.repo,
context.loaded,
context.base,
strict,
)
},
gate,
),
}
}
fn remote_look(lookback: u32) -> Look {
Look {
name: REMOTE,
run: Run::Remote { lookback },
}
}
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,
),
|id| shares_changelog(&context.loaded.workspace, &context.loaded.config, id),
),
})
.into_iter()
.chain(refuse_if_behind(&tags))
.chain(unread)
.collect();
let report = LookReport {
retired: Some(tags.retired.clone()),
..LookReport::refusing(refusals)
};
Ok((tags, report))
}
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.perform(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.perform(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: GatedLooks,
remote: bool,
look_names: Vec<&'static str>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(transparent)]
pub(super) struct GatedLooks(Vec<&'static str>);
impl GatedLooks {
fn of(plan: &LookPlan) -> Self {
Self(
[COVERAGE, DROPPED_NOTES]
.into_iter()
.filter(|name| {
plan.after
.iter()
.any(|look| look.name == *name && look.blocks())
})
.collect(),
)
}
#[cfg(test)]
pub(super) fn of_check(strict: bool) -> Self {
Self::of(&LookPlan::check(Gate::of(strict), None))
}
fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
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: GatedLooks::of(plan),
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)
})?;
if from.is_none() {
return Ok(base);
}
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, DROPPED_NOTES]
.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}");
}
write!(f, "; not looking at the {REMOTE} (`--remote` asks for it)")
}
}
fn evaluate_staging(repo: &Repository, loaded: &Loaded) -> LookReport {
match staging_refusal(repo, loaded) {
Ok(report) => report,
Err(refusal) => LookReport::from_result(Err(refusal)),
}
}
const PACKAGE_WRITES: [&str; 3] = ["Cargo.toml", "package.json", "CHANGELOG.md"];
fn workspace_writes(workspace: &Workspace) -> Vec<PathBuf> {
let mut written = Vec::new();
written.extend(workspace.cargo_root_manifest().map(PathBuf::from));
if let Some(root) = workspace.cargo_workspace_root() {
written.push(Path::new(root).join("Cargo.lock"));
}
if let Some(dir) = workspace.pnpm_lock_dir() {
written.push(Path::new(dir).join("pnpm-lock.yaml"));
}
written.extend(workspace.catalog_file().map(PathBuf::from));
written
}
fn staging_refusal(repo: &Repository, loaded: &Loaded) -> Result<LookReport, CliError> {
let mut dirs: BTreeSet<String> = [String::from(".changeset"), String::from(".")].into();
let mut written = workspace_writes(&loaded.workspace);
for package in loaded.workspace.packages() {
let dir = package.manifest_dir();
if !dir.is_empty() {
dirs.insert(dir.to_owned());
}
for name in PACKAGE_WRITES {
written.push(PathBuf::from(package.file_path(name)));
}
for extra in loaded.config.extra_files_for(&package.id().name) {
written.push(extra_file_repo_path(package, extra.path())?);
}
}
dirs.extend(
written
.iter()
.filter_map(|path| path.parent().map(repo_path_display))
.filter(|parent| !parent.is_empty()),
);
dirs.extend(
written
.iter()
.filter_map(|path| link_staging_dir(repo.dir(), path)),
);
let mut strays = Vec::new();
for sub in &dirs {
strays.extend(stray_staging_files(repo.dir(), sub)?);
}
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(),
}]))
}
pub(super) struct Loaded {
pub(super) config: LoadedConfig,
pub(super) workspace: Workspace,
pub(super) reachable: tags::Reachable,
}
impl Loaded {
fn load(repo: &Repository) -> Result<Self, CliError> {
let config = load_config(repo)?;
Self::discover(repo, config)
}
pub(super) fn discover(repo: &Repository, config: LoadedConfig) -> Result<Self, CliError> {
let workspace = discover_validated(repo, &config)?;
Ok(Self {
config,
workspace,
reachable: tags::Reachable::default(),
})
}
}
fn evaluate_changelogs(context: &LookContext<'_>) -> LookReport {
let (refused, stood_in) = refused_entries(context);
let mut report = LookReport::refusing(
foreign_changelogs(context.repo, context.loaded)
.into_iter()
.chain(refused)
.collect(),
);
report.lines = stood_in;
report
}
fn refused_entries(context: &LookContext<'_>) -> (Vec<Refusal>, Vec<String>) {
let entries = match super::version::refused_entries(
context.repo,
context.git,
&context.loaded.config,
&context.loaded.workspace,
context.from,
context.base,
context.notes_file,
) {
Ok(entries) => entries,
Err(err) => return (vec![Refusal::bare(CliError::from(err))], Vec::new()),
};
let (mut refused, mut unsettled) = (Vec::new(), Vec::new());
for entry in entries {
match entry {
EntryRefusal::Refused(line) => refused.push(line),
EntryRefusal::Unsettled(line) => unsettled.push(line),
}
}
let mut refusals = Vec::new();
if !refused.is_empty() {
refusals.push(Refusal {
error: CliError::new(format!(
"{} pending changelog entry(ies) `oakum version` would refuse to write",
refused.len()
)),
lines: refused,
});
}
let stood_in = if unsettled.is_empty() {
Vec::new()
} else {
std::iter::once(format!(
"changelogs: {} pending entry(ies) rendered with stand-ins for the commit and pull request of bump files the base does not hold yet; `version` renders them with the real ones if the merge's subject carries the pull request:",
unsettled.len()
))
.chain(unsettled.into_iter().map(|line| format!(" {line}")))
.collect()
};
(refusals, stood_in)
}
fn foreign_changelogs(repo: &Repository, loaded: &Loaded) -> Option<Refusal> {
let reports = match changelog::foreign_changelogs(repo.dir(), &loaded.workspace, |package| {
loaded.config.version_managed(package)
}) {
Ok(reports) => reports,
Err(err) => {
return Some(Refusal::bare(CliError::unverified(format!(
"unverified: {err}"
))))
}
};
(!reports.is_empty()).then(|| 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,
..LookReport::default()
};
}
LookReport::refusing(vec![Refusal {
error: CliError::new(format!(
"{} bump file note(s) have a heading that would reach no changelog",
dropped.len()
)),
lines: dropped,
}])
}
fn dropped_headings_of(file: &BumpFile) -> Vec<&'static str> {
file.entries
.iter()
.map(|(_, level)| *level)
.max()
.map_or_else(Vec::new, |level| {
changelog::dropped_headings(&file.note, level)
})
}
fn dropped_note_lines(context: &LookContext<'_>) -> Result<Vec<String>, CliError> {
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,
context.from,
)?;
Ok(files
.iter()
.filter_map(|file| {
let dropped = dropped_headings_of(file);
(!dropped.is_empty()).then(|| {
format!(
"`{}` has a heading with nothing under it ({})",
file.id,
changelog::heading_list(&dropped)
)
})
})
.collect())
}
pub(super) fn run_tags_only() -> Result<(), CliError> {
let repo = repository::discover()?;
let git = Git::at_repository(&repo)?;
let loaded = Loaded::load(&repo)?;
let context = LookContext {
git: &git,
repo: &repo,
loaded: &loaded,
base: Err("tag-drift does not diff"),
from: None,
notes_file: None,
pins: OnceCell::new(),
};
LookPlan::tag_drift().decide(&context).map(|_| ())
}
pub(super) fn evaluate(
git: &Git,
repo: &Repository,
loaded: &Loaded,
pins: Result<Option<install_pin::Pins>, CliError>,
from: Option<&str>,
) -> Result<TagEvaluation, CliError> {
let base = resolved_base(git, from);
let context = LookContext {
git,
repo,
loaded,
base: base.as_deref().map_err(String::as_str),
from,
notes_file: None,
pins: OnceCell::from(pins),
};
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 refuse_if_behind(tags: &TagEvaluation) -> Option<Refusal> {
(!tags.behind.is_empty()).then(|| Refusal {
error: CliError::new(format!(
"{} package(s) below their highest tag",
tags.behind.len()
)),
lines: tags
.behind
.iter()
.map(|item| behind_tag_line(item.id(), item.manifest(), item.tagged()))
.collect(),
})
}
fn pending_lines(
tags: &TagEvaluation,
tag_name: impl Fn(&PackageId, &Version) -> Option<String>,
shared: impl Fn(&PackageId) -> bool,
) -> Vec<String> {
let drift = tags.drift.iter().map(|item| {
let (id, version) = (item.id(), item.manifest());
if tags.hand_set_drift.contains(id) {
return hand_set_above_tag_line(id, version, item.tagged(), tag_name(id, version));
}
format!(
"{id}: manifest {version} is above tagged {} (local tags; run `git fetch --tags` if the remote is ahead)",
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), shared(id))
}
});
drift.chain(untagged).collect()
}
fn behind_tag_line(id: &PackageId, version: &Version, tagged: &Version) -> String {
format!(
"{id}: manifest {version} is below tagged {tagged}, so its next version would repeat or fall below a released one; set the manifest to {tagged}, or to the version you meant above it"
)
}
fn shares_changelog(workspace: &Workspace, config: &LoadedConfig, id: &PackageId) -> bool {
workspace
.get(id)
.is_some_and(|package| changelog::shares_changelog(workspace, config, package))
}
fn hand_set_line(id: &PackageId, version: &Version, tag: Option<String>, shared: bool) -> String {
let how = tag.map_or_else(String::new, |tag| format!(" (`git tag {tag} <commit>`)"));
let heading = if shared {
format!(
"; its changelog is shared, so only a `## {}@{version}` heading is its section",
id.name
)
} else {
String::new()
};
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{heading}"
)
}
fn hand_set_above_tag_line(
id: &PackageId,
version: &Version,
tagged: &Version,
tag: Option<String>,
) -> String {
let how = tag.map_or_else(String::new, |tag| format!(" (`git tag {tag} <commit>`)"));
format!(
"{id}: manifest {version} is above tagged {tagged} and has no changelog section, so it was set by hand; tag the version you meant{how}, set the manifest back to {tagged}, or run `git fetch --tags` if its tag is on a remote"
)
}
pub(super) struct HandSetLook {
found: Vec<HandSet>,
unread: Vec<String>,
placeholders_unread: Vec<String>,
}
impl HandSetLook {
pub(super) fn refuse(self) -> Result<(), CliError> {
if !self.found.is_empty() {
let lines: Vec<&str> = self.found.iter().map(HandSet::fix).collect();
let mut message = format!(
"the plan bumps a version set by hand:\n {}",
lines.join("\n ")
);
for detail in &self.unread {
let _ = write!(message, "\n also unverified: {detail}");
}
return Err(CliError::new(message));
}
unverified(&self.unread, &[])
}
pub(super) fn reported(self) -> Result<Vec<HandSet>, CliError> {
let unread = [self.unread, self.placeholders_unread].concat();
unverified(&unread, &self.found)?;
Ok(self.found)
}
}
fn behind_hand_set(item: &Behind) -> HandSet {
let fix = behind_tag_line(item.id(), item.manifest(), item.tagged());
HandSet::new(item.id().clone(), item.manifest().clone(), fix)
}
fn is_fresh_placeholder(repo: &Repository, package: &Package, owner: changelog::Owner) -> bool {
oakum::tags::is_placeholder(package.version())
&& matches!(
changelog::has_earlier_section(repo.dir(), package, owner),
Ok(false)
)
}
fn naming_unread<'a>(err: CliError, unread: impl Iterator<Item = &'a CliError>) -> CliError {
if err.exit_code() != 2 {
return err;
}
let mut message = format!("unverified: {}", err.detail());
for unread in unread {
let _ = write!(message, "\n also unverified: {}", unread.detail());
}
err.recast(message)
}
fn unverified(unread: &[String], found: &[HandSet]) -> Result<(), CliError> {
if unread.is_empty() {
return Ok(());
}
let mut message = format!("unverified: {}", unread.join("\n "));
for entry in found {
let _ = write!(message, "\n also set by hand: {}", entry.fix());
}
Err(CliError::unverified(message))
}
pub(super) fn hand_set_versions<T>(
git: &Git,
repo: &Repository,
config: &LoadedConfig,
workspace: &Workspace,
bumped: &BTreeMap<PackageId, T>,
) -> Result<HandSetLook, CliError> {
let mut look = HandSetLook {
found: Vec::new(),
unread: Vec::new(),
placeholders_unread: Vec::new(),
};
let planned: Vec<&Package> = workspace
.packages()
.filter(|package| bumped.contains_key(package.id()))
.filter(|package| config.tag_managed(package))
.collect();
if planned.is_empty() {
return Ok(look);
}
let mut candidates = Vec::new();
let mut placeholders_unread = Vec::new();
let mut fresh = BTreeSet::new();
for &package in &planned {
let owner = changelog::Owner::of(workspace, config, package);
let mut read = match changelog::has_version_section(repo.dir(), package, owner) {
Ok(true) => {
if is_fresh_placeholder(repo, package, owner) {
fresh.insert(package.id());
}
continue;
}
Ok(false) => None,
Err(err) => Some(err),
};
if oakum::tags::is_placeholder(package.version()) {
if let Some(err) = read.take_if(|err| err.exit_code() != 1) {
placeholders_unread.push((package, err));
continue;
}
match changelog::has_earlier_section(repo.dir(), package, owner) {
Ok(true) => {}
Ok(false) => {
fresh.insert(package.id());
continue;
}
Err(err) => {
placeholders_unread.push((package, err));
continue;
}
}
}
candidates.push((package, owner, read));
}
let commits_only = matches!(config.plan_intent_source()?, PlanIntentSource::CommitsOnly);
let needs_tags: BTreeSet<&PackageId> = planned
.iter()
.map(|package| package.id())
.filter(|id| commits_only || !fresh.contains(id))
.collect();
if needs_tags.is_empty() {
return Ok(look);
}
let tagged = tags::reachable_tags(git)
.and_then(|reachable| tagged_versions(git, config, workspace, reachable))
.map(|(tagged, _)| tagged)
.map_err(|err| naming_unread(err, placeholders_unread.iter().map(|(_, unread)| unread)))?;
look.placeholders_unread = placeholders_unread
.into_iter()
.filter(|(package, _)| {
tagged
.get(package.id())
.is_some_and(|tag| package.version().cmp_precedence(tag).is_gt())
})
.map(|(_, err)| err.detail())
.collect();
look.found.extend(
oakum::tags::behind(workspace, &tagged, |package| {
needs_tags.contains(package.id())
})
.iter()
.map(behind_hand_set),
);
let tag_name = super::release::tag_namer(repo, config, workspace);
for (package, owner, read) in candidates {
let (id, version) = (package.id(), package.version());
let above = match tagged.get(id) {
Some(tag) if version.cmp_precedence(tag).is_gt() => Some(tag),
Some(_) => continue,
None if oakum::tags::is_placeholder(version) => continue,
None => None,
};
let fix = match read {
None => match above {
Some(tag) => hand_set_above_tag_line(id, version, tag, tag_name(id, version)),
None => hand_set_line(id, version, tag_name(id, version), owner.shared()),
},
Some(err) if err.exit_code() == 1 => err.detail(),
Some(err) => {
look.unread.push(err.detail());
continue;
}
};
look.found
.push(HandSet::new(id.clone(), version.clone(), fix));
}
Ok(look)
}
fn tagged_versions(
git: &Git,
config: &LoadedConfig,
workspace: &Workspace,
reachable: Vec<CommitTags>,
) -> Result<(BTreeMap<PackageId, Version>, Vec<RetiredPackage>), CliError> {
let bare_candidates = tag_managed_ids(workspace, config);
let retirement = super::retired::without_retired(git, workspace, &bare_candidates, reachable)?;
let owned: Vec<Vec<&str>> = retirement
.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 tagged =
oakum::tags::current_versions(&slices, workspace, |id| bare_candidates.contains(id))
.map_err(|err| CliError::unverified(err.to_string()))?;
Ok((tagged, retirement.packages))
}
pub(super) fn retired_packages(
git: &Git,
config: &LoadedConfig,
workspace: &Workspace,
) -> Option<Vec<RetiredPackage>> {
tags::reachable_tags(git)
.and_then(|reachable| tagged_versions(git, config, workspace, reachable))
.ok()
.map(|(_, retired)| retired)
}
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()?;
let Loaded {
config,
workspace,
reachable,
} = loaded;
let _ = config.plan_intent_source()?;
let (tagged, retired) = tagged_versions(git, config, workspace, reachable.tags(git)?)?;
let (untagged, unread) = oakum::tags::untagged_pending(
workspace,
&tagged,
|package| config.tag_managed(package),
|package| {
let owner = changelog::Owner::of(workspace, config, package);
changelog::has_version_section(repo.dir(), package, owner)
},
);
let drift = oakum::tags::drift(workspace, &tagged, |package| config.tag_managed(package));
let hand_set_drift = drift
.iter()
.filter_map(|item| workspace.get(item.id()))
.filter(|package| {
let owner = changelog::Owner::of(workspace, config, package);
matches!(
changelog::has_version_section(repo.dir(), package, owner),
Ok(false)
)
})
.map(|package| package.id().clone())
.collect();
let evaluation = TagEvaluation {
drift,
hand_set_drift,
behind: oakum::tags::behind(workspace, &tagged, |package| config.tag_managed(package)),
untagged,
current: oakum::tags::tagged_current(workspace, &tagged, |package| {
config.tag_managed(package)
}),
retired,
};
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, level) in &file.entries {
if config.refuses_intent(workspace, id, *level) {
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 PlanIntent {
files,
commit_types,
dropped,
..
} = load_coverage_intent(git, repo, workspace, config, base)?;
let source = config.plan_intent_source()?;
let branch = match source {
PlanIntentSource::ChangeFiles => Some(BranchBumpFiles::read(git, base)?),
PlanIntentSource::CommitsOnly => None,
};
let covering = match &branch {
Some(branch) => Covering::ChangeFiles {
files: branch.own(&files),
commits: super::intent::releaseless_commits(git, workspace, config, base)?,
},
None => Covering::CommitsOnly {
commits: files.clone(),
types: commit_types.unwrap_or_default(),
},
};
let coverage::Uncovered {
committed: oakum::state::Coverage {
unmanaged: _,
changed,
},
outside_head,
} = coverage::changed_by_standing_and_unseen(
git,
workspace,
&covering,
from,
branch.as_ref(),
|package| config.standing(package),
|path| super::fs::read_resolved_text(repo.dir(), std::path::Path::new(path)),
)?;
let generate = (config.generate_allowed() && covering.files().is_empty())
.then(|| super::tags::shell_quote(base));
let hint = |package: &ChangedPackage| super::reasons::cover_hint(package, generate.as_deref());
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 uncovered_lines: Vec<String> = changed
.iter()
.filter(|package| !package.is_covered())
.map(|package| {
let reason = super::reasons::uncovered_reason(package)
.map_or_else(String::new, |reason| format!("; {reason}"));
format!(
"{}: changed{} with no covering intent{reason}; {}",
package.id(),
super::reasons::via_clause(package),
hint(package)
)
})
.collect();
let mut unseen_lines = unseen;
unseen_lines.extend(unreadable_worktree);
unseen_lines.extend(dropped.lines());
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_lines.is_empty();
let (mut lines, uncovered_refusal) = if gated {
let refusal = Refusal {
error: CliError::uncovered(uncovered_lines.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(),
changed: Some(changed),
retired: None,
})
}
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 only_filters_leaving_out_file_contents_keep_the_history() {
for kept in [
"blob:none",
"blob:limit=1k",
"sparse:oid=HEAD:a/b/f",
"combine:blob:none+blob:limit=1k+sparse:oid=HEAD:a/b/f",
"combine:blob%3Anone+blob%3Alimit=1k",
"combine:combine:blob:none+blob:limit=1k",
"combine:blob:none+combine:blob:limit=1k%2bblob:none",
] {
assert!(super::keeps_history(kept), "{kept}");
}
for lacking in [
"tree:0",
"tree:1",
"object:type=commit",
"object:type=tree",
"combine:tree:0+blob:none",
"combine:tree%3A0+blob:none",
"combine:combine:tree:0+blob:none",
"combine:blob:none+combine:blob:limit=1k%2btree:0",
"combine:blob:limit=1%zz",
"combine:blob%3",
"",
] {
assert!(!super::keeps_history(lacking), "{lacking}");
}
}
#[test]
fn the_remedy_names_the_remote_as_a_shell_reads_it() {
let message = super::treeless(
"remote.aaa.partialclonefilter\nblob:none\0remote.my.fork.partialclonefilter\ntree:0\0",
)
.expect("my.fork leaves out trees");
assert!(
message.contains("`my.fork` with `--filter=tree:0`")
&& message.contains("--filter=blob:none my.fork`")
&& message.contains("git config remote.my.fork.partialclonefilter blob:none"),
"{message}"
);
let message = super::refusal("remote.a b.partialclonefilter", "tree:0");
assert!(
message.contains("--filter=blob:none 'a b'`")
&& message.contains("git config 'remote.a b.partialclonefilter' blob:none"),
"{message}"
);
}
#[test]
fn nothing_refused_and_no_evaluation_is_a_look_that_did_not_happen() {
let refusal = super::LookPlan::check(super::Gate::Reports, None)
.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!(super::GatedLooks::of(&super::LookPlan::release()).is_empty());
}
#[test]
fn the_ungated_clause_and_the_document_read_one_gating_set() {
let scope = |gate: super::Gate| {
let plan = super::LookPlan::check(gate, None);
super::Scope {
selected: 1,
packages: 1,
base: Ok(String::from("HEAD~1")),
gating: super::GatedLooks::of(&plan),
remote: false,
look_names: plan.listed_names(),
}
};
let gated = scope(super::Gate::Blocks);
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(super::Gate::Reports);
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() {
use super::{coverage_look, notes_look, Gate, GatedLooks, LookPlan, TAGS};
let names = |gated: GatedLooks| gated.0;
assert_eq!(
names(GatedLooks::of(&LookPlan::check(Gate::Blocks, None))),
[super::COVERAGE, super::DROPPED_NOTES]
);
let release_blocking = LookPlan {
before: &[],
tag: TAGS,
after: Vec::from([coverage_look(Gate::Blocks)]),
};
assert_eq!(names(GatedLooks::of(&release_blocking)), [super::COVERAGE]);
let reversed = LookPlan {
before: &[],
tag: TAGS,
after: Vec::from([notes_look(Gate::Blocks), coverage_look(Gate::Blocks)]),
};
assert_eq!(
names(GatedLooks::of(&reversed)),
[super::COVERAGE, super::DROPPED_NOTES]
);
assert!(GatedLooks::of(&LookPlan::tag_drift()).is_empty());
assert!(GatedLooks::of(&LookPlan::check(Gate::Reports, None)).is_empty());
}
#[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_eq!(
super::dropped_headings_of(&file(vec![
("other", BumpLevel::None),
("demo", BumpLevel::Minor),
])),
["Added"]
);
assert_eq!(
super::dropped_headings_of(&file(vec![
("other", BumpLevel::None),
("demo", BumpLevel::None),
])),
[""; 0]
);
assert_eq!(super::dropped_headings_of(&file(Vec::new())), [""; 0]);
}
#[test]
fn the_announcement_names_every_look() {
let asked = super::LookPlan::check(super::Gate::Reports, Some(3));
assert_eq!(asked.names().last(), Some(&super::REMOTE));
assert!(asked.runs_remote());
assert!(!asked.listed_names().contains(&super::REMOTE));
assert!(!super::LookPlan::check(super::Gate::Reports, None).runs_remote());
let names = super::LookPlan::check(super::Gate::Reports, None).names();
assert_eq!(
names,
[
"management",
"tags",
"install pin",
"schema",
"changelogs",
"staging",
"lockfiles",
"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}"
);
}
}