build: force clippy on github actions and fixed current warnings

Author: LastLeaf

Cargo.toml

@@ -44,3 +44,4 @@ let_and_return = "allow"
 redundant_closure = "allow"
 single_match = "allow"
 clone_on_copy = "allow"
+needless_lifetimes = "allow"

float-pigment-css/src/parser/mod.rs

@@ -642,7 +642,7 @@ fn parse_media_expression_series<'a, 't: 'a, 'i: 't>(
                                 return Ok(());
                             }
                         }
-                        return Err(parser.new_custom_error(CustomError::Unmatched));
+                        Err(parser.new_custom_error(CustomError::Unmatched))
                     }) {
                         Ok(_) => {}
                         Err(err) => {
@@ -1667,7 +1667,7 @@ fn parse_attribute_flags<'a, 't: 'a, 'i: 't>(
                     _ => return Err(location.new_basic_unexpected_token_error(t.clone())),
                 })
             } else {
-                return Err(location.new_basic_unexpected_token_error(t.clone()));
+                Err(location.new_basic_unexpected_token_error(t.clone()))
             }
         }
         Err(_) => Ok(AttributeFlags::CaseSensitivityDependsOnName),

float-pigment-css/src/parser/property_value/calc.rs

@@ -156,7 +156,7 @@ pub(crate) struct ComputeCalcExpr<T> {
 impl ComputeCalcExpr<Angle> {
     pub fn try_compute(expr: &CalcExpr) -> Option<Angle> {
         match expr {
-            CalcExpr::Angle(angle) => return Some(angle.as_ref().clone().to_rad()),
+            CalcExpr::Angle(angle) => Some(angle.as_ref().clone().to_rad()),
             CalcExpr::Plus(l, r) | CalcExpr::Sub(l, r) => {
                 let l = Self::try_compute(l)?;
 

float-pigment-css/src/parser/property_value/gradient.rs

@@ -436,7 +436,7 @@ pub(crate) fn gradient_repr<'a, 't: 'a, 'i: 't>(
                 ))
             }),
             _ => {
-                return Err(parser.new_custom_error(CustomError::Unsupported));
+                Err(parser.new_custom_error(CustomError::Unsupported))
             }
         }
     })

float-pigment-css/src/parser/property_value/mod.rs

@@ -861,7 +861,7 @@ pub(crate) fn element_func_repr<'a, 't: 'a, 'i: 't>(
                 Ok(BackgroundImageItem::Element(hash.into()))
             }),
             _ => {
-                return Err(parser.new_custom_error(CustomError::Unsupported));
+                Err(parser.new_custom_error(CustomError::Unsupported))
             }
         }
     })
@@ -937,7 +937,7 @@ pub(crate) fn image_func_repr<'a, 't: 'a, 'i: 't>(
                 Ok(BackgroundImageItem::Image(image_tags, image_src, color))
             }),
             _ => {
-                return Err(parser.new_custom_error(CustomError::Unsupported));
+                Err(parser.new_custom_error(CustomError::Unsupported))
             }
         }
     })

float-pigment-css/src/query.rs

@@ -85,8 +85,12 @@ impl<L: LengthNum> MediaQueryStatus<L> {
     }
 }
 
+/// The class for a `StyleNode`.
 pub trait StyleNodeClass {
+    /// The name of the class.
     fn name(&self) -> &str;
+
+    /// The style scope of the class.
     fn scope(&self) -> Option<NonZeroUsize>;
 }
 
@@ -100,19 +104,25 @@ impl StyleNodeClass for (String, Option<NonZeroUsize>) {
     }
 }
 
