Preserve xmlns attributes and rewrite the XML serialization algorithm

rcdom/lib.rs

@@ -44,22 +44,22 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashSet, VecDeque};
 use std::default::Default;
 use std::fmt;
-use std::io;
+use std::io::{self, Write};
 use std::mem;
 use std::rc::{Rc, Weak};
 
 use tendril::StrTendril;
 
 use markup5ever::interface::tree_builder;
 use markup5ever::interface::tree_builder::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
-use markup5ever::serialize::TraversalScope;
-use markup5ever::serialize::TraversalScope::{ChildrenOnly, IncludeNode};
-use markup5ever::serialize::{Serialize, Serializer};
+use markup5ever::interface::ElemName;
+use markup5ever::serialize::TraversalScope::{self, ChildrenOnly, IncludeNode};
+use markup5ever::serialize::{AttrRef, Serialize, Serializer};
 use markup5ever::Attribute;
 use markup5ever::ExpandedName;
 use markup5ever::QualName;
-use xml5ever::interface::ElemName;
-use xml5ever::local_name;
+use markup5ever::{local_name, ns, Namespace};
+use xml5ever::serialize::{NamespacePrefixMap, XmlSerializer};
 
 /// The different kinds of nodes in the DOM.
 #[derive(Debug, Clone)]
@@ -673,3 +673,94 @@ impl Serialize for SerializableHandle {
         Ok(())
     }
 }
+
+pub fn serialize_xml<Wr: Write>(writer: &mut Wr, node: &Node) -> io::Result<()> {
+    let mut ser = XmlSerializer::new(writer);
+    serialize_xml_fragment(&mut ser, node)
+}
+
+fn serialize_xml_fragment<Wr: Write>(
+    serializer: &mut XmlSerializer<Wr>,
+    node: &Node,
+) -> io::Result<()> {
+    let namespace = ns!();
+    let prefix_map = NamespacePrefixMap::default();
+    do_serialize_xml_fragment(serializer, node, &namespace, prefix_map)
+}
+
+fn do_serialize_xml_fragment<Wr: Write>(
+    serializer: &mut XmlSerializer<Wr>,
+    node: &Node,
+    namespace: &Namespace,
+    prefix_map: NamespacePrefixMap,
+) -> io::Result<()> {
+    match node.data {
+        NodeData::Element {
+            ref name,
+            ref attrs,
+            ref template_contents,
+            ..
+        } => {
+            let has_children =
+                !node.children.borrow().is_empty() || template_contents.borrow().is_some();
+            let attributes: Vec<_> = attrs
+                .borrow()
+                .iter()
+                .map(|attr| {
+                    let qname = attr.name.clone();
+                    let value = attr.value.clone();
+                    (qname, value)
+                })
+                .collect();
+            let attr_refs = attributes.iter().map(|(qname, value)| {
+                let ar: AttrRef = (qname, &**value);
+                ar
+            });
+            if has_children {
+                let (qualified_name, inherit_ns, inherit_prefix_map) =
+                    serializer.start_elem(name, attr_refs, namespace.clone(), &prefix_map)?;
+                match &*template_contents.borrow() {
+                    Some(template_contents) => {
+                        do_serialize_xml_fragment(
+                            serializer,
+                            template_contents,
+                            &inherit_ns,
+                            inherit_prefix_map,
+                        )?;
+                    },
+                    None => {
+                        for child in node.children.borrow().iter() {
+                            do_serialize_xml_fragment(
+                                serializer,
+                                child,
+                                &inherit_ns,
+                                inherit_prefix_map.clone(),
+                            )?;
+                        }
+                    },
+                }
+                serializer.end_elem(qualified_name)?;
+            } else {
+                serializer.write_empty_elem(name, attr_refs, namespace.clone(), &prefix_map)?;
+            }
+        },
+
+        NodeData::Doctype { ref name, .. } => serializer.write_doctype(name)?,
+
+        NodeData::Text { ref contents } => serializer.write_text(&contents.borrow())?,
+
+        NodeData::Comment { ref contents } => serializer.write_comment(contents)?,
+
+        NodeData::ProcessingInstruction {
+            ref target,
+            ref contents,
+        } => serializer.write_processing_instruction(target, contents)?,
+
+        NodeData::Document => {
+            for child in node.children.borrow().iter() {
+                do_serialize_xml_fragment(serializer, child, namespace, prefix_map.clone())?;
+            }
+        },
+    }
+    Ok(())
+}

rcdom/tests/xml-driver.rs

@@ -1,6 +1,6 @@
-use markup5ever_rcdom::{RcDom, SerializableHandle};
+use markup5ever::{expanded_name, local_name, ns};
+use markup5ever_rcdom::{serialize_xml, NodeData, RcDom};
 use xml5ever::driver;
