1 files changed, 52 insertions, 20 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 1c40ceb..f77befc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,14 +6,28 @@ pub mod db;
 pub mod error;
 pub mod files;
 
-use std::{fmt::Display, fs::{File, remove_file, self}, io::{Write, Read}, time::Duration};
+use std::{
+    fmt::Display,
+    fs::{self, remove_file, File},
+    io::{Read, Write},
+    time::Duration,
+};
 
-pub use apis::*;
 use apis::modrinth::{get_game_versions, GameVersion, GameVersionType};
+pub use apis::*;
 pub use commands::*;
 use error::{ErrorType, MLError, MLE};
+use indicatif::{ProgressBar, ProgressStyle};
 use serde::{Deserialize, Serialize};
 
+pub static STYLE_BAR_BYTE: &str =
+    "{spinner:.green}{wide_msg}{bytes}/{total_bytes} [{bar:.green/lime}]";
+pub static STYLE_BAR_POS: &str = " {wide_msg}{pos}/{len} [{bar:.green/lime}]";
+pub static STYLE_SPINNER: &str = "{spinner:.green}{wide_msg}";
+pub static STYLE_OPERATION: &str = " {wide_msg}";
+pub static STYLE_MESSAGE: &str = "{wide_msg}";
+pub static PROGRESS_CHARS: &str = "#>-";
+
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Modloader {
     #[serde(rename(serialize = "fabric", deserialize = "fabric"))]
@@ -30,7 +44,9 @@ impl Modloader {
             "forge" => Ok(Modloader::Forge),
             "fabric" => Ok(Modloader::Fabric),
             "quilt" => Ok(Modloader::Quilt),
-            _ => Err(MLError::new(ErrorType::ArgumentError, "UNKNOWN_MODLOADER")),
+            _ => {
+                Err(MLError::new(ErrorType::ArgumentError, "UNKNOWN_MODLOADER"))
+            }
         }
     }
 }
@@ -51,21 +67,29 @@ pub enum VersionLevel {
     Release,
     #[serde(rename(serialize = "snapshot", deserialize = "snapshot"))]
     Snapshot,
-    Version(String)
+    Version(String),
 }
 
 /// Checks if update needed (time)
 /// if yes: get versions, update
 pub async fn check_game_versions(path: &str, force: bool) -> MLE<()> {
+    let p = ProgressBar::new(1);
+    p.set_style(ProgressStyle::with_template(STYLE_MESSAGE).unwrap());
+    p.set_message("Update minecraft versions");
+
     let creation_time = fs::metadata(path)?.created()?;
-    if !force && creation_time.elapsed().unwrap() < Duration::from_secs(60 * 60 * 24) { return Ok(()); }
-    print!("Update minecraft versions");
-    std::io::stdout().flush()?;
+    if !force
+        && creation_time.elapsed().unwrap() < Duration::from_secs(60 * 60 * 24)
+    {
+        return Ok(());
+    }
+
     let versions = get_game_versions().await;
     remove_file(path)?;
     let mut file = File::create(path)?;
-    file.write_all(&serde_json::to_string_pretty(&versions)?.as_bytes())?;
-    println!(" ✓");
+    file.write_all(serde_json::to_string_pretty(&versions)?.as_bytes())?;
+
+    p.finish_with_message("Updated minecraft versions");
     Ok(())
 }
 
@@ -79,7 +103,6 @@ pub fn load_game_versions(path: &str) -> MLE<Vec<GameVersion>> {
 }
 
 impl VersionLevel {
-
     pub fn from(str: &str) -> Self {
         match str {
             "release" => VersionLevel::Release,
@@ -88,29 +111,38 @@ impl VersionLevel {
         }
     }
 
-    pub async fn get(self, versions_path: &str, force_update: bool) -> MLE<String> {
+    pub async fn get(
+        self,
+        versions_path: &str,
+        force_update: bool,
+    ) -> MLE<String> {
         let path = format!("{}/versions.json", versions_path);
         check_game_versions(&path, force_update).await?;
         let mut versions = load_game_versions(&path)?.into_iter();
 
         match self {
             VersionLevel::Release => {
-                let release = versions.find(|ver| ver.version_type == GameVersionType::release).unwrap();
-                println!("{:?}", release);
+                let release = versions
+                    .find(|ver| ver.version_type == GameVersionType::release)
+                    .unwrap();
                 Ok(release.version)
-            },
+            }
             VersionLevel::Snapshot => {
-                let snapshot = versions.find(|ver| ver.version_type == GameVersionType::snapshot).unwrap();
-                println!("{:?}", snapshot);
+                let snapshot = versions
+                    .find(|ver| ver.version_type == GameVersionType::snapshot)
+                    .unwrap();
                 Ok(snapshot.version)
-            },
+            }
             VersionLevel::Version(v) => {
-                if versions.find(|ver| ver.version == v).is_some() {
+                if versions.any(|ver| ver.version == v) {
                     Ok(v)
                 } else {
-                    Err(MLError::new(ErrorType::ConfigError, "unknown minecraft version"))
+                    Err(MLError::new(
+                        ErrorType::ConfigError,
+                        "unknown minecraft version",
+                    ))
                 }
-            },
+            }
         }
     }
 }