use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
pub type GraphMemberId = Uuid;
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct ArrangementNodeId(Uuid);
impl ArrangementNodeId {
pub fn new() -> Self {
Self(Uuid::new_v4())
}
pub fn from_uuid(id: Uuid) -> Self {
Self(id)
}
pub fn as_uuid(self) -> Uuid {
self.0
}
}
impl Default for ArrangementNodeId {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum ArrangementNodeKind {
WorkbenchRoot,
MemberIntent { member: GraphMemberId },
TileIntent { member: Option<GraphMemberId> },
Group,
Portal,
Supernode,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ArrangementNode {
pub id: ArrangementNodeId,
pub kind: ArrangementNodeKind,
pub label: Option<String>,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum ArrangementEdgeKind {
MemberOf,
StackedWith,
SplitWith,
AdjacentTo,
CompareWith,
FocusPath,
PinnedIn,
MirrorOf,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ArrangementEdge {
pub from: ArrangementNodeId,
pub to: ArrangementNodeId,
pub kind: ArrangementEdgeKind,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Arrangement {
root: ArrangementNodeId,
nodes: BTreeMap<ArrangementNodeId, ArrangementNode>,
edges: Vec<ArrangementEdge>,
}
impl Arrangement {
pub fn new() -> Self {
let root = ArrangementNodeId::new();
let mut nodes = BTreeMap::new();
nodes.insert(
root,
ArrangementNode {
id: root,
kind: ArrangementNodeKind::WorkbenchRoot,
label: None,
},
);
Self {
root,
nodes,
edges: Vec::new(),
}
}
pub fn identity(members: impl IntoIterator<Item = GraphMemberId>) -> Self {
let mut arrangement = Self::new();
for member in members {
arrangement.add_member_intent(member);
}
arrangement
}
pub fn root(&self) -> ArrangementNodeId {
self.root
}
pub fn preserve_member_identity(&mut self, previous: &Self) {
let member_ids = |arrangement: &Self| {
let mut members = BTreeMap::<GraphMemberId, Vec<ArrangementNodeId>>::new();
for node in arrangement.nodes.values() {
if let ArrangementNodeKind::MemberIntent { member } = node.kind {
members.entry(member).or_default().push(node.id);
}
}
members
};
let old_members = member_ids(previous);
let mut ids = BTreeMap::from([(self.root, previous.root)]);
for (member, current) in member_ids(self) {
if let [id] = current.as_slice()
&& let Some(old) = old_members.get(&member)
&& let [old_id] = old.as_slice()
&& (id == old_id || !self.nodes.contains_key(old_id))
{
ids.insert(*id, *old_id);
}
}
self.root = previous.root;
self.nodes = std::mem::take(&mut self.nodes)
.into_values()
.map(|mut node| {
node.id = ids.get(&node.id).copied().unwrap_or(node.id);
(node.id, node)
})
.collect();
for edge in &mut self.edges {
edge.from = ids.get(&edge.from).copied().unwrap_or(edge.from);
edge.to = ids.get(&edge.to).copied().unwrap_or(edge.to);
}
}
pub fn insert(
&mut self,
kind: ArrangementNodeKind,
label: Option<String>,
) -> ArrangementNodeId {
let id = ArrangementNodeId::new();
self.nodes.insert(id, ArrangementNode { id, kind, label });
id
}
pub fn add_member_intent(&mut self, member: GraphMemberId) -> ArrangementNodeId {
let id = self.insert(ArrangementNodeKind::MemberIntent { member }, None);
self.attach(id, self.root);
id
}
pub fn add_tile_intent(&mut self, member: Option<GraphMemberId>) -> ArrangementNodeId {
let id = self.insert(ArrangementNodeKind::TileIntent { member }, None);
self.attach(id, self.root);
id
}
pub fn add_group(&mut self, label: Option<String>) -> ArrangementNodeId {
let id = self.insert(ArrangementNodeKind::Group, label);
self.attach(id, self.root);
id
}
pub fn attach(&mut self, child: ArrangementNodeId, parent: ArrangementNodeId) {
self.edges
.retain(|e| !(e.from == child && e.kind == ArrangementEdgeKind::MemberOf));
self.relate(child, parent, ArrangementEdgeKind::MemberOf);
}
pub fn relate(
&mut self,
from: ArrangementNodeId,
to: ArrangementNodeId,
kind: ArrangementEdgeKind,
) {
let edge = ArrangementEdge { from, to, kind };
if !self.edges.contains(&edge) {
self.edges.push(edge);
}
}
pub fn stack(&mut self, a: ArrangementNodeId, b: ArrangementNodeId) {
self.relate(a, b, ArrangementEdgeKind::StackedWith);
}
pub fn split(&mut self, a: ArrangementNodeId, b: ArrangementNodeId) {
self.relate(a, b, ArrangementEdgeKind::SplitWith);
}
pub fn node(&self, id: ArrangementNodeId) -> Option<&ArrangementNode> {
self.nodes.get(&id)
}
pub fn set_tile_member(
&mut self,
id: ArrangementNodeId,
member: Option<GraphMemberId>,
) -> bool {
match self.nodes.get_mut(&id).map(|n| &mut n.kind) {
Some(ArrangementNodeKind::TileIntent { member: slot }) => {
*slot = member;
true
},
_ => false,
}
}
pub fn nodes(&self) -> impl Iterator<Item = &ArrangementNode> {
self.nodes.values()
}
pub fn edges(&self) -> impl Iterator<Item = &ArrangementEdge> {
self.edges.iter()
}
pub fn len(&self) -> usize {
self.nodes.len()
}
pub fn is_empty(&self) -> bool {
self.nodes.len() <= 1
}
pub fn members_of(
&self,
container: ArrangementNodeId,
) -> impl Iterator<Item = ArrangementNodeId> + '_ {
self.edges
.iter()
.filter(move |e| e.to == container && e.kind == ArrangementEdgeKind::MemberOf)
.map(|e| e.from)
}
pub fn referenced_members(&self) -> Vec<GraphMemberId> {
let mut out: Vec<GraphMemberId> = self
.nodes
.values()
.filter_map(|n| match &n.kind {
ArrangementNodeKind::MemberIntent { member } => Some(*member),
ArrangementNodeKind::TileIntent { member: Some(m) } => Some(*m),
_ => None,
})
.collect();
out.sort();
out.dedup();
out
}
}
impl Default for Arrangement {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn identity_preservation_does_not_merge_repeated_member_appearances() {
let member = Uuid::from_u128(1);
let mut previous = Arrangement::new();
previous.add_member_intent(member);
previous.add_member_intent(member);
let mut next = Arrangement::new();
let first = next.add_member_intent(member);
let second = next.add_member_intent(member);
next.stack(first, second);
next.preserve_member_identity(&previous);
assert_eq!(next.len(), 3);
assert!(next.node(first).is_some());
assert!(next.node(second).is_some());
assert!(next.edges().any(|edge| {
edge.from == first && edge.to == second && edge.kind == ArrangementEdgeKind::StackedWith
}));
assert_eq!(next.root(), previous.root());
}
#[test]
fn identity_preservation_reuses_only_unambiguous_member_ids() {
let member = Uuid::from_u128(1);
let mut previous = Arrangement::new();
let old = previous.add_member_intent(member);
let mut next = Arrangement::new();
next.add_member_intent(member);
next.preserve_member_identity(&previous);
assert!(next.node(old).is_some());
let mut repeated = Arrangement::new();
let first = repeated.add_member_intent(member);
let second = repeated.add_member_intent(member);
repeated.preserve_member_identity(&previous);
assert_eq!(repeated.len(), 3);
assert!(repeated.node(first).is_some());
assert!(repeated.node(second).is_some());
repeated.preserve_member_identity(&repeated.clone());
assert!(repeated.node(first).is_some());
assert!(repeated.node(second).is_some());
}
#[test]
fn identity_preservation_does_not_overwrite_a_rebound_node() {
let member = Uuid::from_u128(1);
let mut previous = Arrangement::new();
let old = previous.add_member_intent(member);
let mut next = previous.clone();
next.nodes.get_mut(&old).unwrap().kind = ArrangementNodeKind::TileIntent {
member: Some(member),
};
let new = next.add_member_intent(member);
next.preserve_member_identity(&previous);
assert_eq!(next.len(), 3);
assert_eq!(
next.node(old).unwrap().kind,
ArrangementNodeKind::TileIntent {
member: Some(member)
}
);
assert!(next.node(new).is_some());
}
#[test]
fn new_arrangement_has_only_root() {
let a = Arrangement::new();
assert_eq!(a.len(), 1);
assert!(a.is_empty());
assert_eq!(
a.node(a.root()).unwrap().kind,
ArrangementNodeKind::WorkbenchRoot
);
}
#[test]
fn identity_references_every_member_under_the_root() {
let a = Arrangement::identity([Uuid::from_u128(3), Uuid::from_u128(1), Uuid::from_u128(2)]);
assert_eq!(
a.referenced_members(),
vec![Uuid::from_u128(1), Uuid::from_u128(2), Uuid::from_u128(3)]
);
assert_eq!(a.len(), 4, "root + three member intents");
assert_eq!(a.members_of(a.root()).count(), 3);
}
#[test]
fn member_intents_attach_to_root() {
let mut a = Arrangement::new();
let m1 = a.add_member_intent(Uuid::from_u128(1));
let m2 = a.add_member_intent(Uuid::from_u128(2));
let members: Vec<_> = a.members_of(a.root()).collect();
assert!(members.contains(&m1));
assert!(members.contains(&m2));
assert_eq!(a.len(), 3); }
#[test]
fn referenced_members_dedupes_and_sorts() {
let mut a = Arrangement::new();
a.add_member_intent(Uuid::from_u128(2));
a.add_tile_intent(Some(Uuid::from_u128(1)));
a.add_member_intent(Uuid::from_u128(2)); a.add_tile_intent(None); assert_eq!(
a.referenced_members(),
vec![Uuid::from_u128(1), Uuid::from_u128(2)]
);
}
#[test]
fn stack_and_split_are_relations_not_containment() {
let mut a = Arrangement::new();
let t1 = a.add_tile_intent(None);
let t2 = a.add_tile_intent(None);
a.stack(t1, t2);
a.split(t1, t2);
let kinds: Vec<_> = a
.edges()
.filter(|e| e.from == t1 && e.to == t2)
.map(|e| e.kind)
.collect();
assert!(kinds.contains(&ArrangementEdgeKind::StackedWith));
assert!(kinds.contains(&ArrangementEdgeKind::SplitWith));
}
#[test]
fn attach_reparents_exactly_once() {
let mut a = Arrangement::new();
let group = a.add_group(Some("g".into()));
let tile = a.add_tile_intent(None); a.attach(tile, group); let parents: Vec<_> = a
.edges()
.filter(|e| e.from == tile && e.kind == ArrangementEdgeKind::MemberOf)
.map(|e| e.to)
.collect();
assert_eq!(parents, vec![group]);
}
#[test]
fn relate_is_idempotent() {
let mut a = Arrangement::new();
let t1 = a.add_tile_intent(None);
let t2 = a.add_tile_intent(None);
a.stack(t1, t2);
a.stack(t1, t2);
let count = a
.edges()
.filter(|e| e.kind == ArrangementEdgeKind::StackedWith)
.count();
assert_eq!(count, 1);
}
#[test]
fn round_trips_through_json() {
let mut a = Arrangement::new();
let g = a.add_group(Some("research".into()));
let t = a.add_tile_intent(Some(Uuid::from_u128(7)));
a.attach(t, g);
let json = serde_json::to_string(&a).unwrap();
let back: Arrangement = serde_json::from_str(&json).unwrap();
assert_eq!(a, back);
}
#[test]
fn set_tile_member_rebinds_only_tile_intents() {
let mut a = Arrangement::new();
let tile = a.add_tile_intent(None);
let group = a.add_group(Some("g".into()));
assert!(a.set_tile_member(tile, Some(Uuid::from_u128(9))));
assert!(matches!(
a.node(tile).map(|n| &n.kind),
Some(ArrangementNodeKind::TileIntent { member: Some(_) })
));
assert!(!a.set_tile_member(group, Some(Uuid::from_u128(1))));
}
}