fast_xml/se/
mod.rs

1//! Module to handle custom serde `Serializer`
2
3mod var;
4
5use self::var::{Map, Seq, Struct, Tuple};
6use crate::{
7    de::PRIMITIVE_PREFIX,
8    errors::serialize::DeError,
9    events::{BytesEnd, BytesStart, BytesText, Event},
10    writer::Writer,
11};
12use serde::ser::{self, Serialize};
13use serde::serde_if_integer128;
14use std::io::Write;
15
16/// Serialize struct into a `Write`r
17pub fn to_writer<W: Write, S: Serialize>(writer: W, value: &S) -> Result<(), DeError> {
18    let mut serializer = Serializer::new(writer);
19    value.serialize(&mut serializer)
20}
21
22/// Serialize struct into a `String`
23pub fn to_string<S: Serialize>(value: &S) -> Result<String, DeError> {
24    let mut writer = Vec::new();
25    to_writer(&mut writer, value)?;
26    let s = String::from_utf8(writer).map_err(|e| crate::errors::Error::Utf8(e.utf8_error()))?;
27    Ok(s)
28}
29
30/// A Serializer
31pub struct Serializer<'r, W: Write> {
32    writer: Writer<W>,
33    /// Name of the root tag. If not specified, deduced from the structure name
34    root_tag: Option<&'r str>,
35}
36
37impl<'r, W: Write> Serializer<'r, W> {
38    /// Creates a new `Serializer` that uses struct name as a root tag name.
39    ///
40    /// Note, that attempt to serialize a non-struct (including unit structs
41    /// and newtype structs) will end up to an error. Use `with_root` to create
42    /// serializer with explicitly defined root element name
43    pub fn new(writer: W) -> Self {
44        Self::with_root(Writer::new(writer), None)
45    }
46
47    /// Creates a new `Serializer` that uses specified root tag name
48    ///
49    /// # Examples
50    ///
51    /// When serializing a primitive type, only its representation will be written:
52    ///
53    /// ```edition2018
54    /// # use pretty_assertions::assert_eq;
55    /// # use serde::Serialize;
56    /// use fast_xml::Writer;
57    /// # use fast_xml::se::Serializer;
58    ///
59    /// let mut buffer = Vec::new();
60    /// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 2);
61    /// let mut ser = Serializer::with_root(writer, Some("root"));
62    ///
63    /// "node".serialize(&mut ser).unwrap();
64    /// assert_eq!(String::from_utf8(buffer).unwrap(), "node");
65    /// ```
66    ///
67    /// When serializing a struct, newtype struct, unit struct or tuple `root_tag`
68    /// is used as tag name of root(s) element(s):
69    ///
70    /// ```edition2018
71    /// # use pretty_assertions::assert_eq;
72    /// # use serde::Serialize;
73    /// use fast_xml::Writer;
74    /// use fast_xml::se::Serializer;
75    ///
76    /// #[derive(Debug, PartialEq, Serialize)]
77    /// struct Struct {
78    ///     question: String,
79    ///     answer: u32,
80    /// }
81    ///
82    /// let mut buffer = Vec::new();
83    /// let mut writer = Writer::new_with_indent(&mut buffer, b' ', 2);
84    /// let mut ser = Serializer::with_root(writer, Some("root"));
85    ///
86    /// Struct {
87    ///     question: "The Ultimate Question of Life, the Universe, and Everything".into(),
88    ///     answer: 42,
89    /// }.serialize(&mut ser).unwrap();
90    /// assert_eq!(
91    ///     String::from_utf8(buffer.clone()).unwrap(),
92    ///     r#"<root question="The Ultimate Question of Life, the Universe, and Everything" answer="42"/>"#
93    /// );
94    /// ```
95    pub fn with_root(writer: Writer<W>, root_tag: Option<&'r str>) -> Self {
96        Self { writer, root_tag }
97    }
98
99    fn write_primitive<P: std::fmt::Display>(
100        &mut self,
101        value: P,
102        escaped: bool,
103    ) -> Result<(), DeError> {
104        let value = value.to_string().into_bytes();
105        let event = if escaped {
106            BytesText::from_escaped(value)
107        } else {
108            BytesText::from_plain(&value)
109        };
110        self.writer.write_event(Event::Text(event))?;
111        Ok(())
112    }
113
114    /// Writes self-closed tag `<tag_name/>` into inner writer
115    fn write_self_closed(&mut self, tag_name: &str) -> Result<(), DeError> {
116        self.writer
117            .write_event(Event::Empty(BytesStart::borrowed_name(tag_name.as_bytes())))?;
118        Ok(())
119    }
120
121    /// Writes a serialized `value` surrounded by `<tag_name>...</tag_name>`
122    fn write_paired<T: ?Sized + Serialize>(
123        &mut self,
124        tag_name: &str,
125        value: &T,
126    ) -> Result<(), DeError> {
127        self.writer
128            .write_event(Event::Start(BytesStart::borrowed_name(tag_name.as_bytes())))?;
129        value.serialize(&mut *self)?;
130        self.writer
131            .write_event(Event::End(BytesEnd::borrowed(tag_name.as_bytes())))?;
132        Ok(())
133    }
134}
135
136impl<'r, 'w, W: Write> ser::Serializer for &'w mut Serializer<'r, W> {
137    type Ok = ();
138    type Error = DeError;
139
140    type SerializeSeq = Seq<'r, 'w, W>;
141    type SerializeTuple = Tuple<'r, 'w, W>;
142    type SerializeTupleStruct = Tuple<'r, 'w, W>;
143    type SerializeTupleVariant = Tuple<'r, 'w, W>;
144    type SerializeMap = Map<'r, 'w, W>;
145    type SerializeStruct = Struct<'r, 'w, W>;
146    type SerializeStructVariant = Struct<'r, 'w, W>;
147
148    fn serialize_bool(self, v: bool) -> Result<Self::Ok, DeError> {
149        self.write_primitive(if v { "true" } else { "false" }, true)
150    }
151
152    fn serialize_i8(self, v: i8) -> Result<Self::Ok, DeError> {
153        self.write_primitive(v, true)
154    }
155
156    fn serialize_i16(self, v: i16) -> Result<Self::Ok, DeError> {
157        self.write_primitive(v, true)
158    }
159
160    fn serialize_i32(self, v: i32) -> Result<Self::Ok, DeError> {
161        self.write_primitive(v, true)
162    }
163
164    fn serialize_i64(self, v: i64) -> Result<Self::Ok, DeError> {
165        self.write_primitive(v, true)
166    }
167
168    fn serialize_u8(self, v: u8) -> Result<Self::Ok, DeError> {
169        self.write_primitive(v, true)
170    }
171
172    fn serialize_u16(self, v: u16) -> Result<Self::Ok, DeError> {
173        self.write_primitive(v, true)
174    }
175
176    fn serialize_u32(self, v: u32) -> Result<Self::Ok, DeError> {
177        self.write_primitive(v, true)
178    }
179
180    fn serialize_u64(self, v: u64) -> Result<Self::Ok, DeError> {
181        self.write_primitive(v, true)
182    }
183
184    serde_if_integer128! {
185        fn serialize_i128(self, v: i128) -> Result<Self::Ok, DeError> {
186            self.write_primitive(v, true)
187        }
188
189        fn serialize_u128(self, v: u128) -> Result<Self::Ok, DeError> {
190            self.write_primitive(v, true)
191        }
192    }
193
194    fn serialize_f32(self, v: f32) -> Result<Self::Ok, DeError> {
195        self.write_primitive(v, true)
196    }
197
198    fn serialize_f64(self, v: f64) -> Result<Self::Ok, DeError> {
199        self.write_primitive(v, true)
200    }
201
202    fn serialize_char(self, v: char) -> Result<Self::Ok, DeError> {
203        self.write_primitive(v, false)
204    }
205
206    fn serialize_str(self, value: &str) -> Result<Self::Ok, DeError> {
207        self.write_primitive(value, false)
208    }
209
210    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, DeError> {
211        // TODO: I imagine you'd want to use base64 here.
212        // Not sure how to roundtrip effectively though...
213        Err(DeError::Unsupported("serialize_bytes"))
214    }
215
216    fn serialize_none(self) -> Result<Self::Ok, DeError> {
217        Ok(())
218    }
219
220    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, DeError> {
221        value.serialize(self)
222    }
223
224    fn serialize_unit(self) -> Result<Self::Ok, DeError> {
225        self.serialize_none()
226    }
227
228    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, DeError> {
229        self.write_self_closed(self.root_tag.unwrap_or(name))
230    }
231
232    fn serialize_unit_variant(
233        self,
234        _name: &'static str,
235        _variant_index: u32,
236        variant: &'static str,
237    ) -> Result<Self::Ok, DeError> {
238        if variant.starts_with(PRIMITIVE_PREFIX) {
239            let variant = variant.split_at(PRIMITIVE_PREFIX.len()).1;
240            self.write_primitive(variant, false)
241        } else {
242            self.write_self_closed(variant)
243        }
244    }
245
246    fn serialize_newtype_struct<T: ?Sized + Serialize>(
247        self,
248        name: &'static str,
249        value: &T,
250    ) -> Result<Self::Ok, DeError> {
251        self.write_paired(self.root_tag.unwrap_or(name), value)
252    }
253
254    fn serialize_newtype_variant<T: ?Sized + Serialize>(
255        self,
256        _name: &'static str,
257        _variant_index: u32,
258        variant: &'static str,
259        value: &T,
260    ) -> Result<Self::Ok, DeError> {
261        // Flatten structs in enums are serialized as newtype struct variant + map.
262        // As serialize_map should write `root_tag` for ordinal maps (because it's
263        // only way for maps), and for enums this method already written a tag name
264        // (`variant`), we need to clear root tag before writing content and restore
265        // it after
266        let root = self.root_tag.take();
267        let result = self.write_paired(variant, value);
268        self.root_tag = root;
269        result
270    }
271
272    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, DeError> {
273        Ok(Seq::new(self))
274    }
275
276    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, DeError> {
277        let tag = match self.root_tag {
278            Some(tag) => tag,
279            None => {
280                return Err(DeError::Custom(
281                    "root tag name must be specified when serialize unnamed tuple".into(),
282                ))
283            }
284        };
285        Ok(Tuple::new(self, tag))
286    }
287
288    fn serialize_tuple_struct(
289        self,
290        name: &'static str,
291        _len: usize,
292    ) -> Result<Self::SerializeTupleStruct, DeError> {
293        Ok(Tuple::new(self, self.root_tag.unwrap_or(name)))
294    }
295
296    fn serialize_tuple_variant(
297        self,
298        _name: &'static str,
299        _variant_index: u32,
300        variant: &'static str,
301        _len: usize,
302    ) -> Result<Self::SerializeTupleVariant, DeError> {
303        Ok(Tuple::new(self, variant))
304    }
305
306    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, DeError> {
307        if let Some(tag) = self.root_tag {
308            // TODO: Write self-closed tag if map is empty
309            self.writer
310                .write_event(Event::Start(BytesStart::borrowed_name(tag.as_bytes())))?;
311        }
312        Ok(Map::new(self))
313    }
314
315    fn serialize_struct(
316        self,
317        name: &'static str,
318        _len: usize,
319    ) -> Result<Self::SerializeStruct, DeError> {
320        Ok(Struct::new(self, self.root_tag.unwrap_or(name)))
321    }
322
323    fn serialize_struct_variant(
324        self,
325        _name: &'static str,
326        _variant_index: u32,
327        variant: &'static str,
328        _len: usize,
329    ) -> Result<Self::SerializeStructVariant, DeError> {
330        Ok(Struct::new(self, variant))
331    }
332}
333
334#[cfg(test)]
335mod tests {
336    use super::*;
337    use pretty_assertions::assert_eq;
338    use serde::ser::SerializeMap;
339    use serde::{Serialize, Serializer as SerSerializer};
340
341    #[test]
342    fn test_serialize_bool() {
343        let inputs = vec![(true, "true"), (false, "false")];
344
345        for (src, should_be) in inputs {
346            let mut buffer = Vec::new();
347
348            {
349                let mut ser = Serializer::new(&mut buffer);
350                ser.serialize_bool(src).unwrap();
351            }
352
353            let got = String::from_utf8(buffer).unwrap();
354            assert_eq!(got, should_be);
355        }
356    }
357
358    #[test]
359    fn test_serialize_struct() {
360        #[derive(Serialize)]
361        struct Person {
362            name: String,
363            age: u32,
364        }
365
366        let bob = Person {
367            name: "Bob".to_string(),
368            age: 42,
369        };
370        let should_be = "<Person name=\"Bob\" age=\"42\"/>";
371        let mut buffer = Vec::new();
372
373        {
374            let mut ser = Serializer::new(&mut buffer);
375            bob.serialize(&mut ser).unwrap();
376        }
377
378        let got = String::from_utf8(buffer).unwrap();
379        assert_eq!(got, should_be);
380    }
381
382    #[test]
383    fn test_serialize_struct_value_number() {
384        #[derive(Serialize)]
385        struct Person {
386            name: String,
387            #[serde(rename = "$value")]
388            age: u32,
389        }
390
391        let bob = Person {
392            name: "Bob".to_string(),
393            age: 42,
394        };
395        let should_be = "<Person name=\"Bob\">42</Person>";
396        let got = to_string(&bob).unwrap();
397        assert_eq!(got, should_be);
398    }
399
400    #[test]
401    fn test_serialize_struct_value_string() {
402        #[derive(Serialize)]
403        struct Person {
404            name: String,
405            #[serde(rename = "$value")]
406            age: String,
407        }
408
409        let bob = Person {
410            name: "Bob".to_string(),
411            age: "42".to_string(),
412        };
413        let should_be = "<Person name=\"Bob\">42</Person>";
414        let got = to_string(&bob).unwrap();
415        assert_eq!(got, should_be);
416    }
417
418    #[test]
419    fn test_serialize_map_entries() {
420        let should_be = "<name>Bob</name><age>5</age>";
421        let mut buffer = Vec::new();
422
423        {
424            let mut ser = Serializer::new(&mut buffer);
425            let mut map = Map::new(&mut ser);
426            map.serialize_entry("name", "Bob").unwrap();
427            map.serialize_entry("age", "5").unwrap();
428        }
429
430        let got = String::from_utf8(buffer).unwrap();
431        assert_eq!(got, should_be);
432    }
433
434    #[test]
435    fn test_serialize_enum() {
436        #[derive(Serialize)]
437        #[allow(dead_code)]
438        enum Node {
439            Boolean(bool),
440            Number(f64),
441            String(String),
442        }
443
444        let mut buffer = Vec::new();
445        let should_be = "<Boolean>true</Boolean>";
446
447        {
448            let mut ser = Serializer::new(&mut buffer);
449            let node = Node::Boolean(true);
450            node.serialize(&mut ser).unwrap();
451        }
452
453        let got = String::from_utf8(buffer).unwrap();
454        assert_eq!(got, should_be);
455    }
456
457    #[test]
458    #[ignore]
459    fn serialize_a_list() {
460        let inputs = vec![1, 2, 3, 4];
461
462        let mut buffer = Vec::new();
463
464        {
465            let mut ser = Serializer::new(&mut buffer);
466            inputs.serialize(&mut ser).unwrap();
467        }
468
469        let got = String::from_utf8(buffer).unwrap();
470        println!("{}", got);
471        panic!();
472    }
473
474    #[test]
475    fn unit() {
476        #[derive(Serialize)]
477        struct Unit;
478
479        let data = Unit;
480        let should_be = "<root/>";
481        let mut buffer = Vec::new();
482
483        {
484            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
485            data.serialize(&mut ser).unwrap();
486        }
487
488        let got = String::from_utf8(buffer).unwrap();
489        assert_eq!(got, should_be);
490    }
491
492    #[test]
493    fn newtype() {
494        #[derive(Serialize)]
495        struct Newtype(bool);
496
497        let data = Newtype(true);
498        let should_be = "<root>true</root>";
499        let mut buffer = Vec::new();
500
501        {
502            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
503            data.serialize(&mut ser).unwrap();
504        }
505
506        let got = String::from_utf8(buffer).unwrap();
507        assert_eq!(got, should_be);
508    }
509
510    #[test]
511    fn tuple() {
512        let data = (42.0, "answer");
513        let should_be = "<root>42</root><root>answer</root>";
514        let mut buffer = Vec::new();
515
516        {
517            let mut ser =
518                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
519            data.serialize(&mut ser).unwrap();
520        }
521
522        let got = String::from_utf8(buffer).unwrap();
523        assert_eq!(got, should_be);
524    }
525
526    #[test]
527    fn tuple_struct() {
528        #[derive(Serialize)]
529        struct Tuple(f32, &'static str);
530
531        let data = Tuple(42.0, "answer");
532        let should_be = "<root>42</root><root>answer</root>";
533        let mut buffer = Vec::new();
534
535        {
536            let mut ser =
537                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
538            data.serialize(&mut ser).unwrap();
539        }
540
541        let got = String::from_utf8(buffer).unwrap();
542        assert_eq!(got, should_be);
543    }
544
545    #[test]
546    fn struct_() {
547        #[derive(Serialize)]
548        struct Struct {
549            float: f64,
550            string: String,
551        }
552
553        let mut buffer = Vec::new();
554        let should_be = r#"<root float="42" string="answer"/>"#;
555
556        {
557            let mut ser =
558                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
559            let node = Struct {
560                float: 42.0,
561                string: "answer".to_string(),
562            };
563            node.serialize(&mut ser).unwrap();
564        }
565
566        let got = String::from_utf8(buffer).unwrap();
567        assert_eq!(got, should_be);
568    }
569
570    #[test]
571    fn nested_struct() {
572        #[derive(Serialize)]
573        struct Struct {
574            nested: Nested,
575            string: String,
576        }
577
578        #[derive(Serialize)]
579        struct Nested {
580            float: f64,
581        }
582
583        let mut buffer = Vec::new();
584        let should_be = r#"<root string="answer"><nested float="42"/>
585</root>"#;
586
587        {
588            let mut ser =
589                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
590            let node = Struct {
591                nested: Nested { float: 42.0 },
592                string: "answer".to_string(),
593            };
594            node.serialize(&mut ser).unwrap();
595        }
596
597        let got = String::from_utf8(buffer).unwrap();
598        assert_eq!(got, should_be);
599    }
600
601    #[test]
602    fn flatten_struct() {
603        #[derive(Serialize)]
604        struct Struct {
605            #[serde(flatten)]
606            nested: Nested,
607            string: String,
608        }
609
610        #[derive(Serialize)]
611        struct Nested {
612            float: f64,
613        }
614
615        let mut buffer = Vec::new();
616        let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
617
618        {
619            let mut ser =
620                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
621            let node = Struct {
622                nested: Nested { float: 42.0 },
623                string: "answer".to_string(),
624            };
625            node.serialize(&mut ser).unwrap();
626        }
627
628        let got = String::from_utf8(buffer).unwrap();
629        assert_eq!(got, should_be);
630    }
631
632    mod enum_ {
633        use super::*;
634
635        #[derive(Serialize)]
636        struct Nested {
637            float: f64,
638        }
639
640        mod externally_tagged {
641            use super::*;
642            use pretty_assertions::assert_eq;
643
644            #[derive(Serialize)]
645            enum Node {
646                Unit,
647                #[serde(rename = "$primitive=PrimitiveUnit")]
648                PrimitiveUnit,
649                Newtype(bool),
650                Tuple(f64, String),
651                Struct {
652                    float: f64,
653                    string: String,
654                },
655                Holder {
656                    nested: Nested,
657                    string: String,
658                },
659                Flatten {
660                    #[serde(flatten)]
661                    nested: Nested,
662                    string: String,
663                },
664            }
665
666            #[test]
667            fn unit() {
668                let mut buffer = Vec::new();
669                let should_be = "<Unit/>";
670
671                {
672                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
673                    let node = Node::Unit;
674                    node.serialize(&mut ser).unwrap();
675                }
676
677                let got = String::from_utf8(buffer).unwrap();
678                assert_eq!(got, should_be);
679            }
680
681            #[test]
682            fn primitive_unit() {
683                let mut buffer = Vec::new();
684                let should_be = "PrimitiveUnit";
685
686                {
687                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
688                    let node = Node::PrimitiveUnit;
689                    node.serialize(&mut ser).unwrap();
690                }
691
692                let got = String::from_utf8(buffer).unwrap();
693                assert_eq!(got, should_be);
694            }
695
696            #[test]
697            fn newtype() {
698                let mut buffer = Vec::new();
699                let should_be = "<Newtype>true</Newtype>";
700
701                {
702                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
703                    let node = Node::Newtype(true);
704                    node.serialize(&mut ser).unwrap();
705                }
706
707                let got = String::from_utf8(buffer).unwrap();
708                assert_eq!(got, should_be);
709            }
710
711            #[test]
712            fn struct_() {
713                let mut buffer = Vec::new();
714                let should_be = r#"<Struct float="42" string="answer"/>"#;
715
716                {
717                    let mut ser = Serializer::with_root(
718                        Writer::new_with_indent(&mut buffer, b' ', 4),
719                        Some("root"),
720                    );
721                    let node = Node::Struct {
722                        float: 42.0,
723                        string: "answer".to_string(),
724                    };
725                    node.serialize(&mut ser).unwrap();
726                }
727
728                let got = String::from_utf8(buffer).unwrap();
729                assert_eq!(got, should_be);
730            }
731
732            #[test]
733            fn tuple_struct() {
734                let mut buffer = Vec::new();
735                let should_be = "<Tuple>42</Tuple><Tuple>answer</Tuple>";
736
737                {
738                    let mut ser = Serializer::with_root(
739                        Writer::new_with_indent(&mut buffer, b' ', 4),
740                        Some("root"),
741                    );
742                    let node = Node::Tuple(42.0, "answer".to_string());
743                    node.serialize(&mut ser).unwrap();
744                }
745
746                let got = String::from_utf8(buffer).unwrap();
747                assert_eq!(got, should_be);
748            }
749
750            #[test]
751            fn nested_struct() {
752                let mut buffer = Vec::new();
753                let should_be = r#"<Holder string="answer"><nested float="42"/>
754</Holder>"#;
755
756                {
757                    let mut ser = Serializer::with_root(
758                        Writer::new_with_indent(&mut buffer, b' ', 4),
759                        Some("root"),
760                    );
761                    let node = Node::Holder {
762                        nested: Nested { float: 42.0 },
763                        string: "answer".to_string(),
764                    };
765                    node.serialize(&mut ser).unwrap();
766                }
767
768                let got = String::from_utf8(buffer).unwrap();
769                assert_eq!(got, should_be);
770            }
771
772            #[test]
773            fn flatten_struct() {
774                let mut buffer = Vec::new();
775                let should_be = r#"<Flatten><float>42</float><string>answer</string></Flatten>"#;
776
777                {
778                    let mut ser = Serializer::with_root(
779                        Writer::new_with_indent(&mut buffer, b' ', 4),
780                        Some("root"),
781                    );
782                    let node = Node::Flatten {
783                        nested: Nested { float: 42.0 },
784                        string: "answer".to_string(),
785                    };
786                    node.serialize(&mut ser).unwrap();
787                }
788
789                let got = String::from_utf8(buffer).unwrap();
790                assert_eq!(got, should_be);
791            }
792        }
793
794        mod internally_tagged {
795            use super::*;
796            use pretty_assertions::assert_eq;
797
798            #[derive(Serialize)]
799            #[serde(tag = "tag")]
800            enum Node {
801                Unit,
802                /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
803                Newtype(NewtypeContent),
804                // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
805                Struct {
806                    float: f64,
807                    string: String,
808                },
809                Holder {
810                    nested: Nested,
811                    string: String,
812                },
813                Flatten {
814                    #[serde(flatten)]
815                    nested: Nested,
816                    string: String,
817                },
818            }
819
820            #[derive(Serialize)]
821            struct NewtypeContent {
822                value: bool,
823            }
824
825            #[test]
826            fn unit() {
827                let mut buffer = Vec::new();
828                let should_be = r#"<root tag="Unit"/>"#;
829
830                {
831                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
832                    let node = Node::Unit;
833                    node.serialize(&mut ser).unwrap();
834                }
835
836                let got = String::from_utf8(buffer).unwrap();
837                assert_eq!(got, should_be);
838            }
839
840            #[test]
841            fn newtype() {
842                let mut buffer = Vec::new();
843                let should_be = r#"<root tag="Newtype" value="true"/>"#;
844
845                {
846                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
847                    let node = Node::Newtype(NewtypeContent { value: true });
848                    node.serialize(&mut ser).unwrap();
849                }
850
851                let got = String::from_utf8(buffer).unwrap();
852                assert_eq!(got, should_be);
853            }
854
855            #[test]
856            fn struct_() {
857                let mut buffer = Vec::new();
858                let should_be = r#"<root tag="Struct" float="42" string="answer"/>"#;
859
860                {
861                    let mut ser = Serializer::with_root(
862                        Writer::new_with_indent(&mut buffer, b' ', 4),
863                        Some("root"),
864                    );
865                    let node = Node::Struct {
866                        float: 42.0,
867                        string: "answer".to_string(),
868                    };
869                    node.serialize(&mut ser).unwrap();
870                }
871
872                let got = String::from_utf8(buffer).unwrap();
873                assert_eq!(got, should_be);
874            }
875
876            #[test]
877            fn nested_struct() {
878                let mut buffer = Vec::new();
879                let should_be = r#"<root tag="Holder" string="answer"><nested float="42"/>
880</root>"#;
881
882                {
883                    let mut ser = Serializer::with_root(
884                        Writer::new_with_indent(&mut buffer, b' ', 4),
885                        Some("root"),
886                    );
887                    let node = Node::Holder {
888                        nested: Nested { float: 42.0 },
889                        string: "answer".to_string(),
890                    };
891                    node.serialize(&mut ser).unwrap();
892                }
893
894                let got = String::from_utf8(buffer).unwrap();
895                assert_eq!(got, should_be);
896            }
897
898            #[test]
899            fn flatten_struct() {
900                let mut buffer = Vec::new();
901                let should_be =
902                    r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#;
903
904                {
905                    let mut ser = Serializer::with_root(
906                        Writer::new_with_indent(&mut buffer, b' ', 4),
907                        Some("root"),
908                    );
909                    let node = Node::Flatten {
910                        nested: Nested { float: 42.0 },
911                        string: "answer".to_string(),
912                    };
913                    node.serialize(&mut ser).unwrap();
914                }
915
916                let got = String::from_utf8(buffer).unwrap();
917                assert_eq!(got, should_be);
918            }
919        }
920
921        mod adjacently_tagged {
922            use super::*;
923            use pretty_assertions::assert_eq;
924
925            #[derive(Serialize)]
926            #[serde(tag = "tag", content = "content")]
927            enum Node {
928                Unit,
929                Newtype(bool),
930                Tuple(f64, String),
931                Struct {
932                    float: f64,
933                    string: String,
934                },
935                Holder {
936                    nested: Nested,
937                    string: String,
938                },
939                Flatten {
940                    #[serde(flatten)]
941                    nested: Nested,
942                    string: String,
943                },
944            }
945
946            #[test]
947            fn unit() {
948                let mut buffer = Vec::new();
949                let should_be = r#"<root tag="Unit"/>"#;
950
951                {
952                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
953                    let node = Node::Unit;
954                    node.serialize(&mut ser).unwrap();
955                }
956
957                let got = String::from_utf8(buffer).unwrap();
958                assert_eq!(got, should_be);
959            }
960
961            #[test]
962            fn newtype() {
963                let mut buffer = Vec::new();
964                let should_be = r#"<root tag="Newtype" content="true"/>"#;
965
966                {
967                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
968                    let node = Node::Newtype(true);
969                    node.serialize(&mut ser).unwrap();
970                }
971
972                let got = String::from_utf8(buffer).unwrap();
973                assert_eq!(got, should_be);
974            }
975
976            #[test]
977            fn tuple_struct() {
978                let mut buffer = Vec::new();
979                let should_be = r#"<root tag="Tuple"><content>42</content><content>answer</content>
980</root>"#;
981
982                {
983                    let mut ser = Serializer::with_root(
984                        Writer::new_with_indent(&mut buffer, b' ', 4),
985                        Some("root"),
986                    );
987                    let node = Node::Tuple(42.0, "answer".to_string());
988                    node.serialize(&mut ser).unwrap();
989                }
990
991                let got = String::from_utf8(buffer).unwrap();
992                assert_eq!(got, should_be);
993            }
994
995            #[test]
996            fn struct_() {
997                let mut buffer = Vec::new();
998                let should_be = r#"<root tag="Struct"><content float="42" string="answer"/>
999</root>"#;
1000
1001                {
1002                    let mut ser = Serializer::with_root(
1003                        Writer::new_with_indent(&mut buffer, b' ', 4),
1004                        Some("root"),
1005                    );
1006                    let node = Node::Struct {
1007                        float: 42.0,
1008                        string: "answer".to_string(),
1009                    };
1010                    node.serialize(&mut ser).unwrap();
1011                }
1012
1013                let got = String::from_utf8(buffer).unwrap();
1014                assert_eq!(got, should_be);
1015            }
1016
1017            #[test]
1018            fn nested_struct() {
1019                let mut buffer = Vec::new();
1020                let should_be = r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
1021</root>"#;
1022
1023                {
1024                    let mut ser = Serializer::with_root(
1025                        Writer::new_with_indent(&mut buffer, b' ', 4),
1026                        Some("root"),
1027                    );
1028                    let node = Node::Holder {
1029                        nested: Nested { float: 42.0 },
1030                        string: "answer".to_string(),
1031                    };
1032                    node.serialize(&mut ser).unwrap();
1033                }
1034
1035                let got = String::from_utf8(buffer).unwrap();
1036                assert_eq!(got, should_be);
1037            }
1038
1039            #[test]
1040            fn flatten_struct() {
1041                let mut buffer = Vec::new();
1042                let should_be = r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
1043</root>"#;
1044
1045                {
1046                    let mut ser = Serializer::with_root(
1047                        Writer::new_with_indent(&mut buffer, b' ', 4),
1048                        Some("root"),
1049                    );
1050                    let node = Node::Flatten {
1051                        nested: Nested { float: 42.0 },
1052                        string: "answer".to_string(),
1053                    };
1054                    node.serialize(&mut ser).unwrap();
1055                }
1056
1057                let got = String::from_utf8(buffer).unwrap();
1058                assert_eq!(got, should_be);
1059            }
1060        }
1061
1062        mod untagged {
1063            use super::*;
1064            use pretty_assertions::assert_eq;
1065
1066            #[derive(Serialize)]
1067            #[serde(untagged)]
1068            enum Node {
1069                Unit,
1070                Newtype(bool),
1071                Tuple(f64, String),
1072                Struct {
1073                    float: f64,
1074                    string: String,
1075                },
1076                Holder {
1077                    nested: Nested,
1078                    string: String,
1079                },
1080                Flatten {
1081                    #[serde(flatten)]
1082                    nested: Nested,
1083                    string: String,
1084                },
1085            }
1086
1087            #[test]
1088            fn unit() {
1089                let mut buffer = Vec::new();
1090                // Unit variant consists just from the tag, and because tags
1091                // are not written in untagged mode, nothing is written
1092                let should_be = "";
1093
1094                {
1095                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
1096                    let node = Node::Unit;
1097                    node.serialize(&mut ser).unwrap();
1098                }
1099
1100                let got = String::from_utf8(buffer).unwrap();
1101                assert_eq!(got, should_be);
1102            }
1103
1104            #[test]
1105            fn newtype() {
1106                let mut buffer = Vec::new();
1107                let should_be = "true";
1108
1109                {
1110                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
1111                    let node = Node::Newtype(true);
1112                    node.serialize(&mut ser).unwrap();
1113                }
1114
1115                let got = String::from_utf8(buffer).unwrap();
1116                assert_eq!(got, should_be);
1117            }
1118
1119            #[test]
1120            fn tuple_struct() {
1121                let mut buffer = Vec::new();
1122                let should_be = "<root>42</root><root>answer</root>";
1123
1124                {
1125                    let mut ser = Serializer::with_root(
1126                        Writer::new_with_indent(&mut buffer, b' ', 4),
1127                        Some("root"),
1128                    );
1129                    let node = Node::Tuple(42.0, "answer".to_string());
1130                    node.serialize(&mut ser).unwrap();
1131                }
1132
1133                let got = String::from_utf8(buffer).unwrap();
1134                assert_eq!(got, should_be);
1135            }
1136
1137            #[test]
1138            fn struct_() {
1139                let mut buffer = Vec::new();
1140                let should_be = r#"<root float="42" string="answer"/>"#;
1141
1142                {
1143                    let mut ser = Serializer::with_root(
1144                        Writer::new_with_indent(&mut buffer, b' ', 4),
1145                        Some("root"),
1146                    );
1147                    let node = Node::Struct {
1148                        float: 42.0,
1149                        string: "answer".to_string(),
1150                    };
1151                    node.serialize(&mut ser).unwrap();
1152                }
1153
1154                let got = String::from_utf8(buffer).unwrap();
1155                assert_eq!(got, should_be);
1156            }
1157
1158            #[test]
1159            fn nested_struct() {
1160                let mut buffer = Vec::new();
1161                let should_be = r#"<root string="answer"><nested float="42"/>
1162</root>"#;
1163
1164                {
1165                    let mut ser = Serializer::with_root(
1166                        Writer::new_with_indent(&mut buffer, b' ', 4),
1167                        Some("root"),
1168                    );
1169                    let node = Node::Holder {
1170                        nested: Nested { float: 42.0 },
1171                        string: "answer".to_string(),
1172                    };
1173                    node.serialize(&mut ser).unwrap();
1174                }
1175
1176                let got = String::from_utf8(buffer).unwrap();
1177                assert_eq!(got, should_be);
1178            }
1179
1180            #[test]
1181            fn flatten_struct() {
1182                let mut buffer = Vec::new();
1183                let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
1184
1185                {
1186                    let mut ser = Serializer::with_root(
1187                        Writer::new_with_indent(&mut buffer, b' ', 4),
1188                        Some("root"),
1189                    );
1190                    let node = Node::Flatten {
1191                        nested: Nested { float: 42.0 },
1192                        string: "answer".to_string(),
1193                    };
1194                    node.serialize(&mut ser).unwrap();
1195                }
1196
1197                let got = String::from_utf8(buffer).unwrap();
1198                assert_eq!(got, should_be);
1199            }
1200        }
1201    }
1202}
fast_xml/se/mod.rs

fast_xml/se/
mod.rs
