Merge pull request #714 from dcampbell24/fix-lints

Fix lints

Author: AaronErhardt

plotters-backend/src/lib.rs

@@ -26,7 +26,7 @@
   features, you need to play with `ensure_prepared` and `present` method. The following figure illustrates how Plotters operates a drawing backend.
 
   - `ensure_prepared` - Called before each time when plotters want to draw. This function should initialize the backend for current frame, if the backend is already prepared
-     for a frame, this function should simply do nothing.
+    for a frame, this function should simply do nothing.
   - `present` - Called when plotters want to finish current frame drawing
 
 

plotters-backend/src/text.rs

@@ -217,7 +217,7 @@ pub trait BackendTextStyle {
         text_anchor::Pos::default()
     }
 
-    fn family(&self) -> FontFamily;
+    fn family(&self) -> FontFamily<'_>;
 
     #[allow(clippy::type_complexity)]
     fn layout_box(&self, text: &str) -> Result<((i32, i32), (i32, i32)), Self::FontError>;

plotters-bitmap/src/bitmap.rs

@@ -142,7 +142,7 @@ impl<'a, P: PixelFormat> BitMapBackend<'a, P> {
     ///
     /// - `area_size`: The size of the area
     /// - **returns**: The split backends that can be rendered in parallel
-    pub fn split(&mut self, area_size: &[u32]) -> Vec<BitMapBackend<P>> {
+    pub fn split(&mut self, area_size: &[u32]) -> Vec<BitMapBackend<'_, P>> {
         let (w, h) = self.get_size();
         let buf = self.get_raw_pixel_buffer();
 

plotters-bitmap/src/bitmap_pixel/bgrx.rs

@@ -193,7 +193,7 @@ impl PixelFormat for BGRXPixel {
                         // TODO: Consider using AVX instructions when possible
                         let ptr = p as *mut [u8; 8] as *mut u64;
                         unsafe {
-                            let d: u64 = std::mem::transmute([
+                            let d: u64 = u64::from_ne_bytes([
                                 b, g, r, 0, b, g, r, 0, // QW1
                             ]);
                             ptr.write_unaligned(d);

plotters/src/chart/context/cartesian3d/draw_impl.rs

@@ -114,6 +114,8 @@ where
         }
         Ok(())
     }
+
+    #[allow(clippy::needless_range_loop)]
     #[allow(clippy::type_complexity)]
     pub(crate) fn draw_axis(
         &mut self,

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

@@ -45,7 +45,7 @@ impl<T: AsRangedCoord + Sized> ToGroupByRange for T where T::CoordDescType: Disc
 
 impl<T: DiscreteRanged> DiscreteRanged for GroupBy<T> {
     fn size(&self) -> usize {
-        (self.0.size() + self.1 - 1) / self.1
+        self.0.size().div_ceil(self.1)
     }
     fn index_of(&self, value: &Self::ValueType) -> Option<usize> {
         self.0.index_of(value).map(|idx| idx / self.1)
@@ -75,8 +75,9 @@ impl<T: DiscreteRanged> Ranged for GroupBy<T> {
         let range = 0..(self.0.size() + self.1) / self.1;
         //let logic_range: RangedCoordusize = range.into();
 
-        let interval =
-            ((range.end - range.start + hint.bold_points() - 1) / hint.bold_points()).max(1);
+        let interval = (range.end - range.start)
+            .div_ceil(hint.bold_points())
+            .max(1);
         let count = (range.end - range.start) / interval;
 
         let idx_iter = (0..hint.bold_points()).map(|x| x * interval);
@@ -85,7 +86,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.div_ceil(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/types/datetime.rs

@@ -769,7 +769,7 @@ impl Ranged for RangedDuration {
             if let Some(period) = compute_period_per_point(total_ns as u64, max_points, false) {
                 let mut start_ns = self.0.num_nanoseconds().unwrap();
 
-                if start_ns as u64 % period > 0 {
+                if !(start_ns as u64).is_multiple_of(period) {
                     if start_ns > 0 {
                         start_ns += period as i64 - (start_ns % period as i64);
                     } else {

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

@@ -1,10 +1,13 @@
 use std::convert::TryFrom;
 use std::ops::Range;
 
-use crate::coord::{combinators::WithKeyPoints, ranged1d::{
-    AsRangedCoord, DefaultFormatting, DiscreteRanged, KeyPointHint, NoDefaultFormatting, Ranged,
-    ReversibleRanged, ValueFormatter,
-}};
+use crate::coord::{
+    combinators::WithKeyPoints,
+    ranged1d::{
+        AsRangedCoord, DefaultFormatting, DiscreteRanged, KeyPointHint, NoDefaultFormatting,
+        Ranged, ReversibleRanged, ValueFormatter,
+    },
+};
 
 macro_rules! impl_discrete_trait {
     ($name:ident) => {

plotters/src/element/image.rs

@@ -147,7 +147,7 @@ impl<'a, Coord, P: PixelFormat> BitMapElement<'a, Coord, P> {
     /// Copy the existing bitmap element to another location
     ///
     /// - `pos`: The new location to copy
-    pub fn copy_to<Coord2>(&self, pos: Coord2) -> BitMapElement<Coord2, P> {
+    pub fn copy_to<Coord2>(&self, pos: Coord2) -> BitMapElement<'_, Coord2, P> {
         BitMapElement {
             image: Buffer::Borrowed(self.image.borrow()),
             size: self.size,
@@ -165,7 +165,7 @@ impl<'a, Coord, P: PixelFormat> BitMapElement<'a, Coord, P> {
 
     /// Make the bitmap element as a bitmap backend, so that we can use
     /// plotters drawing functionality on the bitmap element
-    pub fn as_bitmap_backend(&mut self) -> BitMapBackend<P> {
+    pub fn as_bitmap_backend(&mut self) -> BitMapBackend<'_, P> {
         BitMapBackend::with_buffer_and_format(self.image.to_mut(), self.size).unwrap()
     }
 }

plotters/src/element/text.rs

@@ -148,7 +148,7 @@ fn layout_multiline_text<'a, F: FnMut(&'a str)>(
 
                 let end_idx = match indices.peek() {
                     Some(idx) => *idx,
-                    None => line.bytes().len(),
+                    None => line.len(),
                 };
 
                 Some(&line[start_idx..end_idx])