Initial support for Document, EventTarget, NodeList and Iterator

Author: jonathanKingston

crates/web-sys/tests/all/element.rs

@@ -50,22 +50,62 @@ fn element() {
                     assert!(element.has_attributes(), "Should have attributes");
                     assert_eq!(element.remove_attribute("title").unwrap(), (), "Should return nothing if removed");
 
+// closest
+
                     assert_eq!(element.matches(".this-is-a-thing").unwrap(), false, "Should not match selector");
                     assert_eq!(element.webkit_matches_selector(".this-is-a-thing").unwrap(), false, "Should not match selector");
                     element.set_class_name("this-is-a-thing");
                     assert_eq!(element.matches(".this-is-a-thing").unwrap(), true, "Should match selector");
                     assert_eq!(element.webkit_matches_selector(".this-is-a-thing").unwrap(), true, "Should match selector");
                     assert_eq!(element.remove_attribute("class").unwrap(), (), "Should return nothing if removed");
 
-
 // TODO non standard moz_matches_selector should we even support?
+
 /* Tests needed for:
+  insert_adjacent_element
   insert_adjacent_text
   set_pointer_capture
   release_pointer_capture
   has_pointer_capture
   set_capture
   release_capture
+  scroll_top
+  set_scroll_top
+  scroll_left
+  set_scroll_left
+  scroll_width
+  scroll_height
+  scroll,
+  scroll_to
+  scroll_by
+  client_top
+  client_left
+  client_width
+  client_height
+  scroll_top_max
+  scroll_left_max
+*/
+                    assert_eq!(element.inner_html(), "", "Should return no content");
+                    element.set_inner_html("<strong>Hey!</strong><em>Web!</em>");
+                    assert_eq!(element.inner_html(), "<strong>Hey!</strong><em>Web!</em>", "Should return HTML conent");
+                    assert_eq!(element.query_selector_all("strong").unwrap().length(), 1, "Should return one element");
+                    assert!(element.query_selector("strong").unwrap().is_some(), "Should return an element");
+                    element.set_inner_html("");
+                    assert_eq!(element.inner_html(), "", "Should return no content");
+
+/* Tests needed for:
+  outer_html
+  set_outer_html
+  insert_adjacent_html
+*/
+
+                    assert!(element.query_selector(".none-existant").unwrap().is_none(), "Should return no results");
+                    assert_eq!(element.query_selector_all(".none-existant").unwrap().length(), 0, "Should return no results");
+/* Tests needed for:
+  slot
+  set_slot
+  request_fullscreen
+  request_pointer_lock
 */
                 }
             "#,

crates/web-sys/webidls/enabled/Document.webidl

@@ -147,10 +147,9 @@ partial interface Document {
   [SameObject] readonly attribute HTMLCollection links;
   [SameObject] readonly attribute HTMLCollection forms;
   [SameObject] readonly attribute HTMLCollection scripts;
-/*TODO
   [Pure]
   NodeList getElementsByName(DOMString elementName);
-*/
+
   //(Not implemented)readonly attribute DOMElementMap cssElementMap;
 
   // dynamic markup insertion
@@ -341,10 +340,8 @@ partial interface Document {
 partial interface Document {
   [Throws, Pure]
   Element?  querySelector(DOMString selectors);
-/*TODO
   [Throws, Pure]
   NodeList  querySelectorAll(DOMString selectors);
-*/
 
   //(Not implemented)Element?  find(DOMString selectors, optional (Element or sequence<Node>)? refNodes);
   //(Not implemented)NodeList  findAll(DOMString selectors, optional (Element or sequence<Node>)? refNodes);
@@ -406,10 +403,12 @@ partial interface Document {
   // XXXbz and another hack for the fact that we can't usefully have optional
   // distinguishing arguments but need a working zero-arg form of
   // createTouchList().
+/*TODO
   [NewObject, Func="nsGenericHTMLElement::TouchEventsEnabled"]
   TouchList createTouchList();
   [NewObject, Func="nsGenericHTMLElement::TouchEventsEnabled"]
   TouchList createTouchList(sequence<Touch> touches);
+*/
 
   [ChromeOnly]
   attribute boolean styleSheetChangeEventsEnabled;
@@ -489,8 +488,10 @@ partial interface Document {
 
 // http://w3c.github.io/selection-api/#extensions-to-document-interface
 partial interface Document {
+/*TODO
   [Throws]
   Selection? getSelection();
+*/
 };
 
 // Extension to give chrome JS the ability to determine whether

crates/web-sys/webidls/enabled/Element.webidl

@@ -29,8 +29,10 @@ interface Element : Node {
            attribute DOMString id;
   [CEReactions, Pure]
            attribute DOMString className;
+/*TODO
   [Constant, PutForwards=value]
   readonly attribute DOMTokenList classList;
+*/
 
   [SameObject]
   readonly attribute NamedNodeMap attributes;
@@ -248,10 +250,8 @@ partial interface Element {
 partial interface Element {
   [Throws, Pure]
   Element?  querySelector(DOMString selectors);
-/*TODO
   [Throws, Pure]
   NodeList  querySelectorAll(DOMString selectors);
-*/
 };
 
 // https://dom.spec.whatwg.org/#dictdef-shadowrootinit

crates/web-sys/webidls/available/EventTarget.webidl renamed to crates/web-sys/webidls/enabled/EventTarget.webidl

@@ -27,11 +27,11 @@ mod util;
 use std::collections::BTreeSet;
 use std::fs;
 use std::io::{self, Read};
-use std::iter::FromIterator;
+use std::iter::{self, FromIterator};
 use std::path::Path;
 
 use backend::defined::{ImportedTypeDefinitions, RemoveUndefinedImports};
-use backend::util::{ident_ty, rust_ident, wrap_import_function};
+use backend::util::{ident_ty, raw_ident, rust_ident, wrap_import_function};
 use failure::ResultExt;
 use heck::{CamelCase, ShoutySnakeCase};
 use quote::ToTokens;
@@ -401,8 +401,10 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
             webidl::ast::InterfaceMember::Const(cnst) => {
                 cnst.webidl_parse(program, first_pass, self_name)
             }
+            webidl::ast::InterfaceMember::Iterable(iterable) => {
+                iterable.webidl_parse(program, first_pass, self_name)
+            }
             // TODO
-            webidl::ast::InterfaceMember::Iterable(_)
             | webidl::ast::InterfaceMember::Maplike(_)
             | webidl::ast::InterfaceMember::Setlike(_) => {
                 warn!("Unsupported WebIDL interface member: {:?}", self);
@@ -520,6 +522,48 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
     }
 }
 
+impl<'a> WebidlParse<&'a str> for webidl::ast::Iterable {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
+        if util::is_chrome_only(&self.extended_attributes) {
+            return Ok(());
+        }
+
+        let throws = util::throws(&self.extended_attributes);
+        let return_value = webidl::ast::ReturnType::NonVoid(self.value_type.clone());
+        let args = [];
+        first_pass
+            .create_basic_method(
+                &args,
+                Some(&"values".to_string()),
+                &return_value,
+                self_name,
+                false,
+                true, // Should be false
+            )
+            .map(wrap_import_function)
+            .map(|import| program.imports.push(import));
+
+        first_pass
+            .create_basic_method(
+                &args,
+                Some(&"item".to_string()),
+                &return_value,
+                self_name,
+                false,
+                true, // Should be false
+            )
+            .map(wrap_import_function)
+            .map(|import| program.imports.push(import));
+
+        Ok(())
+    }
+}
+
 impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
     fn webidl_parse(
         &self,