style: apply cargo fmt

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pythoninthegrass

crates/mt-tauri/src/audio/engine.rs

@@ -63,11 +63,10 @@ impl AudioEngine {
         }
 
         let file = File::open(path)?;
-        let source = Decoder::try_from(file)
-            .map_err(|e| {
-                error!(path, error = %e, "Failed to decode track");
-                AudioError::Decode(e.to_string())
-            })?;
+        let source = Decoder::try_from(file).map_err(|e| {
+            error!(path, error = %e, "Failed to decode track");
+            AudioError::Decode(e.to_string())
+        })?;
 
         let sample_rate = source.sample_rate();
         let channels = source.channels();
@@ -90,13 +89,7 @@ impl AudioEngine {
         self.current_track = Some(track_info.clone());
         self.state = PlaybackState::Paused;
 
-        info!(
-            path,
-            duration_ms,
-            sample_rate,
-            channels,
-            "Track loaded"
-        );
+        info!(path, duration_ms, sample_rate, channels, "Track loaded");
 
         Ok(track_info)
     }
@@ -133,45 +126,44 @@ impl AudioEngine {
     }
 
     pub fn seek(&mut self, position_ms: u64) -> Result<(), AudioError> {
-        let current_pos = self.player_handle
+        let current_pos = self
+            .player_handle
             .as_ref()
             .map(|h| h.sink.get_pos().as_millis() as u64)
             .unwrap_or(0);
-        
+
         let is_backward = position_ms < current_pos;
-        
+
         if is_backward {
             self.seek_by_reload(position_ms)
         } else {
             self.seek_forward(position_ms)
         }
     }
-    
+
     fn seek_forward(&mut self, position_ms: u64) -> Result<(), AudioError> {
         if let Some(ref handle) = self.player_handle {
             let duration = Duration::from_millis(position_ms);
-            handle.sink.try_seek(duration)
-                .map_err(|e| {
-                    error!(position_ms, error = ?e, "Seek forward failed");
-                    AudioError::Seek(format!("{:?}", e))
-                })?;
+            handle.sink.try_seek(duration).map_err(|e| {
+                error!(position_ms, error = ?e, "Seek forward failed");
+                AudioError::Seek(format!("{:?}", e))
+            })?;
             debug!(position_ms, "Seeked forward");
             Ok(())
         } else {
             Err(AudioError::NoTrack)
         }
     }
