automerge-rb 0.1.1

data/vendor/automerge-rust/Cargo.toml

@@ -0,0 +1,15 @@
+[workspace]
+members = [
+    "automerge",
+    "automerge-c",
+    "automerge-test",
+    "hexane",
+]
+resolver = "2"
+
+[profile.release]
+lto = true
+codegen-units = 1
+
+[profile.bench]
+debug = true

data/vendor/automerge-rust/automerge/Cargo.toml

@@ -0,0 +1,78 @@
+[package]
+name = "automerge"
+version = "0.9.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/automerge/automerge"
+rust-version = "1.89.0"
+description = "A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically"
+readme = "./README.md"
+
+[features]
+optree-visualisation = ["dot"]
+wasm = ["js-sys", "wasm-bindgen", "web-sys", "getrandom/wasm_js", "hexane/wasm"]
+utf8-indexing = []
+utf16-indexing = []
+# Whether to enable "slow path" assertions which check that various invariants hold
+# should only be enabled when running tests
+slow_path_assertions = ["hexane/slow_path_assertions"]
+
+[dependencies]
+hexane = { version = "0.2.1", path = "../hexane" }
+hex = "^0.4.3"
+leb128 = "^0.2.5"
+sha2 = "0.11.0"
+thiserror = "^2.0.12"
+itertools = "0.14.0"
+flate2 = "^1.0.22"
+smol_str = { version = "0.3", features = ["serde"] }
+tracing = { version = "^0.1.29" }
+rustc-hash = "^2.1.1"
+tinyvec = { version = "^1.5.1", features = ["alloc"] }
+serde = { version = "^1.0", features = ["derive"] }
+cfg-if = "1.0"
+getrandom = "0.4"
+
+# optional deps
+dot = { version = "0.1.4", optional = true }
+js-sys = { version = "^0.3", optional = true }
+wasm-bindgen = { version = "^0.2", optional = true }
+rand = { version = "^0.10", optional = false }
+
+unicode-segmentation = "1.10.1"
+
+[dependencies.web-sys]
+version = "^0.3.55"
+features = ["console"]
+optional = true
+
+[dev-dependencies]
+pretty_assertions = "1.0.0"
+proptest = { version = "^1.7.0", default-features = false, features = ["std"] }
+serde_json = { version = "^1.0.73", features = [
+    "float_roundtrip",
+], default-features = true }
+maplit = { version = "^1.0" }
+criterion = "0.8"
+test-log = { version = "0.2.10", features = [
+    "trace",
+], default-features = false }
+tracing-subscriber = { version = "^0.3", features = ["fmt", "env-filter"] }
+automerge-test = { path = "../automerge-test" }
+prettytable = "0.10.0"
+
+[[bench]]
+name = "range"
+harness = false
+
+[[bench]]
+name = "map"
+harness = false
+
+[[bench]]
+name = "sync"
+harness = false
+
+[[bench]]
+name = "load_save"
+harness = false

data/vendor/automerge-rust/automerge/README.md

