automorph 0.2.0

Derive macros for bidirectional Automerge-Rust struct synchronization
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Tests for built-in type implementations.

use crate::Automorph;
use automerge::{AutoCommit, ROOT};

#[test]
fn test_bool() {
    let mut doc = AutoCommit::new();

    true.save(&mut doc, &ROOT, "flag").unwrap();

    let mut value = false;
    value.update(&doc, &ROOT, "flag").unwrap();
    assert!(value);

    let restored = bool::load(&doc, &ROOT, "flag").unwrap();
    assert!(restored);
}

#[test]
fn test_integers() {
    let mut doc = AutoCommit::new();

    42i64.save(&mut doc, &ROOT, "num").unwrap();

    let mut value = 0i64;
    value.update(&doc, &ROOT, "num").unwrap();
    assert_eq!(value, 42);

    let restored = i64::load(&doc, &ROOT, "num").unwrap();
    assert_eq!(restored, 42);
}

#[test]
fn test_string() {
    let mut doc = AutoCommit::new();

    "hello"
        .to_string()
        .save(&mut doc, &ROOT, "greeting")
        .unwrap();

    let mut value = String::new();
    value.update(&doc, &ROOT, "greeting").unwrap();
    assert_eq!(value, "hello");

    let restored = String::load(&doc, &ROOT, "greeting").unwrap();
    assert_eq!(restored, "hello");
}

#[test]
fn test_option() {
    let mut doc = AutoCommit::new();

    let some_val: Option<i64> = Some(42);
    some_val.save(&mut doc, &ROOT, "maybe").unwrap();

    let restored = Option::<i64>::load(&doc, &ROOT, "maybe").unwrap();
    assert_eq!(restored, Some(42));

    let none_val: Option<i64> = None;
    none_val.save(&mut doc, &ROOT, "maybe").unwrap();

    let restored = Option::<i64>::load(&doc, &ROOT, "maybe").unwrap();
    assert_eq!(restored, None);
}

#[test]
fn test_vec() {
    let mut doc = AutoCommit::new();

    let values = vec![1i64, 2, 3, 4, 5];
    values.save(&mut doc, &ROOT, "numbers").unwrap();

    let restored = Vec::<i64>::load(&doc, &ROOT, "numbers").unwrap();
    assert_eq!(restored, vec![1, 2, 3, 4, 5]);
}

#[test]
fn test_tuple() {
    let mut doc = AutoCommit::new();

    let tuple = ("hello".to_string(), 42i64);
    tuple.save(&mut doc, &ROOT, "pair").unwrap();

    let restored = <(String, i64)>::load(&doc, &ROOT, "pair").unwrap();
    assert_eq!(restored, ("hello".to_string(), 42));
}

#[test]
fn test_hashmap() {
    use std::collections::HashMap;

    let mut doc = AutoCommit::new();

    let mut map = HashMap::new();
    map.insert("a".to_string(), 1i64);
    map.insert("b".to_string(), 2);

    map.save(&mut doc, &ROOT, "map").unwrap();

    let restored = HashMap::<String, i64>::load(&doc, &ROOT, "map").unwrap();
    assert_eq!(restored.get("a"), Some(&1));
    assert_eq!(restored.get("b"), Some(&2));
}

#[test]
fn test_version_aware() {
    let mut doc = AutoCommit::new();

    // Write initial value
    "version1"
        .to_string()
        .save(&mut doc, &ROOT, "data")
        .unwrap();
    let heads_v1 = doc.get_heads();

    // Write new value
    "version2"
        .to_string()
        .save(&mut doc, &ROOT, "data")
        .unwrap();

    // Read current value
    let current = String::load(&doc, &ROOT, "data").unwrap();
    assert_eq!(current, "version2");

    // Read historical value
    let historical = String::load_at(&doc, &ROOT, "data", &heads_v1).unwrap();
    assert_eq!(historical, "version1");
}

#[test]
fn test_nested_vec_with_empty_inner() {
    let mut doc = AutoCommit::new();

    // Vec containing an empty Vec - this is an edge case
    let value: Vec<Vec<i64>> = vec![vec![]];
    value.save(&mut doc, &ROOT, "nested").unwrap();

    let restored = Vec::<Vec<i64>>::load(&doc, &ROOT, "nested").unwrap();
    let expected: Vec<Vec<i64>> = vec![vec![]];
    assert_eq!(restored, expected);
}

#[test]
fn test_nested_vec_mixed() {
    let mut doc = AutoCommit::new();

    // Vec with mixed empty and non-empty inner vecs
    let value: Vec<Vec<i64>> = vec![vec![1, 2, 3], vec![], vec![4, 5]];
    value.save(&mut doc, &ROOT, "nested").unwrap();

    let restored = Vec::<Vec<i64>>::load(&doc, &ROOT, "nested").unwrap();
    assert_eq!(restored, value);
}