schema_analysis 0.6.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

use serde_json::{Value, json};

use schema_analysis::InferredSchema;

mod shared;
use shared::FormatTests;

struct Json;

test_format!(Json);

impl FormatTests for Json {
    type Value = Value;

    fn infer_schema(value: Self::Value) -> InferredSchema {
        let processed_schema: InferredSchema = serde_json::from_str(&value.to_string()).unwrap();
        processed_schema
    }

    fn null() -> Self::Value {
        json!(null)
    }
    fn boolean() -> Self::Value {
        json!(true)
    }
    fn integer() -> Self::Value {
        json!(123)
    }
    fn float() -> Self::Value {
        json!(123.123)
    }
    fn string() -> Self::Value {
        json!("hello there!")
    }

    fn empty_sequence() -> Self::Value {
        json!([])
    }
    fn string_sequence() -> Self::Value {
        json!(["one", "two", "three"])
    }
    fn integer_sequence() -> Self::Value {
        json!([1, 2, 3])
    }
    fn mixed_sequence() -> Self::Value {
        json!([1, "two", 3])
    }
    fn optional_mixed_sequence() -> Self::Value {
        json!([1, "two", 3, null])
    }

    fn empty_map_struct() -> Self::Value {
        json!({})
    }
    fn map_struct_single() -> Self::Value {
        json!({
            "hello": 1
        })
    }
    fn map_struct_double() -> Self::Value {
        json!({
            "hello": 1,
            "world": "!"
        })
    }
    fn sequence_map_struct_mixed() -> Self::Value {
        json!([
            {
                "hello": 1,
                "world": "!",
                "mixed": 1.1,
            },
            {
                "hello": 1,
                "world": "!",
                "mixed": "1.1",
            }
        ])
    }
    fn sequence_map_struct_optional_or_missing() -> Self::Value {
        json!([
            {
                "hello": 1,
                "possibly_null": "!",
                "possibly_missing": 1.1,
                "null_or_missing": null,
            },
            {
                "hello": 2,
                "possibly_null": null,
            }
        ])
    }
    fn map_struct_mixed_sequence() -> Self::Value {
        json!({
            "hello": 1,
            "world": "!",
            "sequence": ["one", "two", "three"]
        })
    }
    fn map_struct_mixed_sequence_optional() -> Self::Value {
        json!({
            "hello": 1,
            "world": "!",
            "optional": null,
            "sequence": ["one", "two", "three", null]
        })
    }
}