chore: Apply more lints

Stranger6667 · Stranger6667 · commit 7760911eec3a · 2023-06-18T13:09:19.000+02:00
diff --git a/bindings/python/src/lib.rs b/bindings/python/src/lib.rs
@@ -21,8 +21,10 @@
     unused_qualifications,
     variant_size_differences,
     rust_2018_idioms,
-    rust_2018_compatibility
+    rust_2018_compatibility,
+    rust_2021_compatibility
 )]
+#[allow(clippy::module_name_repetitions)]
 use ::css_inline as rust_inline;
 use pyo3::{create_exception, exceptions, prelude::*, types::PyList, wrap_pyfunction};
 use rayon::prelude::*;
diff --git a/bindings/ruby/ext/css_inline/src/lib.rs b/bindings/ruby/ext/css_inline/src/lib.rs
@@ -16,13 +16,16 @@
     missing_debug_implementations,
     trivial_casts,
     trivial_numeric_casts,
+    unreachable_pub,
     unused_extern_crates,
     unused_import_braces,
     unused_qualifications,
     variant_size_differences,
     rust_2018_idioms,
-    rust_2018_compatibility
+    rust_2018_compatibility,
+    rust_2021_compatibility
 )]
+#[allow(clippy::module_name_repetitions)]
 use css_inline as rust_inline;
 use magnus::{
     class, define_module, function, method,
diff --git a/bindings/wasm/src/lib.rs b/bindings/wasm/src/lib.rs
@@ -13,17 +13,19 @@
     clippy::map_unwrap_or,
     clippy::trivially_copy_pass_by_ref,
     clippy::needless_pass_by_value,
-    missing_docs,
     missing_debug_implementations,
     trivial_casts,
     trivial_numeric_casts,
+    unreachable_pub,
     unused_extern_crates,
     unused_import_braces,
     unused_qualifications,
     variant_size_differences,
     rust_2018_idioms,
-    rust_2018_compatibility
+    rust_2018_compatibility,
+    rust_2021_compatibility
 )]
+#[allow(clippy::module_name_repetitions)]
 use css_inline as rust_inline;
 use std::{
     borrow::Cow,
@@ -138,8 +140,15 @@ pub mod tests {
 
     #[wasm_bindgen_test]
     fn default_config() {
-        let result = inline("<html><head><style>h1 { color:red; }</style></head><body><h1>Test</h1></body></html>", JsValue::undefined()).expect("Inlines correctly");
-        assert_eq!(result, "<html><head></head><body><h1 style=\"color:red;\">Test</h1></body></html>");
+        let result = inline(
+            "<html><head><style>h1 { color:red; }</style></head><body><h1>Test</h1></body></html>",
+            JsValue::undefined(),
+        )
+        .expect("Inlines correctly");
+        assert_eq!(
+            result,
+            "<html><head></head><body><h1 style=\"color:red;\">Test</h1></body></html>"
+        );
     }
 
     #[wasm_bindgen_test]
@@ -149,7 +158,11 @@ pub mod tests {
             ..Options::default()
         };
         let options = serde_wasm_bindgen::to_value(&options).expect("Valid value");
-        let result = inline("<html><head><style>h1 { color:red; }</style></head><body><h1>Test</h1></body></html>", options).expect("Inlines correctly");
+        let result = inline(
+            "<html><head><style>h1 { color:red; }</style></head><body><h1>Test</h1></body></html>",
+            options,
+        )
+        .expect("Inlines correctly");
         assert_eq!(result, "<html><head><style>h1 { color:red; }</style></head><body><h1 style=\"color:red;\">Test</h1></body></html>");
     }
 }
