Updates and clippy

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nipper"
-version = "0.1.9"
+version = "0.1.10"
 description = "HTML manipulation with CSS seletors"
 license = "MIT/Apache-2.0"
 repository = "https://github.com/importcjj/nipper"
@@ -13,16 +13,18 @@ readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-html5ever = "0.25.1"
-selectors = "0.22.0"
-cssparser = "0.27.2"
+html5ever = "0.26.0"
+selectors = "0.25.0"
+cssparser = "0.31.2"
 tendril = "0.4.2"
-markup5ever = "0.10.0"
+markup5ever = "0.11.0"
 
+indexmap = "2.1.0"
+fxhash = "0.2.1"
 
 [dev-dependencies]
 reqwest = { version = "0.11.3", features = ["blocking"] }
 regex = "1.4.5"
 lazy_static = "1.4.0"
-readability = "0.2.0"
+readability = "0.3.0"
 url = "2.2.1"

src/css.rs

@@ -0,0 +1,65 @@
+use std::convert::AsRef;
+use std::fmt;
+use std::ops::Deref;
+
+use cssparser::{self, ToCss};
+use html5ever::LocalName;
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct CssString(String);
+
+impl Deref for CssString {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<str> for CssString {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl From<&str> for CssString {
+    fn from(value: &str) -> Self {
+        CssString(value.to_owned())
+    }
+}
+
+impl ToCss for CssString {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        //dest.write_str(&self.0)
+        cssparser::serialize_string(&self.0, dest)
+    }
+}
+
+#[derive(Clone, Eq, PartialEq, Debug, Default)]
+pub struct CssLocalName(LocalName);
+
+impl ToCss for CssLocalName {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        dest.write_str(&self.0)
+    }
+}
+
+impl From<&str> for CssLocalName {
+    fn from(value: &str) -> Self {
+        CssLocalName(value.into())
+    }
+}
+
+impl Deref for CssLocalName {
+    type Target = LocalName;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

src/document.rs

@@ -92,7 +92,7 @@ impl TreeSink for Document {
             NodeData::Element(Element {
                 template_contents: Some(ref contents),
                 ..
-            }) => contents.clone(),
+            }) => *contents,
             _ => panic!("not a template element!"),
         })
     }
