use std::collections::HashSet;
use crate::forme::MemberId;
use crate::forme::subgraph::{
SubgraphBinding, SubgraphId, SubgraphMemberDelta, SubgraphSpec, ReconciliationChoice,
ReconciliationProposal,
};
use crate::forme::member::Lifecycle;
use crate::forme::nav::TreeIntent;
use crate::forme::tree::GraphTree;
pub fn compute_roster_delta<N: MemberId>(
tree: &GraphTree<N>,
subgraph_id: SubgraphId,
graph_truth_members: &[N],
) -> SubgraphMemberDelta<N> {
let truth_set: HashSet<&N> = graph_truth_members.iter().collect();
let tree_members: Vec<N> = tree
.subgraph_members(subgraph_id)
.into_iter()
.cloned()
.collect();
let tree_set: HashSet<&N> = tree_members.iter().collect();
let added: Vec<N> = graph_truth_members
.iter()
.filter(|m| !tree_set.contains(m))
.cloned()
.collect();
let removed: Vec<N> = tree_members
.iter()
.filter(|m| !truth_set.contains(m))
.cloned()
.collect();
SubgraphMemberDelta {
added,
removed,
rebased_seeds: Vec::new(),
}
}
pub fn propose_reconciliation<N: MemberId>(
tree: &GraphTree<N>,
subgraph_id: SubgraphId,
graph_truth_members: &[N],
reason: impl Into<String>,
) -> Option<ReconciliationProposal<N>> {
let delta = compute_roster_delta(tree, subgraph_id, graph_truth_members);
if delta.is_empty() {
return None;
}
Some(ReconciliationProposal {
subgraph_id,
delta,
reason: reason.into(),
})
}
pub fn apply_reconciliation<N: MemberId>(
tree: &mut GraphTree<N>,
proposal: &ReconciliationProposal<N>,
choice: ReconciliationChoice,
) -> Vec<TreeIntent<N>> {
let gid = proposal.subgraph_id;
let mut intents = Vec::new();
match choice {
ReconciliationChoice::ApplyKeepLinked => {
for member in &proposal.delta.added {
if tree.get(member).is_none() {
tree.apply(crate::forme::nav::NavAction::Attach {
member: member.clone(),
provenance: crate::forme::member::Provenance::Derived {
connection: None,
derivation: format!("subgraph-reconciliation:{}", gid),
},
});
}
if let Some(entry) = tree.get_mut(member) {
if !entry.subgraph_membership.contains(&gid) {
entry.subgraph_membership.push(gid);
}
}
intents.push(TreeIntent::MemberAttached(member.clone()));
}
for member in &proposal.delta.removed {
if let Some(entry) = tree.get_mut(member) {
entry.subgraph_membership.retain(|id| *id != gid);
}
let should_detach = tree
.get(member)
.map(|e| e.subgraph_membership.is_empty() && e.lifecycle == Lifecycle::Cold)
.unwrap_or(false);
if should_detach {
tree.apply(crate::forme::nav::NavAction::Detach {
member: member.clone(),
recursive: false,
});
intents.push(TreeIntent::MemberDetached(member.clone()));
}
}
intents.push(TreeIntent::ReconciliationNeeded {
subgraph: gid,
reason: format!("applied: {}", proposal.reason),
});
},
ReconciliationChoice::KeepAsUnlinkedSession => {
if let Some(subgraph) = tree.subgraphs_mut().iter_mut().find(|g| g.id == gid) {
subgraph.binding = SubgraphBinding::UnlinkedSession;
}
},
ReconciliationChoice::SaveAsNewFork { ref reason } => {
if let Some(subgraph) = tree.subgraphs_mut().iter_mut().find(|g| g.id == gid) {
let parent_spec = match &subgraph.binding {
SubgraphBinding::Linked { spec } => spec.clone(),
_ => SubgraphSpec {
kind: subgraph
.kind
.clone()
.unwrap_or(crate::forme::subgraph::SubgraphKind::Session),
anchors: Vec::new(),
primary_anchor: None,
selectors: Vec::new(),
},
};
subgraph.binding = SubgraphBinding::Branched {
parent_spec,
reason: reason.clone(),
};
}
},
ReconciliationChoice::Cancel => {
},
}
intents
}
pub fn detect_fork_on_manual_override<N: MemberId>(
tree: &GraphTree<N>,
member: &N,
operation: &str,
) -> Option<(SubgraphId, String)> {
let entry = tree.get(member)?;
for &gid in &entry.subgraph_membership {
let subgraph = tree.subgraphs().iter().find(|g| g.id == gid)?;
if matches!(subgraph.binding, SubgraphBinding::Linked { .. }) {
return Some((
gid,
format!(
"manual {} on member {:?} diverges from linked subgraph {}",
operation, member, gid
),
));
}
}
None
}
pub fn apply_fork<N: MemberId>(tree: &mut GraphTree<N>, subgraph_id: SubgraphId, reason: String) {
if let Some(subgraph) = tree
.subgraphs_mut()
.iter_mut()
.find(|g| g.id == subgraph_id)
{
let parent_spec = match &subgraph.binding {
SubgraphBinding::Linked { spec } => spec.clone(),
_ => return, };
subgraph.binding = SubgraphBinding::Branched {
parent_spec,
reason,
};
}
}
#[derive(Clone, Debug)]
pub struct ContainmentGroup<N: MemberId> {
pub label: String,
pub members: Vec<N>,
}
pub fn derive_containment_topology<N: MemberId>(
tree: &GraphTree<N>,
groups: &[ContainmentGroup<N>],
) -> Vec<(N, Vec<N>)> {
let all_members: HashSet<N> = tree.members().map(|(k, _)| k.clone()).collect();
let mut grouped: HashSet<N> = HashSet::new();
let mut result: Vec<(N, Vec<N>)> = Vec::new();
for group in groups {
let valid_members: Vec<N> = group
.members
.iter()
.filter(|m| all_members.contains(m))
.cloned()
.collect();
if valid_members.len() < 2 {
for m in &valid_members {
grouped.insert(m.clone());
}
continue;
}
let parent = valid_members[0].clone();
let children: Vec<N> = valid_members[1..].to_vec();
for m in &valid_members {
grouped.insert(m.clone());
}
result.push((parent, children));
}
result
}
#[cfg(test)]
mod tests {
use super::*;
use crate::forme::subgraph::{SubgraphKind, SubgraphRef};
use crate::forme::member::Provenance;
use crate::forme::nav::NavAction;
fn make_tree_with_linked_subgraph(members: &[u64], subgraph_members: &[u64]) -> GraphTree<u64> {
let mut tree = GraphTree::new(
crate::forme::layout::LayoutMode::TreeStyleTabs,
crate::forme::lens::ProjectionLens::Traversal,
);
for &m in members {
tree.apply(NavAction::Attach {
member: m,
provenance: Provenance::Manual {
source: None,
context: None,
},
});
}
let spec = SubgraphSpec {
kind: SubgraphKind::Session,
anchors: Vec::new(),
primary_anchor: None,
selectors: Vec::new(),
};
let subgraph = SubgraphRef {
id: 0,
anchors: Vec::new(),
primary_anchor: None,
binding: SubgraphBinding::Linked { spec },
kind: Some(SubgraphKind::Session),
};
tree.add_subgraph(subgraph);
for &m in subgraph_members {
if let Some(entry) = tree.get_mut(&m) {
entry.subgraph_membership.push(0);
}
}
tree
}
#[test]
fn empty_delta_when_synchronized() {
let tree = make_tree_with_linked_subgraph(&[1, 2, 3], &[1, 2, 3]);
let delta = compute_roster_delta(&tree, 0, &[1, 2, 3]);
assert!(delta.is_empty());
}
#[test]
fn delta_detects_additions() {
let tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let delta = compute_roster_delta(&tree, 0, &[1, 2, 3]);
assert_eq!(delta.added, vec![3]);
assert!(delta.removed.is_empty());
}
#[test]
fn delta_detects_removals() {
let tree = make_tree_with_linked_subgraph(&[1, 2, 3], &[1, 2, 3]);
let delta = compute_roster_delta(&tree, 0, &[1, 2]);
assert!(delta.added.is_empty());
assert_eq!(delta.removed, vec![3]);
}
#[test]
fn delta_detects_both() {
let tree = make_tree_with_linked_subgraph(&[1, 2, 3], &[1, 2, 3]);
let delta = compute_roster_delta(&tree, 0, &[1, 2, 4]);
assert_eq!(delta.added, vec![4]);
assert_eq!(delta.removed, vec![3]);
}
#[test]
fn propose_returns_none_when_synchronized() {
let tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
assert!(propose_reconciliation(&tree, 0, &[1, 2], "test").is_none());
}
#[test]
fn propose_returns_some_when_diverged() {
let tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let proposal = propose_reconciliation(&tree, 0, &[1, 2, 3], "graph change");
assert!(proposal.is_some());
assert_eq!(proposal.unwrap().delta.added, vec![3]);
}
#[test]
fn apply_keep_linked_adds_members() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let proposal = propose_reconciliation(&tree, 0, &[1, 2, 3], "test").unwrap();
let intents =
apply_reconciliation(&mut tree, &proposal, ReconciliationChoice::ApplyKeepLinked);
assert!(tree.get(&3).is_some());
assert!(tree.get(&3).unwrap().subgraph_membership.contains(&0));
assert!(!intents.is_empty());
}
#[test]
fn apply_keep_linked_removes_cold_unaffiliated_members() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2, 3], &[1, 2, 3]);
tree.apply(NavAction::SetLifecycle(3, Lifecycle::Cold));
let proposal = propose_reconciliation(&tree, 0, &[1, 2], "test").unwrap();
apply_reconciliation(&mut tree, &proposal, ReconciliationChoice::ApplyKeepLinked);
assert!(tree.get(&3).is_none());
}
#[test]
fn apply_keep_unlinked_converts_binding() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let proposal = propose_reconciliation(&tree, 0, &[1, 2, 3], "test").unwrap();
apply_reconciliation(
&mut tree,
&proposal,
ReconciliationChoice::KeepAsUnlinkedSession,
);
let binding = &tree.subgraphs()[0].binding;
assert!(matches!(binding, SubgraphBinding::UnlinkedSession));
}
#[test]
fn apply_fork_preserves_parent_spec() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let proposal = propose_reconciliation(&tree, 0, &[1, 2, 3], "test").unwrap();
apply_reconciliation(
&mut tree,
&proposal,
ReconciliationChoice::SaveAsNewFork {
reason: "user override".to_string(),
},
);
let binding = &tree.subgraphs()[0].binding;
match binding {
SubgraphBinding::Branched {
parent_spec,
reason,
} => {
assert_eq!(parent_spec.kind, SubgraphKind::Session);
assert_eq!(reason, "user override");
},
_ => panic!("expected Branched binding"),
}
}
#[test]
fn cancel_leaves_tree_unchanged() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let proposal = propose_reconciliation(&tree, 0, &[1, 2, 3], "test").unwrap();
apply_reconciliation(&mut tree, &proposal, ReconciliationChoice::Cancel);
assert!(tree.get(&3).is_none());
assert!(matches!(
tree.subgraphs()[0].binding,
SubgraphBinding::Linked { .. }
));
}
#[test]
fn detect_fork_finds_linked_subgraph() {
let tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
let result = detect_fork_on_manual_override(&tree, &1, "dismiss");
assert!(result.is_some());
let (gid, _reason) = result.unwrap();
assert_eq!(gid, 0);
}
#[test]
fn detect_fork_ignores_unlinked() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
tree.subgraphs_mut()[0].binding = SubgraphBinding::UnlinkedSession;
let result = detect_fork_on_manual_override(&tree, &1, "dismiss");
assert!(result.is_none());
}
#[test]
fn apply_fork_transitions_to_forked() {
let mut tree = make_tree_with_linked_subgraph(&[1, 2], &[1, 2]);
apply_fork(&mut tree, 0, "manual override".to_string());
assert!(matches!(
tree.subgraphs()[0].binding,
SubgraphBinding::Branched { .. }
));
}
#[test]
fn containment_topology_groups_members() {
let mut tree = GraphTree::new(
crate::forme::layout::LayoutMode::TreeStyleTabs,
crate::forme::lens::ProjectionLens::Traversal,
);
for i in 1..=6u64 {
tree.apply(NavAction::Attach {
member: i,
provenance: Provenance::Manual {
source: None,
context: None,
},
});
}
let groups = vec![
ContainmentGroup {
label: "example.com".to_string(),
members: vec![1, 2, 3],
},
ContainmentGroup {
label: "other.org".to_string(),
members: vec![4, 5],
},
];
let topology = derive_containment_topology(&tree, &groups);
assert_eq!(topology.len(), 2);
assert_eq!(topology[0].0, 1); assert_eq!(topology[0].1, vec![2, 3]); assert_eq!(topology[1].0, 4); assert_eq!(topology[1].1, vec![5]); }
}