+/// The case-sensitivity for attribute matching.
 pub enum StyleNodeAttributeCaseSensitivity {
+    /// Case-sensitive.
     CaseSensitive,
+
+    /// Case-insensitive.
     CaseInsensitive,
 }
 
 impl StyleNodeAttributeCaseSensitivity {
+    /// Matches two strings with this case-sensitivity.
     pub fn eq(&self, a: &str, b: &str) -> bool {
         match self {
             Self::CaseSensitive => a == b,
             Self::CaseInsensitive => a.eq_ignore_ascii_case(b),
         }
     }
 
+    /// Check if `a` starts with `b` in this case-sensitivity.
     pub fn starts_with(&self, a: &str, b: &str) -> bool {
         // FIXME: reduce memory allocation
         match self {
@@ -121,6 +131,7 @@ impl StyleNodeAttributeCaseSensitivity {
         }
     }
 
+    /// Check if `a` ends with `b` in this case-sensitivity.
     pub fn ends_with(&self, a: &str, b: &str) -> bool {
         // FIXME: reduce memory allocation
         match self {
@@ -129,6 +140,7 @@ impl StyleNodeAttributeCaseSensitivity {
         }
     }
 
+    /// Check if `a` contains `b` in this case-sensitivity.
     pub fn contains(&self, a: &str, b: &str) -> bool {
         // FIXME: reduce memory allocation
         match self {
@@ -138,20 +150,38 @@ impl StyleNodeAttributeCaseSensitivity {
     }
 }
 
+/// A node descriptor for a style query.
 pub trait StyleNode {
+    /// The type for a class.
     type Class: StyleNodeClass;
+
+    /// The type for classes iteration.
     type ClassIter<'a>: Iterator<Item = &'a Self::Class>
     where
         Self: 'a;
 
+    /// The style scope of the node itself.
     fn style_scope(&self) -> Option<NonZeroUsize>;
+
+    /// The extra style scope of the node.
     fn extra_style_scope(&self) -> Option<NonZeroUsize>;
+
+    /// The extra style scope for the `:host` selector.
     fn host_style_scope(&self) -> Option<NonZeroUsize>;
+
+    /// The tag name of the node.
     fn tag_name(&self) -> &str;
+
+    /// The id of the node.
     fn id(&self) -> Option<&str>;
+
+    /// The classes of the node.
     fn classes(&self) -> Self::ClassIter<'_>;
+
+    /// Get an attribute of the node.
     fn attribute(&self, name: &str) -> Option<(&str, StyleNodeAttributeCaseSensitivity)>;
 
+    /// Check if the node has a specified scope.
     fn contain_scope(&self, scope: Option<NonZeroUsize>) -> bool {
         scope.is_none()
             || self.style_scope() == scope
@@ -236,7 +266,7 @@ impl<'a> StyleNode for StyleQuery<'a> {
         self.classes.iter()
     }
 
-    fn attribute(&self, name: &str) -> Option<(&str, StyleNodeAttributeCaseSensitivity)> {
+    fn attribute(&self, _name: &str) -> Option<(&str, StyleNodeAttributeCaseSensitivity)> {
         None
     }
 }
@@ -272,7 +302,7 @@ impl<'b, 'a: 'b> StyleNode for &'b StyleQuery<'a> {
         self.classes.iter()
     }
 
-    fn attribute(&self, name: &str) -> Option<(&str, StyleNodeAttributeCaseSensitivity)> {
+    fn attribute(&self, _name: &str) -> Option<(&str, StyleNodeAttributeCaseSensitivity)> {
         None
     }
 }

float-pigment-css/src/sheet/rule.rs

@@ -186,6 +186,7 @@ impl PropertyMeta {
     }
 
     #[cfg(test)]
+    #[doc(hidden)]
     pub fn property(&self) -> Option<Property> {
         match self {
             Self::Normal { property } | Self::Important { property } => Some(property.clone()),

float-pigment-css/src/sheet/selector.rs

@@ -449,6 +449,7 @@ impl Selector {
                                                     }
                                                 }
                                                 AttributeOperator::Hyphen => {
+                                                    #[allow(clippy::comparison_chain)]
                                                     if element_attr_value.len()
                                                         < selector_attr_value.len()
                                                     {

float-pigment-css/tests/utils/mod.rs

@@ -2,7 +2,7 @@ use std::num::NonZeroUsize;
 
 use float_pigment_css::query::{StyleNode, StyleNodeAttributeCaseSensitivity};
 use float_pigment_css::{
-    length_num::LengthNum, property::*, MediaQueryStatus, StyleQuery, StyleSheet, StyleSheetGroup,
+    length_num::LengthNum, property::*, MediaQueryStatus, StyleSheet, StyleSheetGroup,
 };
 
 pub struct StyleQueryTest<'a> {

float-pigment-forest/src/ffi.rs

@@ -777,7 +777,6 @@ pub unsafe extern "C" fn NodeStyleSetRowGapCalcHandle(node: NodePtr, calc_handle
 /// # Safety
 ///
 #[no_mangle]
-
 pub unsafe extern "C" fn NodeStyleSetColumnGap(node: NodePtr, value: f32) {
     let node = &*(node.ptr as *mut Node);
     node.set_column_gap(DefLength::Points(Len::from_f32(value)));