use crate::{
FileWrite, Operation, OperationKind, OperationState, Store, StoreError,
merge::{MergePair, Resolved, blob_text, record_resolved, resolve_target},
plans::FileRecord,
};
use griz_core::Confidence;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum OnStale {
#[default]
Refuse,
Merge,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ApplyRequest {
pub plan: String,
pub min_confidence: Confidence,
pub on_stale: OnStale,
pub purpose: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UndoRequest {
pub operation: String,
pub root: PathBuf,
pub paths: Vec<PathBuf>,
pub on_stale: OnStale,
pub purpose: String,
}
impl Store {
pub fn apply(&self, request: &ApplyRequest) -> Result<Operation, StoreError> {
let record = self.plan(&request.plan)?;
let mut op = Operation::new(OperationKind::Apply, &request.purpose);
op.plan = Some(record.id.clone());
if !record.problems.is_empty() {
return self.refuse(
op,
"the plan has problems; fix the operations and plan again",
);
}
if record.confidence < request.min_confidence {
return self.refuse(op, "the plan has edits below the minimum confidence; select the confident edits or lower the minimum");
}
let paths: Vec<PathBuf> = record.files.iter().map(|file| file.path.clone()).collect();
let _locks = self.lock_paths(&paths)?;
let mut targets = Vec::with_capacity(record.files.len());
let mut changes: Vec<_> = record.files.iter().collect();
let resolved = crate::parallel::map(&mut changes, |change| {
self.resolve_change(change, request.on_stale)
})?;
for (change, resolved) in changes.into_iter().zip(resolved) {
record_resolved(&mut op, &mut targets, change.path.clone(), resolved);
}
if !op.conflicts.is_empty() {
return self.refuse(
op,
"files changed after planning; plan again or apply with on_stale merge",
);
}
self.execute(&mut op, &targets)?;
Ok(op)
}
fn resolve_change(
&self,
change: &FileRecord,
on_stale: OnStale,
) -> Result<Resolved, StoreError> {
let pair = MergePair {
base_hash: change.before_hash.as_deref(),
base: blob_text(self, change.before_hash.as_deref())?,
planned_hash: change.after_hash.as_deref(),
planned: blob_text(self, change.after_hash.as_deref())?,
};
resolve_target(self, &change.path, pair, on_stale)
}
pub fn undo(&self, request: &UndoRequest) -> Result<Operation, StoreError> {
let original = self.operation(&request.operation)?;
let mut op = Operation::new(OperationKind::Undo, &request.purpose);
op.undoes = Some(original.id.clone());
if original.state != OperationState::Applied {
return self.refuse(op, "only an applied operation can be undone");
}
let chosen: Vec<&FileWrite> = original
.files
.iter()
.filter(|file| request.paths.is_empty() || request.paths.contains(&file.path))
.collect();
let outside: Vec<String> = chosen
.iter()
.filter(|file| !file.path.starts_with(&request.root))
.map(|file| file.path.display().to_string())
.collect();
if !outside.is_empty() {
let reason = format!(
"{} lie outside root {}; undo never writes outside the caller's tree",
outside.join(", "),
request.root.display()
);
return self.refuse(op, &reason);
}
let locked: Vec<PathBuf> = chosen.iter().map(|file| file.path.clone()).collect();
let _locks = self.lock_paths(&locked)?;
let original = self.operation(&request.operation)?;
let mut chosen: Vec<_> = original
.files
.iter()
.filter(|file| request.paths.is_empty() || request.paths.contains(&file.path))
.collect();
let resolved =
crate::parallel::map(&mut chosen, |file| self.undo_target(file, request.on_stale))?;
let mut targets = Vec::new();
for (file, resolved) in chosen.into_iter().zip(resolved) {
record_resolved(&mut op, &mut targets, file.path.clone(), resolved);
}
if targets.is_empty() {
return self.refuse(op, "no file is still as the operation left it");
}
self.execute(&mut op, &targets)?;
Ok(op)
}
fn undo_target(&self, file: &FileWrite, on_stale: OnStale) -> Result<Resolved, StoreError> {
let pair = MergePair {
base_hash: file.after_hash.as_deref(),
base: blob_text(self, file.after_hash.as_deref())?,
planned_hash: file.before_hash.as_deref(),
planned: blob_text(self, file.before_hash.as_deref())?,
};
resolve_target(self, &file.path, pair, on_stale)
}
pub(crate) fn refuse(&self, mut op: Operation, reason: &str) -> Result<Operation, StoreError> {
op.state = OperationState::Failed;
op.reason = Some(reason.to_string());
self.save_operation(&op)?;
Ok(op)
}
}