Fix Rust lint blockers for release

Resolve clippy warnings in the ASR, audio capture, CLI, and URL helper code so the 0.0.10 release passes the Rust CI gate.

Author: ComputelessComputer

src-tauri/src/asr.rs

@@ -472,7 +472,7 @@ fn speech_live_transcription_append(
     #[cfg(target_os = "macos")]
     {
         let encode = |samples: &[f32]| {
-            let mut bytes = Vec::with_capacity(samples.len() * std::mem::size_of::<f32>());
+            let mut bytes = Vec::with_capacity(std::mem::size_of_val(samples));
             for sample in samples {
                 bytes.extend_from_slice(&sample.to_le_bytes());
             }

src-tauri/src/audio_capture.rs

@@ -159,12 +159,14 @@ fn run_capture_loop<F>(
                 Ok(WorkerMessage::Audio(chunk)) => {
                     let delivery = process_audio_chunk(
                         chunk,
-                        &mut joiner,
-                        &mut mic_resampler,
-                        &mut speaker_resampler,
-                        &mut mic_frames,
-                        &mut speaker_frames,
-                        &mut echo_canceller,
+                        &mut AudioChunkProcessor {
+                            joiner: &mut joiner,
+                            mic_resampler: &mut mic_resampler,
+                            speaker_resampler: &mut speaker_resampler,
+                            mic_frames: &mut mic_frames,
+                            speaker_frames: &mut speaker_frames,
+                            echo_canceller: &mut echo_canceller,
+                        },
                         &mut on_chunk,
                     );
 
@@ -223,42 +225,50 @@ fn run_capture_loop<F>(
     }
 }
 
+struct AudioChunkProcessor<'a> {
+    joiner: &'a mut ChunkJoiner,
+    mic_resampler: &'a mut LinearResampler,
+    speaker_resampler: &'a mut LinearResampler,
+    mic_frames: &'a mut ChunkAccumulator,
+    speaker_frames: &'a mut ChunkAccumulator,
+    echo_canceller: &'a mut EchoCanceller,
+}
+
 fn process_audio_chunk<F>(
     chunk: AudioChunk,
-    joiner: &mut ChunkJoiner,
-    mic_resampler: &mut LinearResampler,
-    speaker_resampler: &mut LinearResampler,
-    mic_frames: &mut ChunkAccumulator,
-    speaker_frames: &mut ChunkAccumulator,
-    echo_canceller: &mut EchoCanceller,
+    processor: &mut AudioChunkProcessor<'_>,
     on_chunk: &mut F,
 ) -> Result<(), String>
 where
     F: FnMut(Vec<f32>, Vec<f32>, Vec<f32>) -> Result<(), String>,
 {
     let resampled = match chunk.source {
-        AudioSource::Mic => mic_resampler.process(&chunk.samples, chunk.sample_rate),
-        AudioSource::Speaker => speaker_resampler.process(&chunk.samples, chunk.sample_rate),
+        AudioSource::Mic => processor
+            .mic_resampler
+            .process(&chunk.samples, chunk.sample_rate),
+        AudioSource::Speaker => processor
+            .speaker_resampler
+            .process(&chunk.samples, chunk.sample_rate),
     };
 
     if resampled.is_empty() {
         return Ok(());
     }
 
     let ready_frames = match chunk.source {
-        AudioSource::Mic => mic_frames.push(resampled),
-        AudioSource::Speaker => speaker_frames.push(resampled),
+        AudioSource::Mic => processor.mic_frames.push(resampled),
+        AudioSource::Speaker => processor.speaker_frames.push(resampled),
     };
 
     for ready in ready_frames {
         match chunk.source {
-            AudioSource::Mic => joiner.push_mic(ready),
-            AudioSource::Speaker => joiner.push_speaker(ready),
+            AudioSource::Mic => processor.joiner.push_mic(ready),
+            AudioSource::Speaker => processor.joiner.push_speaker(ready),
         }
     }
 
-    while let Some((mic, speaker)) = joiner.pop_pair() {
-        let delivery = echo_canceller.process_frame(&mic, &speaker)?;
+    while let Some((mic, speaker)) = processor.joiner.pop_pair() {
+        let delivery = processor.echo_canceller.process_frame(&mic, &speaker)?;
         deliver_output_chunks(delivery, on_chunk)?;
     }
 

src-tauri/src/cli.rs

@@ -311,7 +311,7 @@ fn run_transcribe(args: &[String]) -> Result<(), String> {
     let model_id = model_id.unwrap_or_else(|| {
         recommend_model(
             &detect_device_profile(),
-            &[language.clone()],
+            std::slice::from_ref(&language),
             TranscriptionMode::Batch,
         )
         .model_id

src-tauri/src/lib.rs

@@ -1710,7 +1710,7 @@ fn show_settings_window<R: tauri::Runtime>(
     let route = settings_window_route(section);
 
     if let Some(window) = app.get_webview_window(SETTINGS_WINDOW_LABEL) {
-        window.eval(&format!("window.location.hash = '#{route}'"))?;
+        window.eval(format!("window.location.hash = '#{route}'"))?;
         let _ = window.unminimize();
         window.show()?;
         window.set_focus()?;
@@ -3153,29 +3153,29 @@ fn yaml_optional_string(value: Option<&str>) -> String {
 fn open_external_url(url: &str) -> Result<(), String> {
     #[cfg(target_os = "macos")]
     {
-        return Command::new("open")
+        Command::new("open")
             .arg(url)
             .spawn()
             .map(|_| ())
-            .map_err(|error| format!("Failed to open {url}: {error}"));
+            .map_err(|error| format!("Failed to open {url}: {error}"))
     }
 
     #[cfg(target_os = "windows")]
     {
-        return Command::new("cmd")
+        Command::new("cmd")
             .args(["/C", "start", "", url])
             .spawn()
             .map(|_| ())
-            .map_err(|error| format!("Failed to open {url}: {error}"));
+            .map_err(|error| format!("Failed to open {url}: {error}"))
     }
 
     #[cfg(all(unix, not(target_os = "macos")))]
     {
-        return Command::new("xdg-open")
+        Command::new("xdg-open")
             .arg(url)
             .spawn()
             .map(|_| ())
-            .map_err(|error| format!("Failed to open {url}: {error}"));
+            .map_err(|error| format!("Failed to open {url}: {error}"))
     }
 
     #[cfg(not(any(target_os = "macos", target_os = "windows", unix)))]