use crate::port::{Observed, Ownership, Repr, State};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Reason {
Conflict,
HandEdited,
RemovedByOther,
}
impl Reason {
pub fn label(self) -> &'static str {
match self {
Reason::Conflict => "conflict",
Reason::HandEdited => "hand-edited",
Reason::RemovedByOther => "removed",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Decision {
Add,
Skip,
Update,
Retract,
Refuse(Reason),
}
impl Decision {
pub fn changes_target(self) -> bool {
matches!(self, Decision::Add | Decision::Update | Decision::Retract)
}
pub fn is_drift(self) -> bool {
matches!(self, Decision::Refuse(_))
}
pub fn label(self) -> &'static str {
match self {
Decision::Add => "add",
Decision::Skip => "skip",
Decision::Update => "update",
Decision::Retract => "retract",
Decision::Refuse(r) => r.label(),
}
}
}
pub fn decide(declared: Option<&Repr>, state: &State) -> Decision {
let Some(declared) = declared else {
return match (state.ownership, &state.observed) {
(Ownership::Ours, Observed::Present(_)) => Decision::Retract,
_ => Decision::Skip,
};
};
match state.ownership {
Ownership::Diverged => Decision::Refuse(Reason::HandEdited),
Ownership::Removed => Decision::Refuse(Reason::RemovedByOther),
Ownership::Ours => {
if state.observed.equals(declared) {
Decision::Skip
} else {
Decision::Update
}
}
Ownership::Unknown => match &state.observed {
Observed::Absent => Decision::Add,
Observed::Present(o) if o == declared => {
Decision::Skip
}
Observed::Present(_) => Decision::Refuse(Reason::Conflict),
},
}
}
#[cfg(test)]
mod tests {
use super::*;
fn repr(s: &str) -> Repr {
Repr::new(s)
}
fn state(observed: Observed, ownership: Ownership) -> State {
State::new(observed, ownership)
}
fn present(s: &str) -> Observed {
Observed::Present(repr(s))
}
#[test]
fn unknown_absent_is_added() {
let s = state(Observed::Absent, Ownership::Unknown);
assert_eq!(decide(Some(&repr("1")), &s), Decision::Add);
}
#[test]
fn unknown_matching_is_adopted_by_skipping() {
let s = state(present("1"), Ownership::Unknown);
assert_eq!(decide(Some(&repr("1")), &s), Decision::Skip);
}
#[test]
fn unknown_differing_is_refused_and_not_updated() {
let s = state(present("1"), Ownership::Unknown);
assert_eq!(
decide(Some(&repr("2")), &s),
Decision::Refuse(Reason::Conflict)
);
}
#[test]
fn ours_differing_is_updated() {
let s = state(present("1"), Ownership::Ours);
assert_eq!(decide(Some(&repr("2")), &s), Decision::Update);
}
#[test]
fn ours_matching_is_skipped() {
let s = state(present("2"), Ownership::Ours);
assert_eq!(decide(Some(&repr("2")), &s), Decision::Skip);
}
#[test]
fn diverged_is_refused_whatever_is_declared() {
let s = state(present("edited"), Ownership::Diverged);
assert_eq!(
decide(Some(&repr("x")), &s),
Decision::Refuse(Reason::HandEdited)
);
}
#[test]
fn removed_is_not_resurrected() {
let s = state(Observed::Absent, Ownership::Removed);
assert_eq!(
decide(Some(&repr("x")), &s),
Decision::Refuse(Reason::RemovedByOther)
);
}
#[test]
fn undeclared_and_ours_is_retracted() {
let s = state(present("old"), Ownership::Ours);
assert_eq!(decide(None, &s), Decision::Retract);
}
#[test]
fn undeclared_and_not_ours_is_left_alone() {
for own in [Ownership::Unknown, Ownership::Diverged, Ownership::Removed] {
let s = state(present("theirs"), own);
assert_eq!(decide(None, &s), Decision::Skip, "ownership {own:?}");
}
}
#[test]
fn nothing_is_written_unless_ours_or_absent() {
for own in [
Ownership::Unknown,
Ownership::Ours,
Ownership::Diverged,
Ownership::Removed,
] {
let s = state(present("theirs"), own);
let d = decide(Some(&repr("mine")), &s);
if d.changes_target() {
assert_eq!(own, Ownership::Ours, "would overwrite with {own:?}");
}
}
}
#[test]
fn an_agreed_declaration_reapplies_as_skip() {
let s = state(present("v"), Ownership::Ours);
assert_eq!(decide(Some(&repr("v")), &s), Decision::Skip);
}
#[test]
fn labels_are_distinct_per_outcome() {
let labels = [
Decision::Add.label(),
Decision::Skip.label(),
Decision::Update.label(),
Decision::Retract.label(),
Decision::Refuse(Reason::Conflict).label(),
Decision::Refuse(Reason::HandEdited).label(),
Decision::Refuse(Reason::RemovedByOther).label(),
];
let mut sorted = labels.to_vec();
sorted.sort_unstable();
sorted.dedup();
assert_eq!(sorted.len(), labels.len(), "labels collide: {labels:?}");
}
#[test]
fn only_refusal_is_drift() {
assert!(Decision::Refuse(Reason::Conflict).is_drift());
assert!(!Decision::Add.is_drift());
assert!(!Decision::Skip.is_drift());
assert!(!Decision::Update.is_drift());
assert!(!Decision::Retract.is_drift());
}
}