re-rustfmt all code

rustfmt 1.4.13-nightly (c126730 2020-03-31)

Author: dekellum

marked/benches/round_trip.rs

@@ -15,10 +15,10 @@ use html5ever::serialize as rc_serialize;
 use markup5ever_rcdom::{RcDom, SerializableHandle};
 
 use marked;
-use marked::{Decoder, Document, EncodingHint};
 use marked::chain_filters;
 use marked::filter;
 use marked::html::parse_buffered;
+use marked::{Decoder, Document, EncodingHint};
 use marked::{Decoder, EncodingHint};
 
 #[bench]
@@ -134,8 +134,7 @@ fn b31_text_normalize_content_identity(b: &mut Bencher) {
 
 #[bench]
 fn b50_sparse_bulk_clone(b: &mut Bencher) {
-    let mut fin = sample_file("github-dekellum.html")
-        .expect("sample_file");
+    let mut fin = sample_file("github-dekellum.html").expect("sample_file");
     let eh = EncodingHint::shared_default(enc::UTF_8);
     let mut doc = parse_buffered(eh, &mut fin).expect("parse");
     filter_all(&mut doc);
@@ -147,8 +146,7 @@ fn b50_sparse_bulk_clone(b: &mut Bencher) {
 
 #[bench]
 fn b51_sparse_compact(b: &mut Bencher) {
-    let mut fin = sample_file("github-dekellum.html")
-        .expect("sample_file");
+    let mut fin = sample_file("github-dekellum.html").expect("sample_file");
     let eh = EncodingHint::shared_default(enc::UTF_8);
     let mut doc = parse_buffered(eh, &mut fin).expect("parse");
     filter_all(&mut doc);
@@ -161,8 +159,7 @@ fn b51_sparse_compact(b: &mut Bencher) {
 
 #[bench]
 fn b52_sparse_deep_clone(b: &mut Bencher) {
-    let mut fin = sample_file("github-dekellum.html")
-        .expect("sample_file");
+    let mut fin = sample_file("github-dekellum.html").expect("sample_file");
     let eh = EncodingHint::shared_default(enc::UTF_8);
     let mut doc = parse_buffered(eh, &mut fin).expect("parse");
     filter_all(&mut doc);

marked/src/dom.rs

@@ -101,22 +101,22 @@ pub enum NodeData {
 #[derive(Clone, Debug)]
 pub struct DocumentType {
     pub name: StrTendril,
-    _priv: ()
+    _priv: (),
 }
 
 /// Processing instruction details.
 #[derive(Clone, Debug)]
 pub struct ProcessingInstruction {
     pub data: StrTendril,
-    _priv: ()
+    _priv: (),
 }
 
 /// A markup element with name and attributes.
 #[derive(Clone, Debug)]
 pub struct Element {
     pub name: QualName,
     pub attrs: Vec<Attribute>,
-    _priv: ()
+    _priv: (),
 }
 
 /// Core implementation.
@@ -133,8 +133,8 @@ impl Document {
     /// specified capacity.
     pub fn with_capacity(count: u32) -> Self {
         let mut nodes = Vec::with_capacity(count as usize);
-        nodes.push(Node::new(NodeData::Hole));        // Index 0: Padding
-        nodes.push(Node::new(NodeData::Document));    // Index 1: DOCUMENT_NODE_ID
+        nodes.push(Node::new(NodeData::Hole)); // Index 0: Padding
+        nodes.push(Node::new(NodeData::Document)); // Index 1: DOCUMENT_NODE_ID
         Document { nodes }
     }
 
@@ -164,18 +164,21 @@ impl Document {
     pub fn root_element(&self) -> Option<NodeId> {
         let document_node = &self[Document::DOCUMENT_NODE_ID];
         debug_assert!(
-            (if let NodeData::Document = document_node.data { true }
-             else { false }),
-            "not document node: {:?}", document_node);
+            (if let NodeData::Document = document_node.data {
+                true
+            } else {
+                false
+            }),
+            "not document node: {:?}",
+            document_node
+        );
         debug_assert!(document_node.parent.is_none());
         debug_assert!(document_node.next_sibling.is_none());
         debug_assert!(document_node.prev_sibling.is_none());
         let mut root = None;
         for child in self.children(Document::DOCUMENT_NODE_ID) {
             match &self[child].data {
-                NodeData::DocType(_) |
-                NodeData::Comment(_) |
-                NodeData::Pi(_) => {}
+                NodeData::DocType(_) | NodeData::Comment(_) | NodeData::Pi(_) => {}
                 NodeData::Document => {
                     debug_assert!(false, "Document child of Document");
                     root = None;
@@ -205,10 +208,17 @@ impl Document {
 
     fn push_node(&mut self, node: Node) -> NodeId {
         debug_assert!(
-            (if let NodeData::Document | NodeData::Hole = node.data { false }
-             else { true }),
-            "Invalid push {:?}", node.data);
-        let next_index = self.nodes.len()
+            (if let NodeData::Document | NodeData::Hole = node.data {
+                false
+            } else {
+                true
+            }),
+            "Invalid push {:?}",
+            node.data
+        );
+        let next_index = self
+            .nodes
+            .len()
             .try_into()
             .expect("Document (u32) node index overflow");
         debug_assert!(next_index > 1);
@@ -283,7 +293,8 @@ impl Document {
 
     fn insert_before(&mut self, sibling: NodeId, new_sibling: NodeId) {
         self.detach(new_sibling);
-        let parent = self[sibling].parent
+        let parent = self[sibling]
+            .parent
             .expect("insert_before sibling has parent");
         self[parent].assert_suitable_parent();
         self[new_sibling].parent = Some(parent);
@@ -370,7 +381,8 @@ impl Document {
         push_if_pair(
             &mut next,
             self[Document::DOCUMENT_NODE_ID].first_child,
-            Document::DOCUMENT_NODE_ID);
+            Document::DOCUMENT_NODE_ID,
+        );
 
         while let Some((id, nid)) = next.pop() {
             let data = mem::replace(&mut self[id].data, NodeData::Hole);
@@ -414,7 +426,9 @@ impl Document {
     /// same as the original. As compared with `deep_clone(DOCUMENT_NODE_ID)`
     /// this is faster but potentially much less memory efficient.
     pub fn bulk_clone(&self) -> Document {
-        Document { nodes: self.nodes.clone() }
+        Document {
+            nodes: self.nodes.clone(),
+        }
     }
 
     /// Replace the specified node ID with its children.
@@ -481,7 +495,7 @@ impl Element {
         Element {
             name: QualName::new(None, ns!(), lname.into()),
             attrs: Vec::new(),
-            _priv: ()
+            _priv: (),
         }
     }
 
@@ -688,9 +702,14 @@ impl NodeData {
     #[inline]
     fn assert_suitable_parent(&self) {
         debug_assert!(
-            (if let NodeData::Document | NodeData::Elem(_) = self { true }
-             else { false }),
-            "Not a suitable parent: {:?}", self)
+            (if let NodeData::Document | NodeData::Elem(_) = self {
+                true
+            } else {
+                false
+            }),
+            "Not a suitable parent: {:?}",
+            self
+        )
     }
 }
 
@@ -700,11 +719,7 @@ fn push_if(stack: &mut Vec<NodeId>, id: Option<NodeId>) {
     }
 }
 
-fn push_if_pair(
-    stack: &mut Vec<(NodeId, NodeId)>,
-    id: Option<NodeId>,
-    oid: NodeId)
-{
+fn push_if_pair(stack: &mut Vec<(NodeId, NodeId)>, id: Option<NodeId>, oid: NodeId) {
     if let Some(id) = id {
         stack.push((id, oid));
     }

marked/src/dom/html.rs

@@ -23,9 +23,8 @@ use log::{debug, info, trace};
 use tendril::{fmt as form, Tendril};
 
 use crate::{
-    Attribute, Decoder, Document, DocumentType, Element, EncodingHint,
-    Node, NodeData, NodeId, ProcessingInstruction, SharedEncodingHint,
-    BOM_CONF, HTML_META_CONF, INITIAL_BUFFER_SIZE,
+    Attribute, Decoder, Document, DocumentType, Element, EncodingHint, Node, NodeData, NodeId,
+    ProcessingInstruction, SharedEncodingHint, BOM_CONF, HTML_META_CONF, INITIAL_BUFFER_SIZE,
 };
 
 mod meta;
@@ -365,19 +364,20 @@ impl TreeSink for Sink {
         &mut self,
         name: QualName,
         attrs: Vec<Attribute>,
-        _flags: ElementFlags)
-        -> NodeId
-    {
-        self.new_node(NodeData::Elem(Element { name, attrs, _priv: () }))
+        _flags: ElementFlags,
+    ) -> NodeId {
+        self.new_node(NodeData::Elem(Element {
+            name,
+            attrs,
+            _priv: (),
+        }))
     }
 
     fn create_comment(&mut self, text: StrTendril) -> NodeId {
         self.new_node(NodeData::Comment(text))
     }
 
-    fn create_pi(&mut self, _target: StrTendril, data: StrTendril)
-        -> NodeId
-    {
+    fn create_pi(&mut self, _target: StrTendril, data: StrTendril) -> NodeId {
         self.new_node(NodeData::Pi(ProcessingInstruction { data, _priv: () }))
     }
 
@@ -414,19 +414,13 @@ impl TreeSink for Sink {
         &mut self,
         name: StrTendril,
         _p_id: StrTendril,
-        _s_id: StrTendril)
-    {
-        let node = self.new_node(NodeData::DocType(
-            DocumentType { name, _priv: () }
-        ));
+        _s_id: StrTendril,
+    ) {
+        let node = self.new_node(NodeData::DocType(DocumentType { name, _priv: () }));
         self.document.append(Document::DOCUMENT_NODE_ID, node)
     }
 
-    fn add_attrs_if_missing(
-        &mut self,
-        &target: &NodeId,
-        attrs: Vec<Attribute>)
-    {
+    fn add_attrs_if_missing(&mut self, &target: &NodeId, attrs: Vec<Attribute>) {
         // Note this is only used in few, strange cases involving re-working of
         // html and body node attributes, but it definitely needs to be
         // implemented.

marked/src/dom/serializer.rs

@@ -36,7 +36,7 @@ impl<'a> Serialize for NodeRef<'a> {
                 if *scope == IncludeNode {
                     serializer.start_elem(
                         elm.name.clone(),
-                        elm.attrs.iter().map(|a| (&a.name, a.value.as_ref()))
+                        elm.attrs.iter().map(|a| (&a.name, a.value.as_ref())),
                     )?;
                 }
                 for child in self.children() {
@@ -49,9 +49,7 @@ impl<'a> Serialize for NodeRef<'a> {
                 Ok(())
             }
 
-            (_, Hole) => {
-                panic!("Hole in Document")
-            }
+            (_, Hole) => panic!("Hole in Document"),
 
             (_, Document) => {
                 for child in self.children() {
@@ -62,18 +60,10 @@ impl<'a> Serialize for NodeRef<'a> {
 
             (ChildrenOnly(_), _) => Ok(()),
 
-            (IncludeNode, DocType(ref dt)) => {
-                serializer.write_doctype(&dt.name)
-            }
-            (IncludeNode, Text(ref t)) => {
-                serializer.write_text(&t)
-            }
-            (IncludeNode, Comment(ref t)) => {
-                serializer.write_comment(&t)
-            }
-            (IncludeNode, Pi(ref pi)) => {
-                serializer.write_processing_instruction(&"", &pi.data)
-            }
+            (IncludeNode, DocType(ref dt)) => serializer.write_doctype(&dt.name),
+            (IncludeNode, Text(ref t)) => serializer.write_text(&t),
+            (IncludeNode, Comment(ref t)) => serializer.write_comment(&t),
+            (IncludeNode, Pi(ref pi)) => serializer.write_processing_instruction(&"", &pi.data),
         }
     }
 }