loftspec 2.1.0

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

//! Equality of field values as the merge sees it: by content alone, never by where a value
//! sat in its file, with an empty list the same as an absent one (AC-799).

use crate::codec::{ConflictRec, Rec, Val};

/// Whether two sides hold the same value of a field.
pub(super) fn same(left: Option<&Val>, right: Option<&Val>) -> bool {
    match (present(left), present(right)) {
        (None, None) => true,
        (Some(left), Some(right)) => same_value(left, right),
        _ => false,
    }
}

/// A value that is there: an empty list counts as absent.
pub(super) fn present(value: Option<&Val>) -> Option<&Val> {
    value.filter(|value| !matches!(value, Val::List(items) if items.is_empty()))
}

pub(super) fn same_value(left: &Val, right: &Val) -> bool {
    match (left, right) {
        (Val::Scalar { text: left, .. }, Val::Scalar { text: right, .. }) => left == right,
        (Val::Null { .. }, Val::Null { .. }) => true,
        (Val::Ext { value: left, .. }, Val::Ext { value: right, .. }) => left == right,
        (Val::List(left), Val::List(right)) => all_same(left, right, same_value),
        (Val::Record(left), Val::Record(right)) => same_record(left, right),
        _ => false,
    }
}

/// Whether two records of one kind hold the same present fields with the same values, and the
/// same conflicts: a record whose conflicts differ is not the same record.
pub(super) fn same_record(left: &Rec, right: &Rec) -> bool {
    let (left_fields, right_fields) = (present_fields(left), present_fields(right));
    left.kind == right.kind
        && left_fields.len() == right_fields.len()
        && left_fields
            .iter()
            .zip(&right_fields)
            .all(|((left_name, left), (right_name, right))| {
                left_name == right_name && same_value(left, right)
            })
        && all_same(&left.conflicts, &right.conflicts, same_conflict)
}

/// Whether two conflicts name the same field with the same sides.
pub(super) fn same_conflict(left: &ConflictRec, right: &ConflictRec) -> bool {
    left.field == right.field
        && left
            .sides()
            .into_iter()
            .zip(right.sides())
            .all(|((_, left), (_, right))| same(left, right))
}

/// Whether a record holds a conflict the same as `conflict`.
pub(super) fn holds(record: &Rec, conflict: &ConflictRec) -> bool {
    record
        .conflicts
        .iter()
        .any(|held| same_conflict(held, conflict))
}

/// Whether two lists hold the same items in the same order, by `same`.
fn all_same<T>(left: &[T], right: &[T], same: fn(&T, &T) -> bool) -> bool {
    left.len() == right.len()
        && left
            .iter()
            .zip(right)
            .all(|(left, right)| same(left, right))
}

/// The fields of a record that hold a present value.
fn present_fields(record: &Rec) -> Vec<&(&'static str, Val)> {
    record
        .fields
        .iter()
        .filter(|(_, value)| present(Some(value)).is_some())
        .collect()
}

/// A value as text that two values share exactly when they are the same.
pub(super) fn text(value: &Val) -> String {
    match value {
        Val::Scalar { text, .. } => text.clone(),
        Val::Null { .. } => "null".to_owned(),
        Val::Ext { value, .. } => format!("ext{}", crate::ext::to_json(value)),
        Val::List(items) => format!("[{}]", items.iter().map(text).collect::<Vec<_>>().join(",")),
        Val::Record(record) => {
            let fields = record
                .fields
                .iter()
                .filter(|(_, value)| present(Some(value)).is_some())
                .map(|(name, value)| format!("{name}={}", text(value)));
            let mut text = format!("{{{}}}", fields.collect::<Vec<_>>().join(";"));
            if !record.conflicts.is_empty() {
                let conflicts: Vec<String> = record.conflicts.iter().map(conflict_text).collect();
                text.push('[');
                text.push_str(&conflicts.join(","));
                text.push(']');
            }
            text
        }
    }
}

/// A conflict as text, its field and each present side by name, as a record's text names its
/// fields.
fn conflict_text(conflict: &ConflictRec) -> String {
    let sides = conflict
        .sides()
        .into_iter()
        .filter_map(|(name, side)| present(side).map(|side| format!("{name}={}", text(side))));
    let fields: Vec<String> = std::iter::once(format!("field={}", conflict.field))
        .chain(sides)
        .collect();
    format!("{{{}}}", fields.join(";"))
}