Fix compiler warnings and clippy lints

Author: milliams

src/axis.rs

@@ -125,7 +125,7 @@ impl TickSteps {
         let base_step_scale = 10f64.powf(power);
         BASE_STEPS
             .iter()
-            .map(|&s| (s as f64 * base_step_scale))
+            .map(|&s| (f64::from(s) * base_step_scale))
             .collect()
     }
 }
@@ -153,7 +153,7 @@ fn generate_ticks(min: f64, max: f64, step_size: f64) -> Vec<f64> {
             // standard spanning axis
             ticks.extend(
                 (1..)
-                    .map(|n| -1.0 * n as f64 * step_size)
+                    .map(|n| -1.0 * f64::from(n) * step_size)
                     .take_while(|&v| v >= min)
                     .collect::<Vec<f64>>()
                     .iter()
@@ -162,14 +162,14 @@ fn generate_ticks(min: f64, max: f64, step_size: f64) -> Vec<f64> {
             ticks.push(0.0);
             ticks.extend(
                 (1..)
-                    .map(|n| n as f64 * step_size)
+                    .map(|n| f64::from(n) * step_size)
                     .take_while(|&v| v <= max),
             );
         } else {
             // entirely negative axis
             ticks.extend(
                 (1..)
-                    .map(|n| -1.0 * n as f64 * step_size)
+                    .map(|n| -1.0 * f64::from(n) * step_size)
                     .skip_while(|&v| v > max)
                     .take_while(|&v| v >= min)
                     .collect::<Vec<f64>>()
@@ -181,7 +181,7 @@ fn generate_ticks(min: f64, max: f64, step_size: f64) -> Vec<f64> {
         // entirely positive axis
         ticks.extend(
             (1..)
-                .map(|n| n as f64 * step_size)
+                .map(|n| f64::from(n) * step_size)
                 .skip_while(|&v| v < min)
                 .take_while(|&v| v <= max),
         );

src/barchart.rs

@@ -89,8 +89,8 @@ impl BarChart {
         &self.label
     }
 
-    fn get_value(&self) -> &f64 {
-        &self.value
+    fn get_value(&self) -> f64 {
+        self.value
     }
 }
 
@@ -125,10 +125,10 @@ impl CategoricalRepresentation for BarChart {
 
     fn to_text(
         &self,
-        x_axis: &axis::CategoricalAxis,
-        y_axis: &axis::ContinuousAxis,
-        face_width: u32,
-        face_height: u32,
+        _x_axis: &axis::CategoricalAxis,
+        _y_axis: &axis::ContinuousAxis,
+        _face_width: u32,
+        _face_height: u32,
     ) -> String {
         "".into()
     }

src/boxplot.rs

@@ -149,10 +149,10 @@ impl<'a> CategoricalRepresentation for BoxPlot<'a> {
 
     fn to_text(
         &self,
-        x_axis: &axis::CategoricalAxis,
-        y_axis: &axis::ContinuousAxis,
-        face_width: u32,
-        face_height: u32,
+        _x_axis: &axis::CategoricalAxis,
+        _y_axis: &axis::ContinuousAxis,
+        _face_width: u32,
+        _face_height: u32,
     ) -> String {
         "".into()
     }

src/function.rs

@@ -41,13 +41,8 @@ impl Style {
             self.colour = Some(v.clone())
         }
 
-        if let Some(ref v) = other.width {
-            self.width = Some(v.clone())
-        }
-
-        match other.width {
-            Some(v) => self.width = Some(v),
-            None => {}
+        if let Some(v) = other.width {
+            self.width = Some(v)
         }
     }
 }
@@ -90,7 +85,7 @@ impl Function {
     {
         let sampling = (upper - lower) / 200.;
         let samples = (0..)
-            .map(|x| lower + (x as f64 * sampling))
+            .map(|x| lower + (f64::from(x) * sampling))
             .take_while(|&x| x <= upper);
         let values = samples.map(|s| (s, f(s))).collect();
         Function {
@@ -157,10 +152,10 @@ impl ContinuousRepresentation for Function {
 
     fn to_text(
         &self,
-        x_axis: &axis::ContinuousAxis,
-        y_axis: &axis::ContinuousAxis,
-        face_width: u32,
-        face_height: u32,
+        _x_axis: &axis::ContinuousAxis,
+        _y_axis: &axis::ContinuousAxis,
+        _face_width: u32,
+        _face_height: u32,
     ) -> String {
         "".into()
     }

src/histogram.rs

@@ -20,6 +20,8 @@ TODO:
     - What should be the default?
 */
 
+use std;
+
 use svg;
 
 use axis;
@@ -76,9 +78,9 @@ impl Histogram {
         let mut max = v.iter().fold(-1. / 0., |a, &b| f64::max(a, b));
         let mut min = v.iter().fold(1. / 0., |a, &b| f64::min(a, b));
 
-        if min == max {
-            min = min - 0.5;
-            max = max + 0.5;
+        if (min - max).abs() < std::f64::EPSILON {
+            min -= 0.5;
+            max += 0.5;
         }
 
         let mut bins = vec![0; num_bins];
@@ -111,7 +113,7 @@ impl Histogram {
                 .unwrap();
             bins[bin] += 1;
         }
-        let density_per_bin = bins.iter().map(|&x| x as f64 / bin_width).collect();
+        let density_per_bin = bins.iter().map(|&x| f64::from(x) / bin_width).collect();
 
         Histogram {
             bin_bounds: bounds,
@@ -134,7 +136,7 @@ impl Histogram {
 
     fn y_range(&self) -> (f64, f64) {
         let max = *self.bin_counts.iter().max().unwrap();
-        (0., max as f64)
+        (0., f64::from(max))
     }
 
     pub fn style(mut self, style: &Style) -> Self {

src/line.rs

@@ -42,7 +42,7 @@ impl Style {
         }
 
         if let Some(ref v) = other.width {
-            self.width = Some(v.clone())
+            self.width = Some(*v)
         }
     }
 }
@@ -144,10 +144,10 @@ impl ContinuousRepresentation for Line {
 
     fn to_text(
         &self,
-        x_axis: &axis::ContinuousAxis,
-        y_axis: &axis::ContinuousAxis,
-        face_width: u32,
-        face_height: u32,
+        _x_axis: &axis::ContinuousAxis,
+        _y_axis: &axis::ContinuousAxis,
+        _face_width: u32,
+        _face_height: u32,
     ) -> String {
         "".into()
     }

src/page.rs

@@ -57,16 +57,16 @@ impl<'a> Page<'a> {
 
         let x_margin = 80;
         let y_margin = 60;
-        let x_offset = 0.6 * x_margin as f64;
-        let y_offset = 0.6 * y_margin as f64;
+        let x_offset = 0.6 * f64::from(x_margin);
+        let y_offset = 0.6 * f64::from(y_margin);
 
         // TODO put multiple views in correct places
         for &view in &self.views {
             let view_group = view
-                .to_svg((width - x_margin) as f64, (height - y_margin) as f64)?
+                .to_svg(f64::from(width - x_margin), f64::from(height - y_margin))?
                 .set(
                     "transform",
-                    format!("translate({}, {})", x_offset, height as f64 - y_offset),
+                    format!("translate({}, {})", x_offset, f64::from(height) - y_offset),
                 );
             document.append(view_group);
         }

src/scatter.rs

@@ -38,8 +38,8 @@ impl Style {
             self.colour = Some(v.clone())
         }
 
-        if let Some(ref v) = other.size {
-            self.size = Some(v.clone())
+        if let Some(v) = other.size {
+            self.size = Some(v)
         }
     }
 }
@@ -98,7 +98,7 @@ impl Scatter {
         }
 
         Scatter {
-            data: data,
+            data,
             style: Style::new(),
         }
     }

src/svg_render.rs

@@ -174,7 +174,7 @@ where
     for &(x, y) in s {
         let x_pos = value_to_face_offset(x, x_axis, face_width);
         let y_pos = -value_to_face_offset(y, y_axis, face_height);
-        let radius = style.get_size().clone().unwrap_or(5.) as f64;
+        let radius = f64::from(style.get_size().clone().unwrap_or(5.));
         match style.get_marker().clone().unwrap_or(style::Marker::Circle) {
             style::Marker::Circle => {
                 group.append(
@@ -241,7 +241,7 @@ where
         let l_pos = value_to_face_offset(l, x_axis, face_width);
         let u_pos = value_to_face_offset(u, x_axis, face_width);
         let width = u_pos - l_pos;
-        let count_scaled = value_to_face_offset(count as f64, y_axis, face_height);
+        let count_scaled = value_to_face_offset(f64::from(count), y_axis, face_height);
         let rect = node::element::Rectangle::new()
             .set("x", l_pos)
             .set("y", -count_scaled)
@@ -385,7 +385,7 @@ where
 }
 
 pub fn draw_face_barchart<L, S>(
-    d: &f64,
+    d: f64,
     label: &L,
     x_axis: &axis::CategoricalAxis,
     y_axis: &axis::ContinuousAxis,
@@ -406,7 +406,7 @@ where
 
     let box_width = space_per_tick / 2.;
 
-    let box_start = -value_to_face_offset(*d, y_axis, face_height);
+    let box_start = -value_to_face_offset(d, y_axis, face_height);
     let box_end = -value_to_face_offset(0.0, y_axis, face_height);
 
     group.append(

src/text_render.rs

@@ -5,14 +5,13 @@ use std::collections::HashMap;
 
 use axis;
 use histogram;
-use scatter;
 use style;
 use utils::PairWise;
 
 // Given a value like a tick label or a bin count,
 // calculate how far from the x-axis it should be plotted
 fn value_to_axis_cell_offset(value: f64, axis: &axis::ContinuousAxis, face_cells: u32) -> i32 {
-    let data_per_cell = (axis.max() - axis.min()) / face_cells as f64;
+    let data_per_cell = (axis.max() - axis.min()) / f64::from(face_cells);
     ((value - axis.min()) / data_per_cell).round() as i32
 }
 
@@ -123,7 +122,7 @@ fn create_x_axis_labels(x_tick_map: &HashMap<i32, f64>) -> Vec<XAxisLabel> {
         .iter()
         .map(|(&offset, &tick)| XAxisLabel {
             text: tick.to_string(),
-            offset: offset,
+            offset,
         }).collect();
     ls.sort_by_key(|l| l.offset);
     ls
@@ -288,7 +287,7 @@ pub fn render_face_bars(
         .map(|&bin| match bin {
             None => 0,
             Some(b) => {
-                value_to_axis_cell_offset(h.bin_counts[b as usize] as f64, y_axis, face_height)
+                value_to_axis_cell_offset(f64::from(h.bin_counts[b as usize]), y_axis, face_height)
             }
         }).collect();
 
@@ -621,6 +620,7 @@ mod tests {
 
     #[test]
     fn test_render_face_points() {
+        use scatter;
         let data = vec![
             (-3.0, 2.3),
             (-1.6, 5.3),