automerge 0.9.0

A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
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());
    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,
                )
            }
        }
    }
}