jss-core 0.2.0

Json Simplified Schema Core Interface
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

use std::fmt::Write;

use text_utils::indent;

use super::*;

impl Display for JssSchema {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        self.write_description(f)?;
        match self.kind {
            JssKind::Scheme => f.write_str("schema "),
            JssKind::Property => f.write_str("."),
            JssKind::PropertyTop => f.write_str("property "),
            JssKind::Definition => f.write_str("define "),
        }?;
        self.head(f)?;
        // for (key, value) in &self.keywords {
        //     writeln!(f, "{}", indent(format!("{}: {:#?}", key, value), 4))?;
        // }
        for (key, value) in &self.attribute {
            writeln!(f, "{}", indent(format!("{}: {:#?}", key, value), 4))?;
        }
        match self.kind {
            JssKind::Scheme => {}
            _ => {
                for (_, value) in &self.property {
                    writeln!(f, "{}", indent(format!("{:#}", value), 4))?;
                    writeln!(f)?;
                }
            }
        }
        f.write_str("}\n")?;
        if let JssKind::Scheme = self.kind {
            for (_, value) in &self.definition {
                Display::fmt(value, f)?;
                writeln!(f)?;
            }
            for (_, value) in &self.property {
                Display::fmt(value, f)?;
                writeln!(f)?;
            }
        }
        Ok(())
    }
}

impl JssSchema {
    #[inline]
    fn head(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match &self.name {
            None => f.write_char('_')?,
            Some(s) => f.write_str(s)?,
        }
        match &self.typing {
            JssType::Undefined => {}
            JssType::Anything => {}
            JssType::Nothing => {}
            JssType::Reference(v) => write!(f, ": \"{}\"", v)?,
            JssType::Complex(v) => write!(f, ": \"{}\"", v)?,
            _ => write!(f, ": {}", self.typing)?,
        }
        f.write_str(" {\n")?;
        Ok(())
    }
    #[inline]
    fn write_description(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if self.has_description() {
            for line in self.description.lines() {
                writeln!(f, "/// {}", line)?
            }
        }
        Ok(())
    }
}

impl Display for JssValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Null => {
                unimplemented!()
            }
            Self::Boolean(_) => {
                unimplemented!()
            }
            Self::Number(_) => {
                unimplemented!()
            }
            Self::String(v) => Debug::fmt(v, f),
            Self::Url(_) => {
                unimplemented!()
            }
            Self::Regex(_) => {
                unimplemented!()
            }
            Self::Array(v) => Debug::fmt(v, f),
            Self::Object(_) => {
                unimplemented!()
            }
        }
    }
}

impl Display for JssType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Undefined => f.write_str("undefined"),
            Self::Anything => f.write_str("anything"),
            Self::Nothing => f.write_str("nothing"),
            Self::Number => f.write_str("number"),
            JssType::Integer => f.write_str("integer"),
            Self::Object => f.write_str("object"),
            Self::Reference(v) => f.write_str(&v),
            JssType::String => f.write_str("string"),
            JssType::Array => f.write_str("array"),
            Self::Complex(v) => f.write_str(&v.to_string()),
        }
    }
}

impl Display for JssComplexType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.pattern.to_string())
    }
}