From 9be012dda0617e868c044a22e815933bc0db2cb0 Mon Sep 17 00:00:00 2001
From: Ryan Lowe <rlowe13@me.com>
Date: Sat, 5 Feb 2022 16:54:11 -0500
Subject: [PATCH] feat!: Add progress indicator

closes #360

BREAKING CHANGE: verify() has a new function signature so it can
know the current completion progress
---
 src/main.rs   | 13 ++++++-------
 src/verify.rs | 25 ++++++++++++++++++-------
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 32e7bba..96378ec 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -214,7 +214,7 @@ fn main() {
         }
 
         Subcommands::Verify(_subargs) => {
-            verify(&exercises, verbose).unwrap_or_else(|_| std::process::exit(1));
+            verify(&exercises, (0, exercises.len()), verbose).unwrap_or_else(|_| std::process::exit(1));
         }
 
         Subcommands::Watch(_subargs) => match watch(&exercises, verbose) {
@@ -351,7 +351,7 @@ fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result<WatchStatus> {
     clear_screen();
 
     let to_owned_hint = |t: &Exercise| t.hint.to_owned();
-    let failed_exercise_hint = match verify(exercises.iter(), verbose) {
+    let failed_exercise_hint = match verify(exercises.iter(), (0, exercises.len()), verbose) {
         Ok(_) => return Ok(WatchStatus::Finished),
         Err(exercise) => Arc::new(Mutex::new(Some(to_owned_hint(exercise)))),
     };
@@ -362,17 +362,16 @@ fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result<WatchStatus> {
                 DebouncedEvent::Create(b) | DebouncedEvent::Chmod(b) | DebouncedEvent::Write(b) => {
                     if b.extension() == Some(OsStr::new("rs")) && b.exists() {
                         let filepath = b.as_path().canonicalize().unwrap();
-                        let pending_exercises = exercises
-                            .iter()
-                            .skip_while(|e| !filepath.ends_with(&e.path))
-                            // .filter(|e| filepath.ends_with(&e.path))
+                        let pending_exercises = exercises.iter()
+                            .find(|e| filepath.ends_with(&e.path)).into_iter()
                             .chain(
                                 exercises
                                     .iter()
                                     .filter(|e| !e.looks_done() && !filepath.ends_with(&e.path)),
                             );
+                        let num_done = exercises.iter().filter(|e| e.looks_done()).count();
                         clear_screen();
-                        match verify(pending_exercises, verbose) {
+                        match verify(pending_exercises, (num_done, exercises.len()), verbose) {
                             Ok(_) => return Ok(WatchStatus::Finished),
                             Err(exercise) => {
                                 let mut failed_exercise_hint = failed_exercise_hint.lock().unwrap();
diff --git a/src/verify.rs b/src/verify.rs
index fd59fa5..eb7af69 100644
--- a/src/verify.rs
+++ b/src/verify.rs
@@ -1,6 +1,6 @@
 use crate::exercise::{CompiledExercise, Exercise, Mode, State};
 use console::style;
-use indicatif::ProgressBar;
+use indicatif::{ProgressBar, ProgressStyle};
 use std::env;
 
 // Verify that the provided container of Exercise objects
@@ -9,10 +9,18 @@ use std::env;
 // If the Exercise being verified is a test, the verbose boolean
 // determines whether or not the test harness outputs are displayed.
 pub fn verify<'a>(
-    start_at: impl IntoIterator<Item = &'a Exercise>,
+    exercises: impl IntoIterator<Item = &'a Exercise>,
+    progress: (usize, usize),
     verbose: bool,
 ) -> Result<(), &'a Exercise> {
-    for exercise in start_at {
+    let (num_done, total) = progress;
+    let bar = ProgressBar::new(total as u64);
+    bar.set_style(ProgressStyle::default_bar()
+        .template("Progress: [{bar:60.green/red}] {pos}/{len}")
+        .progress_chars("#>-")
+    );
+    bar.set_position(num_done as u64);
+    for exercise in exercises {
         let compile_result = match exercise.mode {
             Mode::Test => compile_and_test(exercise, RunMode::Interactive, verbose),
             Mode::Compile => compile_and_run_interactively(exercise),
@@ -21,6 +29,7 @@ pub fn verify<'a>(
         if !compile_result.unwrap_or(false) {
             return Err(exercise);
         }
+        bar.inc(1);
     }
     Ok(())
 }
@@ -45,7 +54,6 @@ fn compile_only(exercise: &Exercise) -> Result<bool, ()> {
     let _ = compile(exercise, &progress_bar)?;
     progress_bar.finish_and_clear();
 
-    success!("Successfully compiled {}!", exercise);
     Ok(prompt_for_completion(exercise, None))
 }
 
@@ -71,8 +79,6 @@ fn compile_and_run_interactively(exercise: &Exercise) -> Result<bool, ()> {
         }
     };
 
-    success!("Successfully ran {}!", exercise);
-
     Ok(prompt_for_completion(exercise, Some(output.stdout)))
 }
 
@@ -92,7 +98,6 @@ fn compile_and_test(exercise: &Exercise, run_mode: RunMode, verbose: bool) -> Re
             if verbose {
                 println!("{}", output.stdout);
             }
-            success!("Successfully tested {}", &exercise);
             if let RunMode::Interactive = run_mode {
                 Ok(prompt_for_completion(exercise, None))
             } else {
@@ -138,6 +143,12 @@ fn prompt_for_completion(exercise: &Exercise, prompt_output: Option<String>) ->
         State::Pending(context) => context,
     };
 
+    match exercise.mode {
+        Mode::Compile => success!("Successfully ran {}!", exercise),
+        Mode::Test => success!("Successfully tested {}!", exercise),
+        Mode::Clippy => success!("Successfully compiled {}!", exercise),
+    }
+
     let no_emoji = env::var("NO_EMOJI").is_ok();
 
     let clippy_success_msg = if no_emoji {