Tweak code to be more idiomatic.

src/args.rs

@@ -8,8 +8,8 @@ pub struct Args {
     #[arg(long, default_value = "mesh.stl")]
     pub output: String,
 
-    /// Shape of the cap.
+    /// Run web server.
-    #[arg(long, default_value_t = false)]
+    #[arg(long, default_value_t = true)]
     pub run_server: bool,
 
     /// Height of total mushroom in millimeters.
@@ -42,12 +42,10 @@ impl Args {
         // Default values are all based on height.
         let stalk_h: f32 = if self.stalk_h != 0 {
             self.stalk_h as f32
+        } else if self.cap_h != 0 {
+            (self.height - self.cap_h) as f32
         } else {
-            if self.cap_h != 0 {
+            self.height as f32 * 0.66
-                (self.height - self.cap_h) as f32
-            } else {
-                self.height as f32 * 0.66
-            }
         };
         let stalk_r: f32 = if self.stalk_d != 0 {
             self.stalk_d as f32

src/layers.rs

@@ -9,12 +9,18 @@ pub struct Layer {
     pub radius: f32,
 }
 
+impl Default for Layer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Layer {
     pub fn new() -> Self {
-        return Self {
+        Self {
             center: Vertex::new([1.0, 0.0, 0.0]),
             radius: 0.0,
-        };
+        }
     }
 }
 
@@ -31,6 +37,6 @@ impl Layers {
         for layer in &self.layers {
             max_radius = max_radius.max(layer.radius);
         }
-        return max_radius;
+        max_radius
     }
 }

src/mushroom.rs

@@ -34,11 +34,11 @@ pub struct Mushroom {
 impl Mushroom {
     /// Total height of the mushroom.
     pub fn height(&self) -> f32 {
-        return self.stalk_h + self.cap_h;
+        self.stalk_h + self.cap_h
     }
 
     /// Maximum radius of the mushroom.
     pub fn radius(&self) -> f32 {
-        return self.stalk_r.max(self.cap_r) / 2.0;
+        self.stalk_r.max(self.cap_r) / 2.0
     }
 }

src/render.rs

@@ -19,7 +19,7 @@ fn new_triangle(p1: &Vertex, p2: &Vertex, p3: &Vertex) -> stl_io::Triangle {
 
     stl_io::Triangle {
         normal: Normal::new([n_x, n_y, n_z]),
-        vertices: [p1.clone(), p2.clone(), p3.clone()],
+        vertices: [*p1, *p2, *p3],
     }
 }
 
@@ -28,7 +28,7 @@ fn radian_steps(steps: u32) -> Vec<f32> {
     let counter = 0..steps;
     let stepsize = std::f64::consts::TAU / steps as f64;
 
-    return counter.map(|i| (i as f64 * stepsize) as f32).collect();
+    counter.map(|i| (i as f64 * stepsize) as f32).collect()
 }
 
 /// Find a point on the cirle at a given angle (in radians).
@@ -37,27 +37,27 @@ fn vertex_on_circle(center: &Vertex, radius: f32, angle: f32) -> Vertex {
     let y = center[1] + (radius * angle.sin());
     let z = center[2];
 
-    return Vertex::new([x, y, z]);
+    Vertex::new([x, y, z])
 }
 
 fn vertexes_on_circle(layer: &Layer, steps: u32) -> Vec<Vertex> {
-    return radian_steps(steps)
+    radian_steps(steps)
         .iter()
         .map(|angle| vertex_on_circle(&layer.center, layer.radius, *angle))
-        .collect();
+        .collect()
 }
 
-fn tube_base(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {
+fn tube_base(center: &Vertex, edge: &[Vertex]) -> Vec<Triangle> {
     let mut result = Vec::with_capacity(edge.len());
 
     for i in 0..edge.len() {
-        result.push(new_triangle(&center, &edge[(i + 1) % edge.len()], &edge[i]));
+        result.push(new_triangle(center, &edge[(i + 1) % edge.len()], &edge[i]));
     }
 
-    return result;
+    result
 }
 
-fn tube_sides(botoom_edge: &Vec<Vertex>, top_edge: &Vec<Vertex>) -> Vec<Triangle> {
+fn tube_sides(botoom_edge: &[Vertex], top_edge: &[Vertex]) -> Vec<Triangle> {
     assert_eq!(botoom_edge.len(), top_edge.len());
 
     let mut result = Vec::with_capacity(2 * botoom_edge.len());
@@ -69,15 +69,15 @@ fn tube_sides(botoom_edge: &Vec<Vertex>, top_edge: &Vec<Vertex>) -> Vec<Triangle
         result.push(new_triangle(&botoom_edge[i], &botoom_edge[j], &top_edge[j]));
     }
 
-    return result;
+    result
 }
 
-fn tube_top(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {
+fn tube_top(center: &Vertex, edge: &[Vertex]) -> Vec<Triangle> {
     // The top is the same, except the normals are reversed. We can do that by reversing the order of the vertexes.
-    let mut edge = edge.clone();
+    let mut edge = edge.to_owned();
     edge.reverse();
 
-    return tube_base(&center, &edge);
+    tube_base(center, &edge)
 }
 
 pub fn render(layers: &Layers, resolution: f32) -> Vec<Triangle> {
@@ -91,7 +91,7 @@ pub fn render(layers: &Layers, resolution: f32) -> Vec<Triangle> {
     let mut layer_vertexes: Vec<Vec<Vertex>> = Vec::new();
 
     for layer in &layers.layers {
-        layer_vertexes.push(vertexes_on_circle(&layer, circle_steps));
+        layer_vertexes.push(vertexes_on_circle(layer, circle_steps));
     }
 
     let mut result: Vec<Triangle> = Vec::new();
@@ -100,9 +100,9 @@ pub fn render(layers: &Layers, resolution: f32) -> Vec<Triangle> {
     for i in 0..layer_vertexes.len() - 1 {
         result.append(&mut tube_sides(&layer_vertexes[i], &layer_vertexes[i + 1]));
     }
-    result.append(&mut tube_top(&layers.top, &layer_vertexes.last().unwrap()));
+    result.append(&mut tube_top(&layers.top, layer_vertexes.last().unwrap()));
 
-    return result;
+    result
 }
 
 #[cfg(test)]

src/server.rs

@@ -37,7 +37,7 @@ fn generate_binary_stl(mushroom: mushroom::Mushroom) -> Vec<u8> {
     // Generate / return the byte array.
     let mut binary_stl = Vec::<u8>::new();
     stl_io::write_stl(&mut binary_stl, mesh.iter()).unwrap();
-    return binary_stl;
+    binary_stl
 }
 
 /// Responder class for BinarySTL or Error.
@@ -56,13 +56,13 @@ enum AsyncBinaryStlResponder {
 async fn generate_helper(mushroom: mushroom::Mushroom) -> AsyncBinaryStlResponder {
     let result = rocket::tokio::task::spawn_blocking(move || {
         // Return the byte array.
-        return generate_binary_stl(mushroom);
+        generate_binary_stl(mushroom)
     })
     .await;
 
-    return if result.is_ok() {
+    if let Ok(inner) = result {
         AsyncBinaryStlResponder::BinaryStl {
-            inner: result.unwrap(),
+            inner,
             header: ContentType::parse_flexible("model/x.stl-binary").unwrap(),
             filename: Header {
                 name: "Content-Disposition".into(),
@@ -71,7 +71,7 @@ async fn generate_helper(mushroom: mushroom::Mushroom) -> AsyncBinaryStlResponde
         }
     } else {
         AsyncBinaryStlResponder::Error("Internal JoinError")
-    };
+    }
 }
 
 /// Handler for /generate GEt endpoint.
@@ -91,5 +91,5 @@ async fn generate(
         cap_style: cap_style.unwrap_or(mushroom::CapStyle::Dome),
     };
 
-    return generate_helper(mushroom).await;
+    generate_helper(mushroom).await
 }

src/translate.rs

@@ -6,9 +6,9 @@ use crate::mushroom::{CapStyle, Mushroom};
 fn stalk_layers(mushroom: &Mushroom, base: &Vertex, _resolution: f32) -> Vec<layers::Layer> {
     let stalk_top = Vertex::new([base[0], base[1], base[2] + mushroom.stalk_h]);
 
-    return [
+    [
         layers::Layer {
-            center: base.clone(),
+            center: *base,
             radius: mushroom.stalk_r,
         },
         layers::Layer {
@@ -16,15 +16,15 @@ fn stalk_layers(mushroom: &Mushroom, base: &Vertex, _resolution: f32) -> Vec<lay
             radius: mushroom.stalk_r,
         },
     ]
-    .to_vec();
+    .to_vec()
 }
 
 fn cap_layers_cylinder(mushroom: &Mushroom, base: &Vertex) -> Vec<layers::Layer> {
     let top = Vertex::new([base[0], base[1], base[2] + mushroom.cap_h]);
 
-    return [
+    [
         layers::Layer {
-            center: base.clone(),
+            center: *base,
             radius: mushroom.cap_r,
         },
         layers::Layer {
@@ -32,7 +32,7 @@ fn cap_layers_cylinder(mushroom: &Mushroom, base: &Vertex) -> Vec<layers::Layer>
             radius: mushroom.cap_r,
         },
     ]
-    .to_vec();
+    .to_vec()
 }
 
 fn cap_layers_dome(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec<layers::Layer> {
@@ -47,7 +47,7 @@ fn cap_layers_dome(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec<l
 
         result.push(layers::Layer {
             center: Vertex::new([base[0], base[1], base[2] + height]),
-            radius: radius,
+            radius,
         });
 
         height += resolution;
@@ -56,7 +56,7 @@ fn cap_layers_dome(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec<l
         }
     }
 
-    return result;
+    result
 }
 
 fn cap_layers_pointed(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec<layers::Layer> {
@@ -112,7 +112,7 @@ fn cap_layers_pointed(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Ve
 
     // TODO:
     // Investigate using spline to generate a pointed style cap.
-    return cap_layers_dome(mushroom, base, resolution);
+    cap_layers_dome(mushroom, base, resolution)
 }
 
 fn cap_layers(mushroom: &Mushroom, base: &Vertex, resolution: f32) -> Vec<layers::Layer> {
@@ -144,5 +144,5 @@ pub fn mushroom(mushroom: &Mushroom, resolution: f32) -> layers::Layers {
     let mut layers: Vec<layers::Layer> = Vec::new();
     layers.append(&mut stalk_layers);
     layers.append(&mut cap_layers);
-    return layers::Layers { base, top, layers };
+    layers::Layers { base, top, layers }
 }