-use xml5ever::serialize;
 use xml5ever::tendril::TendrilSink;
 
 #[test]
@@ -76,16 +76,14 @@ fn from_utf8() {
 
 fn assert_eq_serialization(text: &'static str, dom: RcDom) {
     let mut serialized = Vec::new();
-    let document: SerializableHandle = dom.document.clone().into();
-    serialize::serialize(&mut serialized, &document, Default::default()).unwrap();
+    serialize_xml(&mut serialized, &dom.document).unwrap();
 
     let dom_from_text = driver::parse_document(RcDom::default(), Default::default())
         .from_utf8()
         .one(text.as_bytes());
 
     let mut reserialized = Vec::new();
-    let document: SerializableHandle = dom_from_text.document.clone().into();
-    serialize::serialize(&mut reserialized, &document, Default::default()).unwrap();
+    serialize_xml(&mut reserialized, &dom_from_text.document).unwrap();
 
     assert_eq!(
         String::from_utf8(serialized).unwrap(),
@@ -95,7 +93,76 @@ fn assert_eq_serialization(text: &'static str, dom: RcDom) {
 
 fn assert_serialization(text: &'static str, dom: RcDom) {
     let mut serialized = Vec::new();
-    let document: SerializableHandle = dom.document.clone().into();
-    serialize::serialize(&mut serialized, &document, Default::default()).unwrap();
+    serialize_xml(&mut serialized, &dom.document).unwrap();
     assert_eq!(String::from_utf8(serialized).unwrap(), text);
 }
+
+#[test]
+fn xmlns_on_root() {
+    assert_serialization(
+       r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd">
+    <sodipodi:namedview>
+        ...
+    </sodipodi:namedview>
+
+    <path d="..." sodipodi:nodetypes="cccc"/>
+</svg>"##,
+        driver::parse_document(RcDom::default(), Default::default())
+            .from_utf8()
+            .one(r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd">
+    <sodipodi:namedview>
+        ...
+    </sodipodi:namedview>
+
+    <path d="..." sodipodi:nodetypes="cccc"/>
+</svg>"##.as_bytes()),
+    );
+}
+
+#[test]
+fn xmlns_applies_to_attr() {
+    assert_serialization(
+        r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd">
+    <path d="..." sodipodi:nodetypes="cccc"/>
+</svg>"##,
+        driver::parse_document(RcDom::default(), Default::default())
+            .from_utf8()
+            .one(r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://inkscape.sourceforge.net/DTD/sodipodi-0.dtd">
+    <path d="..." sodipodi:nodetypes="cccc"/>
+</svg>"##.as_bytes()),
+    );
+}
+
+#[test]
+fn template() {
+    let dom = driver::parse_document(RcDom::default(), Default::default())
+        .from_utf8()
+        .one(r##"<template xmlns="http://www.w3.org/1999/xhtml"/>"##.as_bytes());
+    let contents = driver::parse_document(RcDom::default(), Default::default())
+        .from_utf8()
+        .one(r##"<div xmlns="http://www.w3.org/1999/xhtml">Pass</div>"##.as_bytes());
+    match &dom.document.children.borrow()[0].data {
+        NodeData::Element {
+            name,
+            template_contents,
+            ..
+        } => {
+            match name.expanded() {
+                expanded_name!(html "template") => {},
+                name => panic!("Root element should be template, was {:?}", name),
+            }
+            template_contents
+                .borrow()
+                .as_ref()
+                .expect("Should have template contents")
+                .children
+                .borrow_mut()
+                .push(contents.document.children.borrow()[0].clone());
+        },
+        _ => panic!("Unexpected child of document"),
+    }
+    assert_serialization(
+        r##"<template xmlns="http://www.w3.org/1999/xhtml"><div>Pass</div></template>"##,
+        dom,
+    );
+}

rcdom/tests/xml-tree-builder.rs

@@ -126,11 +126,7 @@ fn serialize(buf: &mut String, indent: usize, handle: Handle) {
             buf.push_str(&name.local);
             buf.push_str(">\n");
 
-            let mut attrs = attrs.borrow().clone();
-            attrs.sort_by(|x, y| x.name.local.cmp(&y.name.local));
-            // FIXME: sort by UTF-16 code unit
-
-            for attr in attrs.into_iter() {
+            for attr in &*attrs.borrow() {
                 buf.push('|');
                 buf.extend(iter::repeat_n(" ", indent + 2));
 
@@ -140,8 +136,8 @@ fn serialize(buf: &mut String, indent: usize, handle: Handle) {
                     buf.push('}');
                 }
 
-                if let Some(attr_prefix) = attr.name.prefix {
-                    buf.push_str(&attr_prefix);
+                if let Some(ref attr_prefix) = attr.name.prefix {
+                    buf.push_str(attr_prefix);
                     buf.push(':');
                 }