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

use toml::{Value, value::Table};

use schema_analysis::InferredSchema;

mod shared;
use shared::FormatTests;

struct Toml;

test_format!(Toml);

impl FormatTests for Toml {
    type Value = Value;

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

    fn test_null() {}
    fn null() -> Self::Value {
        unreachable!() // Toml doesn't have null values
    }

    // Toml doesn't allow top-level primitives
    fn test_boolean() {}
    fn boolean() -> Self::Value {
        unreachable!()
    }
    fn test_integer() {}
    fn integer() -> Self::Value {
        unreachable!()
    }
    fn test_float() {}
    fn float() -> Self::Value {
        unreachable!()
    }
    fn test_string() {}
    fn string() -> Self::Value {
        unreachable!()
    }

    // Toml doesn't allow top-level arrays
    fn test_empty_sequence() {}
    fn empty_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_string_sequence() {}
    fn string_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_integer_sequence() {}
    fn integer_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_mixed_sequence() {}
    fn mixed_sequence() -> Self::Value {
        unreachable!()
    }
    fn test_optional_mixed_sequence() {}
    fn optional_mixed_sequence() -> Self::Value {
        unreachable!()
    }

    fn empty_map_struct() -> Self::Value {
        Value::Table(Table::new())
    }
    fn map_struct_single() -> Self::Value {
        let mut mapping = Table::new();
        mapping.insert("hello".into(), 1.into());
        Value::Table(mapping)
    }
    fn map_struct_double() -> Self::Value {
        let mut mapping = Table::new();
        mapping.insert("hello".into(), 1.into());
        mapping.insert("world".into(), "!".into());
        Value::Table(mapping)
    }
    fn test_sequence_map_struct_mixed() {}
    fn sequence_map_struct_mixed() -> Self::Value {
        unreachable!() // Toml doesn't allow top-level arrays
    }
    fn test_sequence_map_struct_optional_or_missing() {}
    fn sequence_map_struct_optional_or_missing() -> Self::Value {
        unreachable!() // Toml doesn't allow top-level arrays
    }
    fn map_struct_mixed_sequence() -> Self::Value {
        let mut mapping = Table::new();
        mapping.insert("hello".into(), 1.into());
        mapping.insert("world".into(), "!".into());
        mapping.insert(
            "sequence".into(),
            Value::Array(vec!["one".into(), "two".into(), "three".into()]),
        );
        Value::Table(mapping)
    }
    fn test_map_struct_mixed_sequence_optional() {}
    fn map_struct_mixed_sequence_optional() -> Self::Value {
        unreachable!() // Toml doesn't have null values
    }
}