Document.creatElementNS() and reftest

src/components/script/dom/bindings/codegen/Bindings.conf

@@ -154,6 +154,7 @@ DOMInterfaces = {
         'createComment',
         'createDocumentFragment',
         'createElement',
+        'createElementNS',
         'createTextNode',
         'title',
     ],
@@ -309,6 +310,7 @@ DOMInterfaces = {
         'appendChild',
         'nodeName',
         'nodeValue',
+        'namespaceURI',
         'removeChild',
         'textContent',
         'childNodes'

src/components/script/dom/bindings/codegen/Document.webidl

@@ -42,8 +42,8 @@ interface Document : Node {
 
   [Creator, Throws]
   Element createElement(DOMString localName);
-  // [Creator, Throws]
-  // Element createElementNS(DOMString? namespace, DOMString qualifiedName);
+  [Creator, Throws]
+  Element createElementNS(DOMString? namespace, DOMString qualifiedName);
   [Creator]
   DocumentFragment createDocumentFragment();
   [Creator]

src/components/script/dom/document.rs

@@ -3,18 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::comment::Comment;
+use dom::bindings::codegen::ElementBinding;
 use dom::bindings::codegen::DocumentBinding;
 use dom::bindings::utils::{Reflectable, Reflector, Traceable, reflect_dom_object};
-use dom::bindings::utils::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
+use dom::bindings::utils::{ErrorResult, Fallible, NotSupported, InvalidCharacter, NamespaceError};
 use dom::bindings::utils::DOMString;
-use dom::bindings::utils::{xml_name_type, InvalidXMLName};
+use dom::bindings::utils::{xml_name_type, InvalidXMLName, Name, QName};
 use dom::documentfragment::DocumentFragment;
 use dom::element::{Element};
-use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId};
+use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId, nonHTMLTypeId};
 use dom::event::{AbstractEvent, Event};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmldocument::HTMLDocument;
 use dom::mouseevent::MouseEvent;
+use dom::namespace;
+use dom::namespace::Namespace;
 use dom::node::{AbstractNode, ScriptView, Node, ElementNodeTypeId, DocumentNodeTypeId};
 use dom::text::Text;
 use dom::uievent::UIEvent;
@@ -201,6 +204,56 @@ impl Document {
         Ok(build_element_from_tag(local_name, abstract_self))
     }
 
+    pub fn CreateElementNS(&self, abstract_self: AbstractDocument, namespace: Option<DOMString>, qualified_name: DOMString) -> Fallible<AbstractNode<ScriptView>> {
+        let ns: Namespace = Namespace::from_str(namespace);
+        let mut local_name;
+        match xml_name_type(qualified_name) {
+            InvalidXMLName => {
+                debug!("Not a valid element name");
+                return Err(InvalidCharacter);
+            },
+            Name => {
+                debug!("Not a valid qualified element name");
+                return Err(NamespaceError);
+            },
+            QName => {
+                let (prefix_from_qname, local_name_from_qname) = if qualified_name.contains(":")  {
+                    let parts: ~[&str] = qualified_name.splitn_iter(':', 1).collect();
+                    (Some(parts[0].to_owned()), parts[1].to_owned())
+                } else {
+                    (None, qualified_name.clone())
+                };
+                match (ns.clone(), prefix_from_qname, local_name_from_qname.clone()) {
+                    (namespace::Null, None, _) => {},
+                    (namespace::Null, _, _) => {
+                        debug!("Namespace can't be null with a non-null prefix");
+                        return Err(NamespaceError);
+                    },
+                    (namespace::XML, Some(~"xml"), _) => {},
+                    (namespace::XML, _, _) => {
+                        debug!("Namespace must be the xml namespace if the prefix is 'xml'");
+                        return Err(NamespaceError);
+                    },
+                    (namespace::XMLNS, Some(~"xmlns"), _) | (namespace::XMLNS, _, ~"xmlns") => {},
+                    (_, Some(~"xmlns"), _) | (_, _, ~"xmlns") => {
+                        debug!("Namespace must be the xmlns namespace if the prefix or the qualified name is 'xmlns'");
+                        return Err(NamespaceError);
+                    },
+                    _ => {}
+                }
+                local_name = local_name_from_qname;
+            }
+        }
+
+        if ns == namespace::HTML {
+            local_name = local_name.to_ascii_lower();
+            Ok(build_element_from_tag(local_name, abstract_self))
+        } else {
+            let element = Element::new(nonHTMLTypeId, local_name, ns, abstract_self);
+            Ok(Node::reflect_node(@mut element, abstract_self, ElementBinding::Wrap))
+        }
+    }
+
     pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode<ScriptView> {
         DocumentFragment::new(abstract_self)
     }

