Remove write_serializable_content from element writer

Author: dralley

src/writer.rs

@@ -271,13 +271,14 @@ impl<W: Write> Writer<W> {
     pub fn write_serializable<T: Serialize>(
         &mut self,
         content: &T,
+        tag_name: Option<&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::new(&mut fmt);
+        let mut serializer = Serializer::with_root(&mut fmt, Some(tag_name))?;
 
         if let Some(indent) = indent {
             serializer.indent(
@@ -370,39 +371,7 @@ 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 fmt = &mut ToFmtWrite(self.writer.get_mut());
-        let mut serializer = Serializer::new(fmt);
-
-        if let Some(indent) = indent {
-            serializer.indent(
-                indent.indent_char as char,
-                indent.indent_size,
-                indent.current_indent_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);
 
@@ -628,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();
@@ -704,110 +738,4 @@ mod indentation {
 </outer>"#
         );
     }
-
-    #[cfg(feature = "serialize")]
-    mod write_serializable {
-        use super::*;
-
-        #[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,
-        }
-
-        #[cfg(feature = "serialize")]
-        #[test]
-        fn serializable() {
-            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)
-                .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 attribute="attribute">
-            <element>
-                <baz>42</baz>
-                <bat>43</bat>
-            </element>
-            <list>first element</list>
-            <list>second element</list>
-            text
-            <val>foo</val>
-        </Foo>
-    </paired>"#
-            );
-        }
-
-        #[test]
-        fn element_writer_serializable() {
-            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_string(),
-            };
-
-            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 attribute="attribute">
-            <element>
-                <baz>42</baz>
-                <bat>43</bat>
-            </element>
-            <list>first element</list>
-            <list>second element</list>
-            text
-            <val>foo</val>
-        </Foo>
-    </paired>"#
-            );
-        }
-    }
 }