diff --git a/css-inline/src/hasher.rs b/css-inline/src/hasher.rs
@@ -9,41 +9,38 @@ impl Hasher for NoHashHasher {
     fn finish(&self) -> u64 {
         self.0
     }
-
     fn write(&mut self, _: &[u8]) {
-        panic!("Should not happen")
+        unreachable!("Should not be used")
     }
-    fn write_u8(&mut self, n: u8) {
-        self.0 = u64::from(n)
+    fn write_u8(&mut self, _: u8) {
+        unreachable!("Should not be used")
     }
-    fn write_u16(&mut self, n: u16) {
-        self.0 = u64::from(n)
+    fn write_u16(&mut self, _: u16) {
+        unreachable!("Should not be used")
     }
-    fn write_u32(&mut self, n: u32) {
-        self.0 = u64::from(n)
+    fn write_u32(&mut self, _: u32) {
+        unreachable!("Should not be used")
     }
-    fn write_u64(&mut self, n: u64) {
-        self.0 = n
+    fn write_u64(&mut self, _: u64) {
+        unreachable!("Should not be used")
     }
-
     fn write_usize(&mut self, n: usize) {
-        self.0 = n as u64
+        self.0 = n as u64;
     }
-    fn write_i8(&mut self, n: i8) {
-        self.0 = n as u64
+    fn write_i8(&mut self, _: i8) {
+        unreachable!("Should not be used")
     }
-    fn write_i16(&mut self, n: i16) {
-        self.0 = n as u64
+    fn write_i16(&mut self, _: i16) {
+        unreachable!("Should not be used")
     }
-    fn write_i32(&mut self, n: i32) {
-        self.0 = n as u64
+    fn write_i32(&mut self, _: i32) {
+        unreachable!("Should not be used")
     }
-    fn write_i64(&mut self, n: i64) {
-        self.0 = n as u64
+    fn write_i64(&mut self, _: i64) {
+        unreachable!("Should not be used")
     }
-
-    fn write_isize(&mut self, n: isize) {
-        self.0 = n as u64
+    fn write_isize(&mut self, _: isize) {
+        unreachable!("Should not be used")
     }
 }
 
@@ -52,34 +49,29 @@ mod tests {
     use super::NoHashHasher;
     use std::hash::Hasher;
 
-    #[test]
-    fn hasher() {
-        let mut hasher = NoHashHasher::default();
-        hasher.write_u8(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_u16(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_u32(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_u64(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_usize(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_i8(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_i16(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_i32(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_i64(42);
-        assert_eq!(hasher.0, 42);
-        hasher.write_isize(42);
-        assert_eq!(hasher.0, 42);
+    macro_rules! test_panic {
+        ($($method:ident),+ $(,)?) => {
+            $(
+                mod $method {
+                    use super::NoHashHasher;
+                    use std::hash::Hasher;
+    
+                    #[test]
+                    #[should_panic]
+                    fn test_panic() {
+                        let mut hasher = NoHashHasher::default();
+                        hasher.$method(42);
+                    }
+                }
+            )+
+        };
     }
 
+    test_panic!(write_u8, write_u16, write_u32, write_u64, write_i8, write_i16, write_i32, write_i64, write_isize);
+
     #[test]
     #[should_panic]
-    fn test_panic() {
+    fn test_panic_write() {
         let mut hasher = NoHashHasher::default();
         hasher.write(b"a");
     }
diff --git a/css-inline/src/html/element.rs b/css-inline/src/html/element.rs
@@ -36,18 +36,22 @@ impl<'a> Element<'a> {
         }
     }
     /// Qualified name of the element.
+    #[inline]
     pub(crate) fn name(&self) -> &QualName {
         &self.data.name
     }
     /// Attributes of the element.
+    #[inline]
     pub(crate) fn attributes(&self) -> &Attributes {
         &self.data.attributes
     }
     /// A reference to the element data.
+    #[inline]
     pub(crate) fn data(&self) -> &'a ElementData {
         self.data
     }
     /// ID of the parent node of the element, if it exists.
+    #[inline]
     pub(crate) fn parent(&self) -> Option<NodeId> {
         self.document[self.node_id].parent
     }
@@ -162,6 +166,7 @@ impl<'a> selectors::Element for Element<'a> {
         }
     }
 
+    #[allow(clippy::enum_glob_use)]
     fn match_non_ts_pseudo_class<F>(
         &self,
         pseudo: &PseudoClass,
diff --git a/css-inline/src/html/node.rs b/css-inline/src/html/node.rs
@@ -15,6 +15,7 @@ pub(crate) struct Node {
 }
 
 impl Node {
+    #[inline]
     pub(crate) fn new(data: NodeData) -> Node {
         Node {
             parent: None,
@@ -25,18 +26,21 @@ impl Node {
             data,
         }
     }
+    #[inline]
     pub(crate) fn as_element(&self) -> Option<&ElementData> {
         match &self.data {
             NodeData::Element { element: data, .. } => Some(data),
             _ => None,
         }
     }
+    #[inline]
     pub(crate) fn as_element_mut(&mut self) -> Option<&mut ElementData> {
         match &mut self.data {
             NodeData::Element { element: data, .. } => Some(data),
             _ => None,
         }
     }
+    #[inline]
     pub(crate) fn as_not_ignored_element_mut(&mut self) -> Option<&mut ElementData> {
         match &mut self.data {
             NodeData::Element {
@@ -46,6 +50,7 @@ impl Node {
             _ => None,
         }
     }
+    #[inline]
     pub(crate) fn as_text(&self) -> Option<&str> {
         match &self.data {
             NodeData::Text { text } => Some(&**text),
@@ -59,9 +64,11 @@ impl Node {
 pub(crate) struct NodeId(NonZeroUsize);
 
 impl NodeId {
+    #[inline]
     pub(super) fn new(value: usize) -> NodeId {
         NodeId(NonZeroUsize::new(value).expect("Value is zero"))
     }
+    #[inline]
     pub(super) fn document_id() -> NodeId {
         NodeId::new(1)
     }
@@ -103,6 +110,7 @@ pub(crate) struct ElementData {
 }
 
 impl ElementData {
+    #[inline]
     pub(crate) fn new(name: QualName, attributes: Vec<html5ever::Attribute>) -> ElementData {
         ElementData {
             name,
diff --git a/css-inline/src/html/selectors/parser.rs b/css-inline/src/html/selectors/parser.rs
@@ -9,6 +9,7 @@ impl<'i> Parser<'i> for SelectorParser {
     type Impl = InlinerSelectors;
     type Error = SelectorParseErrorKind<'i>;
 
+    #[allow(clippy::enum_glob_use)]
     fn parse_non_ts_pseudo_class(
         &self,
         location: SourceLocation,
diff --git a/css-inline/src/lib.rs b/css-inline/src/lib.rs
@@ -1,5 +1,6 @@
 #![doc = include_str!("../README.md")]
 #![warn(
+    clippy::pedantic,
     clippy::doc_markdown,
     clippy::redundant_closure,
     clippy::explicit_iter_loop,
@@ -22,9 +23,10 @@
     unused_qualifications,
     variant_size_differences,
     rust_2018_idioms,
-    rust_2018_compatibility
+    rust_2018_compatibility,
+    rust_2021_compatibility
 )]
-
+#[allow(clippy::module_name_repetitions)]
 pub mod error;
 mod hasher;
 mod html;
@@ -468,7 +470,7 @@ fn merge_styles(
     let mut first = true;
     for style in &final_styles {
         if first {
-            first = false
+            first = false;
         } else {
             existing_style.push_char(';');
         }

Original file line number	Diff line number	Diff line change
`@@ -36,18 +36,22 @@ impl<'a> Element<'a> {`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`/// Qualified name of the element.`
	`39`	`+ #[inline]`
`39`	`40`	`pub(crate) fn name(&self) -> &QualName {`
`40`	`41`	`&self.data.name`
`41`	`42`	`}`
`42`	`43`	`/// Attributes of the element.`
	`44`	`+ #[inline]`
`43`	`45`	`pub(crate) fn attributes(&self) -> &Attributes {`
`44`	`46`	`&self.data.attributes`
`45`	`47`	`}`
`46`	`48`	`/// A reference to the element data.`
	`49`	`+ #[inline]`
`47`	`50`	`pub(crate) fn data(&self) -> &'a ElementData {`
`48`	`51`	`self.data`
`49`	`52`	`}`
`50`	`53`	`/// ID of the parent node of the element, if it exists.`
	`54`	`+ #[inline]`
`51`	`55`	`pub(crate) fn parent(&self) -> Option<NodeId> {`
`52`	`56`	`self.document[self.node_id].parent`
`53`	`57`	`}`
`@@ -162,6 +166,7 @@ impl<'a> selectors::Element for Element<'a> {`
`162`	`166`	`}`
`163`	`167`	`}`
`164`	`168`
	`169`	`+ #[allow(clippy::enum_glob_use)]`
`165`	`170`	`fn match_non_ts_pseudo_class<F>(`
`166`	`171`	`&self,`
`167`	`172`	`pseudo: &PseudoClass,`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ pub(crate) struct Node {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`impl Node {`
	`18`	`+ #[inline]`
`18`	`19`	`pub(crate) fn new(data: NodeData) -> Node {`
`19`	`20`	`Node {`
`20`	`21`	`parent: None,`
`@@ -25,18 +26,21 @@ impl Node {`
`25`	`26`	`data,`
`26`	`27`	`}`
`27`	`28`	`}`
	`29`	`+ #[inline]`
`28`	`30`	`pub(crate) fn as_element(&self) -> Option<&ElementData> {`
`29`	`31`	`match &self.data {`
`30`	`32`	`NodeData::Element { element: data, .. } => Some(data),`
`31`	`33`	`_ => None,`
`32`	`34`	`}`
`33`	`35`	`}`
	`36`	`+ #[inline]`
`34`	`37`	`pub(crate) fn as_element_mut(&mut self) -> Option<&mut ElementData> {`
`35`	`38`	`match &mut self.data {`
`36`	`39`	`NodeData::Element { element: data, .. } => Some(data),`
`37`	`40`	`_ => None,`
`38`	`41`	`}`
`39`	`42`	`}`
	`43`	`+ #[inline]`
`40`	`44`	`pub(crate) fn as_not_ignored_element_mut(&mut self) -> Option<&mut ElementData> {`
`41`	`45`	`match &mut self.data {`
`42`	`46`	`NodeData::Element {`
`@@ -46,6 +50,7 @@ impl Node {`
`46`	`50`	`_ => None,`
`47`	`51`	`}`
`48`	`52`	`}`
	`53`	`+ #[inline]`
`49`	`54`	`pub(crate) fn as_text(&self) -> Option<&str> {`
`50`	`55`	`match &self.data {`
`51`	`56`	`NodeData::Text { text } => Some(&**text),`
`@@ -59,9 +64,11 @@ impl Node {`
`59`	`64`	`pub(crate) struct NodeId(NonZeroUsize);`
`60`	`65`
`61`	`66`	`impl NodeId {`
	`67`	`+ #[inline]`
`62`	`68`	`pub(super) fn new(value: usize) -> NodeId {`
`63`	`69`	`NodeId(NonZeroUsize::new(value).expect("Value is zero"))`
`64`	`70`	`}`
	`71`	`+ #[inline]`
`65`	`72`	`pub(super) fn document_id() -> NodeId {`
`66`	`73`	`NodeId::new(1)`
`67`	`74`	`}`
`@@ -103,6 +110,7 @@ pub(crate) struct ElementData {`
`103`	`110`	`}`
`104`	`111`
`105`	`112`	`impl ElementData {`
	`113`	`+ #[inline]`
`106`	`114`	`pub(crate) fn new(name: QualName, attributes: Vec<html5ever::Attribute>) -> ElementData {`
`107`	`115`	`ElementData {`
`108`	`116`	`name,`