automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/exid.rs

@@ -0,0 +1,238 @@
+use crate::storage::parse;
+use crate::types::{ObjId, OpId};
+use crate::ActorId;
+use serde::Serialize;
+use serde::Serializer;
+use std::cmp::{Ord, Ordering};
+use std::fmt;
+use std::hash::{Hash, Hasher};
+
+/// An identifier for an object in a document
+///
+/// This can be persisted using `to_bytes` and `TryFrom<&[u8]>` breaking changes to the
+/// serialization format will be considered breaking changes for this library version.
+#[derive(Debug, Clone)]
+pub enum ExId {
+    Root,
+    Id(u64, ActorId, usize),
+}
+
+const SERIALIZATION_VERSION_TAG: u8 = 0;
+const TYPE_ROOT: u8 = 0;
+const TYPE_ID: u8 = 1;
+
+impl ExId {
+    /// Serialize this object ID to a byte array.
+    ///
+    /// This serialization format is versioned and incompatible changes to it will be considered a
+    /// breaking change for the version of this library.
+    pub fn to_bytes(&self) -> Vec<u8> {
+        // The serialized format is
+        //
+        // .--------------------------------.
+        // | version   | type   | data      |
+        // +--------------------------------+
+        // |  4 bytes  |4 bytes | variable  |
+        // '--------------------------------'
+        //
+        // Version is currently always `0`
+        //
+        // `data` depends on the type
+        //
+        // * If the type is `TYPE_ROOT` (0) then there is no data
+        // * If the type is `TYPE_ID` (1) then the data is
+        //
+        // .-------------------------------------------------------.
+        // | actor ID len | actor ID bytes | counter | actor index |
+        // '-------------------------------------------------------'
+        //
+        // Where the actor ID len, counter, and actor index are all uLEB encoded
+        // integers. The actor ID bytes is just an array of bytes.
+        //
+        match self {
+            ExId::Root => {
+                let val: u8 = SERIALIZATION_VERSION_TAG | (TYPE_ROOT << 4);
+                vec![val]
+            }
+            ExId::Id(id, actor, counter) => {
+                let actor_bytes = actor.to_bytes();
+                let mut bytes = Vec::with_capacity(actor_bytes.len() + 4 + 4);
+                let tag = SERIALIZATION_VERSION_TAG | (TYPE_ID << 4);
+                bytes.push(tag);
+                leb128::write::unsigned(&mut bytes, actor_bytes.len() as u64).unwrap();
+                bytes.extend_from_slice(actor_bytes);
+                leb128::write::unsigned(&mut bytes, *counter as u64).unwrap();
+                leb128::write::unsigned(&mut bytes, *id).unwrap();
+                bytes
+            }
+        }
+    }
+
+    pub(crate) fn to_internal_obj(&self) -> ObjId {
+        match self {
+            ExId::Root => ObjId::root(),
+            ExId::Id(ctr, _, actor) => ObjId(OpId::new(*ctr, *actor)),
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ObjIdFromBytesError {
+    #[error("no version tag")]
+    NoVersion,
+    #[error("invalid version tag")]
+    InvalidVersion(u8),
+    #[error("invalid type tag")]
+    InvalidType(u8),
+    #[error("invalid Actor ID length: {0}")]
+    ParseActorLen(String),
+    #[error("Not enough bytes in actor ID")]
+    ParseActor,
+    #[error("invalid counter: {0}")]
+    ParseCounter(String),
+    #[error("invalid actor index hint: {0}")]
+    ParseActorIdxHint(String),
+}
+
+impl<'a> TryFrom<&'a [u8]> for ExId {
+    type Error = ObjIdFromBytesError;
+
+    fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
+        let i = parse::Input::new(value);
+        let (i, tag) = parse::take1::<()>(i).map_err(|_| ObjIdFromBytesError::NoVersion)?;
+        let version = tag & 0b1111;
+        if version != SERIALIZATION_VERSION_TAG {
+            return Err(ObjIdFromBytesError::InvalidVersion(version));
+        }
+        let type_tag = tag >> 4;
+        match type_tag {
+            TYPE_ROOT => Ok(ExId::Root),
+            TYPE_ID => {
+                let (i, len) = parse::leb128_u64::<parse::leb128::Error>(i)
+                    .map_err(|e| ObjIdFromBytesError::ParseActorLen(e.to_string()))?;
+                let (i, actor) = parse::take_n::<()>(len as usize, i)
+                    .map_err(|_| ObjIdFromBytesError::ParseActor)?;
+                let (i, counter) = parse::leb128_u64::<parse::leb128::Error>(i)
+                    .map_err(|e| ObjIdFromBytesError::ParseCounter(e.to_string()))?;
+                let (_i, actor_idx_hint) = parse::leb128_u64::<parse::leb128::Error>(i)
+                    .map_err(|e| ObjIdFromBytesError::ParseActorIdxHint(e.to_string()))?;
+                Ok(Self::Id(actor_idx_hint, actor.into(), counter as usize))
+            }
+            other => Err(ObjIdFromBytesError::InvalidType(other)),
+        }
+    }
+}
+
+impl PartialEq for ExId {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (ExId::Root, ExId::Root) => true,
+            (ExId::Id(ctr1, actor1, _), ExId::Id(ctr2, actor2, _))
+                if ctr1 == ctr2 && actor1 == actor2 =>
+            {
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<ObjId> for ExId {
+    fn eq(&self, other: &ObjId) -> bool {
+        &self.to_internal_obj() == other
+    }
+}
+
+impl Eq for ExId {}
+
+impl fmt::Display for ExId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExId::Root => write!(f, "_root"),
+            ExId::Id(ctr, actor, _) => write!(f, "{}@{}", ctr, actor),
+        }
+    }
+}
+
+impl Hash for ExId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            ExId::Root => 0.hash(state),
+            ExId::Id(ctr, actor, _) => {
+                ctr.hash(state);
+                actor.hash(state);
+            }
+        }
+    }
+}
+
+impl Serialize for ExId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_str())
+    }
+}
+
+impl AsRef<ExId> for ExId {
+    fn as_ref(&self) -> &ExId {
+        self
+    }
+}
+
+impl Ord for ExId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (ExId::Root, ExId::Root) => Ordering::Equal,
+            (ExId::Root, _) => Ordering::Less,
+            (_, ExId::Root) => Ordering::Greater,
+            (ExId::Id(c1, a1, _), ExId::Id(c2, a2, _)) if c1 == c2 => a1.cmp(a2),
+            (ExId::Id(c1, _, _), ExId::Id(c2, _, _)) => c1.cmp(c2),
+        }
+    }
+}
+
+impl PartialOrd for ExId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ExId;
+    use proptest::prelude::*;
+
+    use crate::ActorId;
+
+    fn gen_actorid() -> impl Strategy<Value = ActorId> {
+        proptest::collection::vec(any::<u8>(), 0..100).prop_map(ActorId::from)
+    }
+
+    prop_compose! {
+        fn gen_non_root_objid()(actor in gen_actorid(), counter in any::<usize>(), idx in any::<usize>()) -> ExId {
+            ExId::Id(idx as u64, actor, counter)
+        }
+    }
+
+    fn gen_obji() -> impl Strategy<Value = ExId> {
+        prop_oneof![Just(ExId::Root), gen_non_root_objid()]
+    }
+
+    proptest! {
+        #[test]
+        fn objid_roundtrip(objid in gen_obji()) {
+            let bytes = objid.to_bytes();
+            let objid2 = ExId::try_from(&bytes[..]).unwrap();
+            assert_eq!(objid, objid2);
+        }
+    }
+
+    #[test]
+    fn test_root_roundtrip() {
+        let bytes = ExId::Root.to_bytes();
+        let objid2 = ExId::try_from(&bytes[..]).unwrap();
+        assert_eq!(ExId::Root, objid2);
+    }
+}

