Format script component

1 files changed, 269 insertions, 128 deletions

diff --git a/components/script/dom/servoparser/async_html.rs b/components/script/dom/servoparser/async_html.rs
index 5fe911deb0b..051ea86cfb0 100644
--- a/components/script/dom/servoparser/async_html.rs
+++ b/components/script/dom/servoparser/async_html.rs
@@ -58,49 +58,77 @@ struct Attribute {
 
 #[derive(JSTraceable, MallocSizeOf)]
 enum ParseOperation {
-    GetTemplateContents { target: ParseNodeId, contents: ParseNodeId },
+    GetTemplateContents {
+        target: ParseNodeId,
+        contents: ParseNodeId,
+    },
 
     CreateElement {
         node: ParseNodeId,
         name: QualName,
         attrs: Vec<Attribute>,
-        current_line: u64
+        current_line: u64,
     },
 
-    CreateComment { text: String, node: ParseNodeId },
-    AppendBeforeSibling { sibling: ParseNodeId, node: NodeOrText },
-    AppendBasedOnParentNode { element: ParseNodeId, prev_element: ParseNodeId, node: NodeOrText },
-    Append { parent: ParseNodeId, node: NodeOrText },
+    CreateComment {
+        text: String,
+        node: ParseNodeId,
+    },
+    AppendBeforeSibling {
+        sibling: ParseNodeId,
+        node: NodeOrText,
+    },
+    AppendBasedOnParentNode {
+        element: ParseNodeId,
+        prev_element: ParseNodeId,
+        node: NodeOrText,
+    },
+    Append {
+        parent: ParseNodeId,
+        node: NodeOrText,
+    },
 
     AppendDoctypeToDocument {
         name: String,
         public_id: String,
-        system_id: String
+        system_id: String,
     },
 
-    AddAttrsIfMissing { target: ParseNodeId, attrs: Vec<Attribute> },
-    RemoveFromParent { target: ParseNodeId },
-    MarkScriptAlreadyStarted { node: ParseNodeId },
-    ReparentChildren { parent: ParseNodeId, new_parent: ParseNodeId },
+    AddAttrsIfMissing {
+        target: ParseNodeId,
+        attrs: Vec<Attribute>,
+    },
+    RemoveFromParent {
+        target: ParseNodeId,
+    },
+    MarkScriptAlreadyStarted {
+        node: ParseNodeId,
+    },
+    ReparentChildren {
+        parent: ParseNodeId,
+        new_parent: ParseNodeId,
+    },
 
     AssociateWithForm {
         target: ParseNodeId,
         form: ParseNodeId,
         element: ParseNodeId,
-        prev_element: Option<ParseNodeId>
+        prev_element: Option<ParseNodeId>,
     },
 
     CreatePI {
         node: ParseNodeId,
         target: String,
-        data: String
+        data: String,
     },
 
-    Pop { node: ParseNodeId },
+    Pop {
+        node: ParseNodeId,
+    },
 
     SetQuirksMode {
         #[ignore_malloc_size_of = "Defined in style"]
-        mode: ServoQuirksMode
+        mode: ServoQuirksMode,
     },
 }
 
@@ -109,12 +137,12 @@ enum ToTokenizerMsg {
     // From HtmlTokenizer
     TokenizerResultDone {
         #[ignore_malloc_size_of = "Defined in html5ever"]
-        updated_input: VecDeque<SendTendril<UTF8>>
+        updated_input: VecDeque<SendTendril<UTF8>>,
     },
     TokenizerResultScript {
         script: ParseNode,
         #[ignore_malloc_size_of = "Defined in html5ever"]
-        updated_input: VecDeque<SendTendril<UTF8>>
+        updated_input: VecDeque<SendTendril<UTF8>>,
     },
     End, // Sent to Tokenizer to signify HtmlTokenizer's end method has returned
 
@@ -126,7 +154,7 @@ enum ToTokenizerMsg {
 enum ToHtmlTokenizerMsg {
     Feed {
         #[ignore_malloc_size_of = "Defined in html5ever"]
-        input: VecDeque<SendTendril<UTF8>>
+        input: VecDeque<SendTendril<UTF8>>,
     },
     End,
     SetPlainTextState,
@@ -180,10 +208,10 @@ pub struct Tokenizer {
 
 impl Tokenizer {
     pub fn new(
-            document: &Document,
-            url: ServoUrl,
-            fragment_context: Option<super::FragmentContext>)
-            -> Self {
+        document: &Document,
+        url: ServoUrl,
+        fragment_context: Option<super::FragmentContext>,
+    ) -> Self {
         // Messages from the Tokenizer (main thread) to HtmlTokenizer (parser thread)
         let (to_html_tokenizer_sender, html_tokenizer_receiver) = channel();
         // Messages from HtmlTokenizer and Sink (parser thread) to Tokenizer (main thread)
@@ -194,7 +222,7 @@ impl Tokenizer {
             receiver: tokenizer_receiver,
             html_tokenizer_sender: to_html_tokenizer_sender,
             nodes: HashMap::new(),
-            url: url
+            url: url,
         };
         tokenizer.insert_node(0, Dom::from_ref(document.upcast()));
 
@@ -218,14 +246,18 @@ impl Tokenizer {
         // Create new thread for HtmlTokenizer. This is where parser actions
         // will be generated from the input provided. These parser actions are then passed
         // onto the main thread to be executed.
-        thread::Builder::new().name(String::from("HTML Parser")).spawn(move || {
-            run(sink,
-                fragment_context_is_some,
-                ctxt_parse_node,
-                form_parse_node,
-                to_tokenizer_sender,
-                html_tokenizer_receiver);
-        }).expect("HTML Parser thread spawning failed");
+        thread::Builder::new()
+            .name(String::from("HTML Parser"))
+            .spawn(move || {
+                run(
+                    sink,
+                    fragment_context_is_some,
+                    ctxt_parse_node,
+                    form_parse_node,
+                    to_tokenizer_sender,
+                    html_tokenizer_receiver,
+                );
+            }).expect("HTML Parser thread spawning failed");
 
         tokenizer
     }
@@ -238,31 +270,47 @@ impl Tokenizer {
 
         // Send message to parser thread, asking it to start reading from the input.
         // Parser operation messages will be sent to main thread as they are evaluated.
-        self.html_tokenizer_sender.send(ToHtmlTokenizerMsg::Feed { input: send_tendrils }).unwrap();
+        self.html_tokenizer_sender
+            .send(ToHtmlTokenizerMsg::Feed {
+                input: send_tendrils,
+            }).unwrap();
 
         loop {
-            match self.receiver.recv().expect("Unexpected channel panic in main thread.") {
+            match self
+                .receiver
+                .recv()
+                .expect("Unexpected channel panic in main thread.")
+            {
                 ToTokenizerMsg::ProcessOperation(parse_op) => self.process_operation(parse_op),
                 ToTokenizerMsg::TokenizerResultDone { updated_input } => {
                     let buffer_queue = create_buffer_queue(updated_input);
                     *input = buffer_queue;
                     return Ok(());
                 },
-                ToTokenizerMsg::TokenizerResultScript { script, updated_input } => {
+                ToTokenizerMsg::TokenizerResultScript {
+                    script,
+                    updated_input,
+                } => {
                     let buffer_queue = create_buffer_queue(updated_input);
                     *input = buffer_queue;
                     let script = self.get_node(&script.id);
                     return Err(DomRoot::from_ref(script.downcast().unwrap()));
-                }
+                },
                 ToTokenizerMsg::End => unreachable!(),
             };
         }
     }
 
     pub fn end(&mut self) {
-        self.html_tokenizer_sender.send(ToHtmlTokenizerMsg::End).unwrap();
+        self.html_tokenizer_sender
+            .send(ToHtmlTokenizerMsg::End)
+            .unwrap();
         loop {
-            match self.receiver.recv().expect("Unexpected channel panic in main thread.") {
+            match self
+                .receiver
+                .recv()
+                .expect("Unexpected channel panic in main thread.")
+            {
                 ToTokenizerMsg::ProcessOperation(parse_op) => self.process_operation(parse_op),
                 ToTokenizerMsg::End => return,
                 _ => unreachable!(),
@@ -275,7 +323,9 @@ impl Tokenizer {
     }
 
     pub fn set_plaintext_state(&mut self) {
-        self.html_tokenizer_sender.send(ToHtmlTokenizerMsg::SetPlainTextState).unwrap();
+        self.html_tokenizer_sender
+            .send(ToHtmlTokenizerMsg::SetPlainTextState)
+            .unwrap();
     }
 
     fn insert_node(&mut self, id: ParseNodeId, node: Dom<Node>) {
@@ -286,26 +336,27 @@ impl Tokenizer {
         self.nodes.get(id).expect("Node not found!")
     }
 
-
     fn append_before_sibling(&mut self, sibling: ParseNodeId, node: NodeOrText) {
         let node = match node {
-            NodeOrText::Node(n) => HtmlNodeOrText::AppendNode(Dom::from_ref(&**self.get_node(&n.id))),
-            NodeOrText::Text(text) => HtmlNodeOrText::AppendText(
-                Tendril::from(text)
-            )
+            NodeOrText::Node(n) => {
+                HtmlNodeOrText::AppendNode(Dom::from_ref(&**self.get_node(&n.id)))
+            },
+            NodeOrText::Text(text) => HtmlNodeOrText::AppendText(Tendril::from(text)),
         };
         let sibling = &**self.get_node(&sibling);
-        let parent = &*sibling.GetParentNode().expect("append_before_sibling called on node without parent");
+        let parent = &*sibling
+            .GetParentNode()
+            .expect("append_before_sibling called on node without parent");
 
         super::insert(parent, Some(sibling), node);
     }
 
     fn append(&mut self, parent: ParseNodeId, node: NodeOrText) {
         let node = match node {
-            NodeOrText::Node(n) => HtmlNodeOrText::AppendNode(Dom::from_ref(&**self.get_node(&n.id))),
-            NodeOrText::Text(text) => HtmlNodeOrText::AppendText(
-                Tendril::from(text)
-            )
+            NodeOrText::Node(n) => {
+                HtmlNodeOrText::AppendNode(Dom::from_ref(&**self.get_node(&n.id)))
+            },
+            NodeOrText::Text(text) => HtmlNodeOrText::AppendText(Tendril::from(text)),
         };
 
         let parent = &**self.get_node(&parent);
@@ -327,15 +378,23 @@ impl Tokenizer {
 
     fn process_operation(&mut self, op: ParseOperation) {
         let document = DomRoot::from_ref(&**self.get_node(&0));
-        let document = document.downcast::<Document>().expect("Document node should be downcasted!");
+        let document = document
+            .downcast::<Document>()
+            .expect("Document node should be downcasted!");
         match op {
             ParseOperation::GetTemplateContents { target, contents } => {
                 let target = DomRoot::from_ref(&**self.get_node(&target));
-                let template = target.downcast::<HTMLTemplateElement>().expect(
-                    "Tried to extract contents from non-template element while parsing");
+                let template = target
+                    .downcast::<HTMLTemplateElement>()
+                    .expect("Tried to extract contents from non-template element while parsing");
                 self.insert_node(contents, Dom::from_ref(template.Content().upcast()));
-            }
-            ParseOperation::CreateElement { node, name, attrs, current_line } => {
+            },
+            ParseOperation::CreateElement {
+                node,
+                name,
+                attrs,
+                current_line,
+            } => {
                 let attrs = attrs
                     .into_iter()
                     .map(|attr| ElementAttribute::new(attr.name, DOMString::from(attr.value)))
@@ -345,60 +404,85 @@ impl Tokenizer {
                     attrs,
                     &*self.document,
                     ElementCreator::ParserCreated(current_line),
-                    ParsingAlgorithm::Normal
+                    ParsingAlgorithm::Normal,
                 );
                 self.insert_node(node, Dom::from_ref(element.upcast()));
-            }
+            },
             ParseOperation::CreateComment { text, node } => {
                 let comment = Comment::new(DOMString::from(text), document);
                 self.insert_node(node, Dom::from_ref(&comment.upcast()));
-            }
+            },
             ParseOperation::AppendBeforeSibling { sibling, node } => {
                 self.append_before_sibling(sibling, node);
-            }
+            },
             ParseOperation::Append { parent, node } => {
                 self.append(parent, node);
-            }
-            ParseOperation::AppendBasedOnParentNode { element, prev_element, node } => {
+            },
+            ParseOperation::AppendBasedOnParentNode {
+                element,
+                prev_element,
+                node,
+            } => {
                 if self.has_parent_node(element) {
                     self.append_before_sibling(element, node);
                 } else {
                     self.append(prev_element, node);
                 }
-            }
-            ParseOperation::AppendDoctypeToDocument { name, public_id, system_id } => {
+            },
+            ParseOperation::AppendDoctypeToDocument {
+                name,
+                public_id,
+                system_id,
+            } => {
                 let doctype = DocumentType::new(
-                    DOMString::from(String::from(name)), Some(DOMString::from(public_id)),
-                    Some(DOMString::from(system_id)), document);
+                    DOMString::from(String::from(name)),
+                    Some(DOMString::from(public_id)),
+                    Some(DOMString::from(system_id)),
+                    document,
+                );
 
-                document.upcast::<Node>().AppendChild(doctype.upcast()).expect("Appending failed");
-            }
+                document
+                    .upcast::<Node>()
+                    .AppendChild(doctype.upcast())
+                    .expect("Appending failed");
+            },
             ParseOperation::AddAttrsIfMissing { target, attrs } => {
-                let elem = self.get_node(&target).downcast::<Element>()
+                let elem = self
+                    .get_node(&target)
+                    .downcast::<Element>()
                     .expect("tried to set attrs on non-Element in HTML parsing");
                 for attr in attrs {
                     elem.set_attribute_from_parser(attr.name, DOMString::from(attr.value), None);
                 }
-            }
+            },
             ParseOperation::RemoveFromParent { target } => {
                 if let Some(ref parent) = self.get_node(&target).GetParentNode() {
                     parent.RemoveChild(&**self.get_node(&target)).unwrap();
                 }
-            }
+            },
             ParseOperation::MarkScriptAlreadyStarted { node } => {
                 let script = self.get_node(&node).downcast::<HTMLScriptElement>();
                 script.map(|script| script.set_already_started(true));
-            }
+            },
             ParseOperation::ReparentChildren { parent, new_parent } => {
                 let parent = self.get_node(&parent);
                 let new_parent = self.get_node(&new_parent);
                 while let Some(child) = parent.GetFirstChild() {
                     new_parent.AppendChild(&child).unwrap();
                 }
-            }
-            ParseOperation::AssociateWithForm { target, form, element, prev_element } => {
+            },
+            ParseOperation::AssociateWithForm {
+                target,
+                form,
+                element,
+                prev_element,
+            } => {
                 let tree_node = prev_element.map_or(element, |prev| {
-                    if self.has_parent_node(element) { element } else { prev }
+                    if self.has_parent_node(element) {
+                        element
+                    } else {
+                        prev
+                    }
                 });
 
                 if !self.same_tree(tree_node, form) {
@@ -416,47 +500,51 @@ impl Tokenizer {
                     control.set_form_owner_from_parser(&form);
                 } else {
                     // TODO remove this code when keygen is implemented.
-                    assert_eq!(node.NodeName(), "KEYGEN", "Unknown form-associatable element");
+                    assert_eq!(
+                        node.NodeName(),
+                        "KEYGEN",
+                        "Unknown form-associatable element"
+                    );
                 }
-            }
+            },
             ParseOperation::Pop { node } => {
                 vtable_for(self.get_node(&node)).pop();
-            }
+            },
             ParseOperation::CreatePI { node, target, data } => {
                 let pi = ProcessingInstruction::new(
                     DOMString::from(target),
                     DOMString::from(data),
-                    document);
+                    document,
+                );
                 self.insert_node(node, Dom::from_ref(pi.upcast()));
-            }
+            },
             ParseOperation::SetQuirksMode { mode } => {
                 document.set_quirks_mode(mode);
-            }
+            },
         }
     }
 }
 
-fn run(sink: Sink,
-       fragment_context_is_some: bool,
-       ctxt_parse_node: Option<ParseNode>,
-       form_parse_node: Option<ParseNode>,
-       sender: Sender<ToTokenizerMsg>,
-       receiver: Receiver<ToHtmlTokenizerMsg>) {
+fn run(
+    sink: Sink,
+    fragment_context_is_some: bool,
+    ctxt_parse_node: Option<ParseNode>,
+    form_parse_node: Option<ParseNode>,
+    sender: Sender<ToTokenizerMsg>,
+    receiver: Receiver<ToHtmlTokenizerMsg>,
+) {
     let options = TreeBuilderOpts {
         ignore_missing_rules: true,
-        .. Default::default()
+        ..Default::default()
     };
 
     let mut html_tokenizer = if fragment_context_is_some {
-        let tb = TreeBuilder::new_for_fragment(
-            sink,
-            ctxt_parse_node.unwrap(),
-            form_parse_node,
-            options);
+        let tb =
+            TreeBuilder::new_for_fragment(sink, ctxt_parse_node.unwrap(), form_parse_node, options);
 
         let tok_options = TokenizerOpts {
             initial_state: Some(tb.tokenizer_state_for_context_elem()),
-            .. Default::default()
+            ..Default::default()
         };
 
         HtmlTokenizer::new(tb, tok_options)
@@ -465,7 +553,10 @@ fn run(sink: Sink,
     };
 
     loop {
-        match receiver.recv().expect("Unexpected channel panic in html parser thread") {
+        match receiver
+            .recv()
+            .expect("Unexpected channel panic in html parser thread")
+        {
             ToHtmlTokenizerMsg::Feed { input } => {
                 let mut input = create_buffer_queue(input);
                 let res = html_tokenizer.feed(&mut input);
@@ -479,7 +570,10 @@ fn run(sink: Sink,
 
                 let res = match res {
                     TokenizerResult::Done => ToTokenizerMsg::TokenizerResultDone { updated_input },
-                    TokenizerResult::Script(script) => ToTokenizerMsg::TokenizerResultScript { script, updated_input }
+                    TokenizerResult::Script(script) => ToTokenizerMsg::TokenizerResultScript {
+                        script,
+                        updated_input,
+                    },
                 };
                 sender.send(res).unwrap();
             },
@@ -488,7 +582,7 @@ fn run(sink: Sink,
                 sender.send(ToTokenizerMsg::End).unwrap();
                 break;
             },
-            ToHtmlTokenizerMsg::SetPlainTextState => html_tokenizer.set_plaintext_state()
+            ToHtmlTokenizerMsg::SetPlainTextState => html_tokenizer.set_plaintext_state(),
         };
     }
 }
@@ -517,7 +611,7 @@ impl Sink {
                 id: 0,
                 qual_name: None,
             },
-            sender: sender
+            sender: sender,
         };
         let data = ParseNodeData::default();
         sink.insert_parse_node_data(0, data);
@@ -536,7 +630,9 @@ impl Sink {
     }
 
     fn send_op(&self, op: ParseOperation) {
-        self.sender.send(ToTokenizerMsg::ProcessOperation(op)).unwrap();
+        self.sender
+            .send(ToTokenizerMsg::ProcessOperation(op))
+            .unwrap();
     }
 
     fn insert_parse_node_data(&mut self, id: ParseNodeId, data: ParseNodeData) {
@@ -544,18 +640,24 @@ impl Sink {
     }
 
     fn get_parse_node_data<'a>(&'a self, id: &'a ParseNodeId) -> &'a ParseNodeData {
-        self.parse_node_data.get(id).expect("Parse Node data not found!")
+        self.parse_node_data
+            .get(id)
+            .expect("Parse Node data not found!")
     }
 
     fn get_parse_node_data_mut<'a>(&'a mut self, id: &'a ParseNodeId) -> &'a mut ParseNodeData {
-        self.parse_node_data.get_mut(id).expect("Parse Node data not found!")
+        self.parse_node_data
+            .get_mut(id)
+            .expect("Parse Node data not found!")
     }
 }
 
 #[allow(unrooted_must_root)]
 impl TreeSink for Sink {
     type Output = Self;
-    fn finish(self) -> Self { self }
+    fn finish(self) -> Self {
+        self
+    }
 
     type Handle = ParseNode;
 
@@ -572,7 +674,10 @@ impl TreeSink for Sink {
             let data = self.get_parse_node_data_mut(&target.id);
             data.contents = Some(node.clone());
         }
-        self.send_op(ParseOperation::GetTemplateContents { target: target.id, contents: node.id });
+        self.send_op(ParseOperation::GetTemplateContents {
+            target: target.id,
+            contents: node.id,
+        });
         node
     }
 
@@ -581,38 +686,52 @@ impl TreeSink for Sink {
     }
 
     fn elem_name<'a>(&self, target: &'a Self::Handle) -> ExpandedName<'a> {
-        target.qual_name.as_ref().expect("Expected qual name of node!").expanded()
+        target
+            .qual_name
+            .as_ref()
+            .expect("Expected qual name of node!")
+            .expanded()
     }
 
-    fn create_element(&mut self, name: QualName, html_attrs: Vec<HtmlAttribute>, _flags: ElementFlags)
-        -> Self::Handle {
+    fn create_element(
+        &mut self,
+        name: QualName,
+        html_attrs: Vec<HtmlAttribute>,
+        _flags: ElementFlags,
+    ) -> Self::Handle {
         let mut node = self.new_parse_node();
         node.qual_name = Some(name.clone());
         {
             let node_data = self.get_parse_node_data_mut(&node.id);
-            node_data.is_integration_point = html_attrs.iter()
-            .any(|attr| {
+            node_data.is_integration_point = html_attrs.iter().any(|attr| {
                 let attr_value = &String::from(attr.value.clone());
                 (attr.name.local == local_name!("encoding") && attr.name.ns == ns!()) &&
-                (attr_value.eq_ignore_ascii_case("text/html") ||
-                attr_value.eq_ignore_ascii_case("application/xhtml+xml"))
+                    (attr_value.eq_ignore_ascii_case("text/html") ||
+                        attr_value.eq_ignore_ascii_case("application/xhtml+xml"))
             });
         }
-        let attrs = html_attrs.into_iter()
-            .map(|attr| Attribute { name: attr.name, value: String::from(attr.value) }).collect();
+        let attrs = html_attrs
+            .into_iter()
+            .map(|attr| Attribute {
+                name: attr.name,
+                value: String::from(attr.value),
+            }).collect();
 
         self.send_op(ParseOperation::CreateElement {
             node: node.id,
             name,
             attrs,
-            current_line: self.current_line
+            current_line: self.current_line,
         });
         node
     }
 
     fn create_comment(&mut self, text: StrTendril) -> Self::Handle {
         let node = self.new_parse_node();
-        self.send_op(ParseOperation::CreateComment { text: String::from(text), node: node.id });
+        self.send_op(ParseOperation::CreateComment {
+            text: String::from(text),
+            node: node.id,
+        });
         node
     }
 
@@ -621,7 +740,7 @@ impl TreeSink for Sink {
         self.send_op(ParseOperation::CreatePI {
             node: node.id,
             target: String::from(target),
-            data: String::from(data)
+            data: String::from(data),
         });
         node
     }
@@ -641,14 +760,19 @@ impl TreeSink for Sink {
         });
     }
 
-    fn append_before_sibling(&mut self,
-                             sibling: &Self::Handle,
-                             new_node: HtmlNodeOrText<Self::Handle>) {
+    fn append_before_sibling(
+        &mut self,
+        sibling: &Self::Handle,
+        new_node: HtmlNodeOrText<Self::Handle>,
+    ) {
         let new_node = match new_node {
             HtmlNodeOrText::AppendNode(node) => NodeOrText::Node(node),
-            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text))
+            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text)),
         };
-        self.send_op(ParseOperation::AppendBeforeSibling { sibling: sibling.id, node: new_node });
+        self.send_op(ParseOperation::AppendBeforeSibling {
+            sibling: sibling.id,
+            node: new_node,
+        });
     }
 
     fn append_based_on_parent_node(
@@ -659,12 +783,12 @@ impl TreeSink for Sink {
     ) {
         let child = match child {
             HtmlNodeOrText::AppendNode(node) => NodeOrText::Node(node),
-            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text))
+            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text)),
         };
         self.send_op(ParseOperation::AppendBasedOnParentNode {
             element: elem.id,
             prev_element: prev_elem.id,
-            node: child
+            node: child,
         });
     }
 
