use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::forme::arrangement::Arrangement;
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct FormeId(Uuid);
impl FormeId {
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 FormeId {
fn default() -> Self {
Self::new()
}
}
pub type GraphId = Uuid;
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum FormeRef {
Stored(FormeId),
Identity(GraphId),
}
impl FormeRef {
pub fn identity_graph(self) -> Option<GraphId> {
match self {
FormeRef::Identity(g) => Some(g),
FormeRef::Stored(_) => None,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct FormeDocument {
pub id: FormeId,
pub graph_id: GraphId,
pub label: Option<String>,
pub created_at_ms: u64,
pub updated_at_ms: u64,
pub arrangement: Arrangement,
}
impl FormeDocument {
pub fn new(graph_id: GraphId, label: Option<String>) -> Self {
Self {
id: FormeId::new(),
graph_id,
label,
created_at_ms: 0,
updated_at_ms: 0,
arrangement: Arrangement::new(),
}
}
pub fn forme_ref(&self) -> FormeRef {
FormeRef::Stored(self.id)
}
pub fn fork(&self, label: Option<String>) -> Self {
Self {
id: FormeId::new(),
graph_id: self.graph_id,
label,
created_at_ms: 0,
updated_at_ms: 0,
arrangement: self.arrangement.clone(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn new_document_is_empty_arrangement_bound_to_graph() {
let g = Uuid::from_u128(42);
let doc = FormeDocument::new(g, Some("research".into()));
assert_eq!(doc.graph_id, g);
assert_eq!(doc.label.as_deref(), Some("research"));
assert!(doc.arrangement.is_empty());
assert_eq!(doc.forme_ref(), FormeRef::Stored(doc.id));
}
#[test]
fn fork_gets_new_id_same_graph_and_arrangement() {
let g = Uuid::from_u128(7);
let mut doc = FormeDocument::new(g, Some("a".into()));
doc.arrangement.add_tile_intent(Some(Uuid::from_u128(1)));
let forked = doc.fork(Some("b".into()));
assert_ne!(forked.id, doc.id);
assert_eq!(forked.graph_id, g);
assert_eq!(forked.arrangement, doc.arrangement);
assert_eq!(forked.label.as_deref(), Some("b"));
}
#[test]
fn forme_ref_identity_carries_graph() {
let g = Uuid::from_u128(9);
assert_eq!(FormeRef::Identity(g).identity_graph(), Some(g));
assert_eq!(FormeRef::Stored(FormeId::new()).identity_graph(), None);
}
#[test]
fn document_round_trips_through_json() {
let mut doc = FormeDocument::new(Uuid::from_u128(3), None);
let g = doc.arrangement.add_group(Some("g".into()));
let t = doc.arrangement.add_tile_intent(Some(Uuid::from_u128(5)));
doc.arrangement.attach(t, g);
let json = serde_json::to_string(&doc).unwrap();
let back: FormeDocument = serde_json::from_str(&json).unwrap();
assert_eq!(doc, back);
}
}