-    
+
     fn seek_by_reload(&mut self, position_ms: u64) -> Result<(), AudioError> {
         let track_info = self.current_track.clone().ok_or(AudioError::NoTrack)?;
         let was_playing = self.state == PlaybackState::Playing;
 
         let file = File::open(&track_info.path)?;
-        let source = Decoder::try_from(file)
-            .map_err(|e| {
-                error!(path = %track_info.path, error = %e, "Decode failed during seek-by-reload");
-                AudioError::Decode(e.to_string())
-            })?;
+        let source = Decoder::try_from(file).map_err(|e| {
+            error!(path = %track_info.path, error = %e, "Decode failed during seek-by-reload");
+            AudioError::Decode(e.to_string())
+        })?;
 
         if let Some(handle) = self.player_handle.take() {
             handle.sink.stop();
@@ -182,11 +174,10 @@ impl AudioEngine {
         sink.append(source);
 
         let duration = Duration::from_millis(position_ms);
-        sink.try_seek(duration)
-            .map_err(|e| {
-                error!(position_ms, error = ?e, "Seek-by-reload seek failed");
-                AudioError::Seek(format!("{:?}", e))
-            })?;
+        sink.try_seek(duration).map_err(|e| {
+            error!(position_ms, error = ?e, "Seek-by-reload seek failed");
+            AudioError::Seek(format!("{:?}", e))
+        })?;
 
         if was_playing {
             sink.play();
@@ -215,7 +206,11 @@ impl AudioEngine {
     pub fn get_progress(&self) -> Progress {
         let (position_ms, duration_ms) = if let Some(ref handle) = self.player_handle {
             let pos = handle.sink.get_pos();
-            let dur = self.current_track.as_ref().map(|t| t.duration_ms).unwrap_or(0);
+            let dur = self
+                .current_track
+                .as_ref()
+                .map(|t| t.duration_ms)
+                .unwrap_or(0);
             (pos.as_millis() as u64, dur)
         } else {
             (0, 0)

crates/mt-tauri/src/audio/engine_test.rs

@@ -268,7 +268,7 @@ mod tests {
     #[test]
     fn test_progress_percentage_calculation() {
         let progress = Progress {
-            position_ms: 90000, // 1.5 minutes
+            position_ms: 90000,  // 1.5 minutes
             duration_ms: 180000, // 3 minutes
             state: PlaybackState::Playing,
         };

crates/mt-tauri/src/commands/audio.rs

@@ -16,7 +16,7 @@ pub struct PlaybackStatus {
 }
 
 enum AudioCommand {
-    Load(String, Option<i64>, Sender<Result<TrackInfo, String>>),  // Add track_id
+    Load(String, Option<i64>, Sender<Result<TrackInfo, String>>), // Add track_id
     LoadAndPlay(String, Option<i64>, Sender<Result<TrackInfo, String>>),
     Play(Sender<Result<(), String>>),
     Pause(Sender<Result<(), String>>),
@@ -176,53 +176,57 @@ fn audio_thread(rx: Receiver<AudioCommand>, app: AppHandle) {
 
             // Check play count threshold (75%)
             if !play_count_state.threshold_reached
-               && progress.duration_ms > 0
-               && play_count_state.track_id.is_some() {
+                && progress.duration_ms > 0
+                && play_count_state.track_id.is_some()
+            {
                 let ratio = progress.position_ms as f64 / progress.duration_ms as f64;
 
                 if ratio >= 0.75
-                    && let Some(track_id) = play_count_state.track_id {
-                        // Spawn async task to avoid blocking audio thread
-                        let app_handle = app.clone();
-                        std::thread::spawn(move || {
-                            use crate::db::Database;
-                            use crate::db::library;
-
-                            let db = app_handle.state::<Database>();
-                            if let Ok(conn) = db.conn() {
-                                let _ = library::update_play_count(&conn, track_id);
-                                debug!(track_id, "Play count updated");
-                            }
-                        });
-                        play_count_state.threshold_reached = true;
-                    }
+                    && let Some(track_id) = play_count_state.track_id
+                {
+                    // Spawn async task to avoid blocking audio thread
+                    let app_handle = app.clone();
+                    std::thread::spawn(move || {
+                        use crate::db::Database;
+                        use crate::db::library;
+
+                        let db = app_handle.state::<Database>();
+                        if let Ok(conn) = db.conn() {
+                            let _ = library::update_play_count(&conn, track_id);
+                            debug!(track_id, "Play count updated");
+                        }
+                    });
+                    play_count_state.threshold_reached = true;
+                }
             }
 
             // Check scrobble threshold (90% default, configurable)
             if !scrobble_state.threshold_reached
-               && progress.duration_ms > 0
-               && scrobble_state.track_id.is_some() {
+                && progress.duration_ms > 0
+                && scrobble_state.track_id.is_some()
+            {
                 let ratio = progress.position_ms as f64 / progress.duration_ms as f64;
 
                 if ratio >= scrobble_state.threshold_percent
-                    && let Some(track_id) = scrobble_state.track_id {
-                        // Spawn async task to avoid blocking audio thread
-                        let app_handle = app.clone();
-                        std::thread::spawn(move || {
-                            use crate::commands::lastfm;
-                            use crate::db::Database;
-
-                            let db = app_handle.state::<Database>();
-                            if let Ok(conn) = db.conn() {
-                                // Queue scrobble from audio thread
-                                match lastfm::scrobble_from_audio_thread(&app_handle, &conn, track_id) {
-                                    Ok(_) => debug!(track_id, "Scrobble queued"),
-                                    Err(e) => error!(track_id, error = %e, "Failed to queue scrobble"),
-                                }
+                    && let Some(track_id) = scrobble_state.track_id
+                {
+                    // Spawn async task to avoid blocking audio thread
+                    let app_handle = app.clone();
+                    std::thread::spawn(move || {
+                        use crate::commands::lastfm;
+                        use crate::db::Database;
+
+                        let db = app_handle.state::<Database>();
+                        if let Ok(conn) = db.conn() {
+                            // Queue scrobble from audio thread
+                            match lastfm::scrobble_from_audio_thread(&app_handle, &conn, track_id) {
+                                Ok(_) => debug!(track_id, "Scrobble queued"),
+                                Err(e) => error!(track_id, error = %e, "Failed to queue scrobble"),
                             }
-                        });
-                        scrobble_state.threshold_reached = true;
-                    }
+                        }
+                    });
+                    scrobble_state.threshold_reached = true;
+                }
             }
         }
 
@@ -235,15 +239,23 @@ fn audio_thread(rx: Receiver<AudioCommand>, app: AppHandle) {
 
 #[tracing::instrument(skip(state))]
 #[tauri::command]
-pub fn audio_load(path: String, track_id: Option<i64>, state: State<AudioState>) -> Result<TrackInfo, String> {
+pub fn audio_load(
+    path: String,
+    track_id: Option<i64>,
+    state: State<AudioState>,
+) -> Result<TrackInfo, String> {
     let (tx, rx) = mpsc::channel();
     state.send_command(AudioCommand::Load(path, track_id, tx));
     rx.recv().map_err(|_| "Channel closed".to_string())?
 }
 
 #[tracing::instrument(skip(state))]
 #[tauri::command]
-pub fn audio_load_and_play(path: String, track_id: Option<i64>, state: State<AudioState>) -> Result<TrackInfo, String> {
+pub fn audio_load_and_play(
+    path: String,
+    track_id: Option<i64>,
+    state: State<AudioState>,
+) -> Result<TrackInfo, String> {
     let (tx, rx) = mpsc::channel();
     state.send_command(AudioCommand::LoadAndPlay(path, track_id, tx));
     rx.recv().map_err(|_| "Channel closed".to_string())?

crates/mt-tauri/src/commands/favorites.rs

@@ -6,7 +6,7 @@
 use tauri::{AppHandle, State};
 use tracing::{debug, warn};
 
-use crate::db::{favorites, library, settings, Database, FavoriteTrack, PaginatedResult, Track};
+use crate::db::{Database, FavoriteTrack, PaginatedResult, Track, favorites, library, settings};
 use crate::events::{EventEmitter, FavoritesUpdatedEvent};
 use crate::lastfm::LastFmClient;
 
@@ -120,7 +120,10 @@ pub fn favorites_get(
 /// Check if a track is favorited
 #[tracing::instrument(skip(db))]
 #[tauri::command]
-pub fn favorites_check(db: State<'_, Database>, track_id: i64) -> Result<FavoriteCheckResponse, String> {
+pub fn favorites_check(
+    db: State<'_, Database>,
+    track_id: i64,
+) -> Result<FavoriteCheckResponse, String> {
     let conn = db.conn().map_err(|e| e.to_string())?;
     let (is_favorite, favorited_date) =
         favorites::is_favorite(&conn, track_id).map_err(|e| e.to_string())?;