use std::path::Path;
use indexmap::IndexMap;
use serde_json::{Value, json};
use std::io::IsTerminal;
use toha::context::InvocationContext;
use toha::hook::ProcessRunner;
use toha::interview::Seed;
use toha::protocol::Context;
use toha::snapshot::{
Action, Base, Change, Cleanliness, ConflictKind, FrozenNow, MergeOptions, Merged, Project,
RepoPath, Snapshot, SnapshotInputs, UpdateDrive, drive_update, drive_update_resume,
merge_apply_reported,
};
use toha::template::{Id, Template};
use toha::{RawAnswer, RawAnswers};
use crate::cli::resolve::ResolvedTemplate;
use crate::{
Dirs, EnvironmentDecision, Outcome, apply_environment_grant, build_context, load_template,
read_answers_text, requirement_error, resolution, setup,
};
#[derive(Clone)]
pub enum UpdateBase {
From(String),
Baseline,
}
#[allow(clippy::too_many_arguments)]
pub fn run_update(
base: UpdateBase,
template_arg: Option<String>,
path: &Path,
answers: Option<String>,
reanswer: bool,
dry_run: bool,
trust: bool,
dirs: &Dirs,
) -> Outcome {
let (target, _store) = match setup(path, dirs) {
Ok(value) => value,
Err(error) => return Outcome::Error(error),
};
let prep = match prepare(
&base,
template_arg,
&target,
dirs,
trust,
PrepareMode::Apply,
false,
answers.is_some(),
) {
Ok(value) => value,
Err(outcome) => return outcome,
};
let overrides = match &answers {
Some(file) => {
let text = match read_answers_text(file) {
Ok(value) => value,
Err(error) => return Outcome::Error(error),
};
match toha::protocol::verify_answers(&prep.resolved.formal_name, &text) {
Ok(value) => value,
Err(error) => return Outcome::Error(error.to_string()),
}
}
None => IndexMap::new(),
};
if answers.is_none() && std::io::stdin().is_terminal() {
return person_update(prep, &target, reanswer, dry_run);
}
let seed = Seed {
now: prep.now.clone(),
defaults: prep.configured_defaults.clone(),
context: prep.context.clone(),
};
let driven = match drive_update(&prep.template, seed, &prep.recorded, overrides, reanswer) {
Ok(value) => value,
Err(error) => return Outcome::Error(error.to_string()),
};
let (completed, submissions) = match driven {
UpdateDrive::Completed {
completed,
submissions,
} => (completed, submissions),
UpdateDrive::Ask {
pending,
rejections,
..
} => {
if answers.is_none() {
return Outcome::Error(
"the update has questions the recorded answers do not settle; \
stage it with `stage --from` to answer them"
.to_owned(),
);
}
let saved = crate::StagedRecord::new_with_context(
prep.context.clone(),
prep.resolved.commit.clone(),
prep.resolved.named,
prep.now.to_string(),
vec![],
);
let ctx = crate::context(&target, &saved);
return Outcome::Document(
toha::protocol::batch_document(pending.batch(), &ctx, Some(&rejections)),
4,
);
}
UpdateDrive::Ended(ended) => {
eprintln!("{}", crate::guidance::flow_ended(&ended));
return Outcome::Error(format!(
"the template ended the interview: {:?}",
ended.kind()
));
}
};
let dry_run = effective_dry_run(dry_run, &completed);
finish_merge(
prep,
&target,
completed,
submissions,
dry_run,
answers.is_some(),
)
}
fn person_update(
prep: Prepared,
target: &toha::staging::CanonicalTarget,
reanswer: bool,
dry_run: bool,
) -> Outcome {
let mut staged: Vec<IndexMap<Id, RawAnswer>> = Vec::new();
loop {
let seed = Seed {
now: prep.now.clone(),
defaults: prep.configured_defaults.clone(),
context: prep.context.clone(),
};
let driven =
match drive_update_resume(&prep.template, seed, &prep.recorded, &staged, reanswer) {
Ok(value) => value,
Err(error) => return Outcome::Error(error.to_string()),
};
match driven {
UpdateDrive::Completed {
completed,
submissions,
} => {
let dry_run = effective_dry_run(dry_run, &completed);
return finish_merge(prep, target, completed, submissions, dry_run, false);
}
UpdateDrive::Ask { pending, .. } => {
let submission =
match crate::terminal::prompt_batch(&pending, &mut crate::terminal::InquireAsk)
{
Ok(submission) => submission,
Err(error) => return Outcome::Error(error),
};
staged.push(submission);
}
UpdateDrive::Ended(ended) => {
eprintln!("{}", crate::guidance::flow_ended(&ended));
return Outcome::Error(format!(
"the template ended the interview: {:?}",
ended.kind()
));
}
}
}
}
pub(crate) struct Prepared {
pub project: Project,
pub merge_base: Base,
pub base_snapshot: Option<Snapshot>,
pub resolved: ResolvedTemplate,
pub template: Template,
pub now: jiff::Zoned,
pub context: InvocationContext,
pub configured_defaults: RawAnswers,
pub recorded: Vec<IndexMap<Id, RawAnswer>>,
pub trusted: bool,
}
pub(crate) enum PrepareMode {
Apply,
Stage,
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn prepare(
base: &UpdateBase,
template_arg: Option<String>,
target: &toha::staging::CanonicalTarget,
dirs: &Dirs,
trust: bool,
mode: PrepareMode,
interactive: bool,
scripted: bool,
) -> Result<Prepared, Outcome> {
let project = match Project::open(target) {
Ok(Some(project)) => project,
Ok(None) => {
return Err(Outcome::Error(
"the target is not inside a git repository; an update needs git".to_owned(),
));
}
Err(error) => return Err(Outcome::Error(error.to_string())),
};
let (merge_base, base_snapshot) = match base {
UpdateBase::From(prefix) => match project.find(prefix) {
Ok(snapshot) => (Base::Snapshot(snapshot.clone()), Some(snapshot)),
Err(error) => return Err(Outcome::Error(error.to_string())),
},
UpdateBase::Baseline => (Base::Empty, None),
};
if let Some(snapshot) = &base_snapshot
&& snapshot.target() != project.target()
{
return Err(Outcome::Error(format!(
"the snapshot was taken for target {:?}, not {:?}",
snapshot.target().as_str(),
project.target().as_str()
)));
}
match project.cleanliness() {
Ok(Cleanliness::Clean) => {}
Ok(Cleanliness::Dirty { .. }) => {
return Err(Outcome::Error(
"the target has uncommitted changes; commit or discard them before an update"
.to_owned(),
));
}
Err(error) => return Err(Outcome::Error(error.to_string())),
}
let cwd = std::env::current_dir().map_err(|e| Outcome::Error(e.to_string()))?;
let (config, registry) = cli_context(dirs, &cwd)?;
let resolved = match (&base_snapshot, &template_arg) {
(Some(snapshot), None) => {
let formal = snapshot.template().to_owned();
match crate::cli::resolve::resume_snapshot_template(
&formal,
snapshot.revision(),
&config,
®istry,
dirs,
&cwd,
) {
Ok(value) => value,
Err(error) => return Err(crate::resolve_error(error)),
}
}
(Some(snapshot), Some(arg)) => {
let resolved =
match crate::cli::resolve::resolve_template(arg, &config, ®istry, dirs, &cwd) {
Ok(value) => value,
Err(error) => return Err(crate::resolve_error(error)),
};
if !source_identity_matches(&resolved.formal_name, snapshot.source()) {
return Err(Outcome::Error(format!(
"the template's source {:?} is not the snapshot's source {:?}",
source_of(&resolved.formal_name),
snapshot.source()
)));
}
resolved
}
(None, Some(arg)) => {
match crate::cli::resolve::resolve_template(arg, &config, ®istry, dirs, &cwd) {
Ok(value) => value,
Err(error) => return Err(crate::resolve_error(error)),
}
}
(None, None) => {
return Err(Outcome::Error(
"apply --baseline needs a template operand: apply TEMPLATE PATH --baseline"
.to_owned(),
));
}
};
let template = match Template::load(&resolved.folder) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error.to_string())),
};
if let Err(error) = toha::requirement::check(&template) {
return Err(if scripted {
requirement_error(&error)
} else {
Outcome::Error(error.to_string())
});
}
let (resolution, runtime_now) = match resolution(&resolved.formal_name, &template, &config) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error)),
};
let (configured_defaults, _) = resolution.into_flat_defaults();
let now = match &base_snapshot {
Some(snapshot) => snapshot.generated().get().clone(),
None => runtime_now,
};
let (decision, trusted) = match mode {
PrepareMode::Apply => {
let trusted = apply_environment_grant(trust, &resolved, &template);
(EnvironmentDecision::grant_if_needed(trusted), trusted)
}
PrepareMode::Stage => {
let decision = if trust {
EnvironmentDecision::CarryStageGrant
} else {
EnvironmentDecision::RequireStageGrant
};
(decision, trust)
}
};
let context = match build_context(target, &resolved, &template, decision, interactive) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error)),
};
let recorded = match &base_snapshot {
Some(snapshot) => recorded_submissions(snapshot).map_err(Outcome::Error)?,
None => Vec::new(),
};
Ok(Prepared {
project,
merge_base,
base_snapshot,
resolved,
template,
now,
context,
configured_defaults,
recorded,
trusted,
})
}
pub(crate) fn resume_prepared(
saved: &crate::StagedRecord,
base: &UpdateBase,
target: &toha::staging::CanonicalTarget,
dirs: &Dirs,
trust: bool,
) -> Result<(Prepared, Vec<IndexMap<Id, RawAnswer>>), Outcome> {
let project = match Project::open(target) {
Ok(Some(project)) => project,
Ok(None) => {
return Err(Outcome::Error(
"the target is not inside a git repository; an update needs git".to_owned(),
));
}
Err(error) => return Err(Outcome::Error(error.to_string())),
};
match project.cleanliness() {
Ok(Cleanliness::Clean) => {}
Ok(Cleanliness::Dirty { .. }) => {
return Err(Outcome::Error(
"the target has uncommitted changes; commit or discard them before an update"
.to_owned(),
));
}
Err(error) => return Err(Outcome::Error(error.to_string())),
}
let (merge_base, base_snapshot) = match base {
UpdateBase::From(id) => match project.find(id) {
Ok(snapshot) => (Base::Snapshot(snapshot.clone()), Some(snapshot)),
Err(error) => return Err(Outcome::Error(error.to_string())),
},
UpdateBase::Baseline => (Base::Empty, None),
};
if let Some(snapshot) = &base_snapshot
&& snapshot.target() != project.target()
{
return Err(Outcome::Error(format!(
"the snapshot was taken for target {:?}, not {:?}",
snapshot.target().as_str(),
project.target().as_str()
)));
}
let cwd = std::env::current_dir().map_err(|e| Outcome::Error(e.to_string()))?;
let (config, registry) = cli_context(dirs, &cwd)?;
let resolved = match crate::cli::resolve::resume_template(
&saved.template,
&saved.commit,
saved.named,
&config,
®istry,
dirs,
&cwd,
) {
Ok(value) => value,
Err(error) => return Err(crate::resolve_error(error)),
};
let template = match load_template(&resolved) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error)),
};
let (resolution, _) = match resolution(&resolved.formal_name, &template, &config) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error)),
};
let (configured_defaults, _) = resolution.into_flat_defaults();
let now = match saved.now.parse::<jiff::Zoned>() {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error.to_string())),
};
let context = match saved.invocation_context(target) {
Ok(value) => value,
Err(error) => return Err(Outcome::Error(error.to_string())),
};
let trusted = apply_environment_grant(trust, &resolved, &template);
let recorded = match &base_snapshot {
Some(snapshot) => recorded_submissions(snapshot).map_err(Outcome::Error)?,
None => Vec::new(),
};
let staged = to_raw_staged(&saved.submissions).map_err(Outcome::Error)?;
Ok((
Prepared {
project,
merge_base,
base_snapshot,
resolved,
template,
now,
context,
configured_defaults,
recorded,
trusted,
},
staged,
))
}
fn to_raw_staged(
stored: &[IndexMap<String, Value>],
) -> Result<Vec<IndexMap<Id, RawAnswer>>, String> {
stored
.iter()
.map(|submission| {
submission
.iter()
.map(|(key, value)| {
Id::parse(key)
.map(|id| (id, RawAnswer(value.clone())))
.map_err(|message| format!("staged answer id {key:?}: {message}"))
})
.collect::<Result<IndexMap<_, _>, _>>()
})
.collect()
}
pub(crate) fn effective_dry_run(dry_run: bool, completed: &toha::Completed) -> bool {
dry_run || matches!(completed.step(), toha::Step::Plan { apply: false })
}
pub(crate) fn finish_merge(
prep: Prepared,
target: &toha::staging::CanonicalTarget,
completed: toha::Completed,
submissions: Vec<IndexMap<Id, RawAnswer>>,
dry_run: bool,
scripted: bool,
) -> Outcome {
let saved = crate::StagedRecord::new_with_context(
prep.context.clone(),
prep.resolved.commit.clone(),
prep.resolved.named,
prep.now.to_string(),
vec![],
);
let ctx = crate::context(target, &saved);
let base_id = prep
.base_snapshot
.as_ref()
.map(|snapshot| snapshot.id().to_string());
let revision = match crate::cli::resolve::snapshot_revision(
&prep.resolved.formal_name,
&prep.resolved.commit,
) {
Ok(revision) => revision,
Err(error) => return Outcome::Error(error.to_string()),
};
let generated = match &prep.base_snapshot {
Some(snapshot) => snapshot.generated().clone(),
None => FrozenNow::new(completed.now.clone()),
};
let inputs = SnapshotInputs {
template: prep.resolved.formal_name.clone(),
revision,
generated,
submissions: submissions.into_iter().map(raw_to_values).collect(),
};
let options = MergeOptions {
trusted: prep.trusted,
dry_run,
};
let runner: &dyn toha::hook::HookRunner = if scripted {
&crate::ScriptedRunner
} else {
&ProcessRunner
};
match merge_apply_reported(
&prep.project,
prep.merge_base,
&prep.template,
&completed,
inputs,
options,
runner,
) {
Ok((merged, report)) => {
let outcome = merged_outcome(merged, &ctx, base_id.as_deref());
if scripted {
outcome
} else {
crate::update_output::text_outcome(outcome, &report, dry_run)
}
}
Err(error) => Outcome::Error(error.to_string()),
}
}
fn cli_context(
dirs: &Dirs,
cwd: &Path,
) -> Result<(toha::config::Config, toha::registry::Registry), Outcome> {
crate::cli::resolve::load_context(dirs, cwd).map_err(crate::resolve_error)
}
fn source_of(formal: &str) -> &str {
formal.split_once('@').map_or(formal, |(source, _)| source)
}
fn source_identity_matches(resolved_formal: &str, snapshot_source: &str) -> bool {
source_of(resolved_formal) == snapshot_source
}
fn recorded_submissions(snapshot: &Snapshot) -> Result<Vec<IndexMap<Id, RawAnswer>>, String> {
snapshot
.submissions()
.iter()
.map(|submission| {
submission
.iter()
.map(|(key, value)| {
Id::parse(key)
.map(|id| (id, RawAnswer(value.clone())))
.map_err(|message| format!("recorded answer id {key:?}: {message}"))
})
.collect::<Result<IndexMap<_, _>, _>>()
})
.collect()
}
fn raw_to_values(submission: IndexMap<Id, RawAnswer>) -> IndexMap<Id, Value> {
submission
.into_iter()
.map(|(id, raw)| (id, raw.0))
.collect()
}
fn merged_outcome(merged: Merged, ctx: &Context, base_id: Option<&str>) -> Outcome {
match merged {
Merged::AlreadyCurrent => {
let mut document = toha::protocol::shell("already-current", ctx);
if let Some(id) = base_id {
document["snapshot"] = json!({ "id": id });
}
Outcome::Document(document, 0)
}
Merged::NeedsTrust => {
let mut document = toha::protocol::shell("planned", ctx);
document["files"] = json!([]);
document["messages"] = json!([]);
document["hooks"] = json!([]);
document["trusted"] = json!(false);
document["merge"] = json!({ "changes": [], "conflicted": [] });
Outcome::Document(document, 0)
}
Merged::Planned { changes } => {
let mut document = toha::protocol::shell("planned", ctx);
document["files"] = json!([]);
document["messages"] = json!([]);
document["hooks"] = json!([]);
document["trusted"] = json!(true);
document["merge"] = merge_member(&changes, &[]);
Outcome::Document(document, 0)
}
Merged::Written {
snapshot,
changes,
conflicted,
} => {
let mut document = toha::protocol::shell("applied", ctx);
document["files"] = json!([]);
document["messages"] = json!([]);
document["hooks"] = json!([]);
document["snapshot"] = json!({ "id": snapshot.to_string() });
document["merge"] = merge_member(&changes, &conflicted);
Outcome::Document(document, 0)
}
}
}
fn merge_member(changes: &[Change], conflicted: &[RepoPath]) -> Value {
json!({
"changes": changes.iter().map(change_json).collect::<Vec<_>>(),
"conflicted": conflicted.iter().map(|path| path.to_string()).collect::<Vec<_>>(),
})
}
fn change_json(change: &Change) -> Value {
let (action, conflict) = match change.action {
Action::Added => ("added", None),
Action::Updated => ("updated", None),
Action::Merged => ("merged", None),
Action::Deleted => ("deleted", None),
Action::NotPreviewed => ("not-previewed", None),
Action::Conflicted(kind) => ("conflicted", Some(conflict_name(kind))),
};
let mut object = json!({ "path": change.path.to_string(), "action": action });
if let Some(conflict) = conflict {
object["conflict"] = json!(conflict);
}
object
}
fn conflict_name(kind: ConflictKind) -> &'static str {
match kind {
ConflictKind::Content => "content",
ConflictKind::AddAdd => "add-add",
ConflictKind::ModifyDelete => "modify-delete",
ConflictKind::FileDirectory => "file-directory",
ConflictKind::Binary => "binary",
ConflictKind::Driver => "driver",
}
}
#[cfg(test)]
mod tests {
use super::{source_identity_matches, source_of};
#[test]
fn source_identity_matches_on_source_across_versions_and_refuses_a_foreign_source() {
assert!(
source_identity_matches("forge:catalog/receipt@v2", "forge:catalog/receipt"),
"a new version of the same source is accepted"
);
assert!(
source_identity_matches("forge:catalog/receipt@a1b2c3d", "forge:catalog/receipt"),
"a commit-pinned reference of the same source is accepted"
);
assert!(source_identity_matches(
"forge:catalog/receipt",
"forge:catalog/receipt"
));
assert!(
!source_identity_matches("forge:catalog/invoice@v2", "forge:catalog/receipt"),
"a different source is refused"
);
assert_eq!(
source_of("forge:catalog/receipt@v2"),
"forge:catalog/receipt"
);
}
}