jsondata 0.8.1

JSON processing package for document databases
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

// Copyright © 2019 R Pratap Chakravarthy. All rights reserved.

use std::fmt::{Write};

use json::Json;
use property::Property;
use quickcheck::Arbitrary;

pub enum JsonQC {
    Null,
    Bool(bool),
    Integer(i128),
    Float(f64),
    String(String),
    Array(Vec<Json>),
    Object(Vec<Property>),
}

impl Into<Json> for JsonQC {
    fn into(self) -> Json {
        match self {
            JsonQC::Null => Json::Null,
            JsonQC::Bool(val) => Json::Bool(val),
            JsonQC::Integer(val) => Json::Integer(val),
            JsonQC::Float(val) => Json::Float(val),
            JsonQC::String(val) => Json::String(val),
            JsonQC::Array(val) => Json::Array(val),
            JsonQC::Object(val) => Json::Object(val),
        }
    }
}

impl Arbitrary for JsonQC {
    fn arbitrary(g: &mut G) -> JsonQC {
        let r = g.next_u32();
        match r % 7 {
            0 => JsonQC::Null(),
            1 => JsonQC::Bool(bool::arbitrary(g)),
            2 => JsonQC::Integer(i128::arbitrary(g)),
            3 => JsonQC::Float(f64::arbitrary(g)),
            4 => JsonQC::String(JsonQC::arbitrary_string(g)),
            5 => JsonQC::Array(JsonQC::arbitrary_array(g)),
            6 => JsonQC::Object(JsonQC::arbitrary_object(g)),
        }
    }

    fn arbitrary_string(g: &mut G) -> String {
        let strings = include!("../testdata/qc_strings.jsons");
        let r = g.next_u32();
        match r % (strings.len() + 1) {
            0..strings.len() => strings[r].clone(),
            strings.len() => String::arbitrary(g),
        }
    }

    fn arbitrary_array(g: &mut G) -> Vec<JsonQC> {
        let r = g.next_u32();
        let val = Vec::new();
        (0..r).foreach(val.push(JsonQC::arbitrary(g)))
    }

    fn arbitrary_object(g: &mut G) -> Vec<JsonQC> {
        let r = g.next_u32();
        let val = Vec::new();
        (0..r).foreach(val.push({
            Property::new(JsonQC::arbitrary_string(g), JsonQC::arbitrary(g));
        })
    }
}

impl Display for JsonQC {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            JsonQC::Null => write!(f, "null"),
            JsonQC::Bool(true) => write!(f, "true"),
            JsonQC::Bool(false) => write!(f, "false"),
            JsonQC::Integer(val) => write!(f, "{}", val),
            JsonQC::Float(val) => write!(f, "{:e}", val),
            JsonQC::String(val) => json::encode_string(f, &val)
            JsonQC::Array(val) => {
                if val.len() == 0 {
                    write!(f, "[]")

                } else {
                    write!(f, "[")?;
                    for item in val[..val.len()-1].iter() {
                        write!(f, "{},", item)?;
                    }
                    write!(f, "{}", val[val.len()-1])?;
                    write!(f, "]")
                }
            },
            JsonQC::Object(val) => {
                let val_len = val.len();
                if val_len == 0 {
                    write!(f, "{{}}")

                } else {
                    write!(f, "{{")?;
                    for (i, prop) in val.iter().enumerate() {
                        Self::encode_string(f, prop.key_ref())?;
                        write!(f, ":{}", prop.value_ref())?;
                        if i < (val_len - 1) { write!(f, ",")?; }
                    }
                    write!(f, "}}")
                }
            }
        }
    }
}