1use std::{borrow::Cow, fmt::Display, io::Write, marker::PhantomData};
2
3use serde_core::{
4 Serialize, Serializer,
5 ser::{
6 self, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
7 SerializeTupleStruct, SerializeTupleVariant,
8 },
9};
10use thiserror::Error;
11
12pub struct TsonSerializer<W: Write> {
13 writer: W,
14 field_stack: Vec<Cow<'static, str>>,
15}
16
17#[derive(Debug, Error)]
18pub enum Error {
19 #[error("An error occurred while writing to writer")]
20 Io(#[from] std::io::Error),
21 #[error("Map key must be stringable")]
22 KeyMustBeStringable,
23 #[error("Map keys cannot be any kind of compound type")]
24 AlreadyCalled,
25 #[error("Serialized floats must be finite")]
26 FloatMustBeFinite,
27 #[error("Error during serialization: `{0}`")]
28 Custom(String),
29}
30
31impl ser::Error for Error {
32 fn custom<T>(msg: T) -> Self
33 where
34 T: Display,
35 {
36 Self::Custom(msg.to_string())
37 }
38}
39
40impl<'a, W: Write> TsonSerializer<W> {
41 pub fn new(writer: W) -> Self {
42 Self {
43 writer,
44 field_stack: Vec::new(),
45 }
46 }
47
48 pub fn into_inner(self) -> W {
49 debug_assert!(self.field_stack.is_empty());
50 self.writer
51 }
52
53 fn prefix_that_variant_type_shit(&mut self, variant: &'static str) -> Result<(), Error> {
54 if let Some(key) = self.field_stack.last() {
55 self.writer.write_all(b"\n")?;
56 self.writer.write_all(key.as_bytes())?;
57 if !key.is_empty() {
58 self.writer.write_all(b" ")?;
59 }
60 }
61
62 self.writer.write_all(variant.as_bytes())?;
63 self.writer.write_all(b"\n")?;
64
65 Ok(())
66 }
67
68 fn prefix_that_shit(&mut self, after: &[u8]) -> Result<(), Error> {
69 if let Some(key) = self.field_stack.last() {
70 self.writer.write_all(key.as_bytes())?;
71 if !key.is_empty() {
72 self.writer.write_all(after)?;
73 }
74 }
75
76 Ok(())
77 }
78
79 fn suffix_that_shit(&mut self) -> Result<(), Error> {
80 if !self.field_stack.is_empty() {
81 self.writer.write_all(b" that shit\n")?;
82 }
83
84 Ok(())
85 }
86
87 fn serialize_struct_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
88 where
89 T: ?Sized + Serialize,
90 {
91 self.field_stack.push(Cow::Borrowed(key));
92 value.serialize(&mut *self)?;
93 self.field_stack.pop();
94
95 Ok(())
96 }
97
98 fn end_struct(&mut self) -> Result<(), Error> {
99 if self.field_stack.len() > 0 {
100 self.writer.write_all(b"oh yeah\n\n")?;
101 }
102
103 Ok(())
104 }
105}
106
107macro_rules! serialize_integer {
108 ($fn_name:ident, $v:ty) => {
109 fn $fn_name(self, v: $v) -> Result<Self::Ok, Self::Error> {
110 self.prefix_that_shit(b" ")?;
111 self.writer
112 .write_all(itoa::Buffer::new().format(v).as_bytes())?;
113 self.suffix_that_shit()
114 }
115 };
116}
117
118macro_rules! serialize_float {
119 ($fn_name:ident, $v:ty) => {
120 fn $fn_name(self, v: $v) -> Result<Self::Ok, Self::Error> {
121 self.prefix_that_shit(b" ")?;
122 if v.is_finite() {
123 self.writer
124 .write_all(zmij::Buffer::new().format_finite(v).as_bytes())?;
125 } else {
126 return Err(Error::FloatMustBeFinite);
127 }
128 self.suffix_that_shit()
129 }
130 };
131}
132
133impl<'a, W: Write> Serializer for &'a mut TsonSerializer<W> {
134 type Ok = ();
135
136 type Error = Error;
137 type SerializeSeq = Self;
138 type SerializeTuple = Self;
139 type SerializeTupleStruct = Self;
140 type SerializeTupleVariant = Self;
141 type SerializeMap = Self;
142 type SerializeStruct = Self;
143 type SerializeStructVariant = Self;
144
145 serialize_integer!(serialize_i8, i8);
146 serialize_integer!(serialize_i16, i16);
147 serialize_integer!(serialize_i32, i32);
148 serialize_integer!(serialize_i64, i64);
149 serialize_integer!(serialize_u8, u8);
150 serialize_integer!(serialize_u16, u16);
151 serialize_integer!(serialize_u32, u32);
152 serialize_integer!(serialize_u64, u64);
153
154 serialize_float!(serialize_f32, f32);
155 serialize_float!(serialize_f64, f64);
156
157 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
158 self.prefix_that_shit(b" ")?;
159 let mut ch = [0; 4];
160 self.writer.write_all(v.encode_utf8(&mut ch).as_bytes())?;
161 self.suffix_that_shit()
162 }
163
164 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
165 self.prefix_that_shit(b" ")?;
166 self.writer.write_all(v.as_bytes())?;
167 self.suffix_that_shit()
168 }
169
170 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
171 if !v {
172 self.writer.write_all(b"dont fuckin")?;
173 } else {
174 self.writer.write_all(b"fuckin")?;
175 }
176
177 if let Some(key) = self.field_stack.last() {
178 self.writer.write_all(b" ")?;
179 self.writer.write_all(key.as_bytes())?;
180 }
181
182 self.suffix_that_shit()
183 }
184
185 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
186 self.prefix_that_shit(b"\n")?;
187 for i in v {
188 self.writer.write_fmt(format_args!("{} that shit\n", *i))?;
189 }
190 self.writer.write_all(b"oh yeah\n")?;
191 Ok(())
192 }
193
194 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
195 self.writer.write_all(b"in theory")?;
196
197 if let Some(key) = self.field_stack.last() {
198 self.writer.write_all(b" ")?;
199 self.writer.write_all(key.as_bytes())?;
200 }
201
202 self.suffix_that_shit()
203 }
204
205 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
206 where
207 T: ?Sized + Serialize,
208 {
209 value.serialize(self)
210 }
211
212 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
213 self.prefix_that_shit(b" ")?;
214 self.writer.write_all(b"unit")?;
215 self.suffix_that_shit()
216 }
217
218 fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
219 self.prefix_that_shit(b" ")?;
220 self.writer.write_all(name.as_bytes())?;
221 self.suffix_that_shit()
222 }
223
224 fn serialize_unit_variant(
225 self,
226 _name: &'static str,
227 _variant_index: u32,
228 variant: &'static str,
229 ) -> Result<Self::Ok, Self::Error> {
230 self.prefix_that_shit(b" ")?;
231 self.writer.write_all(variant.as_bytes())?;
232 self.suffix_that_shit()
233 }
234
235 fn serialize_newtype_struct<T>(
236 self,
237 _name: &'static str,
238 value: &T,
239 ) -> Result<Self::Ok, Self::Error>
240 where
241 T: ?Sized + Serialize,
242 {
243 value.serialize(&mut *self)
244 }
245
246 fn serialize_newtype_variant<T>(
247 self,
248 _name: &'static str,
249 _variant_index: u32,
250 variant: &'static str,
251 value: &T,
252 ) -> Result<Self::Ok, Self::Error>
253 where
254 T: ?Sized + Serialize,
255 {
256 self.prefix_that_variant_type_shit(variant)?;
257 value.serialize(&mut *self)?;
258 self.writer.write_all(b"oh yeah\n")?;
259 Ok(())
260 }
261
262 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
263 if self
264 .field_stack
265 .last()
266 .map(|f| f.is_empty())
267 .unwrap_or_default()
268 {
269 self.prefix_that_variant_type_shit("fuckin")?;
270 } else {
271 self.prefix_that_shit(b"\n")?;
272 }
273 self.field_stack.push(Cow::Borrowed(""));
274
275 Ok(self)
276 }
277
278 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
279 self.serialize_seq(Some(len))
280 }
281
282 fn serialize_tuple_struct(
283 self,
284 _name: &'static str,
285 len: usize,
286 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
287 self.serialize_seq(Some(len))
288 }
289
290 fn serialize_tuple_variant(
291 self,
292 _name: &'static str,
293 _variant_index: u32,
294 variant: &'static str,
295 _len: usize,
296 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
297 self.prefix_that_variant_type_shit(variant)?;
298 self.field_stack.push(Cow::Borrowed(""));
299
300 Ok(self)
301 }
302
303 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
304 if !self.field_stack.is_empty() {
305 self.writer.write_all(b"\n")?;
306 }
307 self.prefix_that_shit(b"\n")?;
308
309 Ok(self)
310 }
311
312 fn serialize_struct(
313 self,
314 _name: &'static str,
315 len: usize,
316 ) -> Result<Self::SerializeStruct, Self::Error> {
317 self.serialize_map(Some(len))
318 }
319
320 fn serialize_struct_variant(
321 self,
322 _name: &'static str,
323 _variant_index: u32,
324 variant: &'static str,
325 _len: usize,
326 ) -> Result<Self::SerializeStructVariant, Self::Error> {
327 self.prefix_that_variant_type_shit(variant)?;
328
329 Ok(self)
330 }
331}
332
333pub struct MapKeySerializer<'a, W: Write> {
334 field_stack: &'a mut Vec<Cow<'static, str>>,
335 called: bool,
336 writer: PhantomData<W>,
337}
338
339impl<'a, W: Write> MapKeySerializer<'a, W> {
340 fn push(&mut self, value: Cow<'static, str>) -> Result<(), Error> {
341 if self.called {
342 return Err(Error::AlreadyCalled);
343 }
344 if value.as_ref() == "in theory" || value.split_whitespace().count() > 1 {
345 return Err(Error::KeyMustBeStringable);
346 }
347 self.field_stack.push(value);
348 self.called = true;
349
350 Ok(())
351 }
352}
353
354macro_rules! serialize_key_value {
355 ($fn_name:ident, $v:ty) => {
356 fn $fn_name(self, v: $v) -> Result<Self::Ok, Self::Error> {
357 self.push(Cow::Owned(format!("{}", v)))
358 }
359 };
360}
361
362macro_rules! cannot_serialize {
363 ($fn_name:ident, $v:ty) => {
364 fn $fn_name(self, _v: $v) -> Result<Self::Ok, Self::Error> {
365 Err(Error::KeyMustBeStringable)
366 }
367 };
368}
369
370impl<'a, W: Write> Serializer for &'a mut MapKeySerializer<'a, W> {
371 type Ok = ();
372
373 type Error = Error;
374 type SerializeSeq = &'a mut TsonSerializer<W>;
375 type SerializeTuple = &'a mut TsonSerializer<W>;
376 type SerializeTupleStruct = &'a mut TsonSerializer<W>;
377 type SerializeTupleVariant = &'a mut TsonSerializer<W>;
378 type SerializeMap = &'a mut TsonSerializer<W>;
379 type SerializeStruct = &'a mut TsonSerializer<W>;
380 type SerializeStructVariant = &'a mut TsonSerializer<W>;
381
382 serialize_key_value!(serialize_i8, i8);
383 serialize_key_value!(serialize_i16, i16);
384 serialize_key_value!(serialize_i32, i32);
385 serialize_key_value!(serialize_i64, i64);
386 serialize_key_value!(serialize_u8, u8);
387 serialize_key_value!(serialize_u16, u16);
388 serialize_key_value!(serialize_u32, u32);
389 serialize_key_value!(serialize_u64, u64);
390 serialize_key_value!(serialize_f32, f32);
391 serialize_key_value!(serialize_f64, f64);
392 serialize_key_value!(serialize_char, char);
393 serialize_key_value!(serialize_str, &str);
394
395 cannot_serialize!(serialize_bytes, &[u8]);
396
397 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
398 if v {
399 self.push(Cow::Borrowed("true"))
400 } else {
401 self.push(Cow::Borrowed("false"))
402 }
403 }
404
405 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
406 self.push(Cow::Borrowed("in theory"))
407 }
408
409 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
410 where
411 T: ?Sized + Serialize,
412 {
413 value.serialize(self)
414 }
415
416 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
417 self.push(Cow::Borrowed("unit"))
418 }
419
420 fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
421 self.push(Cow::Borrowed(name))
422 }
423
424 fn serialize_unit_variant(
425 self,
426 _name: &'static str,
427 _variant_index: u32,
428 variant: &'static str,
429 ) -> Result<Self::Ok, Self::Error> {
430 self.push(Cow::Borrowed(variant))
431 }
432
433 fn serialize_newtype_struct<T>(
434 self,
435 _name: &'static str,
436 value: &T,
437 ) -> Result<Self::Ok, Self::Error>
438 where
439 T: ?Sized + Serialize,
440 {
441 value.serialize(&mut *self)
442 }
443
444 fn serialize_newtype_variant<T>(
445 self,
446 _name: &'static str,
447 _variant_index: u32,
448 _variant: &'static str,
449 _value: &T,
450 ) -> Result<Self::Ok, Self::Error>
451 where
452 T: ?Sized + Serialize,
453 {
454 Err(Error::KeyMustBeStringable)
455 }
456
457 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
458 Err(Error::KeyMustBeStringable)
459 }
460
461 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
462 Err(Error::KeyMustBeStringable)
463 }
464
465 fn serialize_tuple_struct(
466 self,
467 _name: &'static str,
468 _len: usize,
469 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
470 Err(Error::KeyMustBeStringable)
471 }
472
473 fn serialize_tuple_variant(
474 self,
475 _name: &'static str,
476 _variant_index: u32,
477 _variant: &'static str,
478 _len: usize,
479 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
480 Err(Error::KeyMustBeStringable)
481 }
482
483 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
484 Err(Error::KeyMustBeStringable)
485 }
486
487 fn serialize_struct(
488 self,
489 _name: &'static str,
490 _len: usize,
491 ) -> Result<Self::SerializeStruct, Self::Error> {
492 Err(Error::KeyMustBeStringable)
493 }
494
495 fn serialize_struct_variant(
496 self,
497 _name: &'static str,
498 _variant_index: u32,
499 _variant: &'static str,
500 _len: usize,
501 ) -> Result<Self::SerializeStructVariant, Self::Error> {
502 Err(Error::KeyMustBeStringable)
503 }
504}
505
506impl<'a, W: Write> MapKeySerializer<'a, W> {
507 fn new(field_stack: &'a mut Vec<Cow<'static, str>>) -> MapKeySerializer<'a, W> {
508 Self {
509 field_stack,
510 called: false,
511 writer: PhantomData,
512 }
513 }
514}
515
516impl<'a, W: Write> SerializeSeq for &'a mut TsonSerializer<W> {
517 type Ok = ();
518
519 type Error = Error;
520
521 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
522 where
523 T: ?Sized + Serialize,
524 {
525 value.serialize(&mut **self)
526 }
527
528 fn end(self) -> Result<Self::Ok, Self::Error> {
529 self.field_stack.pop();
530 self.end_struct()
531 }
532}
533
534impl<'a, W: Write> SerializeTuple for &'a mut TsonSerializer<W> {
535 type Ok = ();
536
537 type Error = Error;
538
539 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
540 where
541 T: ?Sized + Serialize,
542 {
543 value.serialize(&mut **self)
544 }
545
546 fn end(self) -> Result<Self::Ok, Self::Error> {
547 self.field_stack.pop();
548 self.end_struct()
549 }
550}
551
552impl<'a, W: Write> SerializeTupleStruct for &'a mut TsonSerializer<W> {
553 type Ok = ();
554
555 type Error = Error;
556
557 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
558 where
559 T: ?Sized + Serialize,
560 {
561 value.serialize(&mut **self)
562 }
563
564 fn end(self) -> Result<Self::Ok, Self::Error> {
565 self.field_stack.pop();
566 self.end_struct()
567 }
568}
569
570impl<'a, W: Write> SerializeTupleVariant for &'a mut TsonSerializer<W> {
571 type Ok = ();
572
573 type Error = Error;
574
575 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
576 where
577 T: ?Sized + Serialize,
578 {
579 value.serialize(&mut **self)
580 }
581
582 fn end(self) -> Result<Self::Ok, Self::Error> {
583 self.field_stack.pop();
584 self.end_struct()
585 }
586}
587
588impl<'a, W: Write> SerializeMap for &'a mut TsonSerializer<W> {
589 type Ok = ();
590
591 type Error = Error;
592
593 fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
594 where
595 T: ?Sized + Serialize,
596 {
597 key.serialize(&mut MapKeySerializer::<W>::new(&mut self.field_stack))
598 }
599
600 fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
601 where
602 T: ?Sized + Serialize,
603 {
604 value.serialize(&mut **self)?;
605 self.field_stack.pop();
606 Ok(())
607 }
608
609 fn end(self) -> Result<Self::Ok, Self::Error> {
610 self.end_struct()
611 }
612}
613
614impl<'a, W: Write> SerializeStruct for &'a mut TsonSerializer<W> {
615 type Ok = ();
616
617 type Error = Error;
618
619 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
620 where
621 T: ?Sized + Serialize,
622 {
623 self.serialize_struct_field(key, value)
624 }
625
626 fn end(self) -> Result<Self::Ok, Self::Error> {
627 self.end_struct()
628 }
629}
630
631impl<'a, W: Write> SerializeStructVariant for &'a mut TsonSerializer<W> {
632 type Ok = ();
633
634 type Error = Error;
635
636 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
637 where
638 T: ?Sized + Serialize,
639 {
640 self.serialize_struct_field(key, value)
641 }
642
643 fn end(self) -> Result<Self::Ok, Self::Error> {
644 self.end_struct()
645 }
646}