automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/legacy/serde_impls/opid.rs

@@ -0,0 +1,25 @@
+use std::str::FromStr;
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::legacy::OpId;
+
+impl<'de> Deserialize<'de> for OpId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        OpId::from_str(&s)
+            .map_err(|_| de::Error::invalid_value(de::Unexpected::Str(&s), &"A valid OpID"))
+    }
+}
+
+impl Serialize for OpId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_str())
+    }
+}

data/vendor/automerge-rust/automerge/src/legacy/serde_impls/scalar_value.rs

@@ -0,0 +1,63 @@
+use serde::{de, Deserialize, Deserializer};
+use smol_str::SmolStr;
+
+use crate::types::ScalarValue;
+
+impl<'de> Deserialize<'de> for ScalarValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ValueVisitor;
+        impl de::Visitor<'_> for ValueVisitor {
+            type Value = ScalarValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("a number, string, bool, or null")
+            }
+
+            fn visit_bool<E>(self, value: bool) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::Boolean(value))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::Uint(value))
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::Int(value))
+            }
+
+            fn visit_f64<E>(self, value: f64) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::F64(value))
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::Str(SmolStr::new(value)))
+            }
+
+            fn visit_none<E>(self) -> Result<ScalarValue, E>
+            where
+                E: de::Error,
+            {
+                Ok(ScalarValue::Null)
+            }
+        }
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}

data/vendor/automerge-rust/automerge/src/legacy/utility_impls/element_id.rs

@@ -0,0 +1,66 @@
+use std::{
+    cmp::{Ordering, PartialOrd},
+    str::FromStr,
+};
+
+use crate::error::InvalidElementId;
+use crate::legacy::{ElementId, OpId};
+
+impl PartialOrd for ElementId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ElementId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (ElementId::Id(a), ElementId::Id(b)) => a.cmp(b),
+            (ElementId::Head, ElementId::Head) => Ordering::Equal,
+            (ElementId::Head, _) => Ordering::Less,
+            (_, ElementId::Head) => Ordering::Greater,
+        }
+    }
+}
+
+impl From<OpId> for ElementId {
+    fn from(o: OpId) -> Self {
+        ElementId::Id(o)
+    }
+}
+
+impl From<&OpId> for ElementId {
+    fn from(o: &OpId) -> Self {
+        ElementId::Id(o.clone())
+    }
+}
+
+impl FromStr for ElementId {
+    type Err = InvalidElementId;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "_head" => Ok(ElementId::Head),
+            id => Ok(ElementId::Id(
+                OpId::from_str(id).map_err(|_| InvalidElementId(id.to_string()))?,
+            )),
+        }
+    }
+}
+
+impl TryFrom<&str> for ElementId {
+    type Error = InvalidElementId;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        ElementId::from_str(value)
+    }
+}
+
+impl std::fmt::Display for ElementId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ElementId::Head => write!(f, "_head"),
+            ElementId::Id(id) => write!(f, "{}", id),
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/legacy/utility_impls/key.rs

@@ -0,0 +1,49 @@
+use std::cmp::{Ordering, PartialOrd};
+
+use smol_str::SmolStr;
+
+use crate::legacy::{ElementId, Key, OpId};
+
+impl PartialOrd for Key {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Key {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (Key::Map(a), Key::Map(b)) => a.cmp(b),
+            (Key::Seq(a), Key::Seq(b)) => a.cmp(b),
+            (Key::Map(_), _) => Ordering::Less,
+            (_, Key::Map(_)) => Ordering::Greater,
+        }
+    }
+}
+
+impl From<OpId> for Key {
+    fn from(id: OpId) -> Self {
+        Key::Seq(ElementId::Id(id))
+    }
+}
+
+impl From<&OpId> for Key {
+    fn from(id: &OpId) -> Self {
+        Key::Seq(ElementId::Id(id.clone()))
+    }
+}
+
+impl From<ElementId> for Key {
+    fn from(id: ElementId) -> Self {
+        Key::Seq(id)
+    }
+}
+
+impl<S> From<S> for Key
+where
+    S: AsRef<str>,
+{
+    fn from(s: S) -> Self {
+        Key::Map(SmolStr::new(s))
+    }
+}

data/vendor/automerge-rust/automerge/src/legacy/utility_impls/mod.rs

