use std::io::{self, IsTerminal};
use std::path::Path;
use cap_std::fs::Dir;
use clap::Args;
use oakum::changeset::{
instruction_occupants, is_bump_file_name, load_migration_bump_files, parse_migration,
resolve_migration_change, write, ChangeFile, KnopePresence, LoadError, MigrationBumpFile,
MigrationLoadAbort, UnknownReason,
};
use oakum::detect::{DetectReport, ReleaseTool};
use oakum::plan::{
aggregate, compare_plans, compose, plan_fingerprint, BumpFile, BumpLevel, CascadeAs, Plan,
PlanFingerprint, Versioning, Workspace,
};
use super::workspace::try_discover_workspace;
use super::binary_version;
use super::changelog::foreign_changelogs;
use super::config::{read_config_source, LoadedConfig};
use super::detect_tools;
use super::fs::{read_text, report_stray_staging, write_file_via_rename};
use super::git::Git;
use super::init::{
changeset_file_names, ensure_changeset_dir, list_paths, print_workflow_and_footer,
VersioningArg,
};
use super::install_pin::{self, PinPolicy};
use super::intent::refuse_malformed;
use super::migrate_config::{
carried_private_packages, commit_message_steps, consequential_drop_steps, knope_scope_steps,
lossy_mapping_steps, migrated_settings, read_source_configs, shadowed_commit_messages,
SourceConfig,
};
use super::migrate_gates::find_bump_file_gates;
use super::migrate_output::{
gate_look_refusal, pending_owned_line, print_left_alone, print_pending, print_plan_comparison,
print_remaining_steps, print_tag_shape, verdict, Remaining,
};
use super::migrate_source_plan::{fetch_source_before_plan, primary_plan_tool, SourceBeforePlan};
use super::owned_files::{
missing_owned_files, restore_owned_file, write_owned_files, ConfigSettings, OwnedPlan,
OwnedWrites, PrivatePackages, Records,
};
use super::release::default_tag_template;
use super::repository;
use super::tag_shape::{self, ReadableTemplate, TagShape};
use super::tags::all_tag_objects;
use super::workflow::{npm_workspace, InstallFacts, TokenArgs, WorkflowPins};
use super::CliError;
use super::{ask, say_err, say_out};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum VersioningChoice {
Requested(Versioning),
Inferred(ReleaseTool),
}
impl VersioningChoice {
pub(super) fn versioning(self) -> Versioning {
match self {
Self::Requested(versioning) => versioning,
Self::Inferred(tool) => Self::implied_by(tool),
}
}
pub(super) fn implied_by(tool: ReleaseTool) -> Versioning {
match tool {
ReleaseTool::Knope | ReleaseTool::ReleasePlz => Versioning::ZeroMajor,
ReleaseTool::Changesets
| ReleaseTool::Bumpy
| ReleaseTool::ReleasePlease
| ReleaseTool::SemanticRelease
| ReleaseTool::NxRelease => Versioning::Semver,
}
}
}
#[derive(Debug, Args)]
pub(super) struct MigrateArgs {
#[arg(long, value_enum)]
versioning: Option<VersioningArg>,
#[arg(long)]
yes: bool,
#[command(flatten)]
token: TokenArgs,
}
pub(super) fn run(args: &MigrateArgs) -> Result<(), Box<dyn std::error::Error>> {
let repo = repository::discover()?;
report_stray_staging(repo.dir())?;
let owed_pin = install_pin::gate(&repo, PinPolicy::Adopt)?;
if let Some(source) = read_config_source(&repo)? {
return already_migrated(&repo, &source, args, owed_pin.as_ref());
}
let report = detect_tools::scan(repo.dir())?;
detect_tools::refuse_on_detection_errors(&report)?;
if report.detections.is_empty() {
return Err(Box::new(CliError::new(
"nothing to migrate; run `oakum init`",
)));
}
let found = SourceTools::read(repo.dir(), &report)?;
let SourceTools {
knope,
changesets,
bumpy,
ref changeset_names,
ref bumpy_names,
} = found;
let chosen = versioning_choice(&report.detections, args.versioning)
.ok_or_else(|| CliError::new("nothing to migrate; run `oakum init`"))?;
let versioning = chosen.versioning();
let owned = OwnedPlan::probe(repo.dir())?;
report_changeset_subdirs(repo.dir())?;
let (sources, unreadable_sources) = read_and_report_source_configs(repo.dir());
let workspace = optional_workspace(&repo)?;
let path = repo.ambient_path()?;
let install = InstallFacts::read(repo.dir(), path, npm_workspace(path))?;
let foreign = foreign_changelog_reports(&repo, workspace.as_ref())?;
let prepared = prepare_migration(
repo.dir(),
changeset_names,
bumpy_names,
knope,
workspace.as_ref(),
)?;
let before_files = prepared.bump_files();
let before = resolve_before_proof(
&repo,
workspace.as_ref(),
&before_files,
infer_versioning(&report.detections),
knope,
primary_plan_tool(knope, bumpy, changesets),
&report.detections,
)?;
let (shape, settings) = tag_shape_and_settings(&repo, workspace.as_ref(), versioning, &sources);
print_pending(&prepared.rewrites, &sources, &settings, owned, chosen);
confirm_migration(args.yes)?;
let owned_now = recheck_owned(repo.dir(), owned)?;
let binary = binary_version()?;
let pins = WorkflowPins::lookup(install, args.token.token())?;
let (created, records) =
write_migration(repo.dir(), &prepared.rewrites, owned_now, settings.clone())?;
let after_plan = after_plan(
repo.dir(),
workspace.as_ref(),
&prepared.unknown_pairs(),
versioning,
);
print_left_alone(owned_now.readme, &sources, &unreadable_sources);
print_tag_shape(&shape, settings.tag_format);
let comparison = conclude_plan_comparison(
workspace.as_ref(),
&before_files,
knope,
before.as_ref(),
after_plan,
prepared.unverified,
);
let leftovers: Vec<&str> = prepared
.rewrites
.iter()
.filter_map(BumpRewrite::leftover)
.collect();
let gates = find_bump_file_gates(&repo, &report.detections);
let mut owed_steps = owed_by_the_source_configs(&sources);
if knope {
owed_steps.extend(knope_scope_steps(repo.dir()));
}
print_steps_and_workflow(
&Remaining {
detections: &report.detections,
knope,
foreign_changelogs: &foreign,
owed_pin: owed_pin.as_ref(),
pins: &pins,
binary: &binary,
shape: &shape,
leftovers: &leftovers,
gates: &gates,
owed: &owed_steps,
},
&created.written,
records,
comparison,
)?;
Ok(())
}
fn owed_by_the_source_configs(sources: &[SourceConfig]) -> Vec<String> {
let mut owed = lossy_mapping_steps(sources);
owed.extend(consequential_drop_steps(sources));
owed.extend(commit_message_steps(sources));
owed.extend(shadowed_commit_messages(sources));
owed
}
fn print_steps_and_workflow(
remaining: &Remaining<'_>,
written: &[&str],
mut records: Records,
comparison: Result<(), Box<dyn std::error::Error>>,
) -> Result<(), CliError> {
print_remaining_steps(remaining);
print_workflow_and_footer(remaining.binary, remaining.pins, written, &mut records);
verdict(
comparison
.err()
.map(CliError::from_boxed)
.into_iter()
.chain(records.finish().err())
.chain(remaining.gates.failure().map(|why| gate_look_refusal(&why)))
.chain(remaining.owed_pin.and_then(install_pin::Owed::refusal)),
)
}
struct SourceTools {
knope: bool,
changesets: bool,
bumpy: bool,
changeset_names: Vec<String>,
bumpy_names: Vec<String>,
}
impl SourceTools {
fn read(dir: &Dir, report: &DetectReport) -> Result<Self, Box<dyn std::error::Error>> {
let has = |tool| report.detections.iter().any(|hit| hit.tool() == tool);
let bumpy = has(ReleaseTool::Bumpy);
let changeset_names = changeset_file_names(dir)?;
for occupant in instruction_occupants(changeset_names.iter().map(String::as_str)) {
say_out(&occupant.migrate_message());
}
Ok(Self {
knope: knope_present(dir)?,
changesets: has(ReleaseTool::Changesets),
bumpy,
changeset_names,
bumpy_names: if bumpy {
dir_file_names(dir, ".bumpy")?
} else {
Vec::new()
},
})
}
}
fn settings_with_tag_shape(
shape: &TagShape,
workspace: Option<&Workspace>,
versioning: Versioning,
sources: &[SourceConfig],
private_packages: PrivatePackages,
) -> ConfigSettings {
migrated_settings(
versioning,
sources,
written_tag_format(shape, workspace, private_packages),
)
}
fn tag_shape_and_settings(
repo: &repository::Repository,
workspace: Option<&Workspace>,
versioning: Versioning,
sources: &[SourceConfig],
) -> (TagShape, ConfigSettings) {
let private_packages = carried_private_packages(sources);
let shape = derive_tag_shape(repo, workspace, private_packages);
let settings =
settings_with_tag_shape(&shape, workspace, versioning, sources, private_packages);
(shape, settings)
}
fn derive_tag_shape(
repo: &repository::Repository,
workspace: Option<&Workspace>,
private_packages: PrivatePackages,
) -> TagShape {
match read_tag_names(repo) {
Ok(names) => tag_shape::derive(&names, workspace, private_packages),
Err(err) => TagShape::Unread(err.detail()),
}
}
fn read_tag_names(repo: &repository::Repository) -> Result<Vec<String>, CliError> {
let git = Git::at_repository(repo)?;
Ok(all_tag_objects(&git)?
.into_iter()
.map(|(name, _)| name)
.collect())
}
fn written_tag_format(
shape: &TagShape,
workspace: Option<&Workspace>,
private_packages: PrivatePackages,
) -> Option<ReadableTemplate> {
let TagShape::Derived { template, .. } = shape else {
return None;
};
let managed = tag_shape::tag_managed_count(workspace, private_packages);
(template.as_str() != default_tag_template(managed)).then_some(*template)
}
fn read_and_report_source_configs(dir: &Dir) -> (Vec<SourceConfig>, Vec<String>) {
let (sources, unreadable) = read_source_configs(dir);
for line in &unreadable {
say_err(line);
}
(sources, unreadable)
}
fn write_migration(
dir: &Dir,
rewrites: &[BumpRewrite],
owned: OwnedPlan,
settings: ConfigSettings,
) -> Result<(OwnedWrites, Records), Box<dyn std::error::Error>> {
ensure_changeset_dir(dir)?;
let mut records = Records::default();
let written = apply_bump_rewrites(dir, rewrites, &mut records)
.and_then(|()| write_owned_files(dir, owned, settings, &mut records))
.map_err(|err| records.abandon(err))?;
Ok((written, records))
}
fn recheck_owned(dir: &Dir, before: OwnedPlan) -> Result<OwnedPlan, Box<dyn std::error::Error>> {
let now = OwnedPlan::probe(dir)?;
if now != before {
say_out("changed while waiting:");
let line = pending_owned_line(now);
if line == pending_owned_line(before) {
say_out(" .changeset/README.md changed; it is left as is");
} else {
say_out(&format!(" {line}"));
}
}
Ok(now)
}
fn foreign_changelog_reports(
repo: &super::repository::Repository,
workspace: Option<&Workspace>,
) -> Result<Vec<String>, Box<dyn std::error::Error>> {
let Some(workspace) = workspace else {
return Ok(Vec::new());
};
let config = LoadedConfig::from_parsed(repo, oakum::config::OakumConfig::defaults(), "")?;
foreign_changelogs(repo.dir(), workspace, |package| {
config.version_managed(package)
})
}
fn double_quoted_scoped_keys(body: &str) -> String {
let mut out = String::with_capacity(body.len());
let mut delimiters = 0;
for line in body.split_inclusive('\n') {
let content = line.trim_end_matches(['\n', '\r']);
if content == "---" {
delimiters += 1;
}
let in_frontmatter = delimiters == 1 && content != "---";
match content
.strip_prefix('\'')
.and_then(|rest| rest.split_once("': "))
{
Some((key, level)) if in_frontmatter => {
out.push('"');
out.push_str(key);
out.push_str("\": ");
out.push_str(level);
out.push_str(&line[content.len()..]);
}
_ => out.push_str(line),
}
}
out
}
fn skip_migration_confirmation(yes: bool, stdin_is_tty: bool) -> Result<bool, CliError> {
if yes {
return Ok(true);
}
if !stdin_is_tty {
return Err(CliError::new(
"stdin is not a terminal; rerun with --yes to apply the changes above",
));
}
Ok(false)
}
fn confirm_migration(yes: bool) -> Result<(), Box<dyn std::error::Error>> {
if skip_migration_confirmation(yes, io::stdin().is_terminal())? {
return Ok(());
}
ask("Apply these changes? [y/N] ")?;
let mut line = String::new();
io::stdin().read_line(&mut line)?;
accept_migration_answer(line.trim()).map_err(Into::into)
}
fn accept_migration_answer(answer: &str) -> Result<(), CliError> {
match answer {
"y" | "yes" | "Y" | "Yes" | "YES" => Ok(()),
"" | "n" | "no" | "N" | "No" | "NO" => Err(CliError::new("migration cancelled")),
other => Err(CliError::new(format!(
"migration cancelled: unknown answer `{other}`; use y or n"
))),
}
}
fn already_migrated(
repo: &super::repository::Repository,
source: &super::config::ConfigSource,
args: &MigrateArgs,
owed_pin: Option<&install_pin::Owed>,
) -> Result<(), Box<dyn std::error::Error>> {
let parsed = oakum::config::parse(source.text()).map_err(|err| {
CliError::new(format!(
"`.changeset/_config.toml` is not a valid oakum config: {err}"
))
})?;
let loaded = LoadedConfig::from_parsed(repo, parsed, source.text())?;
if let Some(flag) = args.versioning {
let wanted = flag.to_versioning();
let have = loaded.versioning();
if wanted != have {
return Err(Box::new(CliError::new(format!(
"`--versioning` is `{wanted}` but `.changeset/_config.toml` has `versioning = \"{have}\"`; change `versioning` in `.changeset/_config.toml` to `{wanted}`"
))));
}
}
args.token.refuse_without_workflow("migrate")?;
restore_missing_owned_files(repo, args.yes)?;
say_out("already migrated");
if let Some(owed_pin) = owed_pin {
say_out(&format!("remaining: {}", owed_pin.step(None)));
if let Some(refusal) = owed_pin.refusal() {
return Err(Box::new(refusal));
}
}
Ok(())
}
fn restore_missing_owned_files(
repo: &super::repository::Repository,
yes: bool,
) -> Result<(), Box<dyn std::error::Error>> {
let missing = missing_owned_files(repo.dir())?;
if missing.is_empty() {
return Ok(());
}
let rels: Vec<&str> = missing.iter().map(|file| file.rel()).collect();
say_out("pending:");
say_out(&format!(" write {}", list_paths(&rels)));
confirm_migration(yes)?;
let mut records = Records::default();
for file in missing {
restore_owned_file(repo.dir(), file).map_err(|err| records.abandon(err))?;
records.record(&format!("created {}", file.rel()));
}
records.finish()?;
Ok(())
}
fn optional_workspace(
repo: &repository::Repository,
) -> Result<Option<Workspace>, Box<dyn std::error::Error>> {
try_discover_workspace(repo)
}
pub(super) struct BumpRewrite {
source: String,
dest: String,
body: String,
}
impl BumpRewrite {
pub(super) fn in_place(rel: String, body: String) -> Self {
Self {
source: rel.clone(),
dest: rel,
body,
}
}
pub(super) fn copied_out(from: String, to: String, body: String) -> Self {
Self {
source: from,
dest: to,
body,
}
}
pub(super) fn dest(&self) -> &str {
&self.dest
}
pub(super) fn body(&self) -> &str {
&self.body
}
pub(super) fn leftover(&self) -> Option<&str> {
(self.source != self.dest).then_some(self.source.as_str())
}
}
#[derive(Default)]
struct PreparedMigration {
rewrites: Vec<BumpRewrite>,
snapshots: Vec<MigrationBumpFile>,
unverified: bool,
}
impl PreparedMigration {
fn bump_files(&self) -> Vec<BumpFile> {
self.snapshots
.iter()
.map(MigrationBumpFile::bump_file)
.collect()
}
fn unknown_pairs(&self) -> Vec<(String, String)> {
self.snapshots
.iter()
.flat_map(|file| {
file.unknown_missing()
.iter()
.map(|name| (file.id().to_string(), name.clone()))
})
.collect()
}
}
fn prepare_migration(
dir: &Dir,
changeset_names: &[String],
bumpy_names: &[String],
knope: bool,
workspace: Option<&Workspace>,
) -> Result<PreparedMigration, Box<dyn std::error::Error>> {
let mut prepared = PreparedMigration::default();
let mut dests = Vec::new();
if workspace.is_none() {
prepared.unverified = changeset_names
.iter()
.chain(bumpy_names)
.any(|name| is_bump_file_name(name));
if prepared.unverified {
say_out("plan comparison skipped: no packages discovered");
} else {
say_out("plan comparison skipped: nothing to compare");
}
}
for name in changeset_names {
if !is_bump_file_name(name) {
continue;
}
let rel = format!(".changeset/{name}");
let Some(body) = read_text(dir, &rel)? else {
if workspace.is_some() {
return Err(Box::new(CliError::new(format!(
"`{rel}` was listed but is missing"
))));
}
continue;
};
let change = parse_migration(&body).map_err(|err| {
CliError::new(format!("`.changeset/{name}` is not a bump file: {err}"))
})?;
refuse_knope_unsafe(&rel, &change, knope)?;
let next =
write(change.entries(), change.note(), KnopePresence::Absent).map_err(|err| {
CliError::new(format!("failed to rewrite `.changeset/{name}`: {err}"))
})?;
dests.push(name.clone());
if next != body && double_quoted_scoped_keys(&body) != next {
prepared
.rewrites
.push(BumpRewrite::in_place(rel.clone(), next));
}
if let Some(workspace) = workspace {
push_snapshot(&mut prepared, rel, change, workspace)?;
}
}
for name in bumpy_names {
if !is_bump_file_name(name) {
continue;
}
if dests.iter().any(|existing| existing == name) {
return Err(Box::new(CliError::new(format!(
"refusing to migrate `.bumpy/{name}`: `.changeset/{name}` already exists"
))));
}
let src = format!(".bumpy/{name}");
let Some(body) = read_text(dir, &src)? else {
if workspace.is_some() {
return Err(Box::new(CliError::new(format!(
"`{src}` was listed but is missing"
))));
}
continue;
};
let change = parse_migration(&body)
.map_err(|err| CliError::new(format!("`.bumpy/{name}` is not a bump file: {err}")))?;
refuse_knope_unsafe(&src, &change, knope)?;
let next = write(change.entries(), change.note(), KnopePresence::Absent)
.map_err(|err| CliError::new(format!("failed to rewrite `.bumpy/{name}`: {err}")))?;
prepared.rewrites.push(BumpRewrite::copied_out(
src.clone(),
format!(".changeset/{name}"),
next,
));
dests.push(name.clone());
if let Some(workspace) = workspace {
push_snapshot(&mut prepared, src, change, workspace)?;
}
}
for (path, name) in prepared.unknown_pairs() {
say_out(&format!("unknown package `{name}` in `{path}`"));
}
Ok(prepared)
}
fn push_snapshot(
prepared: &mut PreparedMigration,
rel: String,
change: ChangeFile,
workspace: &Workspace,
) -> Result<(), Box<dyn std::error::Error>> {
let resolved = resolve_migration_change(rel, change, workspace).map_err(map_resolve_err)?;
prepared.snapshots.push(resolved);
Ok(())
}
fn map_resolve_err(err: LoadError) -> CliError {
match err {
LoadError::UnknownPackage(unknown) if unknown.reason == UnknownReason::Ambiguous => {
CliError::new(format!(
"package `{}` in `{}` matches more than one workspace package",
unknown.name, unknown.file
))
}
other => CliError::new(other.to_string()),
}
}
fn map_migration_load_abort(err: &MigrationLoadAbort) -> CliError {
CliError::new(err.to_string())
}
enum BeforeProof {
Source {
tool: ReleaseTool,
fingerprint: PlanFingerprint,
under_convention: bool,
},
Simulated {
plan: Plan,
tool_label: String,
reason: String,
},
}
fn resolve_before_proof(
repo: &super::repository::Repository,
workspace: Option<&Workspace>,
files: &[BumpFile],
versioning: Versioning,
remap_knope_features: bool,
plan_tool: Option<ReleaseTool>,
detections: &[oakum::detect::Detection],
) -> Result<Option<BeforeProof>, Box<dyn std::error::Error>> {
let Some(workspace) = workspace else {
return Ok(None);
};
let Some(tool) = plan_tool else {
let tool_label = detections.first().map_or_else(
|| String::from("unknown"),
|hit| hit.tool().name().to_string(),
);
let reason = String::from("no supported source-tool before-plan command");
say_out(&format!(
"plan comparison: source tool {tool_label} not runnable ({reason}); using oakum simulation — will exit unverified"
));
let plan = compose_plan(workspace, files, versioning, false)?;
return Ok(Some(BeforeProof::Simulated {
plan,
tool_label,
reason,
}));
};
let cwd = repo.ambient_path()?;
match fetch_source_before_plan(tool, cwd, workspace) {
SourceBeforePlan::Available {
tool,
fingerprint,
under_convention,
} => {
say_out(&format!(
"plan comparison: before-plan from {}",
tool.name()
));
Ok(Some(BeforeProof::Source {
tool,
fingerprint,
under_convention,
}))
}
SourceBeforePlan::Unavailable { tool, reason } => {
say_out(&format!(
"plan comparison: source tool {} not runnable ({reason}); using oakum simulation — will exit unverified",
tool.name()
));
let plan = compose_plan(workspace, files, versioning, remap_knope_features)?;
Ok(Some(BeforeProof::Simulated {
plan,
tool_label: tool.name().to_string(),
reason,
}))
}
}
}
enum AfterPlan {
Skipped,
Compared(Plan),
Failed(Box<dyn std::error::Error>),
}
fn after_plan(
dir: &Dir,
workspace: Option<&Workspace>,
already_unknown: &[(String, String)],
versioning: Versioning,
) -> AfterPlan {
let Some(workspace) = workspace else {
return AfterPlan::Skipped;
};
let after_names = match changeset_file_names(dir) {
Ok(names) => names,
Err(err) => return AfterPlan::Failed(err),
};
let after_snapshots = match load_after_snapshots(dir, &after_names, workspace) {
Ok(loaded) => loaded,
Err(err) => return AfterPlan::Failed(err),
};
for file in &after_snapshots {
for name in file.unknown_missing() {
if !already_unknown
.iter()
.any(|(seen_path, seen)| seen == name && same_bump_file(seen_path, file.id()))
{
say_out(&format!("unknown package `{name}` in `{}`", file.id()));
}
}
}
let after_files: Vec<BumpFile> = after_snapshots
.iter()
.map(MigrationBumpFile::bump_file)
.collect();
match compose_plan(workspace, &after_files, versioning, false) {
Ok(plan) => AfterPlan::Compared(plan),
Err(err) => AfterPlan::Failed(err),
}
}
fn load_after_snapshots(
dir: &Dir,
changeset_names: &[String],
workspace: &Workspace,
) -> Result<Vec<MigrationBumpFile>, Box<dyn std::error::Error>> {
let mut bodies = Vec::new();
for name in changeset_names {
if !is_bump_file_name(name) {
continue;
}
let rel = format!(".changeset/{name}");
let Some(body) = read_text(dir, &rel)? else {
return Err(Box::new(CliError::new(format!(
"`{rel}` was listed but is missing"
))));
};
bodies.push((rel, body));
}
let refs: Vec<(&str, &str)> = bodies
.iter()
.map(|(rel, body)| (rel.as_str(), body.as_str()))
.collect();
let loaded =
load_migration_bump_files(refs, workspace).map_err(|err| map_migration_load_abort(&err))?;
refuse_malformed(loaded.malformed())?;
Ok(loaded.files().to_vec())
}
fn conclude_plan_comparison(
workspace: Option<&Workspace>,
files: &[BumpFile],
knope: bool,
before: Option<&BeforeProof>,
after: AfterPlan,
unverified_no_packages: bool,
) -> Result<(), Box<dyn std::error::Error>> {
let unexpected = match (workspace, before, after) {
(Some(workspace), Some(before), AfterPlan::Compared(after)) => {
report_plan_comparison(workspace, files, knope, before, &after)
}
(_, _, AfterPlan::Failed(err)) => {
say_out("plan comparison: failed to recompute");
return Err(Box::new(CliError::new(format!(
"failed to recompute the release plan: {err}"
))));
}
_ => false,
};
if unexpected {
if matches!(
before,
Some(BeforeProof::Source {
under_convention: true,
..
})
) {
return Err(Box::new(CliError::unverified(
"unverified: the release plan differs from a before-plan read under bumpy's exit-1 convention, which a crashed run is indistinguishable from",
)));
}
return Err(Box::new(CliError::new("the release plan changed")));
}
if unverified_no_packages {
return Err(Box::new(CliError::unverified(
"unverified: plan comparison skipped; no packages discovered",
)));
}
if let Some(BeforeProof::Simulated {
tool_label, reason, ..
}) = before
{
return Err(Box::new(CliError::unverified(format!(
"unverified: source-tool before-plan unavailable ({tool_label}): {reason}"
))));
}
Ok(())
}
fn infer_versioning(detections: &[oakum::detect::Detection]) -> Versioning {
versioning_choice(detections, None).map_or(Versioning::Semver, VersioningChoice::versioning)
}
fn versioning_choice(
detections: &[oakum::detect::Detection],
flag: Option<VersioningArg>,
) -> Option<VersioningChoice> {
if let Some(flag) = flag {
return Some(VersioningChoice::Requested(flag.to_versioning()));
}
let tools: Vec<ReleaseTool> = detections
.iter()
.map(oakum::detect::Detection::tool)
.collect();
Some(VersioningChoice::Inferred(settles_the_mode(&tools)?))
}
fn settles_the_mode(tools: &[ReleaseTool]) -> Option<ReleaseTool> {
tools
.iter()
.copied()
.find(|tool| VersioningChoice::implied_by(*tool) == Versioning::ZeroMajor)
.or_else(|| tools.first().copied())
}
fn report_plan_comparison(
workspace: &Workspace,
files: &[BumpFile],
knope: bool,
before: &BeforeProof,
after: &Plan,
) -> bool {
let simulated_fp;
let (before_fp, before_plan, before_label, planned_by) = match before {
BeforeProof::Source {
tool, fingerprint, ..
} => (
fingerprint,
None,
tool.name(),
format!("planned by {}", tool.name()),
),
BeforeProof::Simulated {
plan, tool_label, ..
} => {
simulated_fp = plan_fingerprint(plan);
(
&simulated_fp,
Some(plan),
tool_label.as_str(),
String::from("planned by the oakum simulation"),
)
}
};
let match_suffix = match before {
BeforeProof::Source { .. } => String::new(),
BeforeProof::Simulated { .. } => format!(" (unverified: {before_label} did not run)"),
};
let comparison = compare_plans(workspace, files, knope, before_fp, before_plan, after);
print_plan_comparison(
&comparison,
before_label,
&planned_by,
&match_suffix,
after.changes().len(),
);
comparison.expected_knope_feature().is_none() && comparison.unexpected().is_some()
}
fn report_changeset_subdirs(dir: &Dir) -> Result<(), Box<dyn std::error::Error>> {
let entries = match dir.read_dir(".changeset") {
Ok(entries) => entries,
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()),
Err(err) => {
return Err(Box::new(CliError::new(format!(
"failed to read `.changeset/`: {err}"
))));
}
};
for entry in entries {
let entry =
entry.map_err(|err| CliError::new(format!("failed to read `.changeset/`: {err}")))?;
let name = entry.file_name();
let Some(name) = name.to_str() else {
return Err(Box::new(CliError::new(
"a path under `.changeset/` is not valid UTF-8",
)));
};
if name == "." || name == ".." {
continue;
}
let meta = entry.metadata().map_err(|err| {
CliError::new(format!("failed to inspect `.changeset/{name}`: {err}"))
})?;
if meta.is_dir() {
say_out(&format!("subdirectory `.changeset/{name}` (ignored)"));
}
}
Ok(())
}
fn compose_plan(
workspace: &Workspace,
files: &[BumpFile],
versioning: Versioning,
remap_knope_features: bool,
) -> Result<Plan, Box<dyn std::error::Error>> {
let mut files = files.to_vec();
if remap_knope_features {
for file in &mut files {
for (id, level) in &mut file.entries {
if *level == BumpLevel::Minor
&& workspace
.get(id)
.is_some_and(|pkg| pkg.version().major == 0)
{
*level = BumpLevel::Patch;
}
}
}
}
let intent = aggregate(files);
compose(workspace, &intent, |_| versioning, CascadeAs::Patch)
.map_err(|err| -> Box<dyn std::error::Error> { Box::new(CliError::new(err.to_string())) })
}
fn same_bump_file(left: &str, right: &str) -> bool {
Path::new(left).file_name() == Path::new(right).file_name()
}
fn knope_present(dir: &Dir) -> Result<bool, Box<dyn std::error::Error>> {
match dir.metadata("knope.toml") {
Ok(meta) => Ok(meta.is_file()),
Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
Err(err) => Err(Box::new(CliError::new(format!(
"failed to inspect `knope.toml`: {err}"
)))),
}
}
fn dir_file_names(dir: &Dir, rel: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
let entries = match dir.read_dir(rel) {
Ok(entries) => entries,
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(err) => {
return Err(Box::new(CliError::new(format!(
"failed to read `{rel}/`: {err}"
))));
}
};
let mut names = Vec::new();
for entry in entries {
let entry =
entry.map_err(|err| CliError::new(format!("failed to read `{rel}/`: {err}")))?;
let name = entry.file_name();
let Some(name) = name.to_str() else {
return Err(Box::new(CliError::new(format!(
"a path under `{rel}/` is not valid UTF-8"
))));
};
if name == "." || name == ".." {
continue;
}
let meta = entry
.metadata()
.map_err(|err| CliError::new(format!("failed to inspect `{rel}/{name}`: {err}")))?;
if meta.is_file() {
names.push(name.to_string());
}
}
names.sort();
Ok(names)
}
fn refuse_knope_unsafe(
path: &str,
parsed: &ChangeFile,
knope: bool,
) -> Result<(), Box<dyn std::error::Error>> {
if !knope {
return Ok(());
}
if parsed.entries().is_empty() {
return Err(Box::new(CliError::new(format!(
"refusing to migrate `{path}`: empty frontmatter is unsafe while knope.toml is present"
))));
}
if let Some((pkg, _)) = parsed
.entries()
.iter()
.find(|(pkg, _)| pkg.starts_with('@'))
{
return Err(Box::new(CliError::new(format!(
"refusing to migrate scoped package `{pkg}` while knope.toml is present (quoted keys are invisible to knope; unquoting them breaks @changesets/cli)"
))));
}
if parsed
.entries()
.iter()
.any(|(_, level)| *level == BumpLevel::None)
{
return Err(Box::new(CliError::new(format!(
"refusing to migrate `{path}`: a `none` entry is unsafe while knope.toml is present"
))));
}
Ok(())
}
fn apply_bump_rewrites(
dir: &Dir,
planned: &[BumpRewrite],
records: &mut Records,
) -> Result<(), Box<dyn std::error::Error>> {
for rewrite in planned {
write_file_via_rename(dir, Path::new(rewrite.dest()), rewrite.body())?;
match rewrite.leftover() {
Some(source) => records.record(&format!("wrote {} from {source}", rewrite.dest())),
None => records.record(&format!("rewrote {}", rewrite.dest())),
}
}
Ok(())
}
#[cfg(test)]
mod versioning_modes {
use oakum::detect::ReleaseTool;
use oakum::plan::Versioning;
use super::VersioningChoice;
#[test]
fn a_tool_holding_breaking_changes_below_one_settles_the_mode_whatever_its_order() {
let pairs = [
(Vec::from([ReleaseTool::ReleasePlz]), Versioning::ZeroMajor),
(
Vec::from([ReleaseTool::Bumpy, ReleaseTool::ReleasePlz]),
Versioning::ZeroMajor,
),
(
Vec::from([ReleaseTool::ReleasePlz, ReleaseTool::Bumpy]),
Versioning::ZeroMajor,
),
(
Vec::from([ReleaseTool::Bumpy, ReleaseTool::Changesets]),
Versioning::Semver,
),
(
Vec::from([ReleaseTool::Changesets, ReleaseTool::Knope]),
Versioning::ZeroMajor,
),
];
for (tools, expected) in pairs {
let settled = super::settles_the_mode(&tools).expect("a detection");
assert_eq!(
VersioningChoice::Inferred(settled).versioning(),
expected,
"{tools:?}"
);
}
}
#[test]
fn an_empty_scan_settles_nothing() {
assert_eq!(super::settles_the_mode(&[]), None);
assert_eq!(super::versioning_choice(&[], None), None);
}
#[test]
fn release_plz_holds_a_breaking_change_below_one() {
assert_eq!(
VersioningChoice::Inferred(ReleaseTool::ReleasePlz).versioning(),
Versioning::ZeroMajor
);
assert_eq!(
VersioningChoice::Inferred(ReleaseTool::Knope).versioning(),
Versioning::ZeroMajor
);
for semver in [
ReleaseTool::Changesets,
ReleaseTool::Bumpy,
ReleaseTool::ReleasePlease,
ReleaseTool::SemanticRelease,
ReleaseTool::NxRelease,
] {
assert_eq!(
VersioningChoice::Inferred(semver).versioning(),
Versioning::Semver,
"{}",
semver.name()
);
}
}
}
#[cfg(test)]
mod confirmation {
use super::{accept_migration_answer, skip_migration_confirmation};
#[test]
fn yes_skips_the_prompt_and_a_tty_gets_it() {
assert!(skip_migration_confirmation(true, true).expect("yes"));
assert!(skip_migration_confirmation(true, false).expect("yes"));
assert!(!skip_migration_confirmation(false, true).expect("tty"));
}
#[test]
fn non_tty_without_yes_refuses_and_names_the_flag() {
let err = skip_migration_confirmation(false, false).expect_err("non-tty");
assert!(err.to_string().contains("--yes"), "{err}");
}
#[test]
fn accepts_yes_variants() {
for answer in ["y", "yes", "Y", "Yes", "YES"] {
accept_migration_answer(answer).expect("yes");
}
}
#[test]
fn declines_empty_or_no() {
for answer in ["", "n", "no", "N", "No", "NO"] {
let err = accept_migration_answer(answer).expect_err("no");
assert_eq!(err.to_string(), "migration cancelled");
}
}
#[test]
fn declines_unknown_answers() {
let err = accept_migration_answer("maybe").expect_err("unknown");
assert!(err.to_string().contains("unknown answer `maybe`"));
}
}
#[cfg(test)]
mod after_load_policy {
use super::super::intent::refuse_malformed;
use oakum::changeset::load_migration_bump_files;
use oakum::plan::{Ecosystem, Package, PackageId, ResolvesDependenciesAt, Workspace};
use semver::Version;
fn workspace(packages: Vec<Package>) -> Workspace {
Workspace::new(packages).expect("workspace")
}
fn cargo_pkg(name: &str) -> Package {
Package::new(
PackageId::new(Ecosystem::Cargo, name),
Version::new(0, 1, 0),
ResolvesDependenciesAt::Install,
true,
vec![],
)
}
#[test]
fn refuse_malformed_ok_when_empty() {
refuse_malformed(&[]).expect("empty");
}
#[test]
fn refuse_malformed_names_every_report() {
let ws = workspace(vec![cargo_pkg("core")]);
let loaded = load_migration_bump_files(
[
(".changeset/a.md", "not a bump"),
(".changeset/b.md", "also broken"),
(".changeset/ok.md", "---\ncore: patch\n---\n"),
],
&ws,
)
.expect("missing packages only");
assert_eq!(loaded.malformed().len(), 2);
assert_eq!(loaded.files().len(), 1);
let err = refuse_malformed(loaded.malformed()).expect_err("refuse");
let message = err.to_string();
assert!(
message.contains("`.changeset/a.md` is not a bump file"),
"{message}"
);
assert!(message.contains("; also "), "{message}");
assert!(
message.contains("`.changeset/b.md` is not a bump file"),
"{message}"
);
}
}