refactor: clippy fixes

Author: roderickvd

benches/effects.rs

@@ -60,7 +60,7 @@ fn agc_enabled(bencher: Bencher) {
 #[cfg(feature = "experimental")]
 #[divan::bench]
 fn agc_disabled(bencher: Bencher) {
-    bencher.with_inputs(|| music_wav()).bench_values(|source| {
+    bencher.with_inputs(music_wav).bench_values(|source| {
         // Create the AGC source
         let amplified_source = source.automatic_gain_control(
             1.0,   // target_level

examples/error_callback.rs

@@ -17,7 +17,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             // Filter for where err is a DeviceNotAvailable error.
             if let cpal::StreamError::DeviceNotAvailable = err {
                 if let Err(e) = tx.send(err) {
-                    eprintln!("Error emitting StreamError: {}", e);
+                    eprintln!("Error emitting StreamError: {e}");
                 }
             }
         })
@@ -34,7 +34,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         // Here we print the error that was emitted by the error callback.
         // but in a real application we may want to destroy the stream and
         // try to reopen it, either with the same device or a different one.
-        eprintln!("Error with stream {}", err);
+        eprintln!("Error with stream {err}");
     }
 
     Ok(())

examples/limit_settings.rs

@@ -44,7 +44,7 @@ fn main() {
 
     // Show peak reduction
     let max_sample = samples.iter().fold(0.0f32, |acc, &x| acc.max(x.abs()));
-    println!("  Peak amplitude after limiting: {:.3}", max_sample);
+    println!("  Peak amplitude after limiting: {max_sample:.3}");
     println!();
 
     println!("Example 4: Custom settings with builder pattern");
@@ -138,12 +138,11 @@ fn main() {
         strict_limiting.threshold
     );
     println!("    Original max amplitude: {AMPLITUDE}");
-    println!("    Target threshold: {:.3}", target_linear);
-    println!("    Early peak (0-500 samples): {:.3}", early_peak);
-    println!("    Mid peak (1000-1500 samples): {:.3}", mid_peak);
-    println!("    Settled peak (2000+ samples): {:.3}", settled_peak);
+    println!("    Target threshold: {target_linear:.3}");
+    println!("    Early peak (0-500 samples): {early_peak:.3}");
+    println!("    Mid peak (1000-1500 samples): {mid_peak:.3}");
+    println!("    Settled peak (2000+ samples): {settled_peak:.3}");
     println!(
-        "    ALL samples now well below 1.0: max = {:.3}",
-        max_settled
+        "    ALL samples now well below 1.0: max = {max_settled:.3}"
     );
 }

examples/music_m4a.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 
 fn main() -> Result<(), Box<dyn Error>> {
     let stream_handle = rodio::OutputStreamBuilder::open_default_stream()?;
-    let sink = rodio::Sink::connect_new(&stream_handle.mixer());
+    let sink = rodio::Sink::connect_new(stream_handle.mixer());
 
     let file = std::fs::File::open("assets/music.m4a")?;
     sink.append(rodio::Decoder::try_from(file)?);

src/conversions/sample_rate.rs

@@ -352,7 +352,7 @@ mod test {
             let duration =
                 Duration::from_secs_f32(resampled.count() as f32 / to as f32);
 
-            let delta = if d < duration { duration - d } else { d - duration };
+            let delta = duration.abs_diff(d);
             TestResult::from_bool(delta < Duration::from_millis(1))
         }
     }

src/decoder/symphonia.rs

@@ -267,7 +267,7 @@ impl fmt::Display for SeekError {
                 write!(f, "The decoder needs to know the length of the file/byte stream to be able to seek backwards. You can set that by using the `DecoderBuilder` or creating a decoder using `Decoder::try_from(some_file)`.")
             }
             SeekError::Demuxer(err) => {
-                write!(f, "Demuxer failed to seek: {:?}", err)
+                write!(f, "Demuxer failed to seek: {err:?}")
             }
         }
     }

src/math.rs

@@ -165,17 +165,15 @@ mod test {
 
             assert!(
                 relative_error < MAX_RELATIVE_ERROR,
-                "Implementation precision failed for {}dB: exact {:.8}, got {:.8}, relative error: {:.2e}",
-                db, exact_linear, actual_linear, relative_error
+                "Implementation precision failed for {db}dB: exact {exact_linear:.8}, got {actual_linear:.8}, relative error: {relative_error:.2e}"
             );
 
             // Sanity check: ensure we're in the right order of magnitude as Wikipedia data
             // This is lenient to account for rounding in the reference values
             let magnitude_ratio = actual_linear / wikipedia_linear;
             assert!(
                 magnitude_ratio > 0.99 && magnitude_ratio < 1.01,
-                "Result magnitude differs significantly from Wikipedia reference for {}dB: Wikipedia {}, got {}, ratio: {:.4}",
-                db, wikipedia_linear, actual_linear, magnitude_ratio
+                "Result magnitude differs significantly from Wikipedia reference for {db}dB: Wikipedia {wikipedia_linear}, got {actual_linear}, ratio: {magnitude_ratio:.4}"
             );
         }
     }
@@ -197,8 +195,7 @@ mod test {
 
                 assert!(
                     relative_error < MAX_RELATIVE_ERROR,
-                    "Linear to dB conversion precision failed for {}: exact {:.8}, got {:.8}, relative error: {:.2e}",
-                    linear, exact_db, actual_db, relative_error
+                    "Linear to dB conversion precision failed for {linear}: exact {exact_db:.8}, got {actual_db:.8}, relative error: {relative_error:.2e}"
                 );
             } else {
                 // Use absolute error for values very close to 0 dB (linear ≈ 1.0)
@@ -207,8 +204,7 @@ mod test {
 
                 assert!(
                     absolute_error < MAX_ABSOLUTE_ERROR,
-                    "Linear to dB conversion precision failed for {}: exact {:.8}, got {:.8}, absolute error: {:.2e}",
-                    linear, exact_db, actual_db, absolute_error
+                    "Linear to dB conversion precision failed for {linear}: exact {exact_db:.8}, got {actual_db:.8}, absolute error: {absolute_error:.2e}"
                 );
             }
 
@@ -223,8 +219,7 @@ mod test {
             if expected_db.abs() > 10.0 * f32::EPSILON {
                 assert!(
                     magnitude_ratio > 0.99 && magnitude_ratio < 1.01,
-                    "Result differs significantly from table reference for linear {}: expected {}dB, got {}dB, ratio: {:.4}",
-                    linear, expected_db, actual_db, magnitude_ratio
+                    "Result differs significantly from table reference for linear {linear}: expected {expected_db}dB, got {actual_db}dB, ratio: {magnitude_ratio:.4}"
                 );
             }
         }
@@ -244,10 +239,7 @@ mod test {
 
             assert!(
                 error < MAX_ROUND_TRIP_ERROR,
-                "Round-trip conversion failed for {}dB: got {:.8}dB, error: {:.2e}",
-                original_db,
-                round_trip_db,
-                error
+                "Round-trip conversion failed for {original_db}dB: got {round_trip_db:.8}dB, error: {error:.2e}"
             );
         }
 
@@ -263,10 +255,7 @@ mod test {
 
             assert!(
                 relative_error < MAX_ROUND_TRIP_RELATIVE_ERROR,
-                "Round-trip conversion failed for {}: got {:.8}, relative error: {:.2e}",
-                original_linear,
-                round_trip_linear,
-                relative_error
+                "Round-trip conversion failed for {original_linear}: got {round_trip_linear:.8}, relative error: {relative_error:.2e}"
             );
         }
     }

src/source/mod.rs

@@ -700,14 +700,13 @@ impl fmt::Display for SeekError {
             SeekError::NotSupported { underlying_source } => {
                 write!(
                     f,
-                    "Seeking is not supported by source: {}",
-                    underlying_source
+                    "Seeking is not supported by source: {underlying_source}"
                 )
             }
             #[cfg(feature = "symphonia")]
-            SeekError::SymphoniaDecoder(err) => write!(f, "Error seeking: {}", err),
+            SeekError::SymphoniaDecoder(err) => write!(f, "Error seeking: {err}"),
             #[cfg(feature = "hound")]
-            SeekError::HoundDecoder(err) => write!(f, "Error seeking in wav source: {}", err),
+            SeekError::HoundDecoder(err) => write!(f, "Error seeking in wav source: {err}"),
             SeekError::Other(_) => write!(f, "An error occurred"),
         }
     }

