better logging

Use callbacks to report progress, indicatif for progress bars, no direct logs but progress messages

src/main.rs

@@ -1,26 +1,34 @@
 use std::env;
-use std::error::Error;
-use std::collections::HashMap;
-
-extern crate serde;
-use serde::Deserialize;
+use std::io::Write;
+use std::time::Duration;
 
 extern crate clap;
-use clap::{arg, command, value_parser, ArgAction, Command};
+use clap::{arg, command, Command};
 
 extern crate flate2;
 
-extern crate cmd_lib;
-use cmd_lib::{run_cmd};
-
 mod get;
 use get::get;
 
 mod changelog;
 use changelog::generate_entry;
 
+use log::{info, error};
+use indicatif_log_bridge::LogWrapper;
+
 fn main() {
     let rt = tokio::runtime::Runtime::new().unwrap();
+    let logger =
+        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
+            .format_timestamp(None)
+            .format(|buf, record| {
+                writeln!(buf, "{}", record.args())
+            })
+            .build();
+    let multi = indicatif::MultiProgress::new();
+    LogWrapper::new(multi.clone(), logger)
+        .try_init()
+        .unwrap();
 	let matches = command!()
         .subcommand_required(true)
         .disable_version_flag(true)
@@ -59,17 +67,46 @@ fn main() {
             let ppa = sub_matches.get_one::<String>("ppa").map(|s| s.as_str()).unwrap_or("");
             
             // Since get is async, we need to block on it
-            if let Err(e) = rt.block_on(get(package, version, series, "", ppa, None)) {
-                eprintln!("Error: {}", e);
+            let pb = multi.add(indicatif::ProgressBar::new(0));
+            pb.enable_steady_tick(Duration::from_millis(50));
+
+            let mut progress_callback = |prefix: &str, msg: &str, progress: usize, total: usize| {
+
+                if progress != 0 && total != 0 {
+                    pb.set_style(indicatif::ProgressStyle::default_bar()
+                    .template("> {spinner:.blue} {prefix}\n      {msg} [{bar:40.cyan/blue}] {pos}/{len} ({eta})")
+                    .unwrap()
+                    .progress_chars("=> "));
+                } else {
+                    pb.set_style(indicatif::ProgressStyle::default_bar()
+                        .template("> {spinner:.blue} {prefix}")
+                        .unwrap());
+                }
+
+                if ! prefix.is_empty() {
+                    pb.set_prefix(prefix.to_string());
+                }
+
+                pb.set_message(msg.to_string());
+                pb.set_length(total as u64);
+                pb.set_position(progress as u64);
+            };
+
+            if let Err(e) = rt.block_on(get(package, version, series, "", ppa, None, Some(&mut progress_callback))) {
+                pb.finish_and_clear();
+                error!("{}", e);
                 std::process::exit(1);
             }
+            pb.finish_and_clear();
+            multi.remove(&pb);
+            info!("Done.");
         },
         Some(("chlog", sub_matches)) => {
             let cwd = std::env::current_dir().unwrap();
             let version = sub_matches.get_one::<String>("version").map(|s| s.as_str());
 
             if let Err(e) = generate_entry("debian/changelog", Some(&cwd), version) {
-                eprintln!("Error: {}", e);
+                error!("{}", e);
                 std::process::exit(1);
             }