change type ChildrenOnly to ChildrenOnly(Option<QualName>)

Author: moonlightdrive

html5ever/src/serialize/mod.rs

@@ -15,11 +15,11 @@ use {LocalName, QualName};
 
 pub fn serialize<Wr, T>(writer: Wr, node: &T, opts: SerializeOpts) -> io::Result<()>
 where Wr: Write, T: Serialize {
-    let mut ser = HtmlSerializer::new(writer, opts);
+    let mut ser = HtmlSerializer::new(writer, opts.clone());
     node.serialize(&mut ser, opts.traversal_scope)
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SerializeOpts {
     /// Is scripting enabled?
     pub scripting_enabled: bool,
@@ -39,7 +39,7 @@ impl Default for SerializeOpts {
     fn default() -> SerializeOpts {
         SerializeOpts {
             scripting_enabled: true,
-            traversal_scope: TraversalScope::ChildrenOnly,
+            traversal_scope: TraversalScope::ChildrenOnly(None),
             create_missing_parent: false,
         }
     }
@@ -72,10 +72,18 @@ fn tagname(name: &QualName) -> LocalName {
 
 impl<Wr: Write> HtmlSerializer<Wr> {
     fn new(writer: Wr, opts: SerializeOpts) -> Self {
+        let html_name = match opts.traversal_scope {
+            TraversalScope::IncludeNode | TraversalScope::ChildrenOnly(None) => None,
+            TraversalScope::ChildrenOnly(Some(ref n)) => Some(tagname(n))
+        };
         HtmlSerializer {
             writer: writer,
             opts: opts,
-            stack: vec![Default::default()],
+            stack: vec!(ElemInfo {
+                html_name: html_name,
+                ignore_children: false,
+                processed_first_child: false,
+            }),
         }
     }
 
@@ -190,18 +198,6 @@ impl<Wr: Write> Serializer for HtmlSerializer<Wr> {
     }
 
     fn write_text(&mut self, text: &str) -> io::Result<()> {
-        let prepend_lf = text.starts_with("\n") && {
-            let parent = self.parent();
-            !parent.processed_first_child && match parent.html_name {
-                Some(local_name!("pre")) | Some(local_name!("textarea")) | Some(local_name!("listing")) => true,
-                _ => false,
-            }
-        };
-
-        if prepend_lf {
-            try!(self.writer.write_all(b"\n"));
-        }
-
         let escape = match self.parent().html_name {
             Some(local_name!("style")) | Some(local_name!("script")) | Some(local_name!("xmp"))
             | Some(local_name!("iframe")) | Some(local_name!("noembed")) | Some(local_name!("noframes"))

html5ever/tests/serializer.rs

@@ -165,15 +165,15 @@ test!(noframes_literal, r#"<noframes>(x & 1) < 2; y > "foo" + 'bar'</noframes>"#
 
 test!(pre_lf_0, "<pre>foo bar</pre>");
 test!(pre_lf_1, "<pre>\nfoo bar</pre>", "<pre>foo bar</pre>");
-test!(pre_lf_2, "<pre>\n\nfoo bar</pre>");
+test!(pre_lf_2, "<pre>\n\nfoo bar</pre>", "<pre>\nfoo bar</pre>");
 
 test!(textarea_lf_0, "<textarea>foo bar</textarea>");
 test!(textarea_lf_1, "<textarea>\nfoo bar</textarea>", "<textarea>foo bar</textarea>");
-test!(textarea_lf_2, "<textarea>\n\nfoo bar</textarea>");
+test!(textarea_lf_2, "<textarea>\n\nfoo bar</textarea>", "<textarea>\nfoo bar</textarea>");
 
 test!(listing_lf_0, "<listing>foo bar</listing>");
 test!(listing_lf_1, "<listing>\nfoo bar</listing>", "<listing>foo bar</listing>");
-test!(listing_lf_2, "<listing>\n\nfoo bar</listing>");
+test!(listing_lf_2, "<listing>\n\nfoo bar</listing>", "<listing>\nfoo bar</listing>");
 
 test!(comment_1, r#"<p>hi <!--world--></p>"#);
 test!(comment_2, r#"<p>hi <!-- world--></p>"#);

markup5ever/rcdom.rs

@@ -326,7 +326,7 @@ impl Default for RcDom {
 impl Serialize for Handle {
     fn serialize<S>(&self, serializer: &mut S, traversal_scope: TraversalScope) -> io::Result<()>
     where S: Serializer {
-        match (traversal_scope, &self.data) {
+        match (&traversal_scope, &self.data) {
             (_, &NodeData::Element { ref name, ref attrs, .. }) => {
                 if traversal_scope == IncludeNode {
                     try!(serializer.start_elem(name.clone(),
@@ -343,28 +343,28 @@ impl Serialize for Handle {
                 Ok(())
             }
 
-            (ChildrenOnly, &NodeData::Document) => {
+            (&ChildrenOnly(_), &NodeData::Document) => {
                 for handle in self.children.borrow().iter() {
                     try!(handle.clone().serialize(serializer, IncludeNode));
                 }
                 Ok(())
             }
 
-            (ChildrenOnly, _) => Ok(()),
+            (&ChildrenOnly(_), _) => Ok(()),
 
-            (IncludeNode, &NodeData::Doctype { ref name, .. }) => {
+            (&IncludeNode, &NodeData::Doctype { ref name, .. }) => {
                 serializer.write_doctype(&name)
             }
-            (IncludeNode, &NodeData::Text { ref contents }) => {
+            (&IncludeNode, &NodeData::Text { ref contents }) => {
                 serializer.write_text(&contents.borrow())
             }
-            (IncludeNode, &NodeData::Comment { ref contents }) => {
+            (&IncludeNode, &NodeData::Comment { ref contents }) => {
                 serializer.write_comment(&contents)
             }
-            (IncludeNode, &NodeData::ProcessingInstruction { ref target, ref contents }) => {
+            (&IncludeNode, &NodeData::ProcessingInstruction { ref target, ref contents }) => {
                 serializer.write_processing_instruction(target, contents)
             },
-            (IncludeNode, &NodeData::Document) => {
+            (&IncludeNode, &NodeData::Document) => {
                 panic!("Can't serialize Document node itself")
             }
         }

markup5ever/serialize.rs

@@ -11,10 +11,10 @@ use QualName;
 use std::io;
 
 //§ serializing-html-fragments
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub enum TraversalScope {
     IncludeNode,
-    ChildrenOnly
+    ChildrenOnly(Option<QualName>)
 }
 
 pub trait Serialize {

xml5ever/src/serialize/mod.rs

@@ -12,7 +12,7 @@ pub use markup5ever::serialize::{Serialize, Serializer, TraversalScope, AttrRef}
 use std::io::{self, Write};
 use tree_builder::NamespaceMap;
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 /// Struct for setting serializer options.
 pub struct SerializeOpts {
     /// Serialize the root node? Default: ChildrenOnly
@@ -22,7 +22,7 @@ pub struct SerializeOpts {
 impl Default for SerializeOpts {
     fn default() -> SerializeOpts {
         SerializeOpts {
-            traversal_scope: TraversalScope::ChildrenOnly
+            traversal_scope: TraversalScope::ChildrenOnly(None)
         }
     }
 }