src/source/noise.rs

@@ -342,12 +342,12 @@ pub struct WhiteGaussian<R: Rng = SmallRng> {
 impl<R: Rng + SeedableRng> WhiteGaussian<R> {
     /// Get the mean (average) value of the noise distribution.
     pub fn mean(&self) -> f32 {
-        self.sampler.distribution.mean() as f32
+        self.sampler.distribution.mean()
     }
 
     /// Get the standard deviation of the noise distribution.
     pub fn std_dev(&self) -> f32 {
-        self.sampler.distribution.std_dev() as f32
+        self.sampler.distribution.std_dev()
     }
 }
 
@@ -709,7 +709,7 @@ mod tests {
             "Violet" => Box::new(Violet::new(TEST_SAMPLE_RATE)),
             "Brownian" => Box::new(Brownian::new(TEST_SAMPLE_RATE)),
             "Velvet" => Box::new(Velvet::new(TEST_SAMPLE_RATE)),
-            _ => panic!("Unknown generator: {}", name),
+            _ => panic!("Unknown generator: {name}"),
         }
     }
 
@@ -724,7 +724,7 @@ mod tests {
             "Violet" => Box::new(Violet::new(TEST_SAMPLE_RATE)),
             "Brownian" => Box::new(Brownian::new(TEST_SAMPLE_RATE)),
             "Velvet" => Box::new(Velvet::new(TEST_SAMPLE_RATE)),
-            _ => panic!("Unknown generator: {}", name),
+            _ => panic!("Unknown generator: {name}"),
         }
     }
 