data/vendor/automerge-rust/automerge/src/hydrate/list.rs

@@ -0,0 +1,140 @@
+use std::collections::HashMap;
+
+use crate::exid::ExId;
+use crate::types::Prop;
+use crate::{PatchAction, ScalarValue, SequenceTree, TextEncoding};
+
+use super::{HydrateError, Value};
+
+#[derive(Clone, Default, PartialEq)]
+pub struct List(SequenceTree<ListValue>);
+
+impl std::fmt::Debug for List {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_list().entries(self.0.iter()).finish()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ListValue {
+    pub value: Value,
+    pub marks: HashMap<String, ScalarValue>,
+    pub conflict: bool,
+}
+
+impl List {
+    pub fn iter(&self) -> impl Iterator<Item = &ListValue> {
+        self.0.iter()
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub(crate) fn apply(
+        &mut self,
+        text_encoding: TextEncoding,
+        patch: PatchAction,
+    ) -> Result<(), HydrateError> {
+        match patch {
+            PatchAction::PutSeq {
+                index,
+                value,
+                conflict,
+            } => {
+                let h_value = Value::new(value.0, text_encoding);
+                *self
+                    .0
+                    .get_mut(index)
+                    .ok_or(HydrateError::InvalidIndex(index))? = ListValue::new(h_value, conflict);
+                Ok(())
+            }
+            PatchAction::Insert { index, values, .. } => {
+                for (n, value) in values.into_iter().enumerate() {
+                    let h_value = Value::new(value.0.clone(), text_encoding);
+                    self.0.insert(index + n, ListValue::new(h_value, value.2));
+                }
+                Ok(())
+            }
+            PatchAction::DeleteSeq { index, length } => {
+                for _ in 0..length {
+                    self.0.remove(index);
+                }
+                Ok(())
+            }
+            PatchAction::Increment {
+                prop: Prop::Seq(index),
+                value,
+            } => {
+                self.0
+                    .get_mut(index)
+                    .ok_or(HydrateError::InvalidIndex(index))?
+                    .increment(value)?;
+                Ok(())
+            }
+            PatchAction::Mark { marks: _ } => {
+                todo!()
+            }
+            _ => Err(HydrateError::InvalidListOp),
+        }
+    }
+
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut Value> {
+        self.0.get_mut(index).map(|lv| &mut lv.value)
+    }
+
+    pub fn get(&mut self, index: usize) -> Option<&Value> {
+        self.0.get(index).map(|lv| &lv.value)
+    }
+
+    pub(crate) fn push<V: Into<Value>>(&mut self, value: V, _id: ExId, conflict: bool) {
+        self.0.push(ListValue::new(value.into(), conflict))
+    }
+
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl ListValue {
+    pub(crate) fn increment(&mut self, n: i64) -> Result<(), HydrateError> {
+        if let Value::Scalar(ScalarValue::Counter(c)) = &mut self.value {
+            c.increment(n);
+            Ok(())
+        } else {
+            Err(HydrateError::BadIncrement)
+        }
+    }
+
+    pub(crate) fn new(value: Value, conflict: bool) -> Self {
+        Self {
+            value,
+            conflict,
+            marks: Default::default(),
+        }
+    }
+}
+
+impl From<Vec<Value>> for List {
+    fn from(values: Vec<Value>) -> Self {
+        let mut s = SequenceTree::new();
+        for value in values {
+            s.push(ListValue {
+                value,
+                conflict: false,
+                marks: Default::default(),
+            })
+        }
+        List(s)
+    }
+}
+
+impl From<Vec<Value>> for Value {
+    fn from(values: Vec<Value>) -> Self {
+        Value::List(List::from(values))
+    }
+}

data/vendor/automerge-rust/automerge/src/hydrate/map.rs

@@ -0,0 +1,132 @@
+use std::collections::HashMap;
+use std::ops::{Deref, DerefMut};
+
+use crate::exid::ExId;
+use crate::types::Prop;
+use crate::{PatchAction, ScalarValue, TextEncoding};
+
+use super::{HydrateError, Value};
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Map(HashMap<String, MapValue>);
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct MapValue {
+    pub value: Value,
+    pub conflict: bool,
+}
+
+impl Map {
+    pub fn iter(&self) -> impl Iterator<Item = (&String, &MapValue)> {
+        self.0.iter()
+    }
+
+    pub(crate) fn apply(
+        &mut self,
+        text_encoding: TextEncoding,
+        patch: PatchAction,
+    ) -> Result<(), HydrateError> {
+        match patch {
+            PatchAction::DeleteMap { key } => {
+                self.0.remove(&key);
+                Ok(())
+            }
+            PatchAction::PutMap {
+                key,
+                value,
+                conflict,
+            } => {
+                let h_value = Value::new(value.0, text_encoding);
+                self.0
+                    .insert(key, MapValue::new(h_value, value.1, conflict));
+                Ok(())
+            }
+            PatchAction::Increment {
+                prop: Prop::Map(key),
+                value,
+            } => {
+                self.0
+                    .get_mut(&key)
+                    .ok_or(HydrateError::InvalidKey(key))?
+                    .increment(value)?;
+                Ok(())
+            }
+            _ => Err(HydrateError::InvalidMapOp),
+        }
+    }
+
+    pub fn get(&self, key: &str) -> Option<&Value> {
+        self.0.get(key).map(|mv| &mv.value)
+    }
+
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Value> {
+        self.0.get_mut(key).map(|mv| &mut mv.value)
+    }
+
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl MapValue {
+    pub(crate) fn new(value: Value, _id: ExId, conflict: bool) -> Self {
+        Self { value, conflict }
+    }
+
+    pub(crate) fn increment(&mut self, n: i64) -> Result<(), HydrateError> {
+        if let Value::Scalar(ScalarValue::Counter(c)) = &mut self.value {
+            c.increment(n);
+            Ok(())
+        } else {
+            Err(HydrateError::BadIncrement)
+        }
+    }
+}
+
+impl Deref for Map {
+    type Target = HashMap<String, MapValue>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Map {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<HashMap<&str, Value>> for Map {
+    fn from(value: HashMap<&str, Value>) -> Self {
+        Map(value
+            .into_iter()
+            .map(|(k, value)| {
+                (
+                    k.to_string(),
+                    MapValue {
+                        value,
+                        conflict: false,
+                    },
+                )
+            })
+            .collect())
+    }
+}
+
+impl From<HashMap<String, Value>> for Map {
+    fn from(value: HashMap<String, Value>) -> Self {
+        Map(value
+            .into_iter()
+            .map(|(k, value)| {
+                (
+                    k,
+                    MapValue {
+                        value,
+                        conflict: false,
+                    },
+                )
+            })
+            .collect())
+    }
+}

data/vendor/automerge-rust/automerge/src/hydrate/tests.rs

@@ -0,0 +1,40 @@
+use text_value::ConcreteTextValue;
+
+use crate::exid::ExId;
+use crate::transaction::Transactable;
+use crate::*;
+
+#[test]
+fn simple_hydrate() -> Result<(), AutomergeError> {
+    let mut doc = AutoCommit::default();
+    let list = doc.put_object(&ObjId::Root, "list", ObjType::List)?;
+    doc.insert(&list, 0, 5)?;
+    doc.insert(&list, 1, 6)?;
+    doc.insert(&list, 2, 7)?;
+    doc.insert(&list, 3, "hello")?;
+    doc.insert(&list, 4, ScalarValue::counter(100))?;
+    doc.insert_object(&list, 5, ObjType::Map)?;
+    doc.insert_object(&list, 6, ObjType::List)?;
+    let text = doc.put_object(&ObjId::Root, "text", ObjType::Text)?;
+    doc.splice_text(&text, 0, 0, "hello world")?;
+    let mut hydrated = doc.hydrate(ExId::Root, None)?;
+    assert_eq!(
+        hydrated,
+        hydrate_map!(
+            "list" => hydrate_list!(5,6,7,"hello", ScalarValue::counter(100), hydrate_map!(), hydrate_list![]),
+            "text" => ConcreteTextValue::new("hello world", TextEncoding::platform_default()),
+        ).into()
+    );
+    doc.splice_text(&text, 6, 0, "big bad ")?;
+    assert_eq!(doc.text(&text)?, "hello big bad world".to_owned());
+    let heads = doc.get_heads();
+    let cursor = doc.diff_cursor().to_vec();
+    let patches = doc.diff(&cursor, &heads);
+    doc.update_diff_cursor();
+    hydrated.apply_patches(TextEncoding::platform_default(), patches)?;
+    let hydrate::Value::Text(val) = &hydrated.as_map().unwrap().get("text").unwrap() else {
+        panic!("expected text");
+    };
+    assert_eq!(String::from(val), "hello big bad world".to_string(),);
+    Ok(())
+}

data/vendor/automerge-rust/automerge/src/hydrate/text.rs

@@ -0,0 +1,89 @@
+use std::{collections::HashMap, fmt::Display};
+
+use crate::{text_value::ConcreteTextValue, PatchAction, ScalarValue, TextEncoding};
+
+use super::HydrateError;
+
+#[derive(Clone, PartialEq)]
+pub struct Text {
+    value: ConcreteTextValue,
+    marks: HashMap<String, ScalarValue>,
+}
+
+impl std::fmt::Debug for Text {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Text")
+            .field("value", &self.value.make_string())
+            .field("marks", &self.marks)
+            .finish()
+    }
+}
+
+impl Text {
+    pub(crate) fn apply(&mut self, patch: PatchAction) -> Result<(), HydrateError> {
+        match patch {
+            PatchAction::SpliceText { index, value, .. } => {
+                self.value
+                    .splice_text_value(index, &value)
+                    .map_err(|_| HydrateError::InvalidEncoding)?;
+                Ok(())
+            }
+            PatchAction::DeleteSeq { index, length } => {
+                for _ in 0..length {
+                    self.value.remove(index);
+                }
+                Ok(())
+            }
+            PatchAction::Mark { marks: _ } => {
+                todo!()
+            }
+            p => Err(HydrateError::InvalidTextOp(p)),
+        }
+    }
+
+    pub fn new<S: AsRef<str>>(text_encoding: TextEncoding, text: S) -> Self {
+        Self {
+            value: ConcreteTextValue::new(text.as_ref(), text_encoding),
+            marks: Default::default(),
+        }
+    }
+}
+
+impl From<&Text> for String {
+    fn from(text: &Text) -> Self {
+        text.value.make_string()
+    }
+}
+
+impl Display for Text {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.value.make_string())
+    }
+}
+
+impl From<ConcreteTextValue> for Text {
+    fn from(value: ConcreteTextValue) -> Self {
+        Self {
+            value,
+            marks: Default::default(),
+        }
+    }
+}
+
+impl From<&ConcreteTextValue> for Text {
+    fn from(value: &ConcreteTextValue) -> Self {
+        Self::from(value.clone())
+    }
+}
+
+impl From<ConcreteTextValue> for crate::hydrate::Value {
+    fn from(value: ConcreteTextValue) -> Self {
+        crate::hydrate::Value::Text(Text::from(value))
+    }
+}
+
+impl From<&ConcreteTextValue> for crate::hydrate::Value {
+    fn from(value: &ConcreteTextValue) -> Self {
+        Self::from(value.clone())
+    }
+}