automerge-rb 0.1.1

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

@@ -0,0 +1,94 @@
+use automerge::transaction::CommitOptions;
+use automerge::transaction::Transactable;
+use automerge::Automerge;
+use automerge::AutomergeError;
+use automerge::ROOT;
+use automerge::{Patch, PatchAction, PatchLog};
+
+fn main() {
+    let mut doc = Automerge::new();
+
+    // a simple scalar change in the root object
+    let mut result = doc
+        .transact_and_log_patches_with::<_, _, AutomergeError, _>(
+            |_result| CommitOptions::default(),
+            |tx| {
+                tx.put(ROOT, "hello", "world").unwrap();
+                Ok(())
+            },
+        )
+        .unwrap();
+    get_changes(&doc, doc.make_patches(&mut result.patch_log));
+
+    let mut tx = doc.transaction_log_patches(PatchLog::active()).unwrap();
+    let map = tx
+        .put_object(ROOT, "my new map", automerge::ObjType::Map)
+        .unwrap();
+    tx.put(&map, "blah", 1).unwrap();
+    tx.put(&map, "blah2", 1).unwrap();
+    let list = tx
+        .put_object(&map, "my list", automerge::ObjType::List)
+        .unwrap();
+    tx.insert(&list, 0, "yay").unwrap();
+    let m = tx.insert_object(&list, 0, automerge::ObjType::Map).unwrap();
+    tx.put(&m, "hi", 2).unwrap();
+    tx.insert(&list, 1, "woo").unwrap();
+    let m = tx.insert_object(&list, 2, automerge::ObjType::Map).unwrap();
+    tx.put(&m, "hi", 2).unwrap();
+    let (_heads3, mut patch_log) = tx.commit_with(CommitOptions::default());
+    let patches = doc.make_patches(&mut patch_log);
+    get_changes(&doc, patches);
+}
+
+fn get_changes(_doc: &Automerge, patches: Vec<Patch>) {
+    for Patch { obj, path, action } in patches {
+        match action {
+            PatchAction::PutMap { key, value, .. } => {
+                println!(
+                    "put {:?} at {:?} in obj {:?}, object path {:?}",
+                    value, key, obj, path,
+                )
+            }
+            PatchAction::PutSeq { index, value, .. } => {
+                println!(
+                    "put {:?} at {:?} in obj {:?}, object path {:?}",
+                    value, index, obj, path,
+                )
+            }
+            PatchAction::Insert { index, values, .. } => {
+                println!(
+                    "insert {:?} at {:?} in obj {:?}, object path {:?}",
+                    values, index, obj, path,
+                )
+            }
+            PatchAction::SpliceText { index, value, .. } => {
+                println!(
+                    "splice '{:?}' at {:?} in obj {:?}, object path {:?}",
+                    value, index, obj, path,
+                )
+            }
+            PatchAction::Increment { prop, value, .. } => {
+                println!(
+                    "increment {:?} in obj {:?} by {:?}, object path {:?}",
+                    prop, obj, value, path,
+                )
+            }
+            PatchAction::DeleteMap { key, .. } => {
+                println!("delete {:?} in obj {:?}, object path {:?}", key, obj, path,)
+            }
+            PatchAction::DeleteSeq { index, .. } => println!(
+                "delete {:?} in obj {:?}, object path {:?}",
+                index, obj, path,
+            ),
+            PatchAction::Mark { marks } => {
+                println!("mark {:?} in obj {:?}, object path {:?}", marks, obj, path,)
+            }
+            PatchAction::Conflict { prop } => {
+                println!(
+                    "conflict on {:?} in obj {:?}, object path {:?}",
+                    prop, obj, path,
+                )
+            }
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+[package]
+name = "automerge-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+leb128 = "^0.2.5"
+sha2 = "^0.10.0"
+
+[dependencies.automerge]
+path = ".."
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[profile.release]
+debug = 1
+
+[[bin]]
+name = "load"
+path = "fuzz_targets/load.rs"
+test = false
+doc = false

data/vendor/automerge-rust/automerge/fuzz/fuzz_targets/load.rs

@@ -0,0 +1,37 @@
+#![no_main]
+
+use sha2::{Sha256, Digest};
+use automerge::{Automerge};
+use libfuzzer_sys::arbitrary::{Arbitrary, Result, Unstructured};
+use libfuzzer_sys::fuzz_target;
+
+#[derive(Debug)]
+struct DocumentChunk {
+    bytes: Vec<u8>,
+}
+
+fn add_header(typ: u8, data: &[u8]) -> Vec<u8> {
+    let mut input = vec![u8::from(typ)];
+    leb128::write::unsigned(&mut input, data.len() as u64).unwrap();
+    input.extend(data.as_ref());
+    let hash_result = Sha256::digest(input.clone());
+    let array: [u8; 32] = hash_result.into();
+
+    let mut out = vec![133, 111, 74, 131, array[0], array[1], array[2], array[3]];
+    out.extend(input);
+    out
+}
+
+impl<'a> Arbitrary<'a> for DocumentChunk
+{
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        let input = u.bytes(u.len())?;
+        let contents = add_header(0, input);
+
+        return Ok(DocumentChunk{bytes: contents})
+    }
+}
+
+fuzz_target!(|doc: DocumentChunk| {
+    Automerge::load(&doc.bytes);
+});