Cleanup clippy errors

Author: 38

src/chart/builder.rs

@@ -155,6 +155,7 @@ impl<'a, 'b, DB: DrawingBackend> ChartBuilder<'a, 'b, DB> {
         self
     }
 
+    #[allow(clippy::type_complexity)]
     #[deprecated(
         note = "`build_ranged` has been renamed to `build_cartesian_2d` and is to be removed in the future."
     )]

src/chart/series.rs

@@ -17,7 +17,9 @@ pub struct SeriesAnno<'a, DB: DrawingBackend> {
 }
 
 impl<'a, DB: DrawingBackend> SeriesAnno<'a, DB> {
+    #[allow(clippy::option_as_ref_deref)]
     pub(crate) fn get_label(&self) -> &str {
+        // TODO: Change this when we bump the MSRV
         self.label.as_ref().map(|x| x.as_str()).unwrap_or("")
     }
 

src/chart/state.rs

@@ -31,22 +31,13 @@ use plotters_backend::DrawingBackend;
 ///    chart.plotting_area().fill(&WHITE).unwrap(); // Clear the previously drawn graph
 ///    // At this point, you are able to draw next frame
 ///```
+///#[derive(Clone)]
 pub struct ChartState<CT: CoordTranslate> {
     drawing_area_pos: (i32, i32),
     drawing_area_size: (u32, u32),
     coord: CT,
 }
 
-impl<'a, CT: CoordTranslate + Clone> Clone for ChartState<CT> {
-    fn clone(&self) -> Self {
-        Self {
-            drawing_area_size: self.drawing_area_size,
-            drawing_area_pos: self.drawing_area_pos,
-            coord: self.coord.clone(),
-        }
-    }
-}
-
 impl<'a, DB: DrawingBackend, CT: CoordTranslate> From<ChartContext<'a, DB, CT>> for ChartState<CT> {
     fn from(chart: ChartContext<'a, DB, CT>) -> ChartState<CT> {
         ChartState {

src/coord/ranged1d/combinators/group_by.rs

@@ -92,7 +92,6 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
                 .collect();
             let size = self.0.size();
             return outter_ticks
-                .into_iter()
                 .map(|base| inner_ticks.iter().map(move |&ofs| base * self.1 + ofs))
                 .flatten()
                 .take_while(|&idx| idx < size)
@@ -101,7 +100,6 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
         }
 
         idx_iter
-            .into_iter()
             .map(|x| self.0.from_index(x * self.1).unwrap())
             .collect()
     }

src/coord/ranged1d/combinators/linspace.rs

@@ -288,7 +288,7 @@ where
     }
 
     fn key_points<Hint: KeyPointHint>(&self, hint: Hint) -> Vec<T::ValueType> {
-        if self.grid_value.len() == 0 {
+        if self.grid_value.is_empty() {
             return vec![];
         }
         let idx_range: RangedCoordusize = (0..(self.grid_value.len() - 1)).into();

src/coord/ranged1d/combinators/logarithmic.rs

@@ -49,16 +49,23 @@ impl_log_scalable!(i, u64);
 impl_log_scalable!(f, f32);
 impl_log_scalable!(f, f64);
 
-/// The logarithmic coodinate decorator.
-/// This decorator is used to make the axis rendered as logarithmically.
-pub struct LogRange<V: LogScalable>(pub Range<V>);
+pub trait IntoLogRange {
+    type ValueType: LogScalable;
+    fn log_scale(self) -> LogRange<Self::ValueType>;
+}
 
-impl<V: LogScalable + Clone> Clone for LogRange<V> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
+impl<T: LogScalable> IntoLogRange for Range<T> {
+    type ValueType = T;
+    fn log_scale(self) -> LogRange<T> {
+        LogRange(self)
     }
 }
 
+/// The logarithmic coodinate decorator.
+/// This decorator is used to make the axis rendered as logarithmically.
+#[derive(Clone)]
+pub struct LogRange<V: LogScalable>(pub Range<V>);
+
 impl<V: LogScalable> From<LogRange<V>> for LogCoord<V> {
     fn from(range: LogRange<V>) -> LogCoord<V> {
         LogCoord {

src/coord/ranged1d/combinators/mod.rs

@@ -8,7 +8,7 @@ mod linspace;
 pub use linspace::{IntoLinspace, Linspace};
 
 mod logarithmic;
-pub use logarithmic::{LogCoord, LogRange, LogScalable};
+pub use logarithmic::{IntoLogRange, LogCoord, LogRange, LogScalable};
 
 mod nested;
 pub use nested::{BuildNestedCoord, NestedRange, NestedValue};

src/coord/ranged1d/combinators/nested.rs

@@ -105,7 +105,7 @@ impl<P: DiscreteRanged, S: Ranged> Ranged for NestedRange<P, S> {
             self.primary
                 .key_points(hint)
                 .into_iter()
-                .map(|x| NestedValue::Category(x))
+                .map(NestedValue::Category)
                 .collect()
         } else {
             let secondary_size =
@@ -176,10 +176,7 @@ where
             .map(|value| builder(value).into())
             .collect();
 
-        NestedRange {
-            primary,
-            secondary: secondary,
-        }
+        NestedRange { primary, secondary }
     }
 }
 

src/coord/ranged1d/combinators/partial_axis.rs

@@ -6,6 +6,7 @@ use std::ops::Range;
 /// This axis decorator will make the axis partially display on the axis.
 /// At some time, we want the axis only covers some part of the value.
 /// This decorator will have an additional display range defined.
+#[derive(Clone)]
 pub struct PartialAxis<R: Ranged>(R, Range<R::ValueType>);
 
 /// The trait for the types that can be converted into a partial axis
@@ -24,15 +25,6 @@ pub trait IntoPartialAxis: AsRangedCoord {
 
 impl<R: AsRangedCoord> IntoPartialAxis for R {}
 
-impl<R: Ranged + Clone> Clone for PartialAxis<R>
-where
-    <R as Ranged>::ValueType: Clone,
-{
-    fn clone(&self) -> Self {
-        PartialAxis(self.0.clone(), self.1.clone())
-    }
-}
-
 impl<R: Ranged> Ranged for PartialAxis<R>
 where
     R::ValueType: Clone,

src/coord/ranged1d/discrete.rs

@@ -91,14 +91,9 @@ where
 /// This is used in histogram types, which uses a discrete coordinate as the buckets. The segmented coord always emits `CenterOf(value)` key points, thus it allows all the label and tick marks
 /// of the coordinate rendered in the middle of each segment.
 /// The coresponding trait [IntoSegmentedCoord](trait.IntoSegmentedCoord.html) is used to apply this decorator to coordinates.
+#[derive(Clone)]
 pub struct SegmentedCoord<D: DiscreteRanged>(D);
 
-impl<D: DiscreteRanged + Clone> Clone for SegmentedCoord<D> {
-    fn clone(&self) -> Self {
-        SegmentedCoord(self.0.clone())
-    }
-}
-
 /// The trait for types that can decorated by [SegmentedCoord](struct.SegmentedCoord.html) decorator.
 pub trait IntoSegmentedCoord: AsRangedCoord
 where
@@ -191,12 +186,10 @@ impl<D: DiscreteRanged> DiscreteRanged for SegmentedCoord<D> {
     }
 
     fn from_index(&self, idx: usize) -> Option<Self::ValueType> {
-        if idx < self.0.size() {
-            self.0.from_index(idx).map(|x| SegmentValue::Exact(x))
-        } else if idx == self.0.size() {
-            Some(SegmentValue::Last)
-        } else {
-            None
+        match idx {
+            idx if idx < self.0.size() => self.0.from_index(idx).map(SegmentValue::Exact),
+            idx if idx == self.0.size() => Some(SegmentValue::Last),
+            _ => None,
         }
     }
 }