Add Writer::write_serializable

Allow serializing individual objects using serde with the raw Writer API

closes tafia#610

Author: Rémi Labeyrie

Changelog.md

@@ -12,11 +12,17 @@
 
 ### New Features
 
+- [#609]: Added `write_serializable_content` for serializing arbitrary types using serde
+  when using the `Writer` API.
+
 ### Bug Fixes
 
 ### Misc Changes
 
 
+[#609]: https://github.com/tafia/quick-xml/issues/609
+
+
 ## 0.29.0 -- 2023-06-13
 
 ### New Features
@@ -45,7 +51,6 @@
 [#606]: https://github.com/tafia/quick-xml/pull/606
 [#608]: https://github.com/tafia/quick-xml/issues/608
 
-
 ## 0.28.2 -- 2023-04-12
 
 ### New Features
@@ -86,8 +91,8 @@
   to trim leading and trailing spaces from text events
 - [#565]: Allow deserialize special field names `$value` and `$text` into borrowed
   fields when use serde deserializer
-- [#568]: Rename `Writter::inner` into `Writter::get_mut`
-- [#568]: Add method `Writter::get_ref`
+- [#568]: Rename `Writer::inner` into `Writer::get_mut`
+- [#568]: Add method `Writer::get_ref`
 - [#569]: Rewrite the `Reader::read_event_into_async` as an async fn, making the future `Send` if possible.
 - [#571]: Borrow element names (`<element>`) when deserialize with serde.
   This change allow to deserialize into `HashMap<&str, T>`, for example

src/se/content.rs

@@ -670,7 +670,7 @@ pub(super) mod tests {
                     let ser = ContentSerializer {
                         writer: &mut buffer,
                         level: QuoteLevel::Full,
-                        indent: Indent::Owned(Indentation::new(b' ', 2)),
+                        indent: Indent::Owned(Indentation::new(b' ', 2, 0)),
                         write_indent: false,
                     };
 
@@ -690,7 +690,7 @@ pub(super) mod tests {
                     let ser = ContentSerializer {
                         writer: &mut buffer,
                         level: QuoteLevel::Full,
-                        indent: Indent::Owned(Indentation::new(b' ', 2)),
+                        indent: Indent::Owned(Indentation::new(b' ', 2, 0)),
                         write_indent: false,
                     };
 

src/se/element.rs

@@ -1531,7 +1531,7 @@ mod tests {
                         ser: ContentSerializer {
                             writer: &mut buffer,
                             level: QuoteLevel::Full,
-                            indent: Indent::Owned(Indentation::new(b' ', 2)),
+                            indent: Indent::Owned(Indentation::new(b' ', 2, 0)),
                             write_indent: false,
                         },
                         key: XmlName("root"),
@@ -1554,7 +1554,7 @@ mod tests {
                         ser: ContentSerializer {
                             writer: &mut buffer,
                             level: QuoteLevel::Full,
-                            indent: Indent::Owned(Indentation::new(b' ', 2)),
+                            indent: Indent::Owned(Indentation::new(b' ', 2, 0)),
                             write_indent: false,
                         },
                         key: XmlName("root"),

src/se/mod.rs

@@ -528,8 +528,19 @@ impl<'w, 'r, W: Write> Serializer<'w, 'r, W> {
     }
 
     /// Configure indent for a serializer
-    pub fn indent(&mut self, indent_char: char, indent_size: usize) -> &mut Self {
-        self.ser.indent = Indent::Owned(Indentation::new(indent_char as u8, indent_size));
+    ///
+    /// Note: `initial_indent_amt` is the initial total length of the indent, not the indent level
+    pub fn indent(
+        &mut self,
+        indent_char: char,
+        indent_size: usize,
+        initial_indent_amt: usize,
+    ) -> &mut Self {
+        self.ser.indent = Indent::Owned(Indentation::new(
+            indent_char as u8,
+            indent_size,
+            initial_indent_amt,
+        ));
         self
     }
 

src/writer.rs

@@ -10,6 +10,10 @@ use crate::events::{attributes::Attribute, BytesCData, BytesStart, BytesText, Ev
 mod async_tokio;
 
 /// XML writer. Writes XML [`Event`]s to a [`std::io::Write`] or [`tokio::io::AsyncWrite`] implementor.
+#[cfg(feature = "serialize")]
+use {crate::de::DeError, serde::Serialize};
+
+/// XML writer. Writes XML [`Event`]s to a [`std::io::Write`] implementor.
 ///
 /// # Examples
 ///
@@ -75,7 +79,7 @@ impl<W> Writer<W> {
     pub fn new_with_indent(inner: W, indent_char: u8, indent_size: usize) -> Writer<W> {
         Writer {
             writer: inner,
-            indent: Some(Indentation::new(indent_char, indent_size)),
+            indent: Some(Indentation::new(indent_char, indent_size, 0)),
         }
     }
 
@@ -261,6 +265,33 @@ impl<W: Write> Writer<W> {
             start_tag: BytesStart::new(name.as_ref()),
         }
     }
+
+    /// Write an arbitrary serializable object
+    #[cfg(feature = "serialize")]
+    pub fn write_serializable<T: Serialize>(
+        &mut self,
+        content: &T,
+        tag_name: &str,
+    ) -> std::result::Result<(), DeError> {
+        use crate::se::Serializer;
+
+        self.write_indent()?;
+        let indent = self.indent.clone();
+        let mut fmt = ToFmtWrite(self.get_mut());
+        let mut serializer = Serializer::with_root(&mut fmt, Some(tag_name))?;
+
+        if let Some(indent) = indent {
+            serializer.indent(
+                indent.indent_char as char,
+                indent.indent_size,
+                indent.current_indent_len,
+            );
+        }
+
+        content.serialize(serializer)?;
+
+        Ok(())
+    }
 }
 
 /// A struct to write an element. Contains methods to add attributes and inner
@@ -341,43 +372,62 @@ impl<'a, W: Write> ElementWriter<'a, W> {
         Ok(self.writer)
     }
 }
+#[cfg(feature = "serialize")]
+struct ToFmtWrite<T>(pub T);
+
+#[cfg(feature = "serialize")]
+impl<T> std::fmt::Write for ToFmtWrite<T>
+where
+    T: std::io::Write,
+{
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.0.write_all(s.as_bytes()).map_err(|_| std::fmt::Error)
+    }
+}
 
 #[derive(Clone)]
 pub(crate) struct Indentation {
+    /// todo: does this even belong here? It has no impact on indentation logic.
     should_line_break: bool,
+    /// The character code to be used for indentations (e.g. ` ` or `\t`)
     indent_char: u8,
+    /// How many instances of the indent character ought to be used for each level of indentation
     indent_size: usize,
+    /// Used as a cache for the bytes used for indentation
     indents: Vec<u8>,
-    indents_len: usize,
+    /// The current amount of indentation - must be less than indents.len()
+    current_indent_len: usize,
 }
 
 impl Indentation {
-    pub fn new(indent_char: u8, indent_size: usize) -> Self {
+    pub fn new(indent_char: u8, indent_size: usize, indents_len: usize) -> Self {
         Self {
             should_line_break: false,
             indent_char,
             indent_size,
             indents: vec![indent_char; 128],
-            indents_len: 0,
+            current_indent_len: indents_len,
         }
     }
 
     /// Increase indentation by one level
     pub fn grow(&mut self) {
-        self.indents_len += self.indent_size;
-        if self.indents_len > self.indents.len() {
-            self.indents.resize(self.indents_len, self.indent_char);
+        self.current_indent_len += self.indent_size;
+        if self.current_indent_len > self.indents.len() {
+            self.indents
+                .resize(self.current_indent_len, self.indent_char);
         }
     }
 
     /// Decrease indentation by one level. Do nothing, if level already zero
     pub fn shrink(&mut self) {
-        self.indents_len = self.indents_len.saturating_sub(self.indent_size);
+        self.current_indent_len = self.current_indent_len.saturating_sub(self.indent_size);
     }
 
     /// Returns indent string for current level
     pub fn current(&self) -> &[u8] {
-        &self.indents[..self.indents_len]
+        // todo: might be buggy if initialized > 128 without a call to grow() first
+        &self.indents[..self.current_indent_len]
     }
 }
 
@@ -547,6 +597,71 @@ mod indentation {
         );
     }
 
+    #[cfg(feature = "serialize")]
+    #[test]
+    fn serializable() {
+        #[derive(Serialize)]
+        struct Foo {
+            #[serde(rename = "@attribute")]
+            attribute: &'static str,
+
+            element: Bar,
+            list: Vec<&'static str>,
+
+            #[serde(rename = "$text")]
+            text: &'static str,
+
+            val: String,
+        }
+
+        #[derive(Serialize)]
+        struct Bar {
+            baz: usize,
+            bat: usize,
+        }
+
+        let mut buffer = Vec::new();
+        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
+
+        let content = Foo {
+            attribute: "attribute",
+            element: Bar { baz: 42, bat: 43 },
+            list: vec!["first element", "second element"],
+            text: "text",
+            val: "foo".to_owned(),
+        };
+
+        let start = BytesStart::new("paired")
+            .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+        let end = start.to_end();
+
+        writer
+            .write_event(Event::Start(start.clone()))
+            .expect("write start tag failed");
+        writer
+            .write_serializable(&content, "foo_element")
+            .expect("write serializable inner contents failed");
+        writer
+            .write_event(Event::End(end))
+            .expect("write end tag failed");
+
+        assert_eq!(
+            std::str::from_utf8(&buffer).unwrap(),
+            r#"<paired attr1="value1" attr2="value2">
+    <foo_element attribute="attribute">
+        <element>
+            <baz>42</baz>
+            <bat>43</bat>
+        </element>
+        <list>first element</list>
+        <list>second element</list>
+        text
+        <val>foo</val>
+    </foo_element>
+</paired>"#
+        );
+    }
+
     #[test]
     fn element_writer_empty() {
         let mut buffer = Vec::new();

tests/serde-se.rs

@@ -699,7 +699,7 @@ mod without_root {
                 fn $name() {
                     let mut buffer = String::new();
                     let mut ser = Serializer::new(&mut buffer);
-                    ser.indent(' ', 2);
+                    ser.indent(' ', 2, 0);
 
                     $data.serialize(ser).unwrap();
                     assert_eq!(buffer, $expected);