Remove unwraps

src/main.rs

@@ -1,3 +1,7 @@
+#![deny(clippy::unwrap_in_result)]
+#![deny(clippy::get_unwrap)]
+#![deny(clippy::unwrap_used)]
+
 mod config;
 mod migration;
 mod platforms;
@@ -16,9 +20,9 @@ fn main() -> Result<()> {
 
     let args: Vec<String> = std::env::args().collect();
     if args.contains(&"--no-ui".to_string()) {
-        ui::run_sync();
+        ui::run_sync()?;
     } else {
-        ui::run_ui(args);
+        ui::run_ui(args)?;
     }
     Ok(())
 }

src/steamgriddb/downloader.rs

@@ -171,13 +171,10 @@ async fn search_for_images_to_download(
     let search_results_a = stream::iter(shortcuts_to_search_for)
         .map(|s| async move {
             let search_result = search.search(s.app_id, &s.app_name).await;
-            if search_result.is_err() {
-                return None;
+            match search_result {
+                Ok(Some(search_result)) => Some((s.app_id, search_result)),
+                _ => None,
             }
-            let search_result = search_result.unwrap();
-            search_result?;
-            let search_result = search_result.unwrap();
-            Some((s.app_id, search_result))
         })
         .buffer_unordered(CONCURRENT_REQUESTS)
         .collect::<Vec<Option<(u32, usize)>>>()
@@ -203,8 +200,14 @@ async fn search_for_images_to_download(
         let shortcuts: Vec<&ShortcutOwned> = images_needed.collect();
 
         for image_ids in image_ids.chunks(99) {
-            let image_search_result =
-                get_images_for_ids(client, image_ids, &image_type, download_animated, settings.steamgrid_db.allow_nsfw).await;
+            let image_search_result = get_images_for_ids(
+                client,
+                image_ids,
+                &image_type,
+                download_animated,
+                settings.steamgrid_db.allow_nsfw,
+            )
+            .await;
             match image_search_result {
                 Ok(images) => {
                     let images = images

src/ui/components/game_image_button.rs

@@ -8,29 +8,45 @@ use crate::steamgriddb::{ImageType, ToDownload};
 use crate::ui::images::{clamp_to_width, ImageHandles, TextureDownloadState};
 use crate::ui::ui_images::load_image_from_path;
 
-
 pub fn render_image_from_path(
     ui: &mut egui::Ui,
     image_handles: &ImageHandles,
     path: &Path,
     max_width: f32,
     text: &str,
 ) -> bool {
-    render_possible_image(ui, image_handles, path, max_width, text, &ImageType::Grid, None, None)
+    render_possible_image(
+        ui,
+        image_handles,
+        path,
+        max_width,
+        text,
+        &ImageType::Grid,
+        None,
+        None,
+    )
 }
 
 pub fn render_image_from_path_image_type(
     ui: &mut egui::Ui,
     image_handles: &ImageHandles,
     path: &Path,
     max_width: f32,
-    text: &str, 
+    text: &str,
     image_type: &ImageType,
 ) -> bool {
-    render_possible_image(ui, image_handles, path, max_width, text, image_type, None, None)
+    render_possible_image(
+        ui,
+        image_handles,
+        path,
+        max_width,
+        text,
+        image_type,
+        None,
+        None,
+    )
 }
 
-
 pub fn render_image_from_path_or_url(
     ui: &mut egui::Ui,
     image_handles: &ImageHandles,
@@ -104,41 +120,62 @@ fn render_possible_image(
                     }
                 }
                 TextureDownloadState::Failed => {
-                    let button =
-                        ui.add_sized([max_width, max_width * image_type.ratio()], Button::new(text).wrap(true));
+                    let button = ui.add_sized(
+                        [max_width, max_width * image_type.ratio()],
+                        Button::new(text).wrap(true),
+                    );
                     if button.clicked() {
                         return true;
                     }
                 }
             }
         }
         None => {
-            if !path.exists() && url.is_none() {
-                image_handles.insert(image_key, TextureDownloadState::Failed);
-            } else {
-                //We need to start a download
-                //Redownload if file is too small
-                if !path.exists()
-                    || std::fs::metadata(path).map(|m| m.len()).unwrap_or_default() < 2
-                {
-                    image_handles.insert(image_key.clone(), TextureDownloadState::Downloading);
-                    let to_download = ToDownload {
-                        path: path.to_path_buf(),
-                        url: url.unwrap().to_string(),
-                        app_name: "Thumbnail".to_string(),
-                        image_type: *image_type,
-                    };
-                    let image_handles = image_handles.clone();
-                    let image_key = image_key.clone();
-                    if let Some(rt) = rt {
-                        rt.spawn_blocking(move || {
-                            block_on(crate::steamgriddb::download_to_download(&to_download))
-                                .unwrap();
-                            image_handles.insert(image_key, TextureDownloadState::Downloaded);
-                        });
+            match url {
+                Some(url) => {
+                    //We need to start a download
+                    //Redownload if file is too small
+                    if !path.exists()
+                        || std::fs::metadata(path).map(|m| m.len()).unwrap_or_default() < 2
+                    {
+                        image_handles.insert(image_key.clone(), TextureDownloadState::Downloading);
+                        let to_download = ToDownload {
+                            path: path.to_path_buf(),
+                            url: url.to_string(),
+                            app_name: "Thumbnail".to_string(),
+                            image_type: *image_type,
+                        };
+                        let image_handles = image_handles.clone();
+                        let image_key = image_key.clone();
+                        if let Some(rt) = rt {
+                            rt.spawn_blocking(move || {
+                                match block_on(crate::steamgriddb::download_to_download(
+                                    &to_download,
+                                )) {
+                                    Ok(_) => {
+                                        image_handles
+                                            .insert(image_key, TextureDownloadState::Downloaded);
+                                    }
+                                    Err(err) => {
+                                        println!(
+                                            "Failed downloading image {} error: {:?}",
+                                            to_download.url, err
+                                        );
+                                        image_handles
+                                            .insert(image_key, TextureDownloadState::Failed);
+                                    }
+                                }
+                            });
+                        }
+                    } else {
+                        image_handles.insert(image_key.clone(), TextureDownloadState::Downloaded);
+                    }
+                }
+                None => {
+                    //Not possible to download
+                    if !path.exists() {
+                        image_handles.insert(image_key, TextureDownloadState::Failed);
                     }
-                } else {
-                    image_handles.insert(image_key.clone(), TextureDownloadState::Downloaded);
                 }
             }
         }

src/ui/images/hasimagekey.rs

@@ -2,19 +2,15 @@ use std::path::{Path, PathBuf};
 
 use steam_shortcuts_util::shortcut::ShortcutOwned;
 
-use crate::{steamgriddb::ImageType, steam::SteamGameInfo};
-
-use super::{gametype::GameType, constants::POSSIBLE_EXTENSIONS};
+use crate::{steam::SteamGameInfo, steamgriddb::ImageType};
 
+use super::{constants::POSSIBLE_EXTENSIONS, gametype::GameType};
 
 pub trait HasImageKey {
-
     ///Gives a unique key to an image given its type and user path
     fn key(&self, image_type: &ImageType, user_path: &Path) -> (PathBuf, String);
-
 }
 
-
 impl HasImageKey for GameType {
     fn key(&self, image_type: &ImageType, user_path: &Path) -> (PathBuf, String) {
         match self {
@@ -24,31 +20,29 @@ impl HasImageKey for GameType {
     }
 }
 
-
 impl HasImageKey for SteamGameInfo {
     fn key(&self, image_type: &ImageType, user_path: &Path) -> (PathBuf, String) {
-        let mut keys = POSSIBLE_EXTENSIONS
-            .iter()
-            .map(|ext| key_from_extension(self.appid, image_type, user_path, ext));
-        let first = keys.next().unwrap();
-        let other = keys.find(|(exsists, _, _)| *exsists);
-        let (_, path, key) = other.unwrap_or(first);
-        (path, key)
+        let app_id = self.appid;
+        key(app_id, image_type, user_path)
     }
 }
 
 impl HasImageKey for ShortcutOwned {
     fn key(&self, image_type: &ImageType, user_path: &Path) -> (PathBuf, String) {
-        let mut keys = POSSIBLE_EXTENSIONS
-            .iter()
-            .map(|ext| key_from_extension(self.app_id, image_type, user_path, ext));
-        let first = keys.next().unwrap();
-        let other = keys.find(|(exsists, _, _)| *exsists);
-        let (_, path, key) = other.unwrap_or(first);
-        (path, key)
+        let app_id = self.app_id;
+        key(app_id, image_type, user_path)
     }
 }
 
+fn key(app_id: u32, image_type: &ImageType, user_path: &Path) -> (PathBuf, String) {
+    let ext = |ext| key_from_extension(app_id, image_type, user_path, ext);
+    let keys = POSSIBLE_EXTENSIONS.map(ext);
+    let other = keys.iter().find(|(exsists, _, _)| *exsists);
+    let first = ext(POSSIBLE_EXTENSIONS[0]);
+    let (_, path, key) = other.unwrap_or_else(|| &first);
+    (path.to_path_buf(), key.to_string())
+}
+
 fn key_from_extension(
     app_id: u32,
     image_type: &ImageType,