facet_json/
serialize.rs

1use facet_core::Facet;
2use facet_reflect::Peek;
3use facet_serialize::{Serializer, serialize_iterative};
4use log::debug;
5use std::io::{self, Write};
6
7/// Serializes a value to JSON
8pub fn to_string<'a, T: Facet<'a>>(value: &T) -> String {
9    let peek = Peek::new(value);
10    let mut output = Vec::new();
11    let mut serializer = JsonSerializer::new(&mut output);
12    serialize_iterative(peek, &mut serializer).unwrap();
13    String::from_utf8(output).unwrap()
14}
15
16/// Serializes a Peek instance to JSON
17pub fn peek_to_string(peek: &Peek<'_, '_>) -> String {
18    let mut output = Vec::new();
19    let mut serializer = JsonSerializer::new(&mut output);
20    serialize_iterative(*peek, &mut serializer).unwrap();
21    String::from_utf8(output).unwrap()
22}
23
24/// Serializes a value to a writer in JSON format
25pub fn to_writer<'a, T: Facet<'a>, W: Write>(value: &T, writer: &mut W) -> io::Result<()> {
26    let peek = Peek::new(value);
27    let mut serializer = JsonSerializer::new(writer);
28    serialize_iterative(peek, &mut serializer)
29}
30
31/// Serializes a Peek instance to a writer in JSON format
32pub fn peek_to_writer<W: Write>(peek: &Peek<'_, '_>, writer: &mut W) -> io::Result<()> {
33    let mut serializer = JsonSerializer::new(writer);
34    serialize_iterative(*peek, &mut serializer)
35}
36
37#[derive(Debug)]
38enum StackItem {
39    ArrayItem { first: bool },
40    ObjectItem { object_state: ObjectItemState },
41}
42
43#[derive(Debug)]
44enum ObjectItemState {
45    FirstKey,
46    Key,
47    Value,
48}
49
50/// A serializer for JSON format that implements the `facet_serialize::Serializer` trait.
51pub struct JsonSerializer<W> {
52    writer: W,
53    stack: Vec<StackItem>,
54}
55
56impl<W> JsonSerializer<W>
57where
58    W: Write,
59{
60    /// Creates a new JSON serializer with the given writer.
61    pub fn new(writer: W) -> Self {
62        Self {
63            writer,
64            stack: Vec::new(),
65        }
66    }
67
68    fn start_value(&mut self) -> Result<(), io::Error> {
69        debug!("start_value, stack = {:?}", self.stack);
70
71        match self.stack.last_mut() {
72            Some(StackItem::ArrayItem { first }) => {
73                if *first {
74                    *first = false;
75                } else {
76                    write!(self.writer, ",")?;
77                }
78            }
79            Some(StackItem::ObjectItem { object_state }) => {
80                debug!("ObjectItem: object_state = {:?}", object_state);
81                match object_state {
82                    ObjectItemState::FirstKey => {
83                        *object_state = ObjectItemState::Value;
84                    }
85                    ObjectItemState::Key => {
86                        write!(self.writer, ",")?;
87                        *object_state = ObjectItemState::Value;
88                    }
89                    ObjectItemState::Value => {
90                        write!(self.writer, ":")?;
91                        *object_state = ObjectItemState::Key;
92                    }
93                }
94            }
95            None => {
96                debug!("No stack frame (top-level value)");
97            }
98        }
99
100        Ok(())
101    }
102
103    fn end_value(&mut self) -> Result<(), io::Error> {
104        Ok(())
105    }
106}
107
108impl<W> Serializer for JsonSerializer<W>
109where
110    W: Write,
111{
112    type Error = io::Error;
113
114    fn serialize_u8(&mut self, value: u8) -> Result<(), Self::Error> {
115        self.start_value()?;
116        write!(self.writer, "{}", value)?;
117        self.end_value()
118    }
119
120    fn serialize_u16(&mut self, value: u16) -> Result<(), Self::Error> {
121        self.start_value()?;
122        write!(self.writer, "{}", value)?;
123        self.end_value()
124    }
125
126    fn serialize_u32(&mut self, value: u32) -> Result<(), Self::Error> {
127        self.start_value()?;
128        write!(self.writer, "{}", value)?;
129        self.end_value()
130    }
131
132    fn serialize_u64(&mut self, value: u64) -> Result<(), Self::Error> {
133        self.start_value()?;
134        write!(self.writer, "{}", value)?;
135        self.end_value()
136    }
137
138    fn serialize_u128(&mut self, value: u128) -> Result<(), Self::Error> {
139        self.start_value()?;
140        write!(self.writer, "{}", value)?;
141        self.end_value()
142    }
143
144    fn serialize_usize(&mut self, value: usize) -> Result<(), Self::Error> {
145        self.start_value()?;
146        write!(self.writer, "{}", value)?;
147        self.end_value()
148    }
149
150    fn serialize_i8(&mut self, value: i8) -> Result<(), Self::Error> {
151        self.start_value()?;
152        write!(self.writer, "{}", value)?;
153        self.end_value()
154    }
155
156    fn serialize_i16(&mut self, value: i16) -> Result<(), Self::Error> {
157        self.start_value()?;
158        write!(self.writer, "{}", value)?;
159        self.end_value()
160    }
161
162    fn serialize_i32(&mut self, value: i32) -> Result<(), Self::Error> {
163        self.start_value()?;
164        write!(self.writer, "{}", value)?;
165        self.end_value()
166    }
167
168    fn serialize_i64(&mut self, value: i64) -> Result<(), Self::Error> {
169        self.start_value()?;
170        write!(self.writer, "{}", value)?;
171        self.end_value()
172    }
173
174    fn serialize_i128(&mut self, value: i128) -> Result<(), Self::Error> {
175        self.start_value()?;
176        write!(self.writer, "{}", value)?;
177        self.end_value()
178    }
179
180    fn serialize_isize(&mut self, value: isize) -> Result<(), Self::Error> {
181        self.start_value()?;
182        write!(self.writer, "{}", value)?;
183        self.end_value()
184    }
185
186    fn serialize_f32(&mut self, value: f32) -> Result<(), Self::Error> {
187        self.start_value()?;
188        write!(self.writer, "{}", value)?;
189        self.end_value()
190    }
191
192    fn serialize_f64(&mut self, value: f64) -> Result<(), Self::Error> {
193        self.start_value()?;
194        write!(self.writer, "{}", value)?;
195        self.end_value()
196    }
197
198    fn serialize_bool(&mut self, value: bool) -> Result<(), Self::Error> {
199        self.start_value()?;
200        write!(self.writer, "{}", if value { "true" } else { "false" })?;
201        self.end_value()
202    }
203
204    fn serialize_char(&mut self, value: char) -> Result<(), Self::Error> {
205        self.start_value()?;
206        self.writer.write_all(b"\"")?;
207        write_json_escaped_char(&mut self.writer, value)?;
208        self.writer.write_all(b"\"")?;
209        self.end_value()
210    }
211
212    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
213        self.start_value()?;
214        write_json_string(&mut self.writer, value)?;
215        self.end_value()
216    }
217
218    fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Self::Error> {
219        panic!("JSON does not support byte arrays")
220    }
221
222    fn serialize_none(&mut self) -> Result<(), Self::Error> {
223        self.start_value()?;
224        self.writer.write_all(b"null")?;
225        self.end_value()
226    }
227
228    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
229        self.start_value()?;
230        self.writer.write_all(b"null")?;
231        self.end_value()
232    }
233
234    fn serialize_unit_variant(
235        &mut self,
236        _variant_index: usize,
237        variant_name: &'static str,
238    ) -> Result<(), Self::Error> {
239        self.start_value()?;
240        write_json_string(&mut self.writer, variant_name)?;
241        self.end_value()
242    }
243
244    fn start_object(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
245        self.start_value()?;
246        self.writer.write_all(b"{")?;
247        self.stack.push(StackItem::ObjectItem {
248            object_state: ObjectItemState::FirstKey,
249        });
250        Ok(())
251    }
252
253    fn end_object(&mut self) -> Result<(), Self::Error> {
254        let object = self.stack.pop().unwrap();
255        match object {
256            StackItem::ArrayItem { .. } => unreachable!(),
257            StackItem::ObjectItem { object_state } => match object_state {
258                ObjectItemState::FirstKey | ObjectItemState::Key => {
259                    // good
260                }
261                ObjectItemState::Value => unreachable!(),
262            },
263        }
264        self.writer.write_all(b"}")?;
265        self.end_value()?;
266        Ok(())
267    }
268
269    fn start_array(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
270        self.start_value()?;
271        self.writer.write_all(b"[")?;
272        self.stack.push(StackItem::ArrayItem { first: true });
273        Ok(())
274    }
275
276    fn end_array(&mut self) -> Result<(), Self::Error> {
277        let item = self.stack.pop().unwrap();
278        match item {
279            StackItem::ArrayItem { .. } => {
280                // good
281            }
282            StackItem::ObjectItem { .. } => unreachable!(),
283        }
284        self.writer.write_all(b"]")?;
285        self.end_value()?;
286        Ok(())
287    }
288
289    fn start_map(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
290        self.start_object(_len)
291    }
292
293    fn end_map(&mut self) -> Result<(), Self::Error> {
294        self.end_object()
295    }
296
297    fn serialize_field_name(&mut self, name: &'static str) -> Result<(), Self::Error> {
298        // Handle object key comma logic
299        if let Some(StackItem::ObjectItem { object_state }) = self.stack.last_mut() {
300            match object_state {
301                ObjectItemState::FirstKey => {
302                    *object_state = ObjectItemState::Key;
303                }
304                ObjectItemState::Key => {
305                    self.writer.write_all(b",")?;
306                }
307                ObjectItemState::Value => unreachable!(),
308            }
309        }
310        write_json_string(&mut self.writer, name)?;
311        if let Some(StackItem::ObjectItem { object_state }) = self.stack.last_mut() {
312            *object_state = ObjectItemState::Value;
313        }
314        Ok(())
315    }
316}
317
318/// Properly escapes and writes a JSON string
319fn write_json_string<W: Write>(writer: &mut W, s: &str) -> io::Result<()> {
320    writer.write_all(b"\"")?;
321
322    for c in s.chars() {
323        write_json_escaped_char(writer, c)?;
324    }
325
326    writer.write_all(b"\"")
327}
328
329/// Writes a single JSON escaped character
330fn write_json_escaped_char<W: Write>(writer: &mut W, c: char) -> io::Result<()> {
331    match c {
332        '"' => writer.write_all(b"\\\""),
333        '\\' => writer.write_all(b"\\\\"),
334        '\n' => writer.write_all(b"\\n"),
335        '\r' => writer.write_all(b"\\r"),
336        '\t' => writer.write_all(b"\\t"),
337        '\u{08}' => writer.write_all(b"\\b"),
338        '\u{0C}' => writer.write_all(b"\\f"),
339        c if c.is_control() => {
340            let mut buf = [0; 6];
341            let s = format!("{:04x}", c as u32);
342            buf[0] = b'\\';
343            buf[1] = b'u';
344            buf[2] = s.as_bytes()[0];
345            buf[3] = s.as_bytes()[1];
346            buf[4] = s.as_bytes()[2];
347            buf[5] = s.as_bytes()[3];
348            writer.write_all(&buf)
349        }
350        c => {
351            let mut buf = [0; 4];
352            let len = c.encode_utf8(&mut buf).len();
353            writer.write_all(&buf[..len])
354        }
355    }
356}
facet_json/serialize.rs

facet_json/
serialize.rs
