implement write_serializable_content on element writer

Author: Rémi Labeyrie

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

@@ -529,7 +529,21 @@ 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));
+        self.indent_with_len(indent_char, indent_size, 0)
+    }
+
+    /// Set initial indent level for a serializer
+    pub fn indent_with_len(
+        &mut self,
+        indent_char: char,
+        indent_size: usize,
+        indents_len: usize,
+    ) -> &mut Self {
+        self.ser.indent = Indent::Owned(Indentation::new(
+            indent_char as u8,
+            indent_size,
+            indents_len,
+        ));
         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)),
         }
     }
 
@@ -340,6 +344,49 @@ impl<'a, W: Write> ElementWriter<'a, W> {
             .write_event(Event::End(self.start_tag.to_end()))?;
         Ok(self.writer)
     }
+
+    /// Serialize an arbitrary value inside the current element
+    #[cfg(feature = "serialize")]
+    pub fn write_serializable_content<T: Serialize>(
+        self,
+        content: T,
+    ) -> std::result::Result<&'a mut Writer<W>, DeError> {
+        use crate::se::Serializer;
+
+        self.writer
+            .write_event(Event::Start(self.start_tag.borrow()))?;
+        self.writer.write_indent()?;
+
+        let indent = self.writer.indent.clone();
+        let mut serializer = Serializer::new(ToFmtWrite(self.writer.inner()));
+
+        if let Some(indent) = indent {
+            serializer.indent_with_len(
+                indent.indent_char as char,
+                indent.indent_size,
+                indent.indents_len,
+            );
+        }
+
+        content.serialize(serializer)?;
+
+        self.writer
+            .write_event(Event::End(self.start_tag.to_end()))?;
+        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)]
@@ -352,13 +399,13 @@ pub(crate) struct Indentation {
 }
 
 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,
+            indents_len,
         }
     }
 
@@ -623,4 +670,49 @@ mod indentation {
 </outer>"#
         );
     }
+
+    #[cfg(feature = "serialize")]
+    #[derive(Serialize)]
+    struct Foo {
+        bar: Bar,
+        val: String,
+    }
+
+    #[cfg(feature = "serialize")]
+    #[derive(Serialize)]
+    struct Bar {
+        baz: usize,
+        bat: usize,
+    }
+
+    #[cfg(feature = "serialize")]
+    #[test]
+    fn element_writer_serialize() {
+        let mut buffer = Vec::new();
+        let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
+        let content = Foo {
+            bar: Bar { baz: 42, bat: 43 },
+            val: "foo".to_owned(),
+        };
+
+        writer
+            .create_element("paired")
+            .with_attribute(("attr1", "value1"))
+            .with_attribute(("attr2", "value2"))
+            .write_serializable_content(content)
+            .expect("failure");
+
+        assert_eq!(
+            std::str::from_utf8(&buffer).unwrap(),
+            r#"<paired attr1="value1" attr2="value2">
+    <Foo>
+        <bar>
+            <baz>42</baz>
+            <bat>43</bat>
+        </bar>
+        <val>foo</val>
+    </Foo>
+</paired>"#
+        );
+    }
 }