loftspec 2.0.2

The Loft Specification Format: document model, identity, canonical bytes, hashing and conversion
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

//! The merge of one record over its fields (F-32): a field one side changed takes the
//! change, a field both changed alike takes it once, and a field both changed apart keeps its
//! base value and gains a conflict on the record that holds it (RQ-120..RQ-122). An unkeyed
//! record inside it merges field by field under a dotted path.

use super::conflict::Host;
use super::list::merge_list;
use super::same::{same, same_conflict};
use crate::codec::schema::{Field, Item, Shape};
use crate::codec::{ConflictRec, Rec, Val, variant_holds};

/// One field's value on each side, and whether base has the record at all.
struct Sides<'a> {
    base: Option<&'a Val>,
    ours: Option<&'a Val>,
    theirs: Option<&'a Val>,
    base_record: bool,
}

/// Merges a record that holds conflicts: its fields, then the conflicts already on it, merged
/// as a set, followed by those the merge writes.
pub(super) fn merge_host(base: Option<&Rec>, ours: &Rec, theirs: &Rec) -> Rec {
    let mut conflicts = carried(base, ours, theirs);
    let mut host = Host::root(&mut conflicts);
    let mut record = merge_fields(base, ours, theirs, &mut host);
    record.conflicts = conflicts;
    record
}

/// The conflicts the inputs already hold: one on both sides is written once, one that a side
/// removed is removed, and one that a side added is added.
fn carried(base: Option<&Rec>, ours: &Rec, theirs: &Rec) -> Vec<ConflictRec> {
    let holds = |record: &Rec, conflict: &ConflictRec| {
        record
            .conflicts
            .iter()
            .any(|each| same_conflict(each, conflict))
    };
    let kept = |conflict: &ConflictRec| match base {
        Some(base) if holds(base, conflict) => holds(ours, conflict) && holds(theirs, conflict),
        _ => true,
    };
    let ours_kept = ours.conflicts.iter().filter(|conflict| kept(conflict));
    let theirs_added = theirs
        .conflicts
        .iter()
        .filter(|conflict| !holds(ours, conflict) && kept(conflict));
    ours_kept.chain(theirs_added).cloned().collect()
}

/// Merges the fields of one record; its conflicts go to `host`. A record whose merged fields
/// form none of its variants keeps its base and conflicts on each field either side changed.
pub(super) fn merge_fields(
    base: Option<&Rec>,
    ours: &Rec,
    theirs: &Rec,
    host: &mut Host<'_>,
) -> Rec {
    let kind = ours.kind;
    let mark = host.conflicts.len();
    let mut record = Rec::new(kind);
    for each in kind.fields() {
        let sides = sides(each, base, ours, theirs);
        if let Some(value) = merge_field(each, &sides, host) {
            record.set(each.name, value);
        }
    }
    if variant_holds(&record) {
        return record;
    }
    host.conflicts.truncate(mark);
    // The host merge sets the record's own conflicts; an unkeyed record holds none.
    let record = base.unwrap_or(ours).clone();
    for each in kind.fields() {
        let sides = sides(each, base, ours, theirs);
        if !same(sides.ours, sides.base) || !same(sides.theirs, sides.base) {
            host.conflict(each.name, [sides.base, sides.ours, sides.theirs]);
        }
    }
    record
}

fn sides<'a>(each: &Field, base: Option<&'a Rec>, ours: &'a Rec, theirs: &'a Rec) -> Sides<'a> {
    Sides {
        base: base.and_then(|record| record.get(each.name)),
        ours: ours.get(each.name),
        theirs: theirs.get(each.name),
        base_record: base.is_some(),
    }
}

fn merge_field(each: &Field, sides: &Sides<'_>, host: &mut Host<'_>) -> Option<Val> {
    if same(sides.ours, sides.theirs) {
        return sides.ours.cloned();
    }
    if same(sides.ours, sides.base) {
        return sides.theirs.cloned();
    }
    if same(sides.theirs, sides.base) {
        return sides.ours.cloned();
    }
    match (each.shape, sides.base, sides.ours, sides.theirs) {
        (Shape::List(_), base, ours, theirs) => Some(Val::List(merge_list(
            each,
            [list(base), list(ours), list(theirs)],
            host,
        ))),
        (Shape::One(Item::Record(_)), base, Some(Val::Record(ours)), Some(Val::Record(theirs))) => {
            // A sub-record base lacks merges as one both sides added (S7).
            let base = match base {
                Some(Val::Record(base)) => Some(base),
                _ => None,
            };
            Some(Val::Record(merge_fields(
                base,
                ours,
                theirs,
                &mut host.nest(each.name),
            )))
        }
        _ => {
            host.conflict(each.name, [sides.base, sides.ours, sides.theirs]);
            if sides.base_record {
                sides.base.cloned()
            } else {
                sides.ours.cloned()
            }
        }
    }
}

fn list(value: Option<&Val>) -> &[Val] {
    match value {
        Some(Val::List(items)) => items,
        _ => &[],
    }
}