use std::collections::{BTreeMap, BTreeSet};
use oakum::plan::{
aggregate_with_updates, compose_managed, declared_range, explain_plan, AggregatedBump,
BumpFile, CascadeAs, ComposeError, DependencyUpdate, Explain, Origin, PackageId, Plan,
Workspace,
};
use oakum::state::{Coverage, CoverageOutcome, ReleaseState, RenderTarget, Unlinked};
use super::config::{intent_names_unmanaged, LoadedConfig, PlanIntentSource};
use super::coverage::{self, BranchBumpFiles, Covering};
use super::generate::resolve_from_ref;
use super::git::Git;
use super::intent::{load_coverage_intent, load_plan_intent, DroppedIntent, PlanIntent};
use super::preconditions;
use super::render::NextStep;
use super::repository;
use super::say_err;
use super::verdict::verdict_line;
use super::workspace::discover_validated;
use super::CliError;
pub(super) struct Discovered {
workspace: Workspace,
git: Git,
files: Vec<BumpFile>,
updates: Vec<DependencyUpdate>,
dropped: DroppedIntent,
}
impl Discovered {
pub(super) fn read(
repo: &repository::Repository,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<Self, CliError> {
let workspace = discover_validated(repo, config)?;
let git = Git::at_repository(repo)?;
let PlanIntent {
files,
updates,
dropped,
..
} = load_plan_intent(&git, repo, &workspace, config, from)?;
Ok(Self {
workspace,
git,
files,
updates,
dropped,
})
}
pub(super) fn into_parts(
self,
) -> (
Workspace,
Git,
Vec<BumpFile>,
Vec<DependencyUpdate>,
DroppedIntent,
) {
(
self.workspace,
self.git,
self.files,
self.updates,
self.dropped,
)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum CoverageMode {
Required,
Reported,
}
pub(super) fn release_state(
repo: &repository::Repository,
config: &LoadedConfig,
from: Option<&str>,
target: RenderTarget,
mode: CoverageMode,
) -> Result<(ReleaseState, NextStep), CliError> {
let Discovered {
workspace,
git,
files,
updates,
dropped,
} = Discovered::read(repo, config, from)?;
let mut generate_from = None;
let coverage = resolve_coverage(
covering(repo, config, &git, &workspace, &files, from).and_then(|(covering, base)| {
if covering.files().is_empty() {
generate_from = Some(super::tags::shell_quote(&base));
}
coverage::changed_by_standing(&git, &workspace, &covering, from, |package| {
config.standing(package)
})
}),
mode,
)?;
let next = match config.plan_intent_source()? {
PlanIntentSource::ChangeFiles => NextStep::BumpFiles {
pending: files.len(),
generate: config.generate_allowed(),
generate_from: generate_from.filter(|_| config.generate_allowed()),
},
PlanIntentSource::CommitsOnly => NextStep::Commits,
};
let intent = aggregate_with_updates(files, updates);
let plan = compose_plan(config, &workspace, &intent)?;
let hand_set =
preconditions::hand_set_versions(&git, repo, config, &workspace, plan.changes())?
.reported()?;
let dropped = DroppedIntent {
only_updates: only_dependency_updates(&intent),
..dropped
};
let state = dropped
.report(ReleaseState::from_plan(&plan, coverage, target))
.with_hand_set(hand_set)
.with_unlinked(
if matches!(target, RenderTarget::Status | RenderTarget::Summary) {
unlinked(config, &workspace)
} else {
Vec::new()
},
)
.with_retired(preconditions::retired_packages(&git, config, &workspace));
let state = if preconditions::manages_nothing(config, &workspace) {
state.managing_nothing()
} else if preconditions::selection_is_empty(config, &workspace) {
state.selection_emptied()
} else {
state
};
Ok((state, next))
}
fn unlinked(config: &LoadedConfig, workspace: &Workspace) -> Vec<Unlinked> {
workspace
.packages()
.filter(|package| config.standing(package) != coverage::Standing::Excluded)
.flat_map(|package| {
package
.unlinked_dependencies()
.iter()
.filter_map(move |dependency| {
let member =
workspace.get(&PackageId::new(package.id().ecosystem, &dependency.on))?;
Some(Unlinked::new(
package.id().clone(),
dependency,
member.version().clone(),
))
})
})
.collect()
}
fn covering(
repo: &repository::Repository,
config: &LoadedConfig,
git: &Git,
workspace: &Workspace,
files: &[BumpFile],
from: Option<&str>,
) -> Result<(Covering, String), CliError> {
let base = resolve_from_ref(git, from)?;
let covering = match config.plan_intent_source()? {
PlanIntentSource::ChangeFiles => Covering::ChangeFiles {
files: BranchBumpFiles::read(git, &base)?.own(files),
commits: super::intent::releaseless_commits(git, workspace, config, &base)?,
},
PlanIntentSource::CommitsOnly => {
let intent = load_coverage_intent(git, repo, workspace, config, &base)?;
Covering::CommitsOnly {
commits: intent.files,
types: intent.commit_types.unwrap_or_default(),
}
}
};
Ok((covering, base))
}
pub(super) fn compose_plan(
config: &LoadedConfig,
workspace: &Workspace,
intent: &BTreeMap<PackageId, AggregatedBump>,
) -> Result<Plan, CliError> {
compose_managed(
workspace,
intent,
|id| config.versioning_for(&id.name),
CASCADE_AS,
|package| config.version_managed(package),
)
.map_err(|err| match err {
ComposeError::Unmanaged(id) => CliError::new(intent_names_unmanaged(&id.name)),
err => CliError::new(err.to_string()),
})
}
const CASCADE_AS: CascadeAs = CascadeAs::Patch;
pub(super) fn only_dependency_updates(
intent: &BTreeMap<PackageId, AggregatedBump>,
) -> BTreeSet<PackageId> {
intent
.iter()
.filter(|(_, bump)| {
let mut releasing = bump
.contributions()
.iter()
.filter(|contribution| contribution.level().is_release())
.peekable();
releasing.peek().is_some()
&& releasing.all(|contribution| contribution.origin() == Origin::DependencyUpdate)
})
.map(|(id, _)| id.clone())
.collect()
}
pub(super) fn explain(
git: &Git,
repo: &repository::Repository,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<Explain, CliError> {
let workspace = discover_validated(repo, config)?;
let PlanIntent { files, updates, .. } = load_plan_intent(git, repo, &workspace, config, from)?;
let plan = compose_plan(config, &workspace, &aggregate_with_updates(files, updates))?;
Ok(explain_plan(&workspace, &plan, CASCADE_AS, declared_range))
}
fn resolve_coverage(
look: Result<Coverage, CliError>,
mode: CoverageMode,
) -> Result<CoverageOutcome, CliError> {
match look {
Ok(coverage) => Ok(CoverageOutcome::Ran(coverage)),
Err(err) if mode == CoverageMode::Required => Err(err),
Err(err) => {
say_err(&format!(
"unverified: coverage not checked: {}",
verdict_line(&err.detail())
));
Ok(CoverageOutcome::Failed)
}
}
}
pub(super) fn apply_package_overrides(
workspace: &Workspace,
config: &LoadedConfig,
) -> Result<Workspace, Box<dyn std::error::Error>> {
let packages: Vec<_> = workspace
.packages()
.cloned()
.map(
|pkg| match config.resolves_dependencies_at(&pkg.id().name) {
Some(at) => pkg.with_resolves_dependencies_at(at),
None => pkg,
},
)
.collect();
Workspace::new(packages)
.map(|built| built.with_discovery_paths(workspace))
.map_err(|err| CliError::new(err.to_string()).into())
}
#[cfg(test)]
mod disposition {
use oakum::state::{Coverage, CoverageOutcome};
use super::{resolve_coverage, CoverageMode};
use crate::cli::CliError;
fn failed_look() -> Result<Coverage, CliError> {
Err(CliError::unverified("unverified: shallow clone"))
}
#[test]
fn a_required_look_that_failed_refuses() {
assert!(resolve_coverage(failed_look(), CoverageMode::Required).is_err());
}
#[test]
fn a_reported_look_that_failed_is_recorded_not_refused() {
assert_eq!(
resolve_coverage(failed_look(), CoverageMode::Reported).expect("reported"),
CoverageOutcome::Failed
);
}
#[test]
fn a_look_that_ran_carries_its_answers_under_either_disposition() {
for mode in [CoverageMode::Required, CoverageMode::Reported] {
let outcome = resolve_coverage(Ok(Coverage::default()), mode).expect("ran");
assert_eq!(outcome, CoverageOutcome::Ran(Coverage::default()));
}
}
}