src/components/script/dom/element.rs

@@ -117,6 +117,8 @@ pub enum ElementTypeId {
     HTMLUListElementTypeId,
     HTMLVideoElementTypeId,
     HTMLUnknownElementTypeId,
+
+    nonHTMLTypeId,
 }
 
 //

src/components/script/dom/node.rs

@@ -21,7 +21,7 @@ use dom::text::Text;
 
 use js::jsapi::{JSObject, JSContext};
 use servo_util::slot::{MutSlotRef, Slot, SlotRef};
-use servo_util::tree::{TreeNode, TreeNodeRef, TreeNodeRefAsElement};
+use servo_util::tree::{TreeNode, TreeNodeRef, TreeNodeRefAsElement, ElementLike};
 use std::cast::transmute;
 use std::cast;
 use std::unstable::raw::Box;
@@ -1177,8 +1177,19 @@ impl Node<ScriptView> {
         false
     }
 
-    pub fn GetNamespaceURI(&self) -> Option<DOMString> {
-        None
+    pub fn GetNamespaceURI(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> {
+        match self.type_id {
+            ElementNodeTypeId(*) => {
+                do abstract_self.with_imm_element_like |element| {
+                    Some(element.get_namespace())
+                }
+            }
+            CommentNodeTypeId |
+            TextNodeTypeId |
+            DocumentFragmentNodeTypeId |
+            DoctypeNodeTypeId |
+            DocumentNodeTypeId(_) => None
+        }
     }
 
     pub fn GetPrefix(&self) -> Option<DOMString> {

src/test/ref/basic.list

@@ -13,3 +13,4 @@
 == last_of_type_pseudo_a.html last_of_type_pseudo_b.html
 == only_of_type_pseudo_a.html only_of_type_pseudo_b.html
 == visibility_hidden.html visibility_hidden_ref.html
+== dom_createelementns_a.html dom_createelementns_b.html

src/test/ref/dom_createelementns_a.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Document.createElementNS() test</title>
+    <script>
+      function test() {
+        var host = document.getElementById("body");
+        function appendElt(e, id) {
+          host.appendChild(e);
+          e.id = id;
+          e.setAttribute("ns", e.namespaceURI);
+        }
+
+        var img1 = document.createElement("address");
+        appendElt(img1, "img1");
+        var img2 = document.createElementNS("http://www.example.org/dummy", "p");
+        appendElt(img2, "img2");
+        var img3 = document.createElementNS("http://www.w3.org/1999/xhtml", "address");
+        appendElt(img3, "img3");
+
+        function appendSpan(id, ns) {
+          var e = document.createElement("span");
+          e.id = id;
+          e.setAttribute("ns", ns);
+          host.appendChild(e);
+        }
+        var ref = document.getElementById("ref");
+        appendSpan("s1", ref.firstChild.namespaceURI);
+        appendSpan("s2", ref.ownerDocument.namespaceURI);
+        appendSpan("s3", ref.lastChild.namespaceURI);
+     }
+    </script>
+    <style>
+      @namespace dummy url("http://www.example.org/dummy");
+      @namespace html url("http://www.w3.org/1999/xhtml");
+
+      * { margin: 0px; padding: 0px; }
+
+      address, dummy|p, p, html|span {
+        width: 40px;
+        height: 40px;
+        background: red;
+        margin-bottom: 10px;
+        display: block;
+      }
+
+      address[ns="http://www.w3.org/1999/xhtml"],
+      dummy|p[ns="http://www.example.org/dummy"],
+      span[ns="null"] {
+        background: green;
+      }
+    </style>
+  </head>
+  <body id="body">
+    <div id="ref"> <!--comment--></div>
+    <script>
+      test();
+    </script>
+  </body>
+</html>

src/test/ref/dom_createelementns_b.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Document.createElementNS() test</title>
+    <style>
+      * { margin: 0px; padding: 0px; }
+
+      address, p, span {
+        width: 40px;
+        height: 40px;
+        background: green;
+        margin-bottom: 10px;
+        display: block;
+      }
+
+   </style>
+  </head>
+  <body id="body">
+    <div id="ref"> <!--comment--></div>
+    <address></address>
+    <p></p>
+    <address></address>
+    <span></span>
+    <span></span>
+    <span></span>
+ </body>
+</html>