jss_core/schema/traits/
display.rs

1use std::fmt::Write;
2
3use text_utils::indent;
4
5use super::*;
6
7impl Display for JssSchema {
8    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
9        self.write_description(f)?;
10        match self.kind {
11            JssKind::Scheme => f.write_str("schema "),
12            JssKind::Property => f.write_str("."),
13            JssKind::PropertyTop => f.write_str("property "),
14            JssKind::Definition => f.write_str("define "),
15        }?;
16        self.head(f)?;
17        // for (key, value) in &self.keywords {
18        //     writeln!(f, "{}", indent(format!("{}: {:#?}", key, value), 4))?;
19        // }
20        for (key, value) in &self.attribute {
21            writeln!(f, "{}", indent(format!("{}: {:#?}", key, value), 4))?;
22        }
23        match self.kind {
24            JssKind::Scheme => {}
25            _ => {
26                for (_, value) in &self.property {
27                    writeln!(f, "{}", indent(format!("{:#}", value), 4))?;
28                    writeln!(f)?;
29                }
30            }
31        }
32        f.write_str("}\n")?;
33        if let JssKind::Scheme = self.kind {
34            for (_, value) in &self.definition {
35                Display::fmt(value, f)?;
36                writeln!(f)?;
37            }
38            for (_, value) in &self.property {
39                Display::fmt(value, f)?;
40                writeln!(f)?;
41            }
42        }
43        Ok(())
44    }
45}
46
47impl JssSchema {
48    #[inline]
49    fn head(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
50        match &self.name {
51            None => f.write_char('_')?,
52            Some(s) => f.write_str(s)?,
53        }
54        match &self.typing {
55            JssType::Undefined => {}
56            JssType::Anything => {}
57            JssType::Nothing => {}
58            JssType::Reference(v) => write!(f, ": \"{}\"", v)?,
59            JssType::Complex(v) => write!(f, ": \"{}\"", v)?,
60            _ => write!(f, ": {}", self.typing)?,
61        }
62        f.write_str(" {\n")?;
63        Ok(())
64    }
65    #[inline]
66    fn write_description(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
67        if self.has_description() {
68            for line in self.description.lines() {
69                writeln!(f, "/// {}", line)?
70            }
71        }
72        Ok(())
73    }
74}
75
76impl Display for JssValue {
77    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
78        match self {
79            Self::Null => {
80                unimplemented!()
81            }
82            Self::Boolean(_) => {
83                unimplemented!()
84            }
85            Self::Number(_) => {
86                unimplemented!()
87            }
88            Self::String(v) => Debug::fmt(v, f),
89            Self::Url(_) => {
90                unimplemented!()
91            }
92            Self::Regex(_) => {
93                unimplemented!()
94            }
95            Self::Array(v) => Debug::fmt(v, f),
96            Self::Object(_) => {
97                unimplemented!()
98            }
99        }
100    }
101}
102
103impl Display for JssType {
104    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
105        match self {
106            Self::Undefined => f.write_str("undefined"),
107            Self::Anything => f.write_str("anything"),
108            Self::Nothing => f.write_str("nothing"),
109            Self::Number => f.write_str("number"),
110            JssType::Integer => f.write_str("integer"),
111            Self::Object => f.write_str("object"),
112            Self::Reference(v) => f.write_str(&v),
113            JssType::String => f.write_str("string"),
114            JssType::Array => f.write_str("array"),
115            Self::Complex(v) => f.write_str(&v.to_string()),
116        }
117    }
118}
119
120impl Display for JssComplexType {
121    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
122        f.write_str(&self.pattern.to_string())
123    }
124}