Skip to main content

jim_rs/
lib.rs

1use std::io::Write;
2use std::{io, marker};
3
4pub struct JsonWriter<Sink, State> {
5    sink: Sink,
6    reentrant: bool,
7    _state: marker::PhantomData<State>,
8}
9
10macro_rules! define_states {
11    ($($state:ident),*) => {
12        $(pub struct $state<Prev> {
13            _prev: marker::PhantomData<Prev>,
14        })*
15    };
16}
17
18macro_rules! ret {
19    ($sink:expr, $reentrant:expr) => {
20        Ok(JsonWriter {
21            sink: $sink,
22            reentrant: $reentrant,
23            _state: marker::PhantomData::default(),
24        })
25    };
26}
27
28macro_rules! impl_values {
29    ($next_state:ty) => {
30        pub fn number(mut self, value: f64) -> io::Result<JsonWriter<Sink, $next_state>> {
31            self.comma()?;
32            write!(self.sink, "{value}")?;
33            ret!(self.sink, true)
34        }
35
36        pub fn string(mut self, value: &str) -> io::Result<JsonWriter<Sink, $next_state>> {
37            self.comma()?;
38            write!(self.sink, "{value:?}")?;
39            ret!(self.sink, true)
40        }
41
42        pub fn null(mut self) -> io::Result<JsonWriter<Sink, $next_state>> {
43            self.comma()?;
44            write!(self.sink, "null")?;
45            ret!(self.sink, true)
46        }
47
48        pub fn array(mut self) -> io::Result<JsonWriter<Sink, Array<$next_state>>> {
49            self.comma()?;
50            write!(self.sink, "[")?;
51            ret!(self.sink, false)
52        }
53
54        pub fn object(mut self) -> io::Result<JsonWriter<Sink, Object<$next_state>>> {
55            self.comma()?;
56            write!(self.sink, "{{")?;
57            ret!(self.sink, false)
58        }
59    };
60}
61
62pub struct Root;
63define_states!(Field, Array, Object);
64
65pub fn new_root<Sink: Write>(mut sink: Sink) -> io::Result<JsonWriter<Sink, Root>> {
66    write!(sink, "{{")?;
67    ret!(sink, false)
68}
69
70impl<Sink: Write, State> JsonWriter<Sink, State> {
71    fn comma(&mut self) -> io::Result<()> {
72        if self.reentrant {
73            write!(self.sink, ", ")
74        } else {
75            Ok(())
76        }
77    }
78}
79
80impl<Sink: Write> JsonWriter<Sink, Root> {
81    pub fn field(mut self, name: &str) -> io::Result<JsonWriter<Sink, Field<Root>>> {
82        self.comma()?;
83        write!(self.sink, "\"{name}\": ")?;
84        ret!(self.sink, false)
85    }
86
87    pub fn end(mut self) -> io::Result<()> {
88        write!(self.sink, "}}")?;
89        self.sink.flush()
90    }
91}
92
93impl<Sink: Write, Prev> JsonWriter<Sink, Field<Prev>> {
94    impl_values!(Prev);
95}
96
97impl<Sink: Write, Prev> JsonWriter<Sink, Object<Prev>> {
98    pub fn field(mut self, name: &str) -> io::Result<JsonWriter<Sink, Field<Object<Prev>>>> {
99        self.comma()?;
100        write!(self.sink, "\"{name}\": ")?;
101        ret!(self.sink, false)
102    }
103
104    pub fn end(mut self) -> io::Result<JsonWriter<Sink, Prev>> {
105        write!(self.sink, "}}")?;
106        ret!(self.sink, true)
107    }
108}
109
110impl<Sink: Write, Prev> JsonWriter<Sink, Array<Prev>> {
111    impl_values!(Array<Prev>);
112
113    pub fn end(mut self) -> io::Result<JsonWriter<Sink, Prev>> {
114        write!(self.sink, "]")?;
115        ret!(self.sink, true)
116    }
117}
118
119#[cfg(test)]
120mod tests {
121    use super::*;
122
123    #[test]
124    fn flat_object() -> std::io::Result<()> {
125        const EXPECTED: &str = r#"{"retcode": 1337, "message": "OK", "data": null}"#;
126
127        let mut buffer: Vec<u8> = Vec::new();
128        new_root(&mut buffer)?
129            .field("retcode")?
130            .number(1337.0)?
131            .field("message")?
132            .string("OK")?
133            .field("data")?
134            .null()?
135            .end()?;
136
137        assert_eq!(String::from_utf8(buffer).unwrap(), EXPECTED);
138        Ok(())
139    }
140
141    #[test]
142    fn arrays() -> std::io::Result<()> {
143        const EXPECTED: &str = r#"{"numbers": [1, 3, 3, 7, 13.37], "strings": ["Hello", "World"], "etc": [777, "foo", {"bar": "baz", "something": "else"}, null, []]}"#;
144
145        let mut buffer: Vec<u8> = Vec::new();
146        new_root(&mut buffer)?
147            .field("numbers")?
148            .array()?
149            .number(1.0)?
150            .number(3.0)?
151            .number(3.0)?
152            .number(7.0)?
153            .number(13.37)?
154            .end()?
155            .field("strings")?
156            .array()?
157            .string("Hello")?
158            .string("World")?
159            .end()?
160            .field("etc")?
161            .array()?
162            .number(777.0)?
163            .string("foo")?
164            .object()?
165            .field("bar")?
166            .string("baz")?
167            .field("something")?
168            .string("else")?
169            .end()?
170            .null()?
171            .array()?
172            .end()?
173            .end()?
174            .end()?;
175
176        assert_eq!(String::from_utf8(buffer).unwrap(), EXPECTED);
177        Ok(())
178    }
179}