[clippy] fixes

Author: aslpavel

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rasterize"
-version = "0.4.1"
+version = "0.4.2"
 authors = ["Pavel Aslanov <asl.pavel@gmail.com>"]
 description = "Simple and small 2D rendering library"
 edition = "2021"

examples/eps.rs

@@ -1,4 +1,5 @@
 //! Basic PostScript rasterizer
+#![allow(dead_code)]
 use rasterize::*;
 use std::{
     cell::{self, RefCell},
@@ -684,9 +685,9 @@ fn create_global_dict() -> PSDict {
                 Ok(())
             }
             val => {
-                let val = val?;
+                val?;
                 state.push(false);
-                Ok(val)
+                Ok(())
             }
         }
     });

examples/hatchet.rs

@@ -62,7 +62,7 @@ impl PartialEq for Intersection {
 impl Eq for Intersection {}
 
 // Intersect path specified by segments with `y = 0` when `tr` transformation is applied.
-fn intersect(segments: &Vec<Vec<Segment>>, tr: Transform, y_low: bool) -> Vec<Intersection> {
+fn intersect(segments: &[Vec<Segment>], tr: Transform, y_low: bool) -> Vec<Intersection> {
     let mut ints = Vec::new();
     for (subpath_index, subpath) in segments.iter().enumerate() {
         for (segment_index, segment) in subpath.iter().enumerate() {
@@ -100,7 +100,7 @@ fn intersect(segments: &Vec<Vec<Segment>>, tr: Transform, y_low: bool) -> Vec<In
     let mut output: Vec<Intersection> = Vec::with_capacity(ints.len());
     for mut int in ints {
         // remove duplicate intersections
-        if output.len() > 0 {
+        if !output.is_empty() {
             let int_prev = output[output.len() - 1];
             if (int.x_coord - int_prev.x_coord).abs() < EPSILON {
                 if int.winding_delta + int_prev.winding_delta == 0 {

src/color.rs

@@ -254,7 +254,7 @@ impl<'de> Deserialize<'de> for RGBA {
 }
 
 #[cfg(feature = "serde")]
-impl<'de, 'a> DeserializeSeed<'de> for RGBADeserializer<'a> {
+impl<'de> DeserializeSeed<'de> for RGBADeserializer<'_> {
     type Value = RGBA;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

src/geometry.rs

@@ -11,7 +11,7 @@ use std::{
 /// Scalar type
 pub type Scalar = f64;
 /// Epsilon value
-pub const EPSILON: f64 = std::f64::EPSILON;
+pub const EPSILON: f64 = f64::EPSILON;
 /// Square root of the epsilon value
 pub const EPSILON_SQRT: f64 = 1.490_116_119_384_765_6e-8;
 /// Mathematical pi constant
@@ -623,9 +623,7 @@ impl FromStr for BBox {
     type Err = SvgParserError;
 
     fn from_str(string: &str) -> Result<Self, Self::Err> {
-        let mut values = string
-            .split(|c| matches!(c, ' ' | ','))
-            .map(|s| s.trim().parse().ok());
+        let mut values = string.split([' ', ',']).map(|s| s.trim().parse().ok());
         let minx: Scalar = values.next().flatten().ok_or(SvgParserError::InvalidBBox)?;
         let miny: Scalar = values.next().flatten().ok_or(SvgParserError::InvalidBBox)?;
         let width: Scalar = values.next().flatten().ok_or(SvgParserError::InvalidBBox)?;

src/image.rs

@@ -222,7 +222,7 @@ pub struct ImageIter<'a, P> {
     data: &'a [P],
 }
 
-impl<'a, P> ImageIter<'a, P> {
+impl<P> ImageIter<'_, P> {
     /// Get current (row, column) of the pixel
     pub fn position(&self) -> (usize, usize) {
         self.shape.nth(self.index).unwrap_or((self.shape.height, 0))
@@ -308,7 +308,7 @@ pub struct ImageMutIter<'a, P> {
     data: &'a mut [P],
 }
 
-impl<'a, P> ImageMutIter<'a, P> {
+impl<P> ImageMutIter<'_, P> {
     /// Current (row, col) position of the iterator
     pub fn position(&self) -> (usize, usize) {
         self.shape.nth(self.index).unwrap_or((self.shape.height, 0))
@@ -427,7 +427,7 @@ pub struct ImageRef<'a, P> {
     data: &'a [P],
 }
 
-impl<'a, P> fmt::Debug for ImageRef<'a, P> {
+impl<P> fmt::Debug for ImageRef<'_, P> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ImageRef")
             .field("shape", &self.shape)
@@ -442,7 +442,7 @@ impl<'a, P> ImageRef<'a, P> {
     }
 }
 
-impl<'a, P> Image for ImageRef<'a, P> {
+impl<P> Image for ImageRef<'_, P> {
     type Pixel = P;
 
     fn shape(&self) -> Shape {
@@ -460,7 +460,7 @@ pub struct ImageMutRef<'a, C> {
     data: &'a mut [C],
 }
 
-impl<'a, C> fmt::Debug for ImageMutRef<'a, C> {
+impl<C> fmt::Debug for ImageMutRef<'_, C> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ImageMutRef")
             .field("shape", &self.shape)
@@ -475,7 +475,7 @@ impl<'a, P> ImageMutRef<'a, P> {
     }
 }
 
-impl<'a, P> Image for ImageMutRef<'a, P> {
+impl<P> Image for ImageMutRef<'_, P> {
     type Pixel = P;
 
     fn shape(&self) -> Shape {
@@ -487,13 +487,13 @@ impl<'a, P> Image for ImageMutRef<'a, P> {
     }
 }
 
-impl<'a, P> ImageMut for ImageMutRef<'a, P> {
+impl<P> ImageMut for ImageMutRef<'_, P> {
     fn data_mut(&mut self) -> &mut [Self::Pixel] {
         self.data
     }
 }
 
-impl<'a, I> Image for &'a I
+impl<I> Image for &I
 where
     I: Image + ?Sized,
 {
@@ -508,7 +508,7 @@ where
     }
 }
 
-impl<'a, I> Image for &'a mut I
+impl<I> Image for &mut I
 where
     I: Image + ?Sized,
 {
@@ -523,7 +523,7 @@ where
     }
 }
 
-impl<'a, I> ImageMut for &'a mut I
+impl<I> ImageMut for &mut I
 where
     I: ImageMut + ?Sized,
 {

src/lib.rs

@@ -10,16 +10,16 @@
 //! ## Overview
 //! **Main types are:**
 //! - [`Path`] - Represents the same concept as an [SVG path](https://www.w3.org/TR/SVG11/paths.html),
-//! the easiest way to construct it is with [`Path::builder`] or it can be parsed from SVG path with [`str::parse`].
-//! Path can be stroked with [`Path::stroke`] to generated new path that represents an outline.
+//!   the easiest way to construct it is with [`Path::builder`] or it can be parsed from SVG path with [`str::parse`].
+//!   Path can be stroked with [`Path::stroke`] to generated new path that represents an outline.
 //! - [`Scene`] - Represents an image that has not been rendered yet, multiple scenes
-//! can be composed to construct more complex scene. This is probably the simplest
-//! way to render something useful. See `examples/simple.rs` for a simple example.
-//! It can also be (de)serialized see `data/firefox.scene` for an example.
+//!   can be composed to construct more complex scene. This is probably the simplest
+//!   way to render something useful. See `examples/simple.rs` for a simple example.
+//!   It can also be (de)serialized see `data/firefox.scene` for an example.
 //! - [`Paint`] - Color/Gradient that can be used to fill a path.
 //! - [`Image`] - 2D matrix that can hold and image and used as a target for rendering.
-//! Image can also be written into a file with [`Image::write_bmp`] or to PNG with
-//! `Image::write_png` if `png` feature is enabled.
+//!   Image can also be written into a file with [`Image::write_bmp`] or to PNG with
+//!   `Image::write_png` if `png` feature is enabled.
 #![deny(warnings)]
 #![allow(clippy::excessive_precision)]
 

src/path.rs

@@ -9,7 +9,6 @@ use std::{
     fmt,
     io::{Cursor, Read, Write},
     str::FromStr,
-    usize,
 };
 
 /// Default flatness used during rasterization.
@@ -257,7 +256,7 @@ impl fmt::Display for Path {
             fmt: &'a mut fmt::Formatter<'b>,
         }
 
-        impl<'a, 'b> std::io::Write for FormatterWrite<'a, 'b> {
+        impl std::io::Write for FormatterWrite<'_, '_> {
             fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
                 self.fmt
                     .write_str(
@@ -551,7 +550,7 @@ pub struct PathVerboseDebug<'a> {
     path: &'a Path,
 }
 
-impl<'a> fmt::Debug for PathVerboseDebug<'a> {
+impl fmt::Debug for PathVerboseDebug<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.path.subpaths.is_empty() {
             write!(f, "Empty")?;
@@ -656,7 +655,7 @@ impl<'a> PathFlattenIter<'a> {
     }
 }
 
-impl<'a> Iterator for PathFlattenIter<'a> {
+impl Iterator for PathFlattenIter<'_> {
     type Item = Line;
 
     fn next(&mut self) -> Option<Self::Item> {

src/rasterize.rs

@@ -114,7 +114,7 @@ fn fill_impl(
     }
 }
 
-impl<'a, R: Rasterizer + ?Sized> Rasterizer for &'a R {
+impl<R: Rasterizer + ?Sized> Rasterizer for &R {
     fn mask(
         &self,
         path: &Path,
@@ -197,7 +197,7 @@ pub trait Paint: fmt::Debug {
     fn to_json(&self) -> Result<serde_json::Value, crate::SvgParserError>;
 }
 
-impl<'a, P: Paint> Paint for &'a P {
+impl<P: Paint> Paint for &P {
     fn at(&self, point: Point) -> LinColor {
         (**self).at(point)
     }
@@ -1143,15 +1143,15 @@ mod tests {
         let r1: Box<dyn Rasterizer> = Box::new(ActiveEdgeRasterizer::default());
         for rasterizer in &[r0, r1] {
             img.clear();
-            path.mask(&rasterizer, tr, FillRule::EvenOdd, &mut img);
+            path.mask(rasterizer, tr, FillRule::EvenOdd, &mut img);
             assert_approx_eq!(img.get(y, x0).unwrap(), 0.0, 1e-6);
             assert_approx_eq!(img.get(y, x1).unwrap(), 0.0, 1e-6);
             assert_approx_eq!(img.get(y, x2).unwrap(), 0.0, 1e-6);
             let area = img.iter().sum::<Scalar>();
             assert_approx_eq!(area, 13130.0, 1.0);
 
             img.clear();
-            path.mask(&rasterizer, tr, FillRule::NonZero, &mut img);
+            path.mask(rasterizer, tr, FillRule::NonZero, &mut img);
             assert_approx_eq!(img.get(y, x0).unwrap(), 1.0, 1e-6);
             assert_approx_eq!(img.get(y, x1).unwrap(), 1.0, 1e-6);
             assert_approx_eq!(img.get(y, x2).unwrap(), 0.0, 1e-6);

src/scene.rs

@@ -645,7 +645,7 @@ mod tests {
     use super::*;
     use crate::ActiveEdgeRasterizer;
     type Error = Box<dyn std::error::Error>;
-    const SCENE: &'static str = r##"
+    const SCENE: &str = r##"
     {
         "type": "transform",
         "tr": "translate(7, 7) rotate(45, 7, 7) scale(10)",