139 add and resolve clippy lints to prevent unwrap and expect functions (#154)

* fix: Add lint and remove all unwraps from lib.rs

Signed-off-by: quexeky <[email protected]>

* chore: Remove all unwraps from util.rs and add state_lock macro

Signed-off-by: quexeky <[email protected]>

* chore: Add CacheError and remove unwraps from fetch_object

Signed-off-by: quexeky <[email protected]>

* chore: Remove unwraps from fetch_object and server_proto

Signed-off-by: quexeky <[email protected]>

* chore: Remove unwraps from auth.rs

Signed-off-by: quexeky <[email protected]>

* chore: Remove unwraps from process_handlers

Signed-off-by: quexeky <[email protected]>

* chore: Clippy unwrap linting

Signed-off-by: quexeky <[email protected]>

* chore: Remove lint

Because not everything is actually resolved yet: will be resolved with a restructure of the library

Signed-off-by: quexeky <[email protected]>

* chore: Make the rest of clippy happy

Signed-off-by: quexeky <[email protected]>

* fix: Send download signal instead of triggering self.on_error

Signed-off-by: quexeky <[email protected]>

* fix: Corrupted state should panic

Signed-off-by: quexeky <[email protected]>

* fix: Use debug instead of display for specific errors

Signed-off-by: quexeky <[email protected]>

* fix: Settings now log error instead of panicking

Signed-off-by: quexeky <[email protected]>

---------

Signed-off-by: quexeky <[email protected]>

Author: quexeky

package.json

@@ -14,7 +14,8 @@
     "@tauri-apps/plugin-os": "^2.3.0",
     "@tauri-apps/plugin-shell": "^2.3.0",
     "pino": "^9.7.0",
-    "pino-pretty": "^13.1.1"
+    "pino-pretty": "^13.1.1",
+    "tauri": "^0.15.0"
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2.7.1"

src-tauri/Cargo.lock

@@ -1,7 +1,7 @@
 use log::{debug, error};
 use tauri::AppHandle;
 
-use crate::AppState;
+use crate::{lock, AppState};
 
 #[tauri::command]
 pub fn quit(app: tauri::AppHandle, state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
@@ -10,7 +10,7 @@ pub fn quit(app: tauri::AppHandle, state: tauri::State<'_, std::sync::Mutex<AppS
 
 pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mutex<AppState<'_>>>) {
     debug!("cleaning up and exiting application");
-    let download_manager = state.lock().unwrap().download_manager.clone();
+    let download_manager = lock!(state).download_manager.clone();
     match download_manager.ensure_terminated() {
         Ok(res) => match res {
             Ok(()) => debug!("download manager terminated correctly"),

src-tauri/src/client/cleanup.rs

@@ -1,10 +1,10 @@
-use crate::AppState;
+use crate::{lock, AppState};
 
 #[tauri::command]
 pub fn fetch_state(
     state: tauri::State<'_, std::sync::Mutex<AppState<'_>>>,
 ) -> Result<String, String> {
-    let guard = state.lock().unwrap();
+    let guard = lock!(state);
     let cloned_state = serde_json::to_string(&guard.clone()).map_err(|e| e.to_string())?;
     drop(guard);
     Ok(cloned_state)

src-tauri/src/client/commands.rs

@@ -4,14 +4,16 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use log::error;
 use serde_json::Value;
 
 use crate::{
-    database::{db::borrow_db_mut_checked, scan::scan_install_dirs}, error::download_manager_error::DownloadManagerError,
+    database::{db::borrow_db_mut_checked, scan::scan_install_dirs},
+    error::download_manager_error::DownloadManagerError,
 };
 
 use super::{
-    db::{borrow_db_checked, DATA_ROOT_DIR},
+    db::{DATA_ROOT_DIR, borrow_db_checked},
     debug::SystemData,
     models::data::Settings,
 };
@@ -67,11 +69,25 @@ pub fn add_download_dir(new_dir: PathBuf) -> Result<(), DownloadManagerError<()>
 #[tauri::command]
 pub fn update_settings(new_settings: Value) {
     let mut db_lock = borrow_db_mut_checked();
-    let mut current_settings = serde_json::to_value(db_lock.settings.clone()).unwrap();
-    for (key, value) in new_settings.as_object().unwrap() {
+    let mut current_settings =
+        serde_json::to_value(db_lock.settings.clone()).expect("Failed to parse existing settings");
+    let values = match new_settings.as_object() {
+        Some(values) => values,
+        None => {
+            error!("Could not parse settings values into object");
+            return;
+        }
+    };
+    for (key, value) in values {
         current_settings[key] = value.clone();
     }
-    let new_settings: Settings = serde_json::from_value(current_settings).unwrap();
+    let new_settings: Settings = match serde_json::from_value(current_settings) {
+        Ok(settings) => settings,
+        Err(e) => {
+            error!("Could not parse settings with error {}", e);
+            return;
+        }
+    };
     db_lock.settings = new_settings;
 }
 #[tauri::command]

src-tauri/src/database/commands.rs

@@ -21,8 +21,13 @@ static DATA_ROOT_PREFIX: &'static str = "drop";
 #[cfg(debug_assertions)]
 static DATA_ROOT_PREFIX: &str = "drop-debug";
 
-pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> =
-    LazyLock::new(|| Arc::new(dirs::data_dir().unwrap().join(DATA_ROOT_PREFIX)));
+pub static DATA_ROOT_DIR: LazyLock<Arc<PathBuf>> = LazyLock::new(|| {
+    Arc::new(
+        dirs::data_dir()
+            .expect("Failed to get data dir")
+            .join(DATA_ROOT_PREFIX),
+    )
+});
 
 // Custom JSON serializer to support everything we need
 #[derive(Debug, Default, Clone)]
@@ -63,13 +68,49 @@ impl DatabaseImpls for DatabaseInterface {
         let pfx_dir = DATA_ROOT_DIR.join("pfx");
 
         debug!("creating data directory at {DATA_ROOT_DIR:?}");
-        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap();
-        create_dir_all(&games_base_dir).unwrap();
-        create_dir_all(&logs_root_dir).unwrap();
-        create_dir_all(&cache_dir).unwrap();
-        create_dir_all(&pfx_dir).unwrap();
-
-        let exists = fs::exists(db_path.clone()).unwrap();
+        create_dir_all(DATA_ROOT_DIR.as_path()).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                DATA_ROOT_DIR.display(),
+                e
+            )
+        });
+        create_dir_all(&games_base_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                games_base_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&logs_root_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                logs_root_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&cache_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                cache_dir.display(),
+                e
+            )
+        });
+        create_dir_all(&pfx_dir).unwrap_or_else(|e| {
+            panic!(
+                "Failed to create directory {} with error {}",
+                pfx_dir.display(),
+                e
+            )
+        });
+
+        let exists = fs::exists(db_path.clone()).unwrap_or_else(|e| {
+            panic!(
+                "Failed to find if {} exists with error {}",
+                db_path.display(),
+                e
+            )
+        });
 
         if exists {
             match PathDatabase::load_from_path(db_path.clone()) {
@@ -78,21 +119,19 @@ impl DatabaseImpls for DatabaseInterface {
             }
         } else {
             let default = Database::new(games_base_dir, None, cache_dir);
-            debug!(
-                "Creating database at path {}",
-                db_path.as_os_str().to_str().unwrap()
-            );
+            debug!("Creating database at path {}", db_path.display());
             PathDatabase::create_at_path(db_path, default).expect("Database could not be created")
         }
     }
 
     fn database_is_set_up(&self) -> bool {
-        !self.borrow_data().unwrap().base_url.is_empty()
+        !borrow_db_checked().base_url.is_empty()
     }
 
     fn fetch_base_url(&self) -> Url {
-        let handle = self.borrow_data().unwrap();
-        Url::parse(&handle.base_url).unwrap()
+        let handle = borrow_db_checked();
+        Url::parse(&handle.base_url)
+            .unwrap_or_else(|_| panic!("Failed to parse base url {}", handle.base_url))
     }
 }
 
@@ -111,13 +150,16 @@ fn handle_invalid_database(
         base
     };
     info!("old database stored at: {}", new_path.to_string_lossy());
-    fs::rename(&db_path, &new_path).unwrap();
-
-    let db = Database::new(
-        games_base_dir.into_os_string().into_string().unwrap(),
-        Some(new_path),
-        cache_dir,
-    );
+    fs::rename(&db_path, &new_path).unwrap_or_else(|e| {
+        panic!(
+            "Could not rename database {} to {} with error {}",
+            db_path.display(),
+            new_path.display(),
+            e
+        )
+    });
+
+    let db = Database::new(games_base_dir, Some(new_path), cache_dir);
 
     PathDatabase::create_at_path(db_path, db).expect("Database could not be created")
 }

src-tauri/src/database/db.rs

@@ -24,11 +24,11 @@ pub fn scan_install_dirs() {
             if !drop_data_file.exists() {
                 continue;
             }
-            let game_id = game.file_name().into_string().unwrap();
+            let game_id = game.file_name().display().to_string();
             let Ok(drop_data) = DropData::read(&game.path()) else {
                 warn!(
                     ".dropdata exists for {}, but couldn't read it. is it corrupted?",
-                    game.file_name().into_string().unwrap()
+                    game.file_name().display()
                 );
                 continue;
             };

src-tauri/src/database/scan.rs

@@ -1,15 +1,15 @@
 use std::sync::Mutex;
 
-use crate::{database::models::data::DownloadableMetadata, AppState};
+use crate::{AppState, database::models::data::DownloadableMetadata, lock};
 
 #[tauri::command]
 pub fn pause_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.pause_downloads();
+    lock!(state).download_manager.pause_downloads();
 }
 
 #[tauri::command]
 pub fn resume_downloads(state: tauri::State<'_, Mutex<AppState>>) {
-    state.lock().unwrap().download_manager.resume_downloads();
+    lock!(state).download_manager.resume_downloads();
 }
 
 #[tauri::command]
@@ -18,14 +18,12 @@ pub fn move_download_in_queue(
     old_index: usize,
     new_index: usize,
 ) {
-    state
-        .lock()
-        .unwrap()
+    lock!(state)
         .download_manager
         .rearrange(old_index, new_index);
 }
 
 #[tauri::command]
 pub fn cancel_game(state: tauri::State<'_, Mutex<AppState>>, meta: DownloadableMetadata) {
-    state.lock().unwrap().download_manager.cancel(meta);
+    lock!(state).download_manager.cancel(meta);
 }