mathml_annotation_xml_integration_point at element creation time

SimonSapin · SimonSapin · commit 0a87717a3ca2 · 2017-05-02T18:25:42.000+02:00
The result shouldn’t change if the attributed is changed in the meantime.
diff --git a/html5ever/examples/noop-tree-builder.rs b/html5ever/examples/noop-tree-builder.rs
@@ -16,7 +16,7 @@ use std::borrow::Cow;
 
 use html5ever::{Attribute, QualName, ExpandedName};
 use html5ever::parse_document;
-use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText};
+use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, ElementFlags};
 use html5ever::tendril::*;
 
 struct Sink {
@@ -61,12 +61,7 @@ impl TreeSink for Sink {
         self.names.get(target).expect("not an element").expanded()
     }
 
-    fn elem_any_attr<P>(&self, _target: &usize, _predicate: P) -> bool
-    where P: FnMut(ExpandedName, &str) -> bool {
-        false
-    }
-
-    fn create_element(&mut self, name: QualName, _attrs: Vec<Attribute>) -> usize {
+    fn create_element(&mut self, name: QualName, _: Vec<Attribute>, _: ElementFlags) -> usize {
         let id = self.get_id();
         self.names.insert(id, name);
         id
diff --git a/html5ever/examples/print-tree-actions.rs b/html5ever/examples/print-tree-actions.rs
@@ -15,7 +15,7 @@ use std::collections::HashMap;
 use std::borrow::Cow;
 
 use html5ever::{QualName, ExpandedName, Attribute};
-use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText};
+use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText, ElementFlags};
 use html5ever::parse_document;
 use html5ever::tendril::*;
 
@@ -65,12 +65,7 @@ impl TreeSink for Sink {
         self.names.get(target).expect("not an element").expanded()
     }
 
-    fn elem_any_attr<P>(&self, _target: &usize, _predicate: P) -> bool
-    where P: FnMut(ExpandedName, &str) -> bool {
-        false
-    }
-
-    fn create_element(&mut self, name: QualName, _attrs: Vec<Attribute>) -> usize {
+    fn create_element(&mut self, name: QualName, _: Vec<Attribute>, _: ElementFlags) -> usize {
         let id = self.get_id();
         println!("Created {:?} as {}", name, id);
         self.names.insert(id, name);
diff --git a/html5ever/src/driver.rs b/html5ever/src/driver.rs
@@ -12,7 +12,7 @@
 use {Attribute, QualName};
 use buffer_queue::BufferQueue;
 use tokenizer::{Tokenizer, TokenizerOpts, TokenizerResult};
-use tree_builder::{TreeBuilderOpts, TreeBuilder, TreeSink};
+use tree_builder::{TreeBuilderOpts, TreeBuilder, TreeSink, create_element};
 
 use std::borrow::Cow;
 use std::mem;
@@ -56,7 +56,7 @@ pub fn parse_fragment<Sink>(mut sink: Sink, opts: ParseOpts,
                             context_name: QualName, context_attrs: Vec<Attribute>)
                             -> Parser<Sink>
                             where Sink: TreeSink {
-    let context_elem = sink.create_element(context_name, context_attrs);
+    let context_elem = create_element(&mut sink, context_name, context_attrs);
     parse_fragment_for_element(sink, opts, context_elem, None)
 }
 
diff --git a/html5ever/src/tree_builder/actions.rs b/html5ever/src/tree_builder/actions.rs
@@ -13,7 +13,7 @@
 //! mode appropriately".
 
 use {LocalName, Namespace, QualName, ExpandedName};
-use interface::{Attribute, TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText};
+use interface::{Attribute, TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText, create_element};
 use tendril::StrTendril;
 use tokenizer::{Tag, StartTag, EndTag};
 use tokenizer::states::{RawData, RawKind};
@@ -358,8 +358,8 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
                 };
                 // FIXME: Is there a way to avoid cloning the attributes twice here (once on their
                 // own, once as part of t.clone() above)?
-                let new_element = self.sink.create_element(
-                    QualName::new(None, ns!(html), tag.name.clone()),
+                let new_element = create_element(
+                    &mut self.sink, QualName::new(None, ns!(html), tag.name.clone()),
                     tag.attrs.clone());
                 self.open_elems[node_index] = new_element.clone();
                 self.active_formatting[node_formatting_index] = Element(new_element.clone(), tag);
@@ -387,8 +387,8 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
             // 15.
             // FIXME: Is there a way to avoid cloning the attributes twice here (once on their own,
             // once as part of t.clone() above)?
-            let new_element = self.sink.create_element(
-                QualName::new(None, ns!(html), fmt_elem_tag.name.clone()),
+            let new_element = create_element(
+                &mut self.sink, QualName::new(None, ns!(html), fmt_elem_tag.name.clone()),
                 fmt_elem_tag.attrs.clone());
             let new_entry = Element(new_element.clone(), fmt_elem_tag);
 
@@ -772,8 +772,8 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
 
     //§ creating-and-inserting-nodes
     fn create_root(&mut self, attrs: Vec<Attribute>) {
-        let elem = self.sink.create_element(
-            QualName::new(None, ns!(html), local_name!("html")),
+        let elem = create_element(
+            &mut self.sink, QualName::new(None, ns!(html), local_name!("html")),
             attrs);
         self.push(&elem);
         self.sink.append(&self.doc_handle, AppendNode(elem));
@@ -791,7 +791,7 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
 
         // Step 7.
         let qname = QualName::new(None, ns, name);
-        let elem = self.sink.create_element(qname.clone(), attrs.clone());
+        let elem = create_element(&mut self.sink, qname.clone(), attrs.clone());
 
         let insertion_point = self.appropriate_place_for_insertion(None);
         let tree_node = match insertion_point {
@@ -953,16 +953,8 @@ impl<Handle, Sink> TreeBuilderActions<Handle>
                 TagToken(Tag { kind: StartTag, name: local_name!("svg"), .. }) => return false,
                 CharacterTokens(..) | NullCharacterToken |
                 TagToken(Tag { kind: StartTag, .. }) => {
-                    let integration_point = self.sink.elem_any_attr(
-                        self.adjusted_current_node(),
-                        |attr_name, attr_value| {
-                            attr_name == expanded_name!("", "encoding") && (
-                                attr_value.eq_ignore_ascii_case("text/html") ||
-                                attr_value.eq_ignore_ascii_case("application/xhtml+xml")
-                            )
-                        }
-                    );
-                    return !integration_point
+                    return !self.sink.is_mathml_annotation_xml_integration_point(
+                        self.adjusted_current_node())
                 }
                 _ => {}
             };
diff --git a/html5ever/src/tree_builder/mod.rs b/html5ever/src/tree_builder/mod.rs
@@ -13,7 +13,7 @@
 
 pub use interface::{QuirksMode, Quirks, LimitedQuirks, NoQuirks};
 pub use interface::{NodeOrText, AppendNode, AppendText};
-pub use interface::{TreeSink, Tracer, NextParserState};
+pub use interface::{TreeSink, Tracer, NextParserState, create_element, ElementFlags};
 
 use self::types::*;
 use self::actions::TreeBuilderActions;
@@ -503,7 +503,7 @@ impl<Handle, Sink> TokenSink
 mod test {
     use markup5ever::interface::{QuirksMode, Quirks, LimitedQuirks, NoQuirks};
     use markup5ever::interface::{NodeOrText, AppendNode, AppendText};
-    use markup5ever::interface::{TreeSink, Tracer};
+    use markup5ever::interface::{TreeSink, Tracer, ElementFlags};
 
     use super::types::*;
     use super::actions::TreeBuilderActions;
@@ -569,14 +569,10 @@ mod test {
             self.rcdom.elem_name(target)
         }
 
-        fn elem_any_attr<P>(&self, target: &Self::Handle, predicate: P) -> bool
-        where P: FnMut(ExpandedName, &str) -> bool {
-            self.rcdom.elem_any_attr(target, predicate)
-        }
-
-        fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>) -> Handle {
+        fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>, flags: ElementFlags)
+                          -> Handle {
             self.line_vec.push((name.clone(), self.current_line));
-            self.rcdom.create_element(name, attrs)
+            self.rcdom.create_element(name, attrs, flags)
         }
 
         fn create_comment(&mut self, text: StrTendril) -> Handle {
diff --git a/html5ever/src/tree_builder/rules.rs b/html5ever/src/tree_builder/rules.rs
@@ -10,7 +10,7 @@
 // The tree builder rules, as a single, enormous nested match expression.
 
 use {ExpandedName, QualName};
-use interface::{Attribute, TreeSink, Quirks, AppendNode};
+use interface::{Attribute, TreeSink, Quirks, AppendNode, create_element};
 use tree_builder::types::*;
 use tree_builder::tag_sets::*;
 use tree_builder::actions::{NoPush, Push, TreeBuilderActions, html_elem};
@@ -139,8 +139,8 @@ impl<Handle, Sink> TreeBuilderStep<Handle>
                 }
 
                 tag @ <script> => {
-                    let elem = self.sink.create_element(
-                        QualName::new(None, ns!(html), local_name!("script")),
+                    let elem = create_element(
+                        &mut self.sink, QualName::new(None, ns!(html), local_name!("script")),
                         tag.attrs);
                     if self.is_fragment() {
                         self.sink.mark_script_already_started(&elem);
diff --git a/markup5ever/interface/mod.rs b/markup5ever/interface/mod.rs
@@ -10,10 +10,8 @@
 use std::fmt;
 use tendril::StrTendril;
 
-pub mod tree_builder;
-
 use super::{LocalName, Prefix, Namespace};
-pub use self::tree_builder::{NodeOrText, AppendNode, AppendText};
+pub use self::tree_builder::{NodeOrText, AppendNode, AppendText, create_element, ElementFlags};
 pub use self::tree_builder::{QuirksMode, Quirks, LimitedQuirks, NoQuirks};
 pub use self::tree_builder::{TreeSink, Tracer, NextParserState};
 
@@ -56,6 +54,8 @@ macro_rules! expanded_name {
     }
 }
 
+pub mod tree_builder;
+
 /// A name with a namespace.
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone)]
 #[cfg_attr(feature = "heap_size", derive(HeapSizeOf))]
diff --git a/markup5ever/interface/tree_builder.rs b/markup5ever/interface/tree_builder.rs
@@ -11,6 +11,8 @@
 ///
 /// Adjacent sibling text nodes are merged into a single node, so
 /// the sink may not want to allocate a `Handle` for each.
+
+use std::ascii::AsciiExt;
 use std::borrow::Cow;
 use tendril::StrTendril;
 use interface::{QualName, ExpandedName, Attribute};
@@ -47,6 +49,42 @@ pub enum NextParserState {
     Continue,
 }
 
+#[derive(Default)]
+pub struct ElementFlags {
+    /// A document fragment should be created, associated with the element,
+    /// and returned in TreeSink::get_template_contents
+    ///
+    /// https://html.spec.whatwg.org/multipage/#template-contents
+    pub template: bool,
+
+    /// This boolean should be recorded with the element and returned
+    /// in TreeSink::is_mathml_annotation_xml_integration_point
+    ///
+    /// https://html.spec.whatwg.org/multipage/#html-integration-point
+    pub mathml_annotation_xml_integration_point: bool,
+
+    _private: ()
+}
+
+pub fn create_element<Sink>(sink: &mut Sink, name: QualName, attrs: Vec<Attribute>) -> Sink::Handle
+where Sink: TreeSink {
+    let mut flags = ElementFlags::default();
+    match name.expanded() {
+        expanded_name!(html "template") => {
+            flags.template = true
+        }
+        expanded_name!(mathml "annotation-xml") => {
+            flags.mathml_annotation_xml_integration_point = attrs.iter().any(|attr| {
+                attr.name.expanded() == expanded_name!("", "encoding") && (
+                    attr.value.eq_ignore_ascii_case("text/html") ||
+                    attr.value.eq_ignore_ascii_case("application/xhtml+xml")
+                )
+            })
+        }
+        _ => {}
+    }
+    sink.create_element(name, attrs, flags)
+}
 
 pub trait TreeSink {
     /// `Handle` is a reference to a DOM node.  The tree builder requires
@@ -79,21 +117,15 @@ pub trait TreeSink {
     /// feel free to `panic!`.
     fn elem_name<'a>(&'a self, target: &'a Self::Handle) -> ExpandedName<'a>;
 
-    /// Does this element have an attribute matching the given predicate?
-    ///
-    /// Should never be called on a non-element node;
-    /// feel free to `panic!`.
-    fn elem_any_attr<P>(&self, target: &Self::Handle, predicate: P) -> bool
-    where P: FnMut(ExpandedName, &str) -> bool;
-
     /// Create an element.
     ///
     /// When creating a template element (`name.ns.expanded() == expanded_name!(html "template")`),
     /// an associated document fragment called the "template contents" should
     /// also be created. Later calls to self.get_template_contents() with that
     /// given element return it.
     /// https://html.spec.whatwg.org/multipage/#htmltemplateelement
-    fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>) -> Self::Handle;
+    fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>, flags: ElementFlags)
+                      -> Self::Handle;
 
     /// Create a comment node.
     fn create_comment(&mut self, text: StrTendril) -> Self::Handle;
@@ -164,6 +196,12 @@ pub trait TreeSink {
     /// Remove all the children from node and append them to new_parent.
     fn reparent_children(&mut self, node: &Self::Handle, new_parent: &Self::Handle);
 
+    /// Returns true if the adjusted current node is an HTML integration point
+    /// and the token is a start tag.
+    fn is_mathml_annotation_xml_integration_point(&self, _handle: &Self::Handle) -> bool {
+        false
+    }
+
     /// Called whenever the line number changes.
     fn set_current_line(&mut self, _line_number: u64) {}
 
diff --git a/markup5ever/rcdom.rs b/markup5ever/rcdom.rs
diff --git a/xml5ever/src/tree_builder/actions.rs b/xml5ever/src/tree_builder/actions.rs
