use crate::error::Result;
use crate::policy::{decide, Decision};
use crate::port::{Addr, Item, Observed, Output, Repr, State, Store};
use std::collections::BTreeMap;
#[derive(Debug, Clone, Copy, Default)]
pub struct Options {
pub force: bool,
pub retract: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Entry {
pub addr: Addr,
pub decision: Decision,
pub declared: Option<Repr>,
pub observed: Observed,
pub note: Option<String>,
pub overridden: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Report {
pub entries: Vec<Entry>,
}
impl Report {
pub fn changed(&self) -> bool {
self.entries.iter().any(|e| e.decision.changes_target())
}
pub fn has_drift(&self) -> bool {
self.entries.iter().any(|e| e.decision.is_drift())
}
pub fn matching(&self, f: impl Fn(Decision) -> bool) -> impl Iterator<Item = &Entry> {
self.entries.iter().filter(move |e| f(e.decision))
}
pub fn tally(&self) -> Tally {
let mut t = Tally::default();
for e in &self.entries {
match e.decision {
Decision::Add => t.added += 1,
Decision::Skip => t.skipped += 1,
Decision::Update => t.updated += 1,
Decision::Retract => t.retracted += 1,
Decision::Refuse(_) => t.refused += 1,
}
}
t
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Tally {
pub added: usize,
pub skipped: usize,
pub updated: usize,
pub retracted: usize,
pub refused: usize,
}
pub fn run<S: Store>(store: &mut S, opts: Options) -> Result<(Report, Output)> {
let declared = store.declared()?;
let prior = store.owned();
let declared_by_addr: BTreeMap<&Addr, &Repr> =
declared.iter().map(|i| (&i.addr, &i.repr)).collect();
let prior_by_addr: BTreeMap<&Addr, &Repr> = prior.iter().map(|i| (&i.addr, &i.repr)).collect();
let mut walk: Vec<&Addr> = declared.iter().map(|i| &i.addr).collect();
let mut extra: Vec<&Addr> = prior_by_addr
.keys()
.copied()
.filter(|a| !declared_by_addr.contains_key(a))
.collect();
extra.sort();
walk.extend(extra);
let mut report = Report::default();
let mut owned: Vec<Item> = Vec::new();
for addr in walk {
let declared_repr = declared_by_addr.get(addr).copied();
let state = store.state(addr)?;
let base = decide(declared_repr, &state);
let (decision, overridden) = override_decision(base, &state, declared_repr.is_some(), opts);
match decision {
Decision::Add | Decision::Update => store.write(addr)?,
Decision::Retract => store.retract(addr)?,
Decision::Skip | Decision::Refuse(_) => {}
}
claim(
&mut owned,
addr,
decision,
base,
declared_repr,
prior_by_addr.get(addr).copied(),
);
report.entries.push(Entry {
addr: addr.clone(),
decision,
declared: declared_repr.cloned(),
observed: state.observed,
note: state.note,
overridden,
});
}
let output = store.finish(&owned)?;
Ok((report, output))
}
fn override_decision(
base: Decision,
state: &State,
is_declared: bool,
opts: Options,
) -> (Decision, bool) {
match base {
Decision::Refuse(_) if opts.force && is_declared => {
let forced = match state.observed {
Observed::Absent => Decision::Add,
Observed::Present(_) => Decision::Update,
};
(forced, true)
}
Decision::Retract if !opts.retract => (Decision::Skip, true),
other => (other, false),
}
}
fn claim(
owned: &mut Vec<Item>,
addr: &Addr,
decision: Decision,
base: Decision,
declared: Option<&Repr>,
prior: Option<&Repr>,
) {
let keep_prior = || prior.map(|r| Item::new(addr.clone(), r.clone()));
let item = match (declared, decision) {
(Some(d), Decision::Add | Decision::Update | Decision::Skip) => {
Some(Item::new(addr.clone(), d.clone()))
}
(Some(_), Decision::Refuse(_)) => keep_prior(),
(None, Decision::Skip) if base == Decision::Retract => keep_prior(),
_ => None,
};
if let Some(item) = item {
owned.push(item);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::policy::Reason;
use crate::port::{Ownership, State};
struct FakeStore {
declared: Vec<Item>,
prior: Vec<Item>,
present: BTreeMap<Addr, Repr>,
writes: Vec<Addr>,
retractions: Vec<Addr>,
}
impl FakeStore {
fn new(
declared: &[(&str, &str)],
prior: &[(&str, &str)],
present: &[(&str, &str)],
) -> Self {
let items = |v: &[(&str, &str)]| -> Vec<Item> {
v.iter()
.map(|(a, r)| Item::new(Addr::new(*a), Repr::new(*r)))
.collect()
};
FakeStore {
declared: items(declared),
prior: items(prior),
present: present
.iter()
.map(|(a, r)| (Addr::new(*a), Repr::new(*r)))
.collect(),
writes: Vec::new(),
retractions: Vec::new(),
}
}
}
impl Store for FakeStore {
fn declared(&self) -> Result<Vec<Item>> {
Ok(self.declared.clone())
}
fn owned(&self) -> Vec<Item> {
self.prior.clone()
}
fn state(&self, addr: &Addr) -> Result<State> {
let observed = match self.present.get(addr) {
Some(r) => Observed::Present(r.clone()),
None => Observed::Absent,
};
let recorded = self.prior.iter().find(|i| &i.addr == addr).map(|i| &i.repr);
let ownership = match (recorded, &observed) {
(None, _) => Ownership::Unknown,
(Some(_), Observed::Absent) => Ownership::Removed,
(Some(p), Observed::Present(o)) if p == o => Ownership::Ours,
(Some(_), Observed::Present(_)) => Ownership::Diverged,
};
Ok(State::new(observed, ownership))
}
fn write(&mut self, addr: &Addr) -> Result<()> {
let repr = self
.declared
.iter()
.find(|i| &i.addr == addr)
.map(|i| i.repr.clone())
.expect("write is only called for declared addresses");
self.present.insert(addr.clone(), repr);
self.writes.push(addr.clone());
Ok(())
}
fn retract(&mut self, addr: &Addr) -> Result<()> {
self.present.remove(addr);
self.retractions.push(addr.clone());
Ok(())
}
fn finish(&mut self, owned: &[Item]) -> Result<Output> {
Ok(Output {
document: self
.present
.iter()
.map(|(a, r)| format!("{a}={r}\n"))
.collect(),
prior: Some(owned.to_vec()),
})
}
}
fn decisions(report: &Report) -> Vec<(String, Decision)> {
report
.entries
.iter()
.map(|e| (e.addr.to_string(), e.decision))
.collect()
}
#[test]
fn adds_what_is_absent_and_claims_it() {
let mut s = FakeStore::new(&[("a", "1")], &[], &[]);
let (r, out) = run(&mut s, Options::default()).unwrap();
assert_eq!(decisions(&r), vec![("a".into(), Decision::Add)]);
assert_eq!(
out.prior.unwrap(),
vec![Item::new(Addr::new("a"), Repr::new("1"))]
);
}
#[test]
fn updates_a_value_this_tool_wrote() {
let mut s = FakeStore::new(&[("a", "2")], &[("a", "1")], &[("a", "1")]);
let (r, _) = run(&mut s, Options::default()).unwrap();
assert_eq!(decisions(&r), vec![("a".into(), Decision::Update)]);
assert_eq!(s.present.get(&Addr::new("a")).unwrap(), &Repr::new("2"));
}
#[test]
fn refuses_a_value_it_cannot_claim() {
let mut s = FakeStore::new(&[("a", "2")], &[], &[("a", "theirs")]);
let (r, _) = run(&mut s, Options::default()).unwrap();
assert_eq!(
decisions(&r),
vec![("a".into(), Decision::Refuse(Reason::Conflict))]
);
assert_eq!(
s.present.get(&Addr::new("a")).unwrap(),
&Repr::new("theirs")
);
assert!(s.writes.is_empty(), "nothing may be written on a refusal");
}
#[test]
fn retraction_is_off_by_default_but_keeps_the_claim() {
let mut s = FakeStore::new(&[], &[("a", "1")], &[("a", "1")]);
let (r, out) = run(&mut s, Options::default()).unwrap();
assert_eq!(decisions(&r), vec![("a".into(), Decision::Skip)]);
assert!(s.retractions.is_empty());
assert_eq!(
out.prior.unwrap(),
vec![Item::new(Addr::new("a"), Repr::new("1"))],
"a suppressed retraction stays claimed so it can be retracted later"
);
}
#[test]
fn retraction_removes_only_what_was_ours() {
let mut s = FakeStore::new(&[], &[("ours", "1")], &[("ours", "1"), ("theirs", "x")]);
let opts = Options {
retract: true,
..Options::default()
};
let (r, out) = run(&mut s, opts).unwrap();
assert_eq!(decisions(&r), vec![("ours".into(), Decision::Retract)]);
assert!(!s.present.contains_key(&Addr::new("ours")));
assert!(
s.present.contains_key(&Addr::new("theirs")),
"an item this tool never wrote is not walked and not touched"
);
assert!(out.prior.unwrap().is_empty());
}
#[test]
fn force_overrides_a_refusal_and_says_so() {
let mut s = FakeStore::new(&[("a", "2")], &[], &[("a", "theirs")]);
let opts = Options {
force: true,
..Options::default()
};
let (r, _) = run(&mut s, opts).unwrap();
assert_eq!(decisions(&r), vec![("a".into(), Decision::Update)]);
assert!(r.entries[0].overridden);
}
#[test]
fn a_second_identical_run_only_skips() {
let mut s = FakeStore::new(&[("a", "1"), ("b", "2")], &[], &[]);
let (first, out) = run(&mut s, Options::default()).unwrap();
assert!(first.changed());
let prior: Vec<(String, String)> = out
.prior
.unwrap()
.iter()
.map(|i| (i.addr.to_string(), i.repr.to_string()))
.collect();
let prior: Vec<(&str, &str)> = prior
.iter()
.map(|(a, r)| (a.as_str(), r.as_str()))
.collect();
let present = prior.clone();
let mut s2 = FakeStore::new(&[("a", "1"), ("b", "2")], &prior, &present);
let (second, _) = run(&mut s2, Options::default()).unwrap();
assert!(!second.changed(), "a settled declaration must not rewrite");
assert!(!second.has_drift());
assert_eq!(second.tally().skipped, 2);
}
#[test]
fn adoption_claims_a_matching_value_written_before_provenance() {
let mut s = FakeStore::new(&[("a", "1")], &[], &[("a", "1")]);
let (r, out) = run(&mut s, Options::default()).unwrap();
assert_eq!(decisions(&r), vec![("a".into(), Decision::Skip)]);
assert_eq!(
out.prior.unwrap(),
vec![Item::new(Addr::new("a"), Repr::new("1"))],
"agreeing on a value adopts it, so a later change can apply"
);
}
#[test]
fn a_hand_edit_keeps_its_history_across_runs() {
let mut s = FakeStore::new(&[("a", "1")], &[("a", "1")], &[("a", "edited")]);
let (r, out) = run(&mut s, Options::default()).unwrap();
assert_eq!(
decisions(&r),
vec![("a".into(), Decision::Refuse(Reason::HandEdited))]
);
assert_eq!(
out.prior.unwrap(),
vec![Item::new(Addr::new("a"), Repr::new("1"))],
"keeping the old record is what lets the next run still say hand-edited"
);
}
#[test]
fn a_deletion_by_someone_else_is_not_undone() {
let mut s = FakeStore::new(&[("a", "1")], &[("a", "1")], &[]);
let (r, _) = run(&mut s, Options::default()).unwrap();
assert_eq!(
decisions(&r),
vec![("a".into(), Decision::Refuse(Reason::RemovedByOther))]
);
assert!(s.writes.is_empty());
}
#[test]
fn walk_order_is_declaration_then_sorted_remainder() {
let mut s = FakeStore::new(
&[("z", "1"), ("a", "2")],
&[("m", "3"), ("b", "4")],
&[("m", "3"), ("b", "4")],
);
let (r, _) = run(&mut s, Options::default()).unwrap();
let order: Vec<String> = r.entries.iter().map(|e| e.addr.to_string()).collect();
assert_eq!(order, vec!["z", "a", "b", "m"]);
}
#[test]
fn tally_counts_each_outcome() {
let mut s = FakeStore::new(
&[("add", "1"), ("skip", "2"), ("conflict", "3")],
&[("skip", "2")],
&[("skip", "2"), ("conflict", "theirs")],
);
let (r, _) = run(&mut s, Options::default()).unwrap();
let t = r.tally();
assert_eq!(t.added, 1);
assert_eq!(t.skipped, 1);
assert_eq!(t.refused, 1);
assert!(r.has_drift());
}
}