@@ -0,0 +1,4 @@
+mod element_id;
+mod key;
+mod object_id;
+mod opid;

data/vendor/automerge-rust/automerge/src/legacy/utility_impls/object_id.rs

@@ -0,0 +1,74 @@
+use std::{
+    cmp::{Ordering, PartialOrd},
+    fmt,
+    str::FromStr,
+};
+
+use crate::error::InvalidObjectId;
+use crate::legacy::{ObjectId, OpId};
+
+impl PartialOrd for ObjectId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ObjectId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match (self, other) {
+            (ObjectId::Root, ObjectId::Root) => Ordering::Equal,
+            (ObjectId::Root, _) => Ordering::Less,
+            (_, ObjectId::Root) => Ordering::Greater,
+            (ObjectId::Id(a), ObjectId::Id(b)) => a.cmp(b),
+        }
+    }
+}
+
+impl From<&OpId> for ObjectId {
+    fn from(o: &OpId) -> Self {
+        ObjectId::Id(o.clone())
+    }
+}
+
+impl From<&ObjectId> for ObjectId {
+    fn from(o: &ObjectId) -> Self {
+        o.clone()
+    }
+}
+
+impl FromStr for ObjectId {
+    type Err = InvalidObjectId;
+
+    fn from_str(s: &str) -> Result<ObjectId, Self::Err> {
+        if s == "_root" {
+            Ok(ObjectId::Root)
+        } else if let Ok(id) = OpId::from_str(s) {
+            Ok(ObjectId::Id(id))
+        } else {
+            Err(InvalidObjectId(s.to_string()))
+        }
+    }
+}
+
+impl From<OpId> for ObjectId {
+    fn from(id: OpId) -> Self {
+        ObjectId::Id(id)
+    }
+}
+
+impl fmt::Display for ObjectId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ObjectId::Root => write!(f, "_root"),
+            ObjectId::Id(oid) => write!(f, "{}", oid),
+        }
+    }
+}
+
+impl TryFrom<&str> for ObjectId {
+    type Error = InvalidObjectId;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        ObjectId::from_str(value)
+    }
+}

data/vendor/automerge-rust/automerge/src/legacy/utility_impls/opid.rs

@@ -0,0 +1,68 @@
+use core::fmt;
+use std::{
+    cmp::{Ordering, PartialOrd},
+    str::FromStr,
+};
+
+use crate::error::InvalidOpId;
+use crate::legacy::{ActorId, OpId};
+
+impl Ord for OpId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        if self.0 != other.0 {
+            self.0.cmp(&other.0)
+        } else {
+            self.1.cmp(&other.1)
+        }
+    }
+}
+
+impl fmt::Debug for OpId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.to_string().as_str())
+    }
+}
+
+impl fmt::Display for OpId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            OpId(seq, actor) => write!(f, "{}@{}", seq, actor),
+        }
+    }
+}
+
+impl PartialOrd for OpId {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl FromStr for OpId {
+    type Err = InvalidOpId;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut i = s.split('@');
+        match (i.next(), i.next(), i.next()) {
+            (Some(counter_str), Some(actor_str), None) => {
+                match (counter_str.parse(), ActorId::from_str(actor_str)) {
+                    (Ok(counter), Ok(actor)) => Ok(OpId(counter, actor)),
+                    _ => Err(InvalidOpId(s.to_string())),
+                }
+            }
+            _ => Err(InvalidOpId(s.to_string())),
+        }
+    }
+}
+
+impl TryFrom<&str> for OpId {
+    type Error = InvalidOpId;
+    fn try_from(s: &str) -> Result<Self, InvalidOpId> {
+        OpId::from_str(s)
+    }
+}
+
+impl From<&OpId> for String {
+    fn from(id: &OpId) -> Self {
+        id.to_string()
+    }
+}

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