@@ -775,11 +775,8 @@ mod tests {
         for i in 0..TEST_SAMPLES_MEDIUM {
             let sample = generator.next().unwrap();
             assert!(
-                sample >= -1.0 && sample <= 1.0,
-                "{} sample {} out of range [-1.0, 1.0]: {}",
-                generator_name,
-                i,
-                sample
+                (-1.0..=1.0).contains(&sample),
+                "{generator_name} sample {i} out of range [-1.0, 1.0]: {sample}"
             );
         }
     }
@@ -793,10 +790,7 @@ mod tests {
             let sample = generator.next().unwrap();
             assert!(
                 sample.is_finite(),
-                "{} produced non-finite sample at index {}: {}",
-                generator_name,
-                i,
-                sample
+                "{generator_name} produced non-finite sample at index {i}: {sample}"
             );
         }
     }
@@ -809,9 +803,7 @@ mod tests {
         let seek_result = generator.try_seek(std::time::Duration::from_secs(1));
         assert!(
             seek_result.is_ok(),
-            "{} should support seeking but returned error: {:?}",
-            generator_name,
-            seek_result
+            "{generator_name} should support seeking but returned error: {seek_result:?}"
         );
     }
 
@@ -822,30 +814,27 @@ mod tests {
         let source = create_generator_source(generator_name);
 
         // All noise generators should be mono (1 channel)
-        assert_eq!(source.channels(), 1, "{} should be mono", generator_name);
+        assert_eq!(source.channels(), 1, "{generator_name} should be mono");
 
         // All should have the expected sample rate
         assert_eq!(
             source.sample_rate(),
             TEST_SAMPLE_RATE,
-            "{} should have correct sample rate",
-            generator_name
+            "{generator_name} should have correct sample rate"
         );
 
         // All should have infinite duration
         assert_eq!(
             source.total_duration(),
             None,
-            "{} should have infinite duration",
-            generator_name
+            "{generator_name} should have infinite duration"
         );
 
         // All should return None for current_span_len (infinite streams)
         assert_eq!(
             source.current_span_len(),
             None,
-            "{} should have no span length limit",
-            generator_name
+            "{generator_name} should have no span length limit"
         );
     }
 
