Merge pull request #3 from FxQnLr/new_input

New input, fuck it

1 files changed, 47 insertions, 40 deletions

diff --git a/src/commands/update.rs b/src/commands/update.rs
index ca28130..d400a24 100644
--- a/src/commands/update.rs
+++ b/src/commands/update.rs
@@ -1,9 +1,6 @@
-use std::io::{Error, ErrorKind};
-
-use crate::{config::Cfg, modrinth::{projects, Project, versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, mods_get_versions, userlist_get_applicable_versions, userlist_change_versions, lists_get_all_ids, lists_get, userlist_get_current_version, mods_change_versions}, List, input::Input, files::{delete_version, download_versions, disable_version}, error::{MLE, MLError, ErrorType}};
+use crate::{config::Cfg, modrinth::{projects, Project, versions, extract_current_version, Version}, get_current_list, db::{userlist_get_all_ids, mods_get_versions, userlist_get_applicable_versions, userlist_change_versions, lists_get_all_ids, lists_get, userlist_get_current_version, mods_change_versions}, List, input::Input, files::{delete_version, download_versions, disable_version, clean_list_dir}, error::{MLE, MLError, ErrorType}};
 
 pub async fn update(config: Cfg, input: Input) -> MLE<()> {
-    
     let mut liststack: Vec<List> = vec![];
     if input.all_lists {
         let list_ids = lists_get_all_ids(config.clone())?;
@@ -12,10 +9,9 @@ pub async fn update(config: Cfg, input: Input) -> MLE<()> {
         }
     } else {
         let current = get_current_list(config.clone())?;
-        println!("Checking for updates of mods in {}", current.id);
+        println!("Check for updates of mods in list {}", current.id);
         liststack.push(current)
     }
-    
     cmd_update(config, liststack, input.clean, input.direct_download, input.delete_old).await
 }
 
@@ -31,6 +27,7 @@ pub async fn cmd_update(config: Cfg, liststack: Vec<List>, clean: bool, direct_d
         let mut projects = projects(String::from(&config.apis.modrinth), mods).await;
         projects.sort_by_key(|pro| pro.id.clone());
 
+        println!("Comparing mod versions:");
         let mut updatestack: Vec<Version> = vec![];
         for (index, project) in projects.into_iter().enumerate() {
             //Get versions for project and check if they match up
@@ -39,6 +36,8 @@ pub async fn cmd_update(config: Cfg, liststack: Vec<List>, clean: bool, direct_d
             let v_id = &current_version.mod_id;
             if &p_id != v_id { return Err(MLError::new(ErrorType::Other, "SORTING_ERROR")) };
             
+            println!("\t({}) Check for update", project.title);
+    
             //Getting current installed version for disable or delete
             let disable_version = userlist_get_current_version(config.clone(), String::from(&current_list.id), String::from(&project.id))?;
             
@@ -51,51 +50,52 @@ pub async fn cmd_update(config: Cfg, liststack: Vec<List>, clean: bool, direct_d
                         current_versions.push((disable_version, p_id));
                         ver
                     },
-                    //TODO handle errors (only continue on "NO_UPDATE_AVAILABLE")
-                    Err(..) => {
-                        //Updating versions in modlist for no repeating version calls
-                        mods_change_versions(config.clone(), version_db_string, project.id)?;
-                        println!("({}) No new version found for the specified", project.title);
+                    Err(e) => {
+                        //Catch no update available
+                        if e.to_string() == "Mod: NO_UPDATE_AVAILABLE" {
+                            mods_change_versions(config.clone(), version_db_string, project.id)?;
+                            println!("\t └No new version found for the specified minecraft version");
+                        } else {
+                            return Err(e);
+                        };
                         continue;
                     },
                 });
             } else {
-                println!("({}) No new version found", project.title);
+                println!("\t └No new version found");
             };
         };
+        
+        //Linebreak readability
+        println!("");
 
-        if clean {
-            let dl_path = &current_list.download_folder;
-            println!("Cleaning {}", dl_path);
-            for entry in std::fs::read_dir(dl_path)? {
-                let entry = entry?;
-                std::fs::remove_file(entry.path())?;
-            }
-        }
+        if clean { clean_list_dir(&current_list)? };
         
