use std::collections::{BTreeMap, BTreeSet};
use std::io;
use std::path::Path;
use clap::Args;
use oakum::changeset::{is_bump_file_name, load_bump_files, MalformedBumpFile};
use oakum::config::DependencyUpdates;
use oakum::plan::{BumpFile, BumpLevel, DependencyUpdate, Package, PackageId, Workspace};
use oakum::state::{ReleaseState, ReleasingCommit, UnresolvedScope};
use oakum::tags::{intent_base, latest_tags, IntentBase};
use serde::Serialize;
use super::changelog::{has_version_section, Owner};
use super::config::{
load_config, named_by_a_commit, tag_managed_ids, unresolved_scope_line, LoadedConfig,
PlanIntentSource,
};
use super::coverage::Standing;
use super::deliver_out;
use super::fs::{repo_path_display, resolve_capability_path};
use super::generate::{commit_intents, resolve_from_ref, CommitIntents, CommitRanges, CommitTypes};
use super::git::Git;
use super::repository::{self, Repository};
use super::tags::reachable_tags;
use super::update_release::dependency_update_releases;
use super::workspace::discover_validated;
use super::write_set::read_text;
use super::CliError;
#[derive(Debug, Args)]
pub(super) struct PlanIntentArgs {
#[arg(long, value_name = "REF", help = super::FROM_INTENT)]
from: Option<String>,
}
pub(super) fn run(args: &PlanIntentArgs) -> Result<(), Box<dyn std::error::Error>> {
let repo = repository::discover()?;
let config = load_config(&repo)?;
let workspace = discover_validated(&repo, &config)?;
let git = Git::at_repository(&repo)?;
let files = load_plan_bump_files(&git, &repo, &workspace, &config, args.from.as_deref())?;
let report: Vec<PlanIntentReportFile> = files.iter().map(PlanIntentReportFile::from).collect();
deliver_out(&serde_json::to_string_pretty(&report)?)
.map_err(|err| CliError::undelivered("report", &err))?;
Ok(())
}
#[derive(Debug, Serialize)]
struct PlanIntentReportFile {
id: String,
entries: Vec<PlanIntentReportEntry>,
note: String,
}
#[derive(Debug, Serialize)]
struct PlanIntentReportEntry {
ecosystem: String,
name: String,
level: String,
}
impl From<&BumpFile> for PlanIntentReportFile {
fn from(file: &BumpFile) -> Self {
Self {
id: file.id.clone(),
entries: file
.entries
.iter()
.map(|(id, level)| PlanIntentReportEntry {
ecosystem: id.ecosystem.to_string(),
name: id.name.clone(),
level: level.to_string(),
})
.collect(),
note: file.note.clone(),
}
}
}
pub(super) fn load_plan_bump_files(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<Vec<BumpFile>, Box<dyn std::error::Error>> {
load_intent(git, repo, workspace, config, from, Updates::Skip).map(|intent| intent.files)
}
pub(super) struct PlanIntent {
pub(super) files: Vec<BumpFile>,
pub(super) updates: Vec<DependencyUpdate>,
pub(super) commit_types: Option<CommitTypes>,
pub(super) dropped: DroppedIntent,
}
#[derive(Debug, Default)]
pub(super) struct DroppedIntent {
pub(super) named_unmanaged: Vec<PackageId>,
pub(super) unresolved: Vec<UnresolvedScope>,
pub(super) awaiting_tag: Vec<PackageId>,
pub(super) updates_unread: Vec<PackageId>,
pub(super) only_updates: BTreeSet<PackageId>,
}
impl DroppedIntent {
pub(super) fn lines(&self) -> Vec<String> {
self.named_unmanaged
.iter()
.map(named_by_a_commit)
.chain(self.unresolved.iter().map(unresolved_scope_line))
.collect()
}
pub(super) fn report(&self, state: ReleaseState) -> ReleaseState {
state
.with_named_unmanaged(self.named_unmanaged.clone())
.with_unresolved_scopes(self.unresolved.clone())
.with_awaiting_tag(self.awaiting_tag.clone())
.with_updates_unread(self.updates_unread.clone())
.with_dependency_updates(&self.only_updates)
}
}
pub(super) fn load_plan_intent(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<PlanIntent, Box<dyn std::error::Error>> {
load_intent(git, repo, workspace, config, from, Updates::Derive)
}
pub(super) fn load_coverage_intent(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
base: &str,
) -> Result<PlanIntent, Box<dyn std::error::Error>> {
load_intent(git, repo, workspace, config, Some(base), Updates::Skip)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Updates {
Derive,
Skip,
}
pub(super) fn releaseless_commits(
git: &Git,
workspace: &Workspace,
config: &LoadedConfig,
base: &str,
) -> Result<BranchCommits, Box<dyn std::error::Error>> {
if !config.generate_allowed() {
return Ok(BranchCommits::default());
}
super::coverage::refuse_shallow(git)?;
let ranges = CommitRanges::from_base(&resolve_from_ref(git, Some(base))?, workspace);
let managed = |package: &oakum::plan::Package| config.version_managed(package);
let CommitIntents {
intents,
merges,
releasing,
types,
..
} = commit_intents(git, workspace, &ranges, managed)?;
let mut released: BTreeMap<PackageId, Vec<ReleasingCommit>> = BTreeMap::new();
let mut blocks = |id: PackageId, hash: &str, level: BumpLevel| {
let by = released.entry(id).or_default();
if by.iter().any(|seen| seen.commit == hash) {
return;
}
let read = types.get(hash).cloned().unwrap_or_default();
by.push(
ReleasingCommit::new(hash.to_owned(), read.subject, read.kind, level)
.expect("only a commit asking for a release blocks"),
);
};
for (hash, intent) in &intents {
if intent.level().is_release() {
for id in intent.packages() {
blocks(id.clone(), hash, intent.level());
}
}
}
for (hash, level, touched) in releasing {
for id in touched? {
blocks(id, &hash, level);
}
}
let files = intents
.iter()
.filter(|(hash, intent)| !intent.level().is_release() && !merges.contains(hash))
.filter_map(|(hash, intent)| {
let mut file = intent.bump_file(hash.clone());
file.entries.retain(|(id, _)| !released.contains_key(id));
(!file.entries.is_empty()).then_some(file)
})
.collect();
Ok(BranchCommits {
files,
types,
released,
})
}
#[derive(Clone, Debug, Default)]
pub(super) struct BranchCommits {
pub(super) files: Vec<BumpFile>,
pub(super) types: CommitTypes,
pub(super) released: BTreeMap<PackageId, Vec<ReleasingCommit>>,
}
fn load_intent(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
from: Option<&str>,
updates: Updates,
) -> Result<PlanIntent, Box<dyn std::error::Error>> {
let (updates, updates_unread) = match updates {
Updates::Derive => release_updates(git, repo, workspace, config, from)?,
Updates::Skip => (Vec::new(), Vec::new()),
};
match config.plan_intent_source()? {
PlanIntentSource::ChangeFiles => Ok(PlanIntent {
files: load_change_files(repo, workspace)?,
updates,
commit_types: None,
dropped: DroppedIntent {
updates_unread,
..DroppedIntent::default()
},
}),
PlanIntentSource::CommitsOnly => {
let (ranges, awaiting_tag) = match from {
Some(from) => (
CommitRanges::from_base(&resolve_from_ref(git, Some(from))?, workspace),
Vec::new(),
),
None => ranges_since_tags(git, repo, workspace, config)?,
};
let CommitIntents {
intents,
left_out,
unresolved,
types,
..
} = commit_intents(git, workspace, &ranges, |package| {
config.version_managed(package)
})?;
let named_unmanaged = workspace
.packages()
.filter(|package| {
left_out.contains(package.id())
&& config.standing(package) == Standing::Unmanaged
})
.map(|package| package.id().clone())
.collect();
let files = intents
.into_iter()
.map(|(hash, intent)| intent.bump_file(hash))
.collect();
Ok(PlanIntent {
files,
updates,
commit_types: Some(types),
dropped: DroppedIntent {
named_unmanaged,
unresolved,
awaiting_tag,
updates_unread,
only_updates: BTreeSet::new(),
},
})
}
}
}
fn release_updates(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<(Vec<DependencyUpdate>, Vec<PackageId>), Box<dyn std::error::Error>> {
if config.dependency_updates() != DependencyUpdates::Release {
return Ok((Vec::new(), Vec::new()));
}
let managed = |package: &Package| config.version_managed(package);
let (bases, unread): (BTreeMap<PackageId, String>, Vec<PackageId>) = if let Some(from) = from {
let base = resolve_from_ref(git, Some(from))?;
let bases = workspace
.packages()
.filter(|package| managed(package))
.map(|package| (package.id().clone(), base.clone()))
.collect();
(bases, Vec::new())
} else {
let tagged = tag_managed_ids(workspace, config);
let (ranges, awaiting) = ranges_since(git, repo, workspace, config, Untagged::Skipped)?;
let bases: BTreeMap<PackageId, String> = ranges
.bases()
.iter()
.filter(|(id, _)| tagged.contains(*id))
.filter(|(id, _)| workspace.get(id).is_some_and(managed))
.filter_map(|(id, base)| Some((id.clone(), base.clone()?)))
.collect();
let awaiting_reported = config.plan_intent_source()? == PlanIntentSource::CommitsOnly;
let unread = workspace
.packages()
.filter(|package| managed(package))
.map(|package| package.id().clone())
.filter(|id| !bases.contains_key(id) && (!awaiting_reported || !awaiting.contains(id)))
.collect();
(bases, unread)
};
Ok((
dependency_update_releases(git, workspace, managed, &bases)?,
unread,
))
}
fn ranges_since_tags(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
) -> Result<(CommitRanges, Vec<PackageId>), Box<dyn std::error::Error>> {
ranges_since(git, repo, workspace, config, Untagged::MergeBase)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Untagged {
MergeBase,
Skipped,
}
fn ranges_since(
git: &Git,
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
untagged: Untagged,
) -> Result<(CommitRanges, Vec<PackageId>), Box<dyn std::error::Error>> {
let tag_managed = tag_managed_ids(workspace, config);
let latest = if tag_managed.is_empty() {
BTreeMap::new()
} else {
let groups =
super::retired::without_retired(git, workspace, &tag_managed, reachable_tags(git)?)?
.groups;
let tags: Vec<Vec<&str>> = groups
.iter()
.map(|group| group.tags().iter().map(String::as_str).collect())
.collect();
let commits: Vec<(&str, &[&str])> = groups
.iter()
.zip(&tags)
.map(|(group, tags)| (group.commit(), tags.as_slice()))
.collect();
latest_tags(&commits, workspace, |id| tag_managed.contains(id))
.map_err(|err| CliError::unverified(err.to_string()))?
};
let mut merge_base: Option<String> = None;
let mut since_merge_base = || -> Result<Option<String>, Box<dyn std::error::Error>> {
if merge_base.is_none() {
merge_base = Some(resolve_from_ref(git, None)?);
}
Ok(merge_base.clone())
};
let mut bases = BTreeMap::new();
let mut awaiting_tag = Vec::new();
for package in workspace.packages() {
let base = if tag_managed.contains(package.id()) {
match intent_base(package, latest.get(package.id()), || {
has_version_section(repo.dir(), package, Owner::of(workspace, config, package))
})? {
IntentBase::Since(commit) => Some(commit),
IntentBase::Root => None,
IntentBase::AwaitingTag => {
if config.version_managed(package) {
awaiting_tag.push(package.id().clone());
}
continue;
}
}
} else if untagged == Untagged::MergeBase {
since_merge_base()?
} else {
continue;
};
bases.insert(package.id().clone(), base);
}
Ok((CommitRanges::new(bases), awaiting_tag))
}
fn load_change_files(
repo: &Repository,
workspace: &Workspace,
) -> Result<Vec<BumpFile>, Box<dyn std::error::Error>> {
let dir = repo.dir();
match dir.symlink_metadata(".changeset") {
Ok(_) => {}
Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(err) => {
return Err(Box::new(CliError::new(format!(
"failed to inspect `.changeset`: {err}"
))));
}
}
let changeset = resolve_capability_path(dir, repo.path(), Path::new(".changeset"))?;
let entries = dir.read_dir(&changeset).map_err(|err| {
CliError::new(format!(
"failed to read `{}`: {err}",
repo_path_display(&changeset)
))
})?;
let mut pairs: Vec<(String, String)> = Vec::new();
for entry in entries {
let entry = entry.map_err(|err| {
CliError::new(format!(
"failed to read `{}`: {err}",
repo_path_display(&changeset)
))
})?;
let name = entry.file_name();
let Some(name) = name.to_str() else {
continue;
};
if !is_bump_file_name(name) {
continue;
}
let relative = changeset.join(name);
match dir.metadata(&relative) {
Ok(meta) if meta.is_file() => {}
Ok(_) => continue,
Err(err) if err.kind() == io::ErrorKind::NotFound => {
return Err(Box::new(CliError::new(format!(
"failed to read `{}`: file disappeared",
repo_path_display(&relative)
))));
}
Err(err) => {
return Err(Box::new(CliError::new(format!(
"failed to inspect `{}`: {err}",
repo_path_display(&relative)
))));
}
}
let Some(body) = read_text(dir, &relative)? else {
return Err(Box::new(CliError::new(format!(
"failed to read `{}`: file disappeared",
repo_path_display(&relative)
))));
};
pairs.push((String::from(name), body));
}
pairs.sort_by(|a, b| a.0.cmp(&b.0));
let loaded = load_bump_files(
pairs
.iter()
.map(|(name, body)| (name.as_str(), body.as_str())),
workspace,
)
.map_err(|err| CliError::new(err.to_string()))?;
refuse_malformed(&loaded.malformed)?;
Ok(loaded.files)
}
pub(super) fn refuse_malformed(malformed: &[MalformedBumpFile]) -> Result<(), CliError> {
if malformed.is_empty() {
return Ok(());
}
let reports: Vec<String> = malformed.iter().map(ToString::to_string).collect();
Err(CliError::new(reports.join("; also ")))
}
#[cfg(test)]
mod tests {
use super::*;
use oakum::plan::Ecosystem;
use oakum::state::ReleaseSource;
#[test]
fn report_marks_releases_made_only_of_dependency_updates() {
let state: ReleaseState = serde_json::from_str(
r#"{"schema_version":1,"target":"status","uncovered":[],"packages":[
{"name":"app","ecosystem":"cargo","from":"0.1.0","to":"0.1.1","bump":"patch","source":{"kind":"intent"}},
{"name":"lib","ecosystem":"cargo","from":"0.1.0","to":"0.1.1","bump":"patch","source":{"kind":"intent"}}]}"#,
)
.expect("state");
let dropped = DroppedIntent {
only_updates: BTreeSet::from([PackageId::new(Ecosystem::Cargo, "app")]),
..DroppedIntent::default()
};
let state = dropped.report(state);
let sources: Vec<&ReleaseSource> = state
.packages()
.iter()
.map(oakum::state::PackageRelease::source)
.collect();
assert_eq!(
sources,
[&ReleaseSource::DependencyUpdate, &ReleaseSource::Intent]
);
}
}