json5/
ser.rs

1use serde::ser::{self, Serialize};
2use std::{f32, f64};
3
4use crate::error::{Error, Result};
5
6/// Attempts to serialize the input as a JSON5 string (actually a JSON string).
7pub fn to_string<T>(value: &T) -> Result<String>
8where
9    T: Serialize,
10{
11    let mut serializer = Serializer {
12        output: String::new(),
13    };
14    value.serialize(&mut serializer)?;
15    Ok(serializer.output)
16}
17
18struct Serializer {
19    output: String,
20    // TODO settings for formatting (single vs double quotes, whitespace etc)
21}
22
23impl Serializer {
24    fn call_to_string<T>(&mut self, v: &T) -> Result<()>
25    where
26        T: ToString,
27    {
28        self.output += &v.to_string();
29        Ok(())
30    }
31}
32
33impl<'a> ser::Serializer for &'a mut Serializer {
34    type Ok = ();
35    type Error = Error;
36
37    type SerializeSeq = Self;
38    type SerializeTuple = Self;
39    type SerializeTupleStruct = Self;
40    type SerializeTupleVariant = Self;
41    type SerializeMap = Self;
42    type SerializeStruct = Self;
43    type SerializeStructVariant = Self;
44
45    fn serialize_bool(self, v: bool) -> Result<()> {
46        self.call_to_string(&v)
47    }
48
49    fn serialize_i8(self, v: i8) -> Result<()> {
50        self.call_to_string(&v)
51    }
52
53    fn serialize_i16(self, v: i16) -> Result<()> {
54        self.call_to_string(&v)
55    }
56
57    fn serialize_i32(self, v: i32) -> Result<()> {
58        self.call_to_string(&v)
59    }
60
61    fn serialize_i64(self, v: i64) -> Result<()> {
62        self.call_to_string(&v)
63    }
64
65    fn serialize_u8(self, v: u8) -> Result<()> {
66        self.call_to_string(&v)
67    }
68
69    fn serialize_u16(self, v: u16) -> Result<()> {
70        self.call_to_string(&v)
71    }
72
73    fn serialize_u32(self, v: u32) -> Result<()> {
74        self.call_to_string(&v)
75    }
76
77    fn serialize_u64(self, v: u64) -> Result<()> {
78        self.call_to_string(&v)
79    }
80
81    fn serialize_f32(self, v: f32) -> Result<()> {
82        if v == f32::INFINITY {
83            self.output += "Infinity";
84        } else if v == f32::NEG_INFINITY {
85            self.output += "-Infinity";
86        } else if v.is_nan() {
87            self.output += "NaN";
88        } else {
89            self.call_to_string(&v)?;
90        }
91        Ok(())
92    }
93
94    fn serialize_f64(self, v: f64) -> Result<()> {
95        if v == f64::INFINITY {
96            self.output += "Infinity";
97        } else if v == f64::NEG_INFINITY {
98            self.output += "-Infinity";
99        } else if v.is_nan() {
100            self.output += "NaN";
101        } else {
102            self.call_to_string(&v)?;
103        }
104        Ok(())
105    }
106
107    fn serialize_char(self, v: char) -> Result<()> {
108        self.serialize_str(&v.to_string())
109    }
110
111    fn serialize_str(self, v: &str) -> Result<()> {
112        self.output += "\"";
113        self.output += &escape(v);
114        self.output += "\"";
115        Ok(())
116    }
117
118    fn serialize_bytes(self, _v: &[u8]) -> Result<()> {
119        unimplemented!() // TODO
120    }
121
122    fn serialize_none(self) -> Result<()> {
123        self.serialize_unit()
124    }
125
126    fn serialize_some<T>(self, value: &T) -> Result<()>
127    where
128        T: ?Sized + Serialize,
129    {
130        value.serialize(self)
131    }
132
133    fn serialize_unit(self) -> Result<()> {
134        self.output += "null";
135        Ok(())
136    }
137
138    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
139        self.serialize_unit()
140    }
141
142    fn serialize_unit_variant(
143        self,
144        _name: &'static str,
145        _variant_index: u32,
146        variant: &'static str,
147    ) -> Result<()> {
148        self.serialize_str(variant)
149    }
150
151    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
152    where
153        T: ?Sized + Serialize,
154    {
155        value.serialize(self)
156    }
157
158    fn serialize_newtype_variant<T>(
159        self,
160        _name: &'static str,
161        _variant_index: u32,
162        variant: &'static str,
163        value: &T,
164    ) -> Result<()>
165    where
166        T: ?Sized + Serialize,
167    {
168        self.output += "{";
169        variant.serialize(&mut *self)?; // TODO drop the quotes where possible
170        self.output += ":";
171        value.serialize(&mut *self)?;
172        self.output += "}";
173        Ok(())
174    }
175
176    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
177        self.output += "[";
178        Ok(self)
179    }
180
181    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
182        self.serialize_seq(Some(len))
183    }
184
185    fn serialize_tuple_struct(
186        self,
187        _name: &'static str,
188        len: usize,
189    ) -> Result<Self::SerializeTupleStruct> {
190        self.serialize_seq(Some(len))
191    }
192
193    fn serialize_tuple_variant(
194        self,
195        _name: &'static str,
196        _variant_index: u32,
197        variant: &'static str,
198        _len: usize,
199    ) -> Result<Self::SerializeTupleVariant> {
200        self.output += "{";
201        variant.serialize(&mut *self)?;
202        self.output += ":[";
203        Ok(self)
204    }
205
206    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
207        self.output += "{";
208        Ok(self)
209    }
210
211    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
212        self.serialize_map(Some(len))
213    }
214
215    fn serialize_struct_variant(
216        self,
217        _name: &'static str,
218        _variant_index: u32,
219        variant: &'static str,
220        _len: usize,
221    ) -> Result<Self::SerializeStructVariant> {
222        self.output += "{";
223        variant.serialize(&mut *self)?;
224        self.output += ":{";
225        Ok(self)
226    }
227}
228
229impl<'a> ser::SerializeSeq for &'a mut Serializer {
230    type Ok = ();
231    type Error = Error;
232
233    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
234    where
235        T: ?Sized + Serialize,
236    {
237        if !self.output.ends_with('[') {
238            self.output += ",";
239        }
240        value.serialize(&mut **self)
241    }
242
243    fn end(self) -> Result<()> {
244        self.output += "]";
245        Ok(())
246    }
247}
248
249impl<'a> ser::SerializeTuple for &'a mut Serializer {
250    type Ok = ();
251    type Error = Error;
252
253    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
254    where
255        T: ?Sized + Serialize,
256    {
257        ser::SerializeSeq::serialize_element(self, value)
258    }
259
260    fn end(self) -> Result<()> {
261        ser::SerializeSeq::end(self)
262    }
263}
264
265impl<'a> ser::SerializeTupleStruct for &'a mut Serializer {
266    type Ok = ();
267    type Error = Error;
268
269    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
270    where
271        T: ?Sized + Serialize,
272    {
273        ser::SerializeSeq::serialize_element(self, value)
274    }
275
276    fn end(self) -> Result<()> {
277        ser::SerializeSeq::end(self)
278    }
279}
280
281impl<'a> ser::SerializeTupleVariant for &'a mut Serializer {
282    type Ok = ();
283    type Error = Error;
284
285    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
286    where
287        T: ?Sized + Serialize,
288    {
289        ser::SerializeSeq::serialize_element(self, value)
290    }
291
292    fn end(self) -> Result<()> {
293        self.output += "]}";
294        Ok(())
295    }
296}
297
298impl<'a> ser::SerializeMap for &'a mut Serializer {
299    type Ok = ();
300    type Error = Error;
301
302    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
303    where
304        T: ?Sized + Serialize,
305    {
306        if !self.output.ends_with('{') {
307            self.output += ",";
308        }
309        key.serialize(&mut **self)
310    }
311
312    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
313    where
314        T: ?Sized + Serialize,
315    {
316        self.output += ":";
317        value.serialize(&mut **self)
318    }
319
320    fn end(self) -> Result<()> {
321        self.output += "}";
322        Ok(())
323    }
324}
325
326impl<'a> ser::SerializeStruct for &'a mut Serializer {
327    type Ok = ();
328    type Error = Error;
329
330    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
331    where
332        T: ?Sized + Serialize,
333    {
334        ser::SerializeMap::serialize_key(self, key)?;
335        ser::SerializeMap::serialize_value(self, value)
336    }
337
338    fn end(self) -> Result<()> {
339        ser::SerializeMap::end(self)
340    }
341}
342
343impl<'a> ser::SerializeStructVariant for &'a mut Serializer {
344    type Ok = ();
345    type Error = Error;
346
347    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
348    where
349        T: ?Sized + Serialize,
350    {
351        ser::SerializeStruct::serialize_field(self, key, value)
352    }
353
354    fn end(self) -> Result<()> {
355        self.output += "}}";
356        Ok(())
357    }
358}
359
360fn escape(v: &str) -> String {
361    v.chars()
362        .flat_map(|c| match c {
363            '"' => vec!['\\', c],
364            '\n' => vec!['\\', 'n'],
365            '\r' => vec!['\\', 'r'],
366            '\t' => vec!['\\', 't'],
367            '/' => vec!['\\', '/'],
368            '\\' => vec!['\\', '\\'],
369            '\u{0008}' => vec!['\\', 'b'],
370            '\u{000c}' => vec!['\\', 'f'],
371            c => vec![c],
372        })
373        .collect()
374}
json5/ser.rs

json5/
ser.rs