-        if direct_download {
-            download_versions(current_list.clone(), updatestack).await?;
+        //Linebreak readability
+        println!("");
+
+        if direct_download && !updatestack.is_empty() {
+            download_versions(current_list.clone(), config.clone(), updatestack).await?;
 
             //Disable old versions
-            for ver in current_versions {
-                if delete_old {
-                    println!("Deleting version {} for mod {}", ver.0, ver.1);
-                    delete_version(current_list.clone(), ver.0)?;
-                } else if ver.0 != "NONE" { 
-                    println!("Disabling version {} for mod {}", ver.0, ver.1);
-                    disable_version(config.clone(), current_list.clone(), ver.0, ver.1)?;
-                };
+            if !clean {
+                for ver in current_versions {
+                    if delete_old {
+                        println!("Deleting version {} for mod {}", ver.0, ver.1);
+                        delete_version(current_list.clone(), ver.0)?;
+                    } else if ver.0 != "NONE" { 
+                        println!("Disabling version {} for mod {}", ver.0, ver.1);
+                        disable_version(config.clone(), current_list.clone(), ver.0, ver.1)?;
+                    };
+                }
             }
         };
-        
     }
 
     Ok(())
 }
 
-async fn specific_update(config: Cfg, clean: bool, list: List, project: Project) -> Result<Version, Box<dyn std::error::Error>> {
-    println!("Checking update for '{}' in {}", project.title, list.id);
-    
+async fn specific_update(config: Cfg, clean: bool, list: List, project: Project) -> MLE<Version> {
     let applicable_versions = versions(String::from(&config.apis.modrinth), String::from(&project.id), list.clone()).await;
     
     let mut versions: Vec<String> = vec![];
@@ -112,18 +112,24 @@ async fn specific_update(config: Cfg, clean: bool, list: List, project: Project)
     let mut current: Vec<Version> = vec![];
     if clean || (versions.join("|") != userlist_get_applicable_versions(config.clone(), String::from(&list.id), String::from(&project.id))?) {
         //get new versions
-        print!(" | getting new version");
+        println!("\t └Get versions for specified minecraft versions");
         let current_str = extract_current_version(applicable_versions.clone())?;
-        let current_ver = applicable_versions.into_iter().find(|ver| ver.id == current_str).ok_or("")?;
+        let current_ver = match applicable_versions.into_iter().find(|ver| ver.id == current_str).ok_or("!no current version in applicable_versions") {
+            Ok(v) => Ok(v),
+            Err(e) => Err(MLError::new(ErrorType::Other, e)),
+        }?;
         current.push(current_ver.clone());
 
-        let link = current_ver.files.into_iter().find(|f| f.primary).ok_or("")?.url;
+        let link = match current_ver.files.into_iter().find(|f| f.primary).ok_or("!no primary in links") {
+            Ok(p) => Ok(p),
+            Err(e) => Err(MLError::new(ErrorType::Other, e)),
+        }?.url;
         userlist_change_versions(config, list.id, current_str, versions.join("|"), link, project.id)?;
     }
 
-    if current.is_empty() { return Err(Box::new(Error::new(ErrorKind::NotFound, "NO_UPDATE_AVAILABLE"))) };
+    if current.is_empty() { return Err(MLError::new(ErrorType::ModError, "NO_UPDATE_AVAILABLE")) };
     
-    println!(" | ✔️");
+    //println!(" ������️");
     Ok(current[0].clone())
 }
 
@@ -132,6 +138,7 @@ async fn download_updates_test() {
 
     use crate::{modrinth::{Version, VersionFile, Hash, VersionType}, Modloader, List};
     
+    let config = Cfg::init("modlist.toml").unwrap();
     let current_list = List { id: String::from("..."), mc_version: String::from("..."), modloader: Modloader::Forge, download_folder: String::from("./dl") }; 
 
     let versions = vec![Version { 
@@ -164,5 +171,5 @@ async fn download_updates_test() {
                 "fabric".to_string()
             ]
         }];
-    assert!(download_versions(current_list, versions).await.is_ok())
+    assert!(download_versions(current_list, config, versions).await.is_ok())
 }