@@ -151,7 +151,7 @@ impl TreeSink for Document {
     // Create a Processing Instruction node.
     fn create_pi(&mut self, target: StrTendril, data: StrTendril) -> NodeId {
         self.tree.create_node(NodeData::ProcessingInstruction {
-            target: target,
+            target,
             contents: data,
         })
     }
@@ -243,9 +243,9 @@ impl TreeSink for Document {
         self.tree.append_child_data_of(
             &root,
             NodeData::Doctype {
-                name: name,
-                public_id: public_id,
-                system_id: system_id,
+                name,
+                public_id,
+                system_id,
             },
         );
     }

src/dom_tree.rs

@@ -265,7 +265,7 @@ impl<T: Debug> Tree<T> {
         with_cell_mut!(self.nodes, nodes, {
             let mut new_nodes = tree.nodes.into_inner();
             assert!(
-                new_nodes.len() > 0,
+                !new_nodes.is_empty(),
                 "The tree should have at leaset one root node"
             );
             assert!(
@@ -296,7 +296,7 @@ impl<T: Debug> Tree<T> {
             let last_child_id = fix_id!(root.last_child);
 
             // Update new parent's first and last child id.
-            let mut parent = get_node_unchecked_mut!(nodes, id);
+            let parent = get_node_unchecked_mut!(nodes, id);
             if parent.first_child.is_none() {
                 parent.first_child = first_child_id;
             }
@@ -306,7 +306,7 @@ impl<T: Debug> Tree<T> {
 
             // Update next_sibling_id
             if let Some(last_child_id) = parent_last_child_id {
-                let mut last_child = get_node_unchecked_mut!(nodes, last_child_id);
+                let last_child = get_node_unchecked_mut!(nodes, last_child_id);
                 last_child.next_sibling = first_child_id;
             }
 
@@ -317,7 +317,7 @@ impl<T: Debug> Tree<T> {
                 node.parent = node.parent.and_then(|parent_id| match parent_id.value {
                     i if i < TRUE_ROOT_ID => None,
                     i if i == TRUE_ROOT_ID => Some(*id),
-                    i @ _ => fix_id!(Some(NodeId::new(i))),
+                    i => fix_id!(Some(NodeId::new(i))),
                 });
 
                 // Update prev_sibling_id
@@ -343,7 +343,7 @@ impl<T: Debug> Tree<T> {
         with_cell_mut!(self.nodes, nodes, {
             let mut new_nodes = tree.nodes.into_inner();
             assert!(
-                new_nodes.len() > 0,
+                !new_nodes.is_empty(),
                 "The tree should have at leaset one root node"
             );
             assert!(
@@ -371,7 +371,7 @@ impl<T: Debug> Tree<T> {
             let first_child_id = fix_id!(root.first_child);
             let last_child_id = fix_id!(root.last_child);
 
-            let mut node = get_node_unchecked_mut!(nodes, id);
+            let node = get_node_unchecked_mut!(nodes, id);
             let prev_sibling_id = node.prev_sibling;
             let parent_id = node.parent;
 
@@ -380,25 +380,24 @@ impl<T: Debug> Tree<T> {
 
             // Update prev sibling's next sibling
             if let Some(prev_sibling_id) = prev_sibling_id {
-                let mut prev_sibling = get_node_unchecked_mut!(nodes, prev_sibling_id);
+                let prev_sibling = get_node_unchecked_mut!(nodes, prev_sibling_id);
                 prev_sibling.next_sibling = first_child_id;
             // Update parent's first child.
             } else if let Some(parent_id) = parent_id {
-                let mut parent = get_node_unchecked_mut!(nodes, parent_id);
+                let parent = get_node_unchecked_mut!(nodes, parent_id);
                 parent.first_child = first_child_id;
             }
 
-            let mut i = 0;
             let mut last_valid_child = 0;
             let mut first_valid_child = true;
             // Fix nodes's ref id.
-            for node in new_nodes.iter_mut() {
+            for (i, node) in new_nodes.iter_mut().enumerate() {
                 node.parent = node
                     .parent
                     .and_then(|old_parent_id| match old_parent_id.value {
                         i if i < TRUE_ROOT_ID => None,
                         i if i == TRUE_ROOT_ID => parent_id,
-                        i @ _ => fix_id!(Some(NodeId::new(i))),
+                        i => fix_id!(Some(NodeId::new(i))),
                     });
 
                 // Update first child's prev_sibling
@@ -416,11 +415,10 @@ impl<T: Debug> Tree<T> {
                 node.last_child = fix_id!(node.last_child);
                 node.prev_sibling = fix_id!(node.prev_sibling);
                 node.next_sibling = fix_id!(node.next_sibling);
-                i += 1;
             }
 
             // Update last child's next_sibling.
-            new_nodes[last_valid_child as usize].next_sibling = Some(*id);
+            new_nodes[last_valid_child].next_sibling = Some(*id);
 
             // Put all the new nodes except the root node into the nodes.
             nodes.extend(new_nodes);
@@ -501,7 +499,7 @@ impl<T: Debug> Tree<T> {
             node.last_child = None;
 
             if let Some(new_parent_id) = new_parent_id {
-                let mut new_parent = get_node_unchecked_mut!(nodes, new_parent_id);
+                let new_parent = get_node_unchecked_mut!(nodes, new_parent_id);
                 new_parent.first_child = first_child_id;
                 new_parent.last_child = last_child_id;
             }
@@ -557,9 +555,8 @@ impl<T: Debug> Tree<T> {
         let node_a = unsafe { nodes.get_unchecked(a.value) };
         let node_b = unsafe { nodes.get_unchecked(b.value) };
 
-        let r = f(node_a, node_b);
         // self.nodes.set(nodes);
-        r
+        f(node_a, node_b)
     }
 }
 
@@ -603,36 +600,27 @@ impl<T: Debug> Debug for InnerNode<T> {
 
 impl InnerNode<NodeData> {
     pub fn is_document(&self) -> bool {
-        match self.data {
-            NodeData::Document => true,
-            _ => false,
-        }
+        matches!(self.data, NodeData::Document)
     }
 
     pub fn is_element(&self) -> bool {
-        match self.data {
-            NodeData::Element(_) => true,
-            _ => false,
-        }
+        matches!(self.data, NodeData::Element(_))
     }
 
     pub fn is_text(&self) -> bool {
-        match self.data {
-            NodeData::Text { .. } => true,
-            _ => false,
-        }
+        matches!(self.data, NodeData::Text { .. })
     }
 }
 
 impl<T: Clone> Clone for InnerNode<T> {
     fn clone(&self) -> Self {
         Self {
-            id: self.id.clone(),
-            parent: self.parent.clone(),
-            prev_sibling: self.prev_sibling.clone(),
-            next_sibling: self.next_sibling.clone(),
-            first_child: self.first_child.clone(),
-            last_child: self.last_child.clone(),
+            id: self.id,
+            parent: self.parent,
+            prev_sibling: self.prev_sibling,
+            next_sibling: self.next_sibling,
+            first_child: self.first_child,
+            last_child: self.last_child,
             data: self.data.clone(),
         }
     }
@@ -775,18 +763,18 @@ impl<'a> Node<'a> {
     }
 
     pub fn add_class(&self, class: &str) {
-        if class.trim().len() == 0 {
+        if class.trim().is_empty() {
             return;
         }
 
-        self.update(|node| match node.data {
-            NodeData::Element(ref mut e) => {
+        self.update(|node| {
+            if let NodeData::Element(ref mut e) = node.data {
                 let mut attr = e.attrs.iter_mut().find(|attr| &attr.name.local == "class");
 
                 let set: HashSet<String> = class
-                    .split(" ")
+                    .split(' ')
                     .map(|s| s.trim())
-                    .filter(|s| s.len() > 0)
+                    .filter(|s| !s.is_empty())
                     .map(|s| s.to_string())
                     .collect();
 
@@ -807,29 +795,28 @@ impl<'a> Node<'a> {
                     e.attrs.push(Attribute { name, value })
                 }
             }
-            _ => (),
         })
     }
 
     pub fn remove_class(&self, class: &str) {
-        if class.trim().len() == 0 {
+        if class.trim().is_empty() {
             return;
         }
 
-        self.update(|node| match node.data {
-            NodeData::Element(ref mut e) => {
+        self.update(|node| {
+            if let NodeData::Element(ref mut e) = node.data {
                 e.attrs
                     .iter_mut()
                     .find(|attr| &attr.name.local == "class")
                     .map(|attr| {
                         let mut set: HashSet<&str> = attr
                             .value
-                            .split(" ")
+                            .split(' ')
                             .map(|s| s.trim())
-                            .filter(|s| s.len() > 0)
+                            .filter(|s| !s.is_empty())
                             .collect();
 
-                        let removes = class.split(" ").map(|s| s.trim()).filter(|s| s.len() > 0);
+                        let removes = class.split(' ').map(|s| s.trim()).filter(|s| !s.is_empty());
 
                         for remove in removes {
                             set.remove(remove);
@@ -839,7 +826,6 @@ impl<'a> Node<'a> {
                             StrTendril::from(set.into_iter().collect::<Vec<&str>>().join(" "));
                     });
             }
-            _ => (),
         })
     }
 
@@ -856,7 +842,7 @@ impl<'a> Node<'a> {
 
     pub fn attrs(&self) -> Vec<Attribute> {
         self.query(|node| match node.data {
-            NodeData::Element(ref e) => e.attrs.iter().map(|attr| attr.clone()).collect(),
+            NodeData::Element(ref e) => e.attrs.to_vec(),
             _ => vec![],
         })
     }
@@ -939,7 +925,7 @@ impl<'a> Node<'a> {
                     }
                 }
 
-                NodeData::Text { ref contents } => text.push_tendril(&contents),
+                NodeData::Text { ref contents } => text.push_tendril(contents),
 
                 _ => continue,
             }
@@ -1040,7 +1026,7 @@ impl<'a> Serialize for SerializableNodeRef<'a> {
             IncludeNode => vec![SerializeOp::Open(id)],
             ChildrenOnly(_) => children_of!(nodes, id)
                 .into_iter()
-                .map(|h| SerializeOp::Open(h))
+                .map(SerializeOp::Open)
                 .collect(),
         };
 
@@ -1061,9 +1047,9 @@ impl<'a> Serialize for SerializableNodeRef<'a> {
 
                         Ok(())
                     }
-                    NodeData::Doctype { ref name, .. } => serializer.write_doctype(&name),
-                    NodeData::Text { ref contents } => serializer.write_text(&contents),
-                    NodeData::Comment { ref contents } => serializer.write_comment(&contents),
+                    NodeData::Doctype { ref name, .. } => serializer.write_doctype(name),
+                    NodeData::Text { ref contents } => serializer.write_text(contents),
+                    NodeData::Comment { ref contents } => serializer.write_comment(contents),
                     NodeData::ProcessingInstruction {
                         ref target,
                         ref contents,