@@ -0,0 +1,315 @@
+//! # Automerge
+//!
+//! Automerge is a library of data structures for building collaborative,
+//! [local-first](https://www.inkandswitch.com/local-first/) applications. The
+//! idea of automerge is to provide a data structure which is quite general
+//! \- consisting of nested key/value maps and/or lists - which can be modified
+//! entirely locally but which can at any time be merged with other instances of
+//! the same data structure.
+//!
+//! In addition to the core data structure (which we generally refer to as a
+//! "document"), we also provide an implementation of a sync protocol (in
+//! [`crate::sync`]) which can be used over any reliable in-order transport; and
+//! an efficient binary storage format.
+//!
+//! This crate is organised around two representations of a document -
+//! [`Automerge`] and [`AutoCommit`]. The difference between the two is that
+//! [`AutoCommit`] manages transactions for you. Both of these representations
+//! implement [`ReadDoc`] for reading values from a document and provide access
+//! to a [`sync::SyncDoc`] implementation (`Automerge` implements it directly
+//! whilst [`AutoCommit`] provides [`AutoCommit::sync`]) for taking part in the
+//! sync protocol. [`AutoCommit`] directly implements
+//! [`transaction::Transactable`] for making changes to a document, whilst
+//! [`Automerge`] requires you to explicitly create a
+//! [`transaction::Transaction`].
+//!
+//! NOTE: The API this library provides for modifying data is quite low level
+//! (somewhat analogous to directly creating JSON values rather than using
+//! [`serde`] derive macros or equivalent). If you're writing a Rust application which uses automerge
+//! you may want to look at [autosurgeon](https://github.com/automerge/autosurgeon).
+//!
+//! ## Data Model
+//!
+//! An automerge document is a map from strings to values
+//! ([`Value`]) where values can be either
+//!
+//! * A nested composite value which is either
+//!   * A map from strings to values ([`ObjType::Map`])
+//!   * A list of values ([`ObjType::List`])
+//!   * A text object (a sequence of unicode characters) ([`ObjType::Text`])
+//! * A primitive value ([`ScalarValue`]) which is one of
+//!   * A string
+//!   * A 64 bit floating point number
+//!   * A signed 64 bit integer
+//!   * An unsigned 64 bit integer
+//!   * A boolean
+//!   * A counter object (a 64 bit integer which merges by addition)
+//!     ([`ScalarValue::Counter`])
+//!   * A timestamp (a 64 bit integer which is milliseconds since the unix epoch)
+//!
+//! All composite values have an ID ([`ObjId`]) which is created when the value
+//! is inserted into the document or is the root object ID [`ROOT`]. Values in
+//! the document are then referred to by the pair (`object ID`, `key`). The
+//! `key` is represented by the [`Prop`] type and is either a string for a maps,
+//! or an index for sequences.
+//!
+//! ### Conflicts
+//!
+//! There are some things automerge cannot merge sensibly. For example, two
+//! actors concurrently setting the key "name" to different values. In this case
+//! automerge will pick a winning value in a random but deterministic way, but
+//! the conflicting value is still available via the [`ReadDoc::get_all()`] method.
+//!
+//! ### Change hashes and historical values
+//!
+//! Like git, points in the history of a document are identified by hash. Unlike
+//! git there can be multiple hashes representing a particular point (because
+//! automerge supports concurrent changes). These hashes can be obtained using
+//! either [`Automerge::get_heads()`] or [`AutoCommit::get_heads()`] (note these
+//! methods are not part of [`ReadDoc`] because in the case of [`AutoCommit`] it
+//! requires a mutable reference to the document).
+//!
+//! These hashes can be used to read values from the document at a particular
+//! point in history using the various `*_at()` methods on [`ReadDoc`] which take a
+//! slice of [`ChangeHash`] as an argument.
+//!
+//! ### Actor IDs
+//!
+//! Any change to an automerge document is made by an actor, represented by an
+//! [`ActorId`]. An actor ID is any random sequence of bytes but each change by
+//! the same actor ID must be sequential. This often means you will want to
+//! maintain at least one actor ID per device. It is fine to generate a new
+//! actor ID for each change, but be aware that each actor ID takes up space in
+//! a document so if you expect a document to be long lived and/or to have many
+//! changes then you should try to reuse actor IDs where possible.
+//!
+//! ### Text Encoding
+//!
+//! Text is encoded in UTF-8 by default but uses UTF-16 when using the wasm target,
+//! you can configure it with the feature `utf16-indexing`.
+//!
+//! ## Sync Protocol
+//!
+//! See the [`sync`] module.
+//!
+//! ## Patches, maintaining materialized state
+//!
+//! Often you will have some state which represents the "current" state of the document. E.g. some
+//! text in a UI which is a view of a text object in the document. Rather than re-rendering this
+//! text every single time a change comes in you can use a [`PatchLog`] to capture incremental
+//! changes made to the document and then use [`Automerge::make_patches()`] to get a set of patches
+//! to apply to the materialized state.
+//!
+//! Many of the methods on [`Automerge`], [`crate::sync::SyncDoc`] and
+//! [`crate::transaction::Transactable`] have a `*_log_patches()` variant which allow you to pass in
+//! a [`PatchLog`] to collect these incremental changes.
+//!
+//! ## Serde serialization
+//!
+//! Sometimes you just want to get the JSON value of an automerge document. For
+//! this you can use [`AutoSerde`], which implements [`serde::Serialize`] for an
+//! automerge document.
+//!
+//! ## Example
+//!
+//! Let's create a document representing an address book.
+//!
+//! ```
+//! use automerge::{ObjType, AutoCommit, transaction::Transactable, ReadDoc};
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! let mut doc = AutoCommit::new();
+//!
+//! // `put_object` creates a nested object in the root key/value map and
+//! // returns the ID of the new object, in this case a list.
+//! let contacts = doc.put_object(automerge::ROOT, "contacts", ObjType::List)?;
+//!
+//! // Now we can insert objects into the list
+//! let alice = doc.insert_object(&contacts, 0, ObjType::Map)?;
+//!
+//! // Finally we can set keys in the "alice" map
+//! doc.put(&alice, "name", "Alice")?;
+//! doc.put(&alice, "email", "alice@example.com")?;
+//!
+//! // Create another contact
+//! let bob = doc.insert_object(&contacts, 1, ObjType::Map)?;
+//! doc.put(&bob, "name", "Bob")?;
+//! doc.put(&bob, "email", "bob@example.com")?;
+//!
+//! // Now we save the address book, we can put this in a file
+//! let data: Vec<u8> = doc.save();
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! Now modify this document on two separate devices and merge the modifications.
+//!
+//! ```
+//! use std::borrow::Cow;
+//! use automerge::{ObjType, AutoCommit, transaction::Transactable, ReadDoc};
+//!
+//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
+//! # let mut doc = AutoCommit::new();
+//! # let contacts = doc.put_object(automerge::ROOT, "contacts", ObjType::List)?;
+//! # let alice = doc.insert_object(&contacts, 0, ObjType::Map)?;
+//! # doc.put(&alice, "name", "Alice")?;
+//! # doc.put(&alice, "email", "alice@example.com")?;
+//! # let bob = doc.insert_object(&contacts, 1, ObjType::Map)?;
+//! # doc.put(&bob, "name", "Bob")?;
+//! # doc.put(&bob, "email", "bob@example.com")?;
+//! # let saved: Vec<u8> = doc.save();
+//!
+//! // Load the document on the first device and change alices email
+//! let mut doc1 = AutoCommit::load(&saved)?;
+//! let contacts = match doc1.get(automerge::ROOT, "contacts")? {
+//!     Some((automerge::Value::Object(ObjType::List), contacts)) => contacts,
+//!     _ => panic!("contacts should be a list"),
+//! };
+//! let alice = match doc1.get(&contacts, 0)? {
+//!    Some((automerge::Value::Object(ObjType::Map), alice)) => alice,
+//!    _ => panic!("alice should be a map"),
+//! };
+//! doc1.put(&alice, "email", "alicesnewemail@example.com")?;
+//!
+//!
+//! // Load the document on the second device and change bobs name
+//! let mut doc2 = AutoCommit::load(&saved)?;
+//! let contacts = match doc2.get(automerge::ROOT, "contacts")? {
+//!    Some((automerge::Value::Object(ObjType::List), contacts)) => contacts,
+//!    _ => panic!("contacts should be a list"),
+//! };
+//! let bob = match doc2.get(&contacts, 1)? {
+//!   Some((automerge::Value::Object(ObjType::Map), bob)) => bob,
+//!   _ => panic!("bob should be a map"),
+//! };
+//! doc2.put(&bob, "name", "Robert")?;
+//!
+//! // Finally, we can merge the changes from the two devices
+//! doc1.merge(&mut doc2)?;
+//! let bobsname: Option<automerge::Value> = doc1.get(&bob, "name")?.map(|(v, _)| v);
+//! assert_eq!(bobsname, Some(automerge::Value::Scalar(Cow::Owned("Robert".into()))));
+//!
+//! let alices_email: Option<automerge::Value> = doc1.get(&alice, "email")?.map(|(v, _)| v);
+//! assert_eq!(alices_email, Some(automerge::Value::Scalar(Cow::Owned("alicesnewemail@example.com".into()))));
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! ## Cursors, referring to positions in sequences
+//!
+//! When working with text or other sequences it is often useful to be able to
+//! refer to a specific position within the sequence whilst merging remote
+//! changes. You can manually do this by maintaining your own offsets and
+//! observing patches, but this is error prone. The [`Cursor`] type provides
+//! an API for allowing automerge to do the index translations for you. Cursors
+//! are created with [`ReadDoc::get_cursor()`] and dereferenced with
+//! [`ReadDoc::get_cursor_position()`].
+
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/automerge/automerge/main/img/brandmark.svg",
+    html_favicon_url = "https:///raw.githubusercontent.com/automerge/automerge/main/img/favicon.ico"
+)]
+#![warn(
+    missing_debug_implementations,
+    // missing_docs, // TODO: add documentation!
+    rust_2018_idioms,
+    unreachable_pub,
+    bad_style,
+    dead_code,
+    improper_ctypes,
+    non_shorthand_field_patterns,
+    no_mangle_generic_items,
+    overflowing_literals,
+    path_statements,
+    patterns_in_fns_without_body,
+    unconditional_recursion,
+    unused,
+    unused_allocation,
+    unused_comparisons,
+    unused_parens,
+    while_true
+)]
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! log {
+     ( $( $t:tt )* ) => {
+          {
+            use $crate::__log;
+            __log!( $( $t )* );
+          }
+     }
+ }
+
+#[cfg(all(feature = "wasm", target_family = "wasm"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log {
+     ( $( $t:tt )* ) => {
+         web_sys::console::log_1(&format!( $( $t )* ).into());
+     }
+ }
+
+#[cfg(not(all(feature = "wasm", target_family = "wasm")))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log {
+     ( $( $t:tt )* ) => {
+         println!( $( $t )* );
+     }
+ }
+
+mod autocommit;
+mod automerge;
+mod autoserde;
+mod change;
+mod change_graph;
+mod change_queue;
+mod clock;
+mod columnar;
+mod convert;
+mod cursor;
+pub mod error;
+mod exid;
+pub mod hydrate;
+mod indexed_cache;
+pub mod iter;
+pub use iter::Span;
+#[doc(hidden)]
+pub mod legacy;
+pub mod marks;
+pub mod op_set2;
+pub mod patches;
+mod read;
+mod sequence_tree;
+mod storage;
+pub mod sync;
+mod text_diff;
+mod text_value;
+pub mod transaction;
+mod types;
+mod validation;
+mod value;
+
+pub use crate::automerge::{Automerge, LoadOptions, OnPartialLoad, SaveOptions, StringMigration};
+pub use autocommit::AutoCommit;
+pub use autoserde::AutoSerde;
+pub use change::{Change, LoadError as LoadChangeError};
+pub use cursor::{Cursor, CursorPosition, MoveCursor, OpCursor};
+pub use error::InvalidActorId;
+pub use error::InvalidChangeHashSlice;
+pub use error::{AutomergeError, PatchLogMismatch};
+pub use exid::{ExId as ObjId, ObjIdFromBytesError};
+pub use legacy::Change as ExpandedChange;
+pub use op_set2::{ChangeMetadata, Parent, Parents, ScalarValue as ScalarValueRef, ValueRef};
+pub use patches::{Patch, PatchAction, PatchLog};
+pub use read::{ReadDoc, Stats};
+pub use sequence_tree::SequenceTree;
+pub use storage::{Bundle, BundleChange, BundleChangeIter, VerificationMode};
+pub use text_value::ConcreteTextValue;
+pub use transaction::BlockOrText;
+pub use types::{ActorId, ChangeHash, ObjType, OpType, ParseChangeHashError, Prop, TextEncoding};
+pub use value::{ScalarValue, Value};
+
+/// The object ID for the root map of a document
+pub const ROOT: ObjId = ObjId::Root;