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 implementing `Facet` to a JSON string.
8#[cfg(feature = "std")]
9pub fn to_string<'facet, T: Facet<'facet>>(value: &T) -> String {
10    peek_to_string(Peek::new(value))
11}
12
13/// Serializes a `Peek` instance to a JSON string.
14#[cfg(feature = "std")]
15pub fn peek_to_string<'input, 'facet, 'shape>(peek: Peek<'input, 'facet, 'shape>) -> String {
16    let mut s = Vec::new();
17    peek_to_writer(peek, &mut s).unwrap();
18    String::from_utf8(s).unwrap()
19}
20
21/// Serializes a `Facet` value to JSON and writes it to the given writer.
22pub fn to_writer<'mem, 'facet, T: Facet<'facet>, W: Write>(
23    value: &'mem T,
24    writer: &mut W,
25) -> io::Result<()> {
26    peek_to_writer(Peek::new(value), writer)
27}
28
29/// Serializes a `Peek` value to JSON and writes it to the given writer.
30pub fn peek_to_writer<'mem, 'facet, 'shape, W: Write>(
31    peek: Peek<'mem, 'facet, 'shape>,
32    writer: &mut W,
33) -> io::Result<()> {
34    let mut serializer = JsonSerializer::new(writer);
35    serialize_iterative(peek, &mut serializer)
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<'shape, W> Serializer<'shape> 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        crate::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        crate::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: &'shape str,
238    ) -> Result<(), Self::Error> {
239        self.start_value()?;
240        crate::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: &'shape 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        crate::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}
facet_json/serialize.rs

facet_json/
serialize.rs
