Implement support for form owner

dom_sink/src/owned_dom.rs

@@ -197,6 +197,17 @@ impl TreeSink for Sink {
         x == y
     }
 
+    fn same_home_subtree(&self, _x: Handle, _y: Handle) -> bool {
+        true
+    }
+
+    fn associate_with_form(&mut self, _target: Handle, _form: Handle) {
+    }
+
+    fn has_parent_node(&self, node: Handle) -> bool {
+        !node.parent.is_null()
+    }
+
     fn elem_name(&self, target: Handle) -> QualName {
         match target.node {
             Element(ref name, _) => name.clone(),
@@ -230,8 +241,9 @@ impl TreeSink for Sink {
 
     fn append_before_sibling(&mut self,
             sibling: Handle,
-            child: NodeOrText<Handle>) -> Result<(), NodeOrText<Handle>> {
-        let (mut parent, i) = unwrap_or_return!(get_parent_and_index(sibling), Err(child));
+            child: NodeOrText<Handle>) {
+        let (mut parent, i) = get_parent_and_index(sibling)
+            .expect("append_before_sibling called on node without parent");
 
         let mut child = match (child, i) {
             // No previous node.
@@ -241,7 +253,7 @@ impl TreeSink for Sink {
             (AppendText(text), i) => {
                 let prev = parent.children[i-1];
                 if append_to_existing_text(prev, &text) {
-                    return Ok(());
+                    return;
                 }
                 self.new_node(Text(text))
             }
@@ -259,7 +271,6 @@ impl TreeSink for Sink {
 
         child.parent = parent;
         parent.children.insert(i, child);
-        Ok(())
     }
 
     fn append_doctype_to_document(&mut self, name: String, public_id: String, system_id: String) {

dom_sink/src/rcdom.rs

@@ -163,6 +163,18 @@ impl TreeSink for RcDom {
         new_node(Comment(text))
     }
 
+    fn same_home_subtree(&self, _x: Handle, _y: Handle) -> bool {
+        true
+    }
+
+    fn associate_with_form(&mut self, _target: Handle, _form: Handle) {
+    }
+
+    fn has_parent_node(&self, node: Handle) -> bool {
+        let node = node.borrow();
+        node.parent.is_some()
+    }
+
     fn append(&mut self, parent: Handle, child: NodeOrText<Handle>) {
         // Append to an existing Text node if we have one.
         match child {
@@ -181,8 +193,9 @@ impl TreeSink for RcDom {
 
     fn append_before_sibling(&mut self,
             sibling: Handle,
-            child: NodeOrText<Handle>) -> Result<(), NodeOrText<Handle>> {
-        let (parent, i) = unwrap_or_return!(get_parent_and_index(&sibling), Err(child));
+            child: NodeOrText<Handle>) {
+        let (parent, i) = get_parent_and_index(&sibling)
+            .expect("append_before_sibling called on node without parent");
 
         let child = match (child, i) {
             // No previous node.
@@ -193,7 +206,7 @@ impl TreeSink for RcDom {
                 let parent = parent.borrow();
                 let prev = &parent.children[i-1];
                 if append_to_existing_text(prev, &text) {
-                    return Ok(());
+                    return;
                 }
                 new_node(Text(text))
             }
@@ -211,7 +224,6 @@ impl TreeSink for RcDom {
 
         child.borrow_mut().parent = Some(parent.clone().downgrade());
         parent.borrow_mut().children.insert(i, child);
-        Ok(())
     }
 
     fn append_doctype_to_document(&mut self, name: String, public_id: String, system_id: String) {

examples/noop-tree-builder.rs

@@ -46,6 +46,10 @@ impl TreeSink for Sink {
         x == y
     }
 
+    fn same_home_subtree(&self, _x: usize, _y: usize) -> bool {
+        true
+    }
+
     fn elem_name(&self, target: usize) -> QualName {
         self.names.get(&target).expect("not an element").clone()
     }
@@ -60,20 +64,23 @@ impl TreeSink for Sink {
         self.get_id()
     }
 
+    fn has_parent_node(&self, _node: usize) -> bool {
+        // `node` will have a parent unless a script moved it, and we're
+        // not running scripts.  Therefore we can aways return true.
+        true
+    }
+
     fn append_before_sibling(&mut self,
             _sibling: usize,
-            _new_node: NodeOrText<usize>) -> Result<(), NodeOrText<usize>> {
-        // `sibling` will have a parent unless a script moved it, and we're
-        // not running scripts.  Therefore we can aways return `Ok(())`.
-        Ok(())
-    }
+            _new_node: NodeOrText<usize>) { }
 
     fn parse_error(&mut self, _msg: Cow<'static, str>) { }
     fn set_quirks_mode(&mut self, _mode: QuirksMode) { }
     fn append(&mut self, _parent: usize, _child: NodeOrText<usize>) { }
 
     fn append_doctype_to_document(&mut self, _name: String, _public_id: String, _system_id: String) { }
     fn add_attrs_if_missing(&mut self, _target: usize, _attrs: Vec<Attribute>) { }
+    fn associate_with_form(&mut self, _target: usize, _form: usize) { }
     fn remove_from_parent(&mut self, _target: usize) { }
     fn reparent_children(&mut self, _node: usize, _new_parent: usize) { }
     fn mark_script_already_started(&mut self, _node: usize) { }

examples/print-tree-actions.rs

@@ -56,6 +56,10 @@ impl TreeSink for Sink {
         x == y
     }
 
+    fn same_home_subtree(&self, _x: usize, _y: usize) -> bool {
+        true
+    }
+
     fn elem_name(&self, target: usize) -> QualName {
         self.names.get(&target).expect("not an element").clone()
     }
@@ -73,6 +77,12 @@ impl TreeSink for Sink {
         id
     }
 
+    fn has_parent_node(&self, _node: usize) -> bool  {
+        // `node` will have a parent unless a script moved it, and we're
+        // not running scripts.  Therefore we can aways return true
+        true
+    }
+
     fn append(&mut self, parent: usize, child: NodeOrText<usize>) {
         match child {
             AppendNode(n)
@@ -84,17 +94,13 @@ impl TreeSink for Sink {
 
     fn append_before_sibling(&mut self,
             sibling: usize,
-            new_node: NodeOrText<usize>) -> Result<(), NodeOrText<usize>> {
+            new_node: NodeOrText<usize>) {
         match new_node {
             AppendNode(n)
                 => println!("Append node {} before {}", n, sibling),
             AppendText(t)
                 => println!("Append text before {}: \"{}\"", sibling, t.escape_default()),
         }
-
-        // `sibling` will have a parent unless a script moved it, and we're
-        // not running scripts.  Therefore we can aways return `Ok(())`.
-        Ok(())
     }
 
     fn append_doctype_to_document(&mut self, name: String, public_id: String, system_id: String) {
@@ -108,6 +114,12 @@ impl TreeSink for Sink {
         }
     }
 
+    fn associate_with_form(&mut self, _target: usize, _form: usize) {
+        // No form owner support. Since same_home_subtree always returns
+        // true we cannot be sure that this associate_with_form call is
+        // valid
+    }
+
     fn remove_from_parent(&mut self, target: usize) {
         println!("Remove {} from parent", target);
     }

src/tree_builder/actions.rs

@@ -207,40 +207,8 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
 
     // Insert at the "appropriate place for inserting a node".
     fn insert_appropriately(&mut self, child: NodeOrText<Handle>, override_target: Option<Handle>) {
-        declare_tag_set!(foster_target = table tbody tfoot thead tr);
-        let target = override_target.unwrap_or_else(|| self.current_node());
-        if !(self.foster_parenting && self.elem_in(target.clone(), foster_target)) {
-            // No foster parenting (the common case).
-            return self.sink.append(target, child);
-        }
-
-        // Foster parenting
-        // FIXME: <template>
-        let last_table = self.open_elems.iter()
-            .enumerate()
-            .rev()
-            .filter(|&(_, e)| self.html_elem_named(e.clone(), atom!(table)))
-            .next();
-
-        match last_table {
-            None => {
-                let html_elem = self.html_elem();
-                self.sink.append(html_elem, child);
-            }
-            Some((idx, last_table)) => {
-                // Try inserting "inside last table's parent node, immediately before last table"
-                match self.sink.append_before_sibling(last_table.clone(), child) {
-                    Ok(()) => (),
-
-                    // If last_table has no parent, we regain ownership of the child.
-                    // Insert "inside previous element, after its last child (if any)"
-                    Err(child) => {
-                        let previous_element = self.open_elems[idx-1].clone();
-                        self.sink.append(previous_element, child);
-                    }
-                }
-            }
-        }
+        let insertion_point = self.appropriate_place_for_insertion(override_target);
+        self.insert_at(insertion_point, child);
     }
 
     fn adoption_agency(&mut self, subject: Atom) {
@@ -755,10 +723,39 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
         // FIXME: application cache selection algorithm
     }
 
+    // https://html.spec.whatwg.org/multipage/syntax.html#create-an-element-for-the-token
     fn insert_element(&mut self, push: PushFlag, ns: Namespace, name: Atom, attrs: Vec<Attribute>)
             -> Handle {
-        let elem = self.sink.create_element(QualName::new(ns, name), attrs);
-        self.insert_appropriately(AppendNode(elem.clone()), None);
+        declare_tag_set!(form_associatable =
+            button fieldset input keygen label
+            object output select textarea img);
+
+        declare_tag_set!(reassociatable = form_associatable - img);
+
+        let qname = QualName::new(ns, name);
+        let elem = self.sink.create_element(qname.clone(), attrs.clone());
+
+        let insertion_point = self.appropriate_place_for_insertion(None);
+        let tree_node = match insertion_point {
+            LastChild(ref p) |
+            BeforeSibling(ref p) => p.clone()
+        };
+
+        // Step 4.
+        // TODO: Handle template element case
+        if form_associatable(qname.clone())
+           && self.form_elem.is_some()
+           && !(reassociatable(qname.clone())
+               && attrs.iter().any(|a| a.name == qualname!("","form"))) {
+
+               let form = self.form_elem.as_ref().unwrap().clone();
+               if self.sink.same_home_subtree(tree_node, form.clone()) {
+                   self.sink.associate_with_form(elem.clone(), form)
+               }
+        }
+
+        self.insert_at(insertion_point, AppendNode(elem.clone()));
+
         match push {
             Push => self.push(&elem),
             NoPush => (),

src/tree_builder/interface.rs

@@ -61,6 +61,10 @@ pub trait TreeSink {
     /// Do two handles refer to the same node?
     fn same_node(&self, x: Self::Handle, y: Self::Handle) -> bool;
 
+    /// Are two handles present in the same tree
+    /// https://html.spec.whatwg.org/multipage/infrastructure.html#home-subtree
+    fn same_home_subtree(&self, x: Self::Handle, y: Self::Handle) -> bool;
+
     /// What is the name of this element?
     ///
     /// Should never be called on a non-element node;
@@ -76,15 +80,18 @@ pub trait TreeSink {
     /// Create a comment node.
     fn create_comment(&mut self, text: String) -> Self::Handle;
 
+    /// Does the node have a parent?
+    fn has_parent_node(&self, node: Self::Handle) -> bool;
+
     /// Append a node as the last child of the given node.  If this would
     /// produce adjacent sibling text nodes, it should concatenate the text
     /// instead.
     ///
     /// The child node will not already have a parent.
     fn append(&mut self, parent: Self::Handle, child: NodeOrText<Self::Handle>);
 
-    /// Append a node as the sibling immediately before the given node.  If that node
-    /// has no parent, do nothing and return Err(new_node).
+    /// Append a node as the sibling immediately before the given node.
+    /// This method will only be called if has_parent_node(sibling) is true
     ///
     /// The tree builder promises that `sibling` is not a text node.  However its
     /// old previous sibling, which would become the new node's previous sibling,
@@ -94,7 +101,7 @@ pub trait TreeSink {
     /// NB: `new_node` may have an old parent, from which it should be removed.
     fn append_before_sibling(&mut self,
         sibling: Self::Handle,
-        new_node: NodeOrText<Self::Handle>) -> Result<(), NodeOrText<Self::Handle>>;
+        new_node: NodeOrText<Self::Handle>);
 
     /// Append a `DOCTYPE` element to the `Document` node.
     fn append_doctype_to_document(&mut self, name: String, public_id: String, system_id: String);
@@ -103,6 +110,9 @@ pub trait TreeSink {
     /// with that name already exists.
     fn add_attrs_if_missing(&mut self, target: Self::Handle, attrs: Vec<Attribute>);
 
+    /// Associate the given form-associatable element with the form element
+    fn associate_with_form(&mut self, target: Self::Handle, form: Self::Handle);
+
     /// Detach the given node from its parent.
     fn remove_from_parent(&mut self, target: Self::Handle);
 

src/tree_builder/mod.rs

@@ -364,6 +364,48 @@ impl<Handle, Sink> TreeBuilder<Handle, Sink>
     pub fn is_fragment(&self) -> bool {
         self.context_elem.is_some()
     }
+
+    fn appropriate_place_for_insertion(&self, override_target: Option<Handle>) -> InsertionPoint<Handle> {
+        use self::tag_sets::*;
+
+        declare_tag_set!(foster_target = table tbody tfoot thead tr);
+        let target = override_target.unwrap_or_else(|| self.current_node());
+        if !(self.foster_parenting && self.elem_in(target.clone(), foster_target)) {
+            // No foster parenting (the common case).
+            return LastChild(target)
+        }
+
+        // Foster parenting
+        // FIXME: <template>
+        let last_table = self.open_elems.iter()
+            .enumerate()
+            .rev()
+            .filter(|&(_, e)| self.html_elem_named(e.clone(), atom!(table)))
+            .next();
+
+        match last_table {
+            None => {
+                LastChild(self.html_elem())
+            }
+            Some((idx, last_table)) => {
+                // Try inserting "inside last table's parent node, immediately before last table"
+                if self.sink.has_parent_node(last_table.clone()) {
+                    BeforeSibling(last_table.clone())
+                } else {
+                    // Insert "inside previous element, after its last child (if any)"
+                    let previous_element = self.open_elems[idx-1].clone();
+                    LastChild(previous_element)
+                }
+            }
+        }
+    }
+
+    fn insert_at(&mut self, insertion_point: InsertionPoint<Handle>, child: NodeOrText<Handle>) {
+        match insertion_point {
+            LastChild(parent) => self.sink.append(parent, child),
+            BeforeSibling(sibling) => self.sink.append_before_sibling(sibling, child)
+        }
+    }
 }
 
 impl<Handle, Sink> TokenSink

src/tree_builder/types.rs

@@ -16,6 +16,7 @@ pub use self::SplitStatus::*;
 pub use self::Token::*;
 pub use self::ProcessResult::*;
 pub use self::FormatEntry::*;
+pub use self::InsertionPoint::*;
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
 pub enum InsertionMode {
@@ -74,3 +75,13 @@ pub enum FormatEntry<Handle> {
     Element(Handle, Tag),
     Marker,
 }
+
+pub enum InsertionPoint<Handle> {
+    /// Holds the parent
+    LastChild(Handle),
+    /// Holds the sibling before which the node will be inserted
+    /// TODO: Is the parent node needed? Is there a problem with using
+    /// the sibling to find if the form element is in the same home
+    /// subtree?
+    BeforeSibling(Handle)
+}