@@ -862,8 +851,8 @@ mod tests {
         }
 
         // Should use the full range approximately
-        assert!(min < -0.9, "Min sample should be close to -1.0: {}", min);
-        assert!(max > 0.9, "Max sample should be close to 1.0: {}", max);
+        assert!(min < -0.9, "Min sample should be close to -1.0: {min}");
+        assert!(max > 0.9, "Max sample should be close to 1.0: {max}");
     }
 
     #[test]
@@ -905,8 +894,7 @@ mod tests {
 
         assert!(
             within_bounds_percentage > 99.0,
-            "Expected >99% of Gaussian samples within [-1.0, 1.0], got {:.1}%",
-            within_bounds_percentage
+            "Expected >99% of Gaussian samples within [-1.0, 1.0], got {within_bounds_percentage:.1}%"
         );
     }
 
@@ -927,8 +915,7 @@ mod tests {
         // Pink noise should have some positive correlation (though not as strong as Brownian)
         assert!(
             avg_correlation > -0.1,
-            "Pink noise should have low positive correlation, got: {}",
-            avg_correlation
+            "Pink noise should have low positive correlation, got: {avg_correlation}"
         );
     }
 
@@ -949,8 +936,7 @@ mod tests {
         // Blue noise should have near-zero or negative correlation
         assert!(
             avg_correlation < 0.1,
-            "Blue noise should have low correlation, got: {}",
-            avg_correlation
+            "Blue noise should have low correlation, got: {avg_correlation}"
         );
     }
 
@@ -980,9 +966,7 @@ mod tests {
         // For violet noise (high-pass), differences should have comparable or higher variance
         assert!(
             diff_variance > signal_variance * 0.1,
-            "Violet noise should have high-frequency characteristics, diff_var: {}, signal_var: {}",
-            diff_variance,
-            signal_variance
+            "Violet noise should have high-frequency characteristics, diff_var: {diff_variance}, signal_var: {signal_variance}"
         );
     }
 
@@ -998,8 +982,7 @@ mod tests {
         // Average should be close to zero due to leak factor
         assert!(
             average.abs() < 0.5,
-            "Brownian noise average too far from zero: {}",
-            average
+            "Brownian noise average too far from zero: {average}"
         );
 
         // Brownian noise should have strong positive correlation between consecutive samples
@@ -1011,8 +994,7 @@ mod tests {
 
         assert!(
             avg_correlation > 0.1,
-            "Brownian noise should have strong positive correlation: {}",
-            avg_correlation
+            "Brownian noise should have strong positive correlation: {avg_correlation}"
         );
     }
 
@@ -1033,9 +1015,7 @@ mod tests {
         assert!(
             impulse_count > (VELVET_DEFAULT_DENSITY * 0.75) as usize
                 && impulse_count < (VELVET_DEFAULT_DENSITY * 1.25) as usize,
-            "Impulse count out of range: expected ~{}, got {}",
-            VELVET_DEFAULT_DENSITY,
-            impulse_count
+            "Impulse count out of range: expected ~{VELVET_DEFAULT_DENSITY}, got {impulse_count}"
         );
     }
 
@@ -1055,9 +1035,7 @@ mod tests {
         let actual_density = impulse_count as f32;
         assert!(
             (actual_density - density).abs() < 200.0,
-            "Custom density not achieved: expected ~{}, got {}",
-            density,
-            actual_density
+            "Custom density not achieved: expected ~{density}, got {actual_density}"
         );
     }
 }