@@ -0,0 +1,5 @@
+# Automerge
+
+Automerge is a library of data structures for building collaborative
+[local-first](https://www.inkandswitch.com/local-first/) applications. This is
+the Rust implementation. See [automerge.org](https://automerge.org/) 

data/vendor/automerge-rust/automerge/benches/load_save.rs

@@ -0,0 +1,102 @@
+use automerge::{transaction::Transactable, Automerge, ObjType, ROOT};
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use rand::distr::Alphanumeric;
+use rand::{rng, RngExt};
+
+fn random_string(n: u64) -> String {
+    let rand_string: String = rng()
+        .sample_iter(&Alphanumeric)
+        .take(n as usize)
+        .map(char::from)
+        .collect();
+
+    rand_string
+}
+
+fn big_paste_doc(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    tx.put(ROOT, "content", random_string(n)).unwrap();
+    tx.commit();
+
+    doc
+}
+
+fn poorly_simulated_typing_doc(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+
+    let mut tx = doc.transaction();
+    let obj = tx.put_object(ROOT, "content", ObjType::Text).unwrap();
+    tx.commit();
+
+    for i in 0..n {
+        let mut tx = doc.transaction();
+        let pos: usize = i.try_into().unwrap();
+        tx.splice_text(&obj, pos, 0, &random_string(1)).unwrap();
+        tx.commit();
+    }
+
+    doc
+}
+
+fn maps_in_maps_doc(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+
+    let mut map = ROOT;
+
+    for i in 0..n {
+        // we make a map
+        map = tx.put_object(map, i.to_string(), ObjType::Map).unwrap();
+    }
+
+    tx.commit();
+    doc
+}
+
+fn deep_history_doc(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    for i in 0..n {
+        let mut tx = doc.transaction();
+        tx.put(ROOT, "x", i.to_string()).unwrap();
+        tx.put(ROOT, "y", i.to_string()).unwrap();
+        tx.commit();
+    }
+
+    doc
+}
+
+fn save_load(doc: &Automerge) {
+    let save_data = doc.save();
+    let new_doc = Automerge::load(save_data.as_slice()).unwrap();
+    assert_eq!(doc.get_heads(), new_doc.get_heads());
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let n = 1_000;
+    let doc = big_paste_doc(n);
+    c.bench_function(&format!("load_save_big_paste_doc {}", n), |b| {
+        b.iter(|| save_load(black_box(&doc)))
+    });
+
+    let doc = poorly_simulated_typing_doc(n);
+    c.bench_function(
+        &format!("load_save_poorly_simulated_typing_doc {}", n),
+        |b| b.iter(|| save_load(black_box(&doc))),
+    );
+
+    let doc = maps_in_maps_doc(n);
+    c.bench_function(&format!("load_save_maps_in_maps_doc {}", n), |b| {
+        b.iter(|| save_load(black_box(&doc)))
+    });
+
+    let doc = deep_history_doc(n);
+    c.bench_function(&format!("load_save_deep_history_doc {}", n), |b| {
+        b.iter(|| save_load(black_box(&doc)))
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

data/vendor/automerge-rust/automerge/benches/map.rs

@@ -0,0 +1,260 @@
+use automerge::{transaction::Transactable, Automerge, ScalarValue, ROOT};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn repeated_increment(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    tx.put(ROOT, "counter", ScalarValue::counter(0)).unwrap();
+    for _ in 0..n {
+        tx.increment(ROOT, "counter", 1).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+fn repeated_put(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    for i in 0..n {
+        tx.put(ROOT, "0", i).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+fn increasing_put(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    for i in 0..n {
+        tx.put(ROOT, i.to_string(), i).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+fn decreasing_put(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    for i in (0..n).rev() {
+        tx.put(ROOT, i.to_string(), i).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let sizes = [100, 1_000, 10_000];
+
+    let mut group = c.benchmark_group("map");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(BenchmarkId::new("repeated put", size), size, |b, &size| {
+            b.iter(|| repeated_put(size))
+        });
+        group.bench_with_input(
+            BenchmarkId::new("repeated increment", size),
+            size,
+            |b, &size| b.iter(|| repeated_increment(size)),
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| b.iter(|| increasing_put(size)),
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("decreasing put", size),
+            size,
+            |b, &size| b.iter(|| decreasing_put(size)),
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("map save");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(BenchmarkId::new("repeated put", size), size, |b, &size| {
+            b.iter_batched(
+                || repeated_put(size),
+                |doc| doc.save(),
+                criterion::BatchSize::LargeInput,
+            )
+        });
+        group.bench_with_input(
+            BenchmarkId::new("repeated increment", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || repeated_increment(size),
+                    |doc| doc.save(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || increasing_put(size),
+                    |doc| doc.save(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("decreasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || decreasing_put(size),
+                    |doc| doc.save(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("map load");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(BenchmarkId::new("repeated put", size), size, |b, &size| {
+            b.iter_batched(
+                || repeated_put(size).save(),
+                |bytes| Automerge::load(&bytes).unwrap(),
+                criterion::BatchSize::LargeInput,
+            )
+        });
+        group.bench_with_input(
+            BenchmarkId::new("repeated increment", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || repeated_increment(size).save(),
+                    |bytes| Automerge::load(&bytes).unwrap(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || increasing_put(size).save(),
+                    |bytes| Automerge::load(&bytes).unwrap(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("decreasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || decreasing_put(size).save(),
+                    |bytes| Automerge::load(&bytes).unwrap(),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("map apply");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(BenchmarkId::new("repeated put", size), size, |b, &size| {
+            b.iter_batched(
+                || {
+                    repeated_put(size)
+                        .get_changes(&[])
+                        .into_iter()
+                        .collect::<Vec<_>>()
+                },
+                |changes| {
+                    let mut doc = Automerge::new();
+                    doc.apply_changes(changes)
+                },
+                criterion::BatchSize::LargeInput,
+            )
+        });
+        group.bench_with_input(
+            BenchmarkId::new("repeated increment", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || {
+                        repeated_increment(size)
+                            .get_changes(&[])
+                            .into_iter()
+                            .collect::<Vec<_>>()
+                    },
+                    |changes| {
+                        let mut doc = Automerge::new();
+                        doc.apply_changes(changes)
+                    },
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || {
+                        increasing_put(size)
+                            .get_changes(&[])
+                            .into_iter()
+                            .collect::<Vec<_>>()
+                    },
+                    |changes| {
+                        let mut doc = Automerge::new();
+                        doc.apply_changes(changes)
+                    },
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+
+        group.throughput(criterion::Throughput::Elements(*size));
+        group.bench_with_input(
+            BenchmarkId::new("decreasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || {
+                        decreasing_put(size)
+                            .get_changes(&[])
+                            .into_iter()
+                            .collect::<Vec<_>>()
+                    },
+                    |changes| {
+                        let mut doc = Automerge::new();
+                        doc.apply_changes(changes)
+                    },
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

data/vendor/automerge-rust/automerge/benches/range.rs

@@ -0,0 +1,37 @@
+use automerge::{transaction::Transactable, Automerge, ReadDoc, ROOT};
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+fn doc(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    for i in 0..n {
+        tx.put(ROOT, i.to_string(), i.to_string()).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+fn range(doc: &Automerge) {
+    let range = doc.values(ROOT);
+    range.for_each(drop);
+}
+
+fn range_at(doc: &Automerge) {
+    let range = doc.values_at(ROOT, &doc.get_heads());
+    range.for_each(drop);
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let n = 100_000;
+    let doc = doc(n);
+    c.bench_function(&format!("range {}", n), |b| {
+        b.iter(|| range(black_box(&doc)))
+    });
+    c.bench_function(&format!("range_at {}", n), |b| {
+        b.iter(|| range_at(black_box(&doc)))
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

data/vendor/automerge-rust/automerge/benches/sync.rs

@@ -0,0 +1,95 @@
+use automerge::{
+    sync::{self, SyncDoc},
+    transaction::Transactable,
+    Automerge, ROOT,
+};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+#[derive(Default)]
+struct DocWithSync {
+    doc: Automerge,
+    peer_state: sync::State,
+}
+
+impl From<Automerge> for DocWithSync {
+    fn from(doc: Automerge) -> Self {
+        Self {
+            doc,
+            peer_state: sync::State::default(),
+        }
+    }
+}
+
+fn increasing_put(n: u64) -> Automerge {
+    let mut doc = Automerge::new();
+    let mut tx = doc.transaction();
+    for i in 0..n {
+        tx.put(ROOT, i.to_string(), i).unwrap();
+    }
+    tx.commit();
+    doc
+}
+
+// keep syncing until doc1 no longer generates a sync message for doc2.
+fn sync(doc1: &mut DocWithSync, doc2: &mut DocWithSync) {
+    while let Some(message1) = doc1.doc.generate_sync_message(&mut doc1.peer_state) {
+        doc2.doc
+            .receive_sync_message(&mut doc2.peer_state, message1)
+            .unwrap();
+
+        if let Some(message2) = doc2.doc.generate_sync_message(&mut doc2.peer_state) {
+            doc1.doc
+                .receive_sync_message(&mut doc1.peer_state, message2)
+                .unwrap()
+        }
+    }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let sizes = [100, 1_000, 10_000];
+
+    let mut group = c.benchmark_group("sync unidirectional");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| {
+                b.iter_batched(
+                    || (increasing_put(size), DocWithSync::default()),
+                    |(doc1, mut doc2)| sync(&mut doc1.into(), &mut doc2),
+                    criterion::BatchSize::LargeInput,
+                )
+            },
+        );
+    }
+    group.finish();
+
+    let mut group = c.benchmark_group("sync unidirectional every change");
+    for size in &sizes {
+        group.throughput(criterion::Throughput::Elements(*size));
+
+        group.bench_with_input(
+            BenchmarkId::new("increasing put", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let mut doc1 = DocWithSync::default();
+                    let mut doc2 = DocWithSync::default();
+
+                    for i in 0..size {
+                        let mut tx = doc1.doc.transaction();
+                        tx.put(ROOT, i.to_string(), i).unwrap();
+                        tx.commit();
+                        sync(&mut doc1, &mut doc2);
+                    }
+                })
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

data/vendor/automerge-rust/automerge/examples/README.md

@@ -0,0 +1,7 @@
+# Automerge examples
+
+## Quickstart
+
+```shell
+cargo run --example quickstart
+```

data/vendor/automerge-rust/automerge/examples/quickstart.rs

@@ -0,0 +1,57 @@
+use automerge::transaction::CommitOptions;
+use automerge::transaction::Transactable;
+use automerge::AutomergeError;
+use automerge::ObjType;
+use automerge::{Automerge, ReadDoc, ROOT};
+
+// Based on https://automerge.org/docs/reference/documents/lists/
+fn main() {
+    let mut doc1 = Automerge::new();
+    let (cards, card1) = doc1
+        .transact_with::<_, _, AutomergeError, _>(
+            |_| CommitOptions::default().with_message("Add card".to_owned()),
+            |tx| {
+                let cards = tx.put_object(ROOT, "cards", ObjType::List).unwrap();
+                let card1 = tx.insert_object(&cards, 0, ObjType::Map)?;
+                tx.put(&card1, "title", "Rewrite everything in Clojure")?;
+                tx.put(&card1, "done", false)?;
+                let card2 = tx.insert_object(&cards, 0, ObjType::Map)?;
+                tx.put(&card2, "title", "Rewrite everything in Haskell")?;
+                tx.put(&card2, "done", false)?;
+                Ok((cards, card1))
+            },
+        )
+        .unwrap()
+        .result;
+
+    let mut doc2 = Automerge::new();
+    doc2.merge(&mut doc1).unwrap();
+
+    let binary = doc1.save();
+    let mut doc2 = Automerge::load(&binary).unwrap();
+
+    doc1.transact_with::<_, _, AutomergeError, _>(
+        |_| CommitOptions::default().with_message("Mark card as done".to_owned()),
+        |tx| {
+            tx.put(&card1, "done", true)?;
+            Ok(())
+        },
+    )
+    .unwrap();
+
+    doc2.transact_with::<_, _, AutomergeError, _>(
+        |_| CommitOptions::default().with_message("Delete card".to_owned()),
+        |tx| {
+            tx.delete(&cards, 0)?;
+            Ok(())
+        },
+    )
+    .unwrap();
+
+    doc1.merge(&mut doc2).unwrap();
+
+    for change in doc1.get_changes(&[]) {
+        let length = doc1.length_at(&cards, &[change.hash()]);
+        println!("{} {}", change.message().unwrap(), length);
+    }
+}