Apply some clippy lints

Author: AaronErhardt

plotters-backend/src/lib.rs

@@ -233,8 +233,8 @@ pub trait DrawingBackend: Sized {
             .layout_box(text)
             .map_err(|e| DrawingErrorKind::FontError(Box::new(e)))?;
         let ((min_x, min_y), (max_x, max_y)) = layout;
-        let width = (max_x - min_x) as i32;
-        let height = (max_y - min_y) as i32;
+        let width = max_x - min_x;
+        let height = max_y - min_y;
         let dx = match style.anchor().h_pos {
             HPos::Left => 0,
             HPos::Right => -width,
@@ -247,15 +247,16 @@ pub trait DrawingBackend: Sized {
         };
         let trans = style.transform();
         let (w, h) = self.get_size();
-        match style.draw(text, (0, 0), |x, y, color| {
+        let drawing_result = style.draw(text, (0, 0), |x, y, color| {
             let (x, y) = trans.transform(x + dx - min_x, y + dy - min_y);
             let (x, y) = (pos.0 + x, pos.1 + y);
             if x >= 0 && x < w as i32 && y >= 0 && y < h as i32 {
                 self.draw_pixel((x, y), color)
             } else {
                 Ok(())
             }
-        }) {
+        });
+        match drawing_result {
             Ok(drawing_result) => drawing_result,
             Err(font_error) => Err(DrawingErrorKind::FontError(Box::new(font_error))),
         }

plotters-backend/src/rasterizer/circle.rs

@@ -168,7 +168,6 @@ fn draw_annulus<B: DrawingBackend, S: BackendStyle>(
             radius.0 as f64 - a0,
             a1.floor(),
             |h, (f, t)| {
-                let h = h as i32;
                 let f = f as i32;
                 let t = t as i32;
                 check_result!(b.draw_line(

plotters-backend/src/rasterizer/line.rs

@@ -110,7 +110,7 @@ pub fn draw_line<DB: DrawingBackend, S: BackendStyle>(
     }
 
     if to.0 > batch_limit && y < f64::from(to.1) {
-        let x = batch_limit as i32 + 1;
+        let x = batch_limit + 1;
         if 1.0 + y.floor() - y > 1e-5 {
             check_result!(put_pixel((x, y as i32), 1.0 + y.floor() - y));
         }

plotters-backend/src/rasterizer/path.rs

@@ -145,8 +145,7 @@ pub fn polygonize(vertices: &[BackendCoord], stroke_width: u32) -> Vec<BackendCo
 }
 
 #[cfg(test)]
-mod test
-{
+mod test {
     use super::*;
 
     /// Test for regression with respect to https://github.com/plotters-rs/plotters/issues/562
@@ -168,6 +167,6 @@ mod test
         compute_polygon_vertex(&path, 2.0, buf.as_mut());
         assert!(!buf.is_empty());
         let buf2 = vec![(18, 12)];
-        assert_eq!(buf,buf2);
+        assert_eq!(buf, buf2);
     }
-}
+}

plotters-backend/src/text.rs

@@ -107,7 +107,6 @@ pub mod text_anchor {
         pub fn new(h_pos: HPos, v_pos: VPos) -> Self {
             Pos { h_pos, v_pos }
         }
-
     }
 }
 

plotters-bitmap/src/bitmap/target.rs

@@ -24,7 +24,7 @@ impl<'a> Buffer<'a> {
         match self {
             #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
             Buffer::Owned(buf) => &mut buf[..],
-            Buffer::Borrowed(buf) => *buf,
+            Buffer::Borrowed(buf) => buf,
         }
     }
 }

plotters-svg/src/svg.rs

@@ -17,11 +17,11 @@ use std::path::Path;
 
 fn make_svg_color(color: BackendColor) -> String {
     let (r, g, b) = color.rgb;
-    return format!("#{:02X}{:02X}{:02X}", r, g, b);
+    format!("#{:02X}{:02X}{:02X}", r, g, b)
 }
 
 fn make_svg_opacity(color: BackendColor) -> String {
-    return format!("{}", color.alpha);
+    format!("{}", color.alpha)
 }
 
 enum Target<'a> {

plotters/src/coord/ranged1d/combinators/group_by.rs

@@ -85,8 +85,7 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
             let outer_ticks = idx_iter;
             let outer_tick_size = interval * self.1;
             let inner_ticks_per_group = hint.max_num_points() / outer_ticks.len();
-            let inner_ticks =
-                (outer_tick_size + inner_ticks_per_group - 1) / inner_ticks_per_group;
+            let inner_ticks = (outer_tick_size + inner_ticks_per_group - 1) / inner_ticks_per_group;
             let inner_ticks: Vec<_> = (0..(outer_tick_size / inner_ticks))
                 .map(move |x| x * inner_ticks)
                 .collect();

plotters/src/coord/ranged1d/combinators/linspace.rs

@@ -315,7 +315,7 @@ where
     }
 
     fn from_index(&self, idx: usize) -> Option<T::ValueType> {
-        self.grid_value.get(idx).map(Clone::clone)
+        self.grid_value.get(idx).cloned()
     }
 }
 

plotters/src/coord/ranged1d/types/datetime.rs

@@ -779,7 +779,7 @@ impl Ranged for RangedDuration {
 
                 while current < self.1 {
                     ret.push(current);
-                    current = current + Duration::nanoseconds(period as i64);
+                    current += Duration::nanoseconds(period as i64);
                 }
 
                 return ret;
@@ -818,7 +818,7 @@ impl Ranged for RangedDuration {
 
         while current < self.1 {
             ret.push(current);
-            current = current + Duration::days(i64::from(days_per_tick));
+            current += Duration::days(i64::from(days_per_tick));
         }
 
         ret