yagit

diff --git a/src/log.rs b/src/log.rs
@@ -1,14 +1,21 @@
 //! Macros for logging.
 //!
-//! This implementation should be thread safe (unlink an implementation using
+//! This implementation should be thread safe (unlike an implementation using
 //! `println!` and `eprintln!`) because access to the global stdout/stderr
 //! handle is syncronized using a lock.
-use std::{io::{self, Write}, fmt::Arguments};
+#![allow(static_mut_refs)]
+use std::{io::{self, Write}, fmt::Arguments, sync::RwLock};
 
-pub const BOLD_GREEN: &str =  "\u{001b}[1;32m";
-pub const BOLD_RED:   &str =  "\u{001b}[1;31m";
-pub const BOLD_YELLOW: &str = "\u{001b}[1;33m";
-pub const RESET:      &str =  "\u{001b}[0m";
+const BOLD_WHITE:  &str = "\u{001b}[1;37m";
+const BOLD_BLUE:   &str = "\u{001b}[1;34m";
+const BOLD_RED:    &str = "\u{001b}[1;31m";
+const BOLD_YELLOW: &str = "\u{001b}[1;33m";
+const RESET:       &str = "\u{001b}[0m";
+
+// TODO: [optimize]: make a thread-unsafe version of this under a compile flag
+static NEEDS_NEWLINE: RwLock<bool> = RwLock::new(false);
+static mut COUNTER_TOTAL: RwLock<usize> = RwLock::new(0);
+static mut COUNTER_STATE: RwLock<Option<CounterState>> = RwLock::new(None);
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) enum Level {
@@ -17,39 +24,141 @@ pub(crate) enum Level {
   Warn,
 }
 
+struct CounterState {
+  count: usize,
+  current_repo_name: String,
+}
+
 pub(crate) fn log(level: Level, args: &Arguments<'_>, newline: bool) {
   match level {
     Level::Error => {
       let mut stderr = io::stderr();
+
+      if needs_newline() {
+        let _ = writeln!(stderr);
+      }
+
       let _ = write!(stderr, "{BOLD_RED}ERROR:{RESET} ");
-      let _ = if newline {
-        writeln!(stderr, "{}", args)
+      if newline {
+        let _ = writeln!(stderr, "{}", args);
+        // shouldn't print the job counter because we are about to die
       } else {
-        write!(stderr, "{}", args)
-      };
-      if !newline { let _ = stderr.flush(); }
+        let _ = write!(stderr, "{}", args);
+        let _ = stderr.flush();
+      }
     }
     Level::Info => {
       let mut stdout = io::stdout().lock();
-      let _ = write!(stdout, "{BOLD_GREEN}INFO:{RESET} ");
-      let _ = if newline {
-        writeln!(stdout, "{}", args)
+
+      if needs_newline() {
+        let _ = writeln!(stdout);
+      }
+
+      let _ = write!(stdout, "{BOLD_BLUE}INFO:{RESET} ");
+      if newline {
+        let counter_state = unsafe { COUNTER_STATE.get_mut().unwrap() };
+        let _ = writeln!(stdout, "{}", args);
+        if let Some(ref counter) = counter_state {
+          log_job_counter(counter);
+        }
       } else {
-        write!(stdout, "{}", args)
-      };
-      if !newline { let _ = stdout.flush(); }
+        let _ = write!(stdout, "{}", args);
+        let _ = stdout.flush();
+      }
     }
     Level::Warn => {
       let mut stdout = io::stdout().lock();
+
+      if needs_newline() {
+        let _ = writeln!(stdout);
+      }
+
       let _ = write!(stdout, "{BOLD_YELLOW}WARNING:{RESET} ");
-      let _ = if newline {
-        writeln!(stdout, "{}", args)
+      if newline {
+        let counter_state = unsafe { COUNTER_STATE.get_mut().unwrap() };
+        let _ = writeln!(stdout, "{}", args);
+        if let Some(ref counter) = counter_state {
+          log_job_counter(counter);
+        }
       } else {
-        write!(stdout, "{}", args)
-      };
+        let _ = write!(stdout, "{}", args);
+      }
       if !newline { let _ = stdout.flush(); }
     }
   }
+
+  if !newline {
+    set_needs_newline(true);
+  }
+}
+
+pub fn info_done(args: Option<&Arguments<'_>>) {
+  let mut stdout = io::stdout().lock();
+  let _ = match args {
+    Some(args) => {
+      writeln!(stdout, " {}", args)
+    }
+    None => {
+      writeln!(stdout, " done!")
+    }
+  };
+  set_needs_newline(false);
+}
+
+pub fn job_counter_start(total: usize) {
+  unsafe {
+    *COUNTER_TOTAL.write().unwrap() = total;
+  }
+}
+
+pub fn job_counter_increment(repo_name: &str) {
+  let counter_total = unsafe { COUNTER_TOTAL.get_mut().unwrap() };
+  let counter = unsafe { COUNTER_STATE.get_mut().unwrap() };
+
+  if let Some(ref mut inner) = counter {
+    inner.count += 1;
+    inner.current_repo_name = repo_name.to_owned();
+
+    log_job_counter(inner);
+
+    // deinit the counter when we reach the total
+    if inner.count == *counter_total {
+      *counter = None;
+      *counter_total = 0;
+    }
+  } else {
+    let new_counter = CounterState {
+      count: 1,
+      current_repo_name: repo_name.to_owned(),
+    };
+
+    log_job_counter(&new_counter);
+    *counter = Some(new_counter);
+  }
+}
+
+fn log_job_counter(counter: &CounterState) {
+  let mut stdout = io::stdout().lock();
+  let counter_total = unsafe { *COUNTER_TOTAL.read().unwrap() };
+
+  let _ = write!(
+    stdout,
+    "{BOLD_BLUE}->{RESET} {BOLD_WHITE}{count:>padding$}/{total}{RESET} {name}...",
+    count = counter.count,
+    total = counter_total,
+    padding = crate::log_floor(counter_total),
+    name = counter.current_repo_name,
+  );
+  let _ = stdout.flush();
+  set_needs_newline(true);
+}
+
+fn needs_newline() -> bool {
+  *NEEDS_NEWLINE.read().unwrap()
+}
+
+fn set_needs_newline(val: bool) {
+  *NEEDS_NEWLINE.write().unwrap() = val;
 }
 
 #[macro_export]
@@ -79,33 +188,26 @@ macro_rules! infoln {
 #[macro_export]
 macro_rules! info_done {
   () => ({
-    let _ = writeln!(io::stdout().lock(), " done!");
+    $crate::log::info_done(None);
   });
 
   // infoln!("a {} event", "log");
   ($($arg:tt)+) => ({
-    let _ = writeln!(
-      io::stdout().lock(),
-      " {}",
-      &std::format_args!($($arg)+)
-    );
+    $crate::log::info_done(Some(&std::format_args!($($arg)+)));
   });
 }
 
 #[macro_export]
-macro_rules! info_count {
-  ($count:expr, $total:expr; $($arg:tt)+) => ({
-    use $crate::log::{BOLD_GREEN, RESET};
-    let mut stdout = io::stdout().lock();
-    let _ = write!(
-      stdout,
-      "{BOLD_GREEN}=> {count:>padding$}/{total}{RESET} {args}",
-      count = $count,
-      total = $total,
-      padding = $crate::log_floor($total),
-      args = std::format_args!($($arg)+)
-    );
-    let _ = stdout.flush();
+macro_rules! job_counter_start {
+  ($total:expr) => ({
+    $crate::log::job_counter_start($total as usize);
+  });
+}
+
+#[macro_export]
+macro_rules! job_counter_increment {
+  ($repo_name:expr) => ({
+    $crate::log::job_counter_increment(&$repo_name);
   });
 }
 

diff --git a/src/main.rs b/src/main.rs
@@ -1608,9 +1608,10 @@ fn main() -> ExitCode {
       info_done!();
 
       let n_repos = repos.len();
+      job_counter_start!(n_repos);
       infoln!("Updating pages for git repositories at {batch_path:?}...");
-      for (i, repo) in repos.into_iter().enumerate() {
-        info_count!(i + 1, n_repos; "{name}...", name = repo.name);
+      for repo in repos {
+        job_counter_increment!(repo.name);
 
         let renderer = RepoRenderer::new(
           repo,