use std::collections::BTreeMap;
use oakum::plan::{
aggregate, compose, AggregatedBump, BumpFile, CascadeAs, PackageId, Plan, Workspace,
};
use oakum::state::{Coverage, CoverageOutcome, ReleaseState, RenderTarget};
use super::add::discover_workspace;
use super::config::{intent_names_unmanaged, LoadedConfig};
use super::coverage;
use super::git::Git;
use super::intent::load_plan_bump_files;
use super::preconditions;
use super::repository;
use super::say_err;
use super::verdict::verdict_line;
use super::CliError;
pub(super) struct Discovered {
workspace: Workspace,
git: Git,
files: Vec<BumpFile>,
}
impl Discovered {
pub(super) fn read(
repo: &repository::Repository,
config: &LoadedConfig,
from: Option<&str>,
) -> Result<Self, CliError> {
let workspace = apply_package_overrides(
&discover_workspace(repo).map_err(CliError::from_boxed)?,
config,
)
.map_err(CliError::from_boxed)?;
config.validate_workspace_selection(&workspace)?;
let git = Git::at_repository(repo).map_err(CliError::from_boxed)?;
let files = load_plan_bump_files(&git, repo, &workspace, config, from)
.map_err(CliError::from_boxed)?;
Ok(Self {
workspace,
git,
files,
})
}
pub(super) fn into_parts(self) -> (Workspace, Git, Vec<BumpFile>) {
(self.workspace, self.git, self.files)
}
}
#[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, CliError> {
let (workspace, git, files) = Discovered::read(repo, config, from)?.into_parts();
let coverage = resolve_coverage(
coverage::changed_by_standing(&git, &workspace, &files, from, |package| {
config.standing(package)
}),
mode,
)?;
let plan = compose_plan(config, &workspace, &aggregate(files))?;
let state = ReleaseState::from_plan(&plan, coverage, target);
Ok(if preconditions::manages_nothing(config, &workspace) {
state.managing_nothing()
} else if preconditions::selection_is_empty(config, &workspace) {
state.selection_emptied()
} else {
state
})
}
pub(super) fn compose_plan(
config: &LoadedConfig,
workspace: &Workspace,
intent: &BTreeMap<PackageId, AggregatedBump>,
) -> Result<Plan, CliError> {
let mut plan = compose(
workspace,
intent,
|id| config.versioning_for(&id.name),
CascadeAs::Patch,
)
.map_err(|err| CliError::new(err.to_string()))?;
apply_version_selection(config, workspace, &mut plan)?;
Ok(plan)
}
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)
}
}
}
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())
}
pub(super) fn apply_version_selection(
config: &LoadedConfig,
workspace: &Workspace,
plan: &mut Plan,
) -> Result<(), CliError> {
plan.retain_managed(|id, _| {
workspace
.get(id)
.is_some_and(|package| config.version_managed(package))
})
.map_err(|id| CliError::new(intent_names_unmanaged(&id.name)))
}
#[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()));
}
}
}