@@ -684,24 +808,38 @@ impl TreeSink for Sink {
     fn append(&mut self, parent: &Self::Handle, child: HtmlNodeOrText<Self::Handle>) {
         let child = match child {
             HtmlNodeOrText::AppendNode(node) => NodeOrText::Node(node),
-            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text))
+            HtmlNodeOrText::AppendText(text) => NodeOrText::Text(String::from(text)),
         };
-        self.send_op(ParseOperation::Append { parent: parent.id, node: child });
+        self.send_op(ParseOperation::Append {
+            parent: parent.id,
+            node: child,
+        });
     }
 
-    fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
-                                  system_id: StrTendril) {
+    fn append_doctype_to_document(
+        &mut self,
+        name: StrTendril,
+        public_id: StrTendril,
+        system_id: StrTendril,
+    ) {
         self.send_op(ParseOperation::AppendDoctypeToDocument {
             name: String::from(name),
             public_id: String::from(public_id),
-            system_id: String::from(system_id)
+            system_id: String::from(system_id),
         });
     }
 
     fn add_attrs_if_missing(&mut self, target: &Self::Handle, html_attrs: Vec<HtmlAttribute>) {
-        let attrs = html_attrs.into_iter()
-            .map(|attr| Attribute { name: attr.name, value: String::from(attr.value) }).collect();
-        self.send_op(ParseOperation::AddAttrsIfMissing { target: target.id, attrs });
+        let attrs = html_attrs
+            .into_iter()
+            .map(|attr| Attribute {
+                name: attr.name,
+                value: String::from(attr.value),
+            }).collect();
+        self.send_op(ParseOperation::AddAttrsIfMissing {
+            target: target.id,
+            attrs,
+        });
     }
 
     fn remove_from_parent(&mut self, target: &Self::Handle) {
@@ -717,7 +855,10 @@ impl TreeSink for Sink {
     }
 
     fn reparent_children(&mut self, parent: &Self::Handle, new_parent: &Self::Handle) {
-        self.send_op(ParseOperation::ReparentChildren { parent: parent.id, new_parent: new_parent.id });
+        self.send_op(ParseOperation::ReparentChildren {
+            parent: parent.id,
+            new_parent: new_parent.id,
+        });
     }
 
     /// <https://html.spec.whatwg.org/multipage/#html-integration-point>