xidl-parser 0.105.0

A IDL codegen.
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

//! Compares adjacent collected surfaces without following references.

use super::helpers::object;
use super::model::{Change, ChangeKind, OperationSurface, TypeChange, TypeSurface, type_shape};
use serde_json::Value;
use std::collections::{BTreeMap, BTreeSet};

pub(crate) fn compare_types(
    from: &BTreeMap<String, TypeSurface>,
    to: &BTreeMap<String, TypeSurface>,
) -> BTreeMap<String, TypeChange> {
    let keys = from
        .keys()
        .chain(to.keys())
        .cloned()
        .collect::<BTreeSet<_>>();
    keys.into_iter()
        .filter_map(|key| match (from.get(&key), to.get(&key)) {
            (None, Some(value)) => Some((
                key,
                TypeChange {
                    change: ChangeKind::Added,
                    kind: Some(value.kind.clone()),
                    details: (!value.details.is_empty()).then(|| value.details.clone()),
                    from: None,
                    to: None,
                    members: BTreeMap::new(),
                },
            )),
            (Some(value), None) => Some((
                key,
                TypeChange {
                    change: ChangeKind::Removed,
                    kind: Some(value.kind.clone()),
                    details: (!value.details.is_empty()).then(|| value.details.clone()),
                    from: None,
                    to: None,
                    members: BTreeMap::new(),
                },
            )),
            (Some(left), Some(right)) => {
                let members = compare_values(&left.members, &right.members);
                (left.kind != right.kind || left.details != right.details || !members.is_empty())
                    .then_some((
                        key,
                        TypeChange {
                            change: ChangeKind::Changed,
                            kind: Some(right.kind.clone()),
                            details: (!right.details.is_empty()).then(|| right.details.clone()),
                            from: Some(type_shape(left)),
                            to: Some(type_shape(right)),
                            members,
                        },
                    ))
            }
            (None, None) => None,
        })
        .collect()
}

pub(crate) fn compare_operations(
    from: &BTreeMap<String, OperationSurface>,
    to: &BTreeMap<String, OperationSurface>,
) -> BTreeMap<String, Change> {
    let keys = from
        .keys()
        .chain(to.keys())
        .cloned()
        .collect::<BTreeSet<_>>();
    keys.into_iter()
        .filter_map(|key| match (from.get(&key), to.get(&key)) {
            (None, Some(value)) => Some((
                key,
                change(ChangeKind::Added, None, Some(operation_descriptor(value))),
            )),
            (Some(value), None) => Some((
                key,
                change(ChangeKind::Removed, Some(operation_descriptor(value)), None),
            )),
            (Some(left), Some(right)) => {
                let mut from_descriptor = left.descriptor.clone();
                from_descriptor.insert(
                    "parameters".to_string(),
                    Value::Object(object(&left.params)),
                );
                let mut to_descriptor = right.descriptor.clone();
                to_descriptor.insert(
                    "parameters".to_string(),
                    Value::Object(object(&right.params)),
                );
                (from_descriptor != to_descriptor).then_some((
                    key,
                    change(
                        ChangeKind::Changed,
                        Some(from_descriptor),
                        Some(to_descriptor),
                    ),
                ))
            }
            (None, None) => None,
        })
        .collect()
}

fn operation_descriptor(value: &OperationSurface) -> BTreeMap<String, Value> {
    let mut descriptor = value.descriptor.clone();
    if !value.params.is_empty() {
        descriptor.insert(
            "parameters".to_string(),
            Value::Object(object(&value.params)),
        );
    }
    descriptor
}

fn compare_values(
    from: &BTreeMap<String, BTreeMap<String, Value>>,
    to: &BTreeMap<String, BTreeMap<String, Value>>,
) -> BTreeMap<String, Change> {
    let keys = from
        .keys()
        .chain(to.keys())
        .cloned()
        .collect::<BTreeSet<_>>();
    keys.into_iter()
        .filter_map(|key| match (from.get(&key), to.get(&key)) {
            (None, Some(value)) => {
                Some((key, change(ChangeKind::Added, None, Some(value.clone()))))
            }
            (Some(value), None) => {
                Some((key, change(ChangeKind::Removed, Some(value.clone()), None)))
            }
            (Some(left), Some(right)) => (left != right).then_some((
                key,
                change(ChangeKind::Changed, Some(left.clone()), Some(right.clone())),
            )),
            (None, None) => None,
        })
        .collect()
}

fn change(
    kind: ChangeKind,
    from: Option<BTreeMap<String, Value>>,
    to: Option<BTreeMap<String, Value>>,
) -> Change {
    Change {
        change: kind,
        from,
        to,
    }
}