Added better logging and multithreading

Author: LeBoufty

Cargo.lock

@@ -6,7 +6,9 @@ edition = "2024"
 [dependencies]
 chrono = { version = "0.4.41", features = ["serde"] }
 clap = { version = "4.5.38", features = ["derive"] }
+console = "0.15.11"
 curl = "0.4.47"
+indicatif = "0.17.11"
 mockito = "1.7.0"
 onig = "6.5.1"
 serde = { version = "1.0.219", features = ["derive"] }

Cargo.toml

@@ -1,8 +1,21 @@
 use crate::build_order::{BuildOrder, BuildOrderError};
 use crate::build_parser::fetch_build_order;
 use crate::index_manager::{LOWEST_INDEX, get_st_highest_index};
+use console::style;
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::thread;
+use std::time::Duration;
 
 pub fn fetch_latest(count: u32) -> Vec<BuildOrder> {
+    let spinner_style = ProgressStyle::with_template(
+        "[{percent:.bold.dim}%] {elapsed:.dim} {spinner} {bar}\t{wide_msg}",
+    )
+    .unwrap()
+    .tick_chars("⡇⣆⣤⣰⢸⠹⠛⠏ ");
+    let pb = ProgressBar::new(count as u64);
+    pb.set_style(spinner_style);
+    pb.enable_steady_tick(Duration::from_millis(100));
+
     let highest_index = get_st_highest_index();
     let mut end_index = if count > highest_index - LOWEST_INDEX {
         LOWEST_INDEX
@@ -21,7 +34,7 @@ pub fn fetch_latest(count: u32) -> Vec<BuildOrder> {
             }
             Err(e) => {
                 if e.eq(&BuildOrderError::Cloaked) {
-                    eprintln!("Build order {} is cloaked, skipping.", current_id);
+                    pb.set_message(format!("Build order {} is cloaked, skipping.", current_id));
                     end_index = if end_index > LOWEST_INDEX {
                         end_index - 1
                     } else {
@@ -35,10 +48,23 @@ pub fn fetch_latest(count: u32) -> Vec<BuildOrder> {
             }
         }
     }
+    pb.finish_with_message(format!(
+        "{} {} build orders fetched.",
+        style("✔").green(),
+        build_orders.len()
+    ));
     build_orders
 }
 
 pub fn fetch_segment(start: u32, end: u32) -> Vec<BuildOrder> {
+    let spinner_style = ProgressStyle::with_template(
+        "[{percent:.bold.dim}%] {elapsed:.dim} {spinner} {bar}\t{wide_msg}",
+    )
+    .unwrap()
+    .tick_chars("⡇⣆⣤⣰⢸⠹⠛⠏ ");
+    let pb = ProgressBar::new((end - start + 1) as u64);
+    pb.set_style(spinner_style);
+
     let highest_index = get_st_highest_index();
     let start = if start < LOWEST_INDEX {
         LOWEST_INDEX
@@ -59,12 +85,52 @@ pub fn fetch_segment(start: u32, end: u32) -> Vec<BuildOrder> {
         return Vec::new();
     }
 
+    let m = MultiProgress::new();
+
     let mut build_orders = Vec::new();
-    for id in (start..=end).rev() {
-        match fetch_build_order(id) {
-            Ok(build_order) => build_orders.push(build_order),
-            Err(e) => eprintln!("Error fetching build order {}: {}", id, e),
+    let mut handles = Vec::new();
+    let count = (end - start + 1) as usize;
+
+    for id in start..=end {
+        let pb_clone = m.add(ProgressBar::new(1));
+        let handle = thread::spawn(move || {
+            let spinner_style =
+                ProgressStyle::with_template("[{prefix:.bold.dim}] {spinner} \t{wide_msg}")
+                    .unwrap()
+                    .tick_chars("⡇⣆⣤⣰⢸⠹⠛⠏ ");
+            pb_clone.set_message(format!("Fetching build order {}", id));
+            pb_clone.set_style(spinner_style.clone());
+            pb_clone.enable_steady_tick(Duration::from_millis(100));
+            pb_clone.set_prefix(format!("{}/{}", id - start + 1, count));
+            match fetch_build_order(id) {
+                Ok(build_order) => {
+                    pb_clone.inc(1);
+                    Some(build_order)
+                }
+                Err(e) => {
+                    if e.eq(&BuildOrderError::Cloaked) {
+                        pb_clone.set_message(format!("Build order {} is cloaked, skipping.", id));
+                    } else {
+                        eprintln!("Error fetching build order {}: {}", id, e);
+                    }
+                    None
+                }
+            }
+        });
+        handles.push(handle);
+    }
+
+    for handle in handles {
+        if let Ok(Some(build_order)) = handle.join() {
+            build_orders.push(build_order);
         }
     }
+
+    pb.finish_with_message(format!(
+        "{} {} build orders fetched.",
+        style("✔").green(),
+        build_orders.len()
+    ));
+
     build_orders
 }

src/handlers.rs

@@ -2,6 +2,7 @@ use build_warren::build_parser::fetch_build_order;
 use build_warren::handlers::{fetch_latest, fetch_segment};
 use build_warren::index_manager::get_st_highest_index;
 use clap::{Parser, Subcommand};
+use console::{Emoji, style};
 use serde_json;
 use std::fs;
 
@@ -42,15 +43,31 @@ enum Commands {
     },
 }
 
+static CLIPBOARD_EMOJI: Emoji = Emoji("📋 ", "");
+static OUTPUT_EMOJI: Emoji = Emoji("📂 ", "");
+
 fn main() {
     let cli = Cli::parse();
 
+    println!(
+        "{} {} {}",
+        CLIPBOARD_EMOJI,
+        style("Build Warren CLI").bold().magenta(),
+        style("v0.1.0").dim()
+    );
+
     match &cli.command {
         Some(Commands::BuildCount) => {
             let highest_index = get_st_highest_index();
             if let Some(output_file) = &cli.output {
                 fs::write(output_file, highest_index.to_string())
                     .expect("Failed to write to output file");
+                println!(
+                    "{} {}Highest build index written to {}",
+                    OUTPUT_EMOJI,
+                    style("Success : ").green(),
+                    output_file
+                );
             } else {
                 println!("Highest build index: {}", highest_index);
             }
@@ -62,6 +79,13 @@ fn main() {
                 if let Some(output_file) = &cli.output {
                     fs::write(output_file, json_output)
                         .expect("Failed to write build order to output file");
+                    println!(
+                        "{} {}Build order {} written to {}",
+                        OUTPUT_EMOJI,
+                        style("Success : ").green(),
+                        id,
+                        output_file
+                    );
                 } else {
                     println!("{}", json_output);
                 }
@@ -75,6 +99,13 @@ fn main() {
             if let Some(output_file) = &cli.output {
                 fs::write(output_file, json_output)
                     .expect("Failed to write build orders to output file");
+                println!(
+                    "{} {}Latest {} build orders written to {}",
+                    OUTPUT_EMOJI,
+                    style("Success : ").green(),
+                    count,
+                    output_file
+                );
             } else {
                 println!("{}", json_output);
             }
@@ -89,6 +120,14 @@ fn main() {
             if let Some(output_file) = &cli.output {
                 fs::write(output_file, json_output)
                     .expect("Failed to write build orders to output file");
+                println!(
+                    "{} {}Build orders from {} to {} written to {}",
+                    OUTPUT_EMOJI,
+                    style("Success : ").green(),
+                    start,
+                    end,
+                    output_file
+                );
             } else {
                 println!("{}", json_output);
             }