schema_analysis 0.7.0

Analyze the schema of any self describing format
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

use std::collections::BTreeMap;

use serde_cbor::Value;

use schema_analysis::InferredSchema;

mod shared;
use shared::FormatTests;

struct Cbor;

test_format!(Cbor);

impl FormatTests for Cbor {
    type Value = Value;

    fn infer_schema(value: Value) -> InferredSchema {
        let vec_value = serde_cbor::to_vec(&value).unwrap();
        let processed_schema: InferredSchema = serde_cbor::from_slice(&vec_value).unwrap();
        processed_schema
    }

    fn null() -> Self::Value {
        Value::Null
    }
    fn boolean() -> Self::Value {
        Value::Bool(true)
    }
    fn integer() -> Self::Value {
        Value::Integer(123)
    }
    fn float() -> Self::Value {
        Value::Float(123.123)
    }
    fn string() -> Self::Value {
        Value::Text("hello".into())
    }

    fn empty_sequence() -> Self::Value {
        Value::Array(vec![])
    }
    fn string_sequence() -> Self::Value {
        Value::Array(vec![
            Value::Text("one".into()),
            Value::Text("two".into()),
            Value::Text("three".into()),
        ])
    }
    fn integer_sequence() -> Self::Value {
        Value::Array(vec![1.into(), 2.into(), 3.into()])
    }
    fn mixed_sequence() -> Self::Value {
        Value::Array(vec![1.into(), Value::Text("two".into()), 3.into()])
    }
    fn optional_mixed_sequence() -> Self::Value {
        Value::Array(vec![
            1.into(),
            Value::Text("two".into()),
            3.into(),
            Value::Null,
        ])
    }

    fn empty_map_struct() -> Self::Value {
        Value::Map(BTreeMap::new())
    }
    fn map_struct_single() -> Self::Value {
        let mut mapping = BTreeMap::new();
        mapping.insert(Value::Text("hello".into()), 1.into());
        Value::Map(mapping)
    }
    fn map_struct_double() -> Self::Value {
        let mut mapping = BTreeMap::new();
        mapping.insert(Value::Text("hello".into()), 1.into());
        mapping.insert(Value::Text("world".into()), Value::Text("!".into()));
        Value::Map(mapping)
    }
    fn sequence_map_struct_mixed() -> Self::Value {
        let mut mapping_1 = BTreeMap::new();
        mapping_1.insert(Value::Text("hello".into()), 1.into());
        mapping_1.insert(Value::Text("world".into()), Value::Text("!".into()));
        mapping_1.insert(Value::Text("mixed".into()), 1.1.into());

        let mut mapping_2 = BTreeMap::new();
        mapping_2.insert(Value::Text("hello".into()), 1.into());
        mapping_2.insert(Value::Text("world".into()), Value::Text("!".into()));
        mapping_2.insert(Value::Text("mixed".into()), Value::Text("1.1".into()));

        Value::Array(vec![Value::Map(mapping_1), Value::Map(mapping_2)])
    }
    fn sequence_map_struct_optional_or_missing() -> Self::Value {
        let mut mapping_1 = BTreeMap::new();
        mapping_1.insert(Value::Text("hello".into()), 1.into());
        mapping_1.insert(Value::Text("possibly_null".into()), Value::Text("!".into()));
        mapping_1.insert(Value::Text("possibly_missing".into()), 1.1.into());
        mapping_1.insert(Value::Text("null_or_missing".into()), Value::Null);

        let mut mapping_2 = BTreeMap::new();
        mapping_2.insert(Value::Text("hello".into()), 2.into());
        mapping_2.insert(Value::Text("possibly_null".into()), Value::Null);

        Value::Array(vec![Value::Map(mapping_1), Value::Map(mapping_2)])
    }
    fn map_struct_mixed_sequence() -> Self::Value {
        let mut mapping = BTreeMap::new();
        mapping.insert(Value::Text("hello".into()), 1.into());
        mapping.insert(Value::Text("world".into()), Value::Text("!".into()));
        mapping.insert(
            Value::Text("sequence".into()),
            Value::Array(vec![
                Value::Text("one".into()),
                Value::Text("two".into()),
                Value::Text("three".into()),
            ]),
        );
        Value::Map(mapping)
    }
    fn map_struct_mixed_sequence_optional() -> Self::Value {
        let mut mapping = BTreeMap::new();
        mapping.insert(Value::Text("hello".into()), 1.into());
        mapping.insert(Value::Text("world".into()), Value::Text("!".into()));
        mapping.insert(Value::Text("optional".into()), Value::Null);
        mapping.insert(
            Value::Text("sequence".into()),
            Value::Array(vec![
                Value::Text("one".into()),
                Value::Text("two".into()),
                Value::Text("three".into()),
                Value::Null,
            ]),
        );
        Value::Map(mapping)
    }
}