clippy.toml

@@ -13,6 +13,4 @@ disallowed-methods = [
   # Use `thread::Builder::spawn` instead and handle the error.
   "std::thread::spawn",
   "std::thread::Scope::spawn",
-  # Return `ExitCode` instead.
-  "std::process::exit",
 ]

src/app_state.rs

@@ -1,15 +1,16 @@
-use anyhow::{bail, Context, Error, Result};
+use anyhow::{bail, Context, Result};
-use crossterm::{cursor, terminal, QueueableCommand};
+use crossterm::{
+    queue,
+    style::{Print, ResetColor, SetForegroundColor},
+    terminal,
+};
 use std::{
     env,
     fs::{File, OpenOptions},
-    io::{Read, Seek, StdoutLock, Write},
+    io::{self, Read, Seek, StdoutLock, Write},
     path::{Path, MAIN_SEPARATOR_STR},
     process::{Command, Stdio},
-    sync::{
+    sync::{atomic::AtomicUsize, mpsc, Arc},
-        atomic::{AtomicUsize, Ordering::Relaxed},
-        mpsc,
-    },
     thread,
 };
 
@@ -20,7 +21,7 @@ use crate::{
     embedded::EMBEDDED_FILES,
     exercise::{Exercise, RunnableExercise},
     info_file::ExerciseInfo,
-    term::{self, CheckProgressVisualizer},
+    term::{self, progress_bar_with_success},
 };
 
 const STATE_FILE_NAME: &str = ".rustlings-state.txt";
@@ -41,12 +42,12 @@ pub enum StateFileStatus {
     NotRead,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq)]
-pub enum CheckProgress {
+enum AllExercisesResult {
-    None,
-    Checking,
-    Done,
     Pending,
+    Success,
+    Failed,
+    Error,
 }
 
 pub struct AppState {
@@ -202,11 +203,6 @@ impl AppState {
         self.n_done
     }
 
-    #[inline]
-    pub fn n_pending(&self) -> u16 {
-        self.exercises.len() as u16 - self.n_done
-    }
-
     #[inline]
     pub fn current_exercise(&self) -> &Exercise {
         &self.exercises[self.current_exercise_ind]
@@ -284,7 +280,7 @@ impl AppState {
     }
 
     // Set the status of an exercise without saving. Returns `true` if the
-    // status actually changed (and thus needs saving later).
+    // status actually changed (and thus needs saving later)
     pub fn set_status(&mut self, exercise_ind: usize, done: bool) -> Result<bool> {
         let exercise = self
             .exercises
@@ -292,25 +288,23 @@ impl AppState {
             .context(BAD_INDEX_ERR)?;
 
         if exercise.done == done {
-            return Ok(false);
+            Ok(false)
-        }
-
-        exercise.done = done;
-        if done {
-            self.n_done += 1;
         } else {
-            self.n_done -= 1;
+            exercise.done = done;
+            if done {
+                self.n_done += 1;
+            } else {
+                self.n_done -= 1;
+            }
+            Ok(true)
         }
-
-        Ok(true)
     }
 
-    // Set the status of an exercise to "pending" and save.
+    // Set the status of an exercise to "pending" and save
     pub fn set_pending(&mut self, exercise_ind: usize) -> Result<()> {
         if self.set_status(exercise_ind, false)? {
             self.write()?;
         }
-
         Ok(())
     }
 
@@ -408,114 +402,174 @@ impl AppState {
         }
     }
 
-    fn check_all_exercises_impl(&mut self, stdout: &mut StdoutLock) -> Result<Option<usize>> {
+    // Return the exercise index of the first pending exercise found.
-        let term_width = terminal::size()
+    pub fn check_all_exercises(
-            .context("Failed to get the terminal size")?
+        &mut self,
-            .0;
+        stdout: &mut StdoutLock,
-        let mut progress_visualizer = CheckProgressVisualizer::build(stdout, term_width)?;
+        final_check: bool,
+    ) -> Result<Option<usize>> {
+        if !final_check {
+            stdout.write_all(INTERMEDIATE_CHECK_MSG)?;
+        } else {
+            stdout.write_all(FINAL_CHECK_MSG)?;
+        }
+        let n_exercises = self.exercises.len();
 
-        let next_exercise_ind = AtomicUsize::new(0);
+        let (mut checked_count, mut results) = thread::scope(|s| {
-        let mut progresses = vec![CheckProgress::None; self.exercises.len()];
+            let (tx, rx) = mpsc::channel();
+            let exercise_ind = Arc::new(AtomicUsize::default());
 
-        thread::scope(|s| {
+            let num_core = thread::available_parallelism()
-            let (exercise_progress_sender, exercise_progress_receiver) = mpsc::channel();
-            let n_threads = thread::available_parallelism()
                 .map_or(DEFAULT_CHECK_PARALLELISM, |count| count.get());
-
+            (0..num_core).for_each(|_| {
-            for _ in 0..n_threads {
+                let tx = tx.clone();
-                let exercise_progress_sender = exercise_progress_sender.clone();
+                let exercise_ind = exercise_ind.clone();
-                let next_exercise_ind = &next_exercise_ind;
+                let this = &self;
-                let slf = &self;
+                let _ = thread::Builder::new().spawn_scoped(s, move || {
-                thread::Builder::new()
+                    loop {
-                    .spawn_scoped(s, move || loop {
+                        let exercise_ind =
-                        let exercise_ind = next_exercise_ind.fetch_add(1, Relaxed);
+                            exercise_ind.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
-                        let Some(exercise) = slf.exercises.get(exercise_ind) else {
+                        let Some(exercise) = this.exercises.get(exercise_ind) else {
-                            // No more exercises.
+                            // No more exercises
                             break;
                         };
 
-                        if exercise_progress_sender
+                        // Notify the progress bar that this exercise is pending
-                            .send((exercise_ind, CheckProgress::Checking))
+                        if tx.send((exercise_ind, None)).is_err() {
-                            .is_err()
-                        {
                             break;
                         };
 
-                        let success = exercise.run_exercise(None, &slf.cmd_runner);
+                        let result = exercise.run_exercise(None, &this.cmd_runner);
-                        let progress = match success {
-                            Ok(true) => CheckProgress::Done,
-                            Ok(false) => CheckProgress::Pending,
-                            Err(_) => CheckProgress::None,
-                        };
 
-                        if exercise_progress_sender
+                        // Notify the progress bar that this exercise is done
-                            .send((exercise_ind, progress))
+                        if tx.send((exercise_ind, Some(result))).is_err() {
-                            .is_err()
-                        {
                             break;
                         }
-                    })
+                    }
-                    .context("Failed to spawn a thread to check all exercises")?;
+                });
+            });
+
+            // Drop this `tx`, since the `rx` loop will not stop while there is
+            // at least one tx alive (i.e. we want the loop to block only while
+            // there are `tx` clones, i.e. threads)
+            drop(tx);
+
+            // Print the legend
+            queue!(
+                stdout,
+                Print("Color legend:  "),
+                SetForegroundColor(term::PROGRESS_FAILED_COLOR),
+                Print("Failure"),
+                ResetColor,
+                Print("  -  "),
+                SetForegroundColor(term::PROGRESS_SUCCESS_COLOR),
+                Print("Success"),
+                ResetColor,
+                Print("  -  "),
+                SetForegroundColor(term::PROGRESS_PENDING_COLOR),
+                Print("Checking"),
+                ResetColor,
+                Print("\n"),
+            )
+            .unwrap();
+            // We expect at least a few "pending" notifications shortly, so don't
+            // bother printing the initial state of the progress bar and flushing
+            // stdout
+
+            let line_width = terminal::size().unwrap().0;
+            let mut results = vec![AllExercisesResult::Pending; n_exercises];
+            let mut pending = 0;
+            let mut success = 0;
+            let mut failed = 0;
+
+            while let Ok((exercise_ind, result)) = rx.recv() {
+                match result {
+                    None => {
+                        pending += 1;
+                    }
+                    Some(Err(_)) => {
+                        results[exercise_ind] = AllExercisesResult::Error;
+                    }
+                    Some(Ok(true)) => {
+                        results[exercise_ind] = AllExercisesResult::Success;
+                        pending -= 1;
+                        success += 1;
+                    }
+                    Some(Ok(false)) => {
+                        results[exercise_ind] = AllExercisesResult::Failed;
+                        pending -= 1;
+                        failed += 1;
+                    }
+                }
+
+                write!(stdout, "\r").unwrap();
+                progress_bar_with_success(
+                    stdout,
+                    pending,
+                    failed,
+                    success,
+                    n_exercises as u16,
+                    line_width,
+                )
+                .unwrap();
+                stdout.flush()?;
             }
 
-            // Drop this sender to detect when the last thread is done.
+            Ok::<_, io::Error>((success, results))
-            drop(exercise_progress_sender);
-
-            while let Ok((exercise_ind, progress)) = exercise_progress_receiver.recv() {
-                progresses[exercise_ind] = progress;
-                progress_visualizer.update(&progresses)?;
-            }
-
-            Ok::<_, Error>(())
         })?;
 
-        let mut first_pending_exercise_ind = None;
+        // If we got an error while checking all exercises in parallel,
-        for exercise_ind in 0..progresses.len() {
+        // it could be because we exceeded the limit of open file descriptors.
-            match progresses[exercise_ind] {
+        // Therefore, re-try those one at a time (i.e. sequentially).
-                CheckProgress::Done => {
+        results
-                    self.set_status(exercise_ind, true)?;
+            .iter_mut()
-                }
+            .enumerate()
-                CheckProgress::Pending => {
+            .filter(|(_, result)| {
-                    self.set_status(exercise_ind, false)?;
+                **result == AllExercisesResult::Pending || **result == AllExercisesResult::Error
-                    if first_pending_exercise_ind.is_none() {
+            })
-                        first_pending_exercise_ind = Some(exercise_ind);
+            .try_for_each(|(exercise_ind, result)| {
-                    }
+                let exercise = self.exercises.get(exercise_ind).context(BAD_INDEX_ERR)?;
-                }
+                *result = match exercise
-                CheckProgress::None | CheckProgress::Checking => {
+                    .run_exercise(None, &self.cmd_runner)
-                    // If we got an error while checking all exercises in parallel,
+                    .context("Sequential retry")
-                    // it could be because we exceeded the limit of open file descriptors.
+                {
-                    // Therefore, try running exercises with errors sequentially.
+                    Ok(true) => AllExercisesResult::Success,
-                    progresses[exercise_ind] = CheckProgress::Checking;
+                    Ok(false) => AllExercisesResult::Failed,
-                    progress_visualizer.update(&progresses)?;
+                    Err(err) => bail!(err),
+                };
+                checked_count += 1;
+                write!(stdout, "\rProgress: {checked_count}/{n_exercises}")?;
+                stdout.flush()?;
+                Ok(())
+            })?;
 
-                    let exercise = &self.exercises[exercise_ind];
+        // Update the state of each exercise and return the first that failed
-                    let success = exercise.run_exercise(None, &self.cmd_runner)?;
+        let first_fail = results
-                    if success {
+            .iter()
-                        progresses[exercise_ind] = CheckProgress::Done;
+            .enumerate()
-                    } else {
+            .filter_map(|(exercise_ind, result)| {
-                        progresses[exercise_ind] = CheckProgress::Pending;
+                match result {
-                        if first_pending_exercise_ind.is_none() {
+                    AllExercisesResult::Success => self
-                            first_pending_exercise_ind = Some(exercise_ind);
+                        .set_status(exercise_ind, true)
-                        }
+                        .map_or_else(|err| Some(Err(err)), |_| None),
-                    }
+                    AllExercisesResult::Failed => self
-                    self.set_status(exercise_ind, success)?;
+                        .set_status(exercise_ind, false)
-                    progress_visualizer.update(&progresses)?;
+                        .map_or_else(|err| Some(Err(err)), |_| Some(Ok(exercise_ind))),
+                    // The sequential check done earlier will have converted all
+                    // exercises to Success/Failed, or bailed, so those are unreachable
+                    AllExercisesResult::Pending | AllExercisesResult::Error => unreachable!(),
                 }
-            }
+            })
-        }
+            .try_fold(None::<usize>, |current_min, index| {
-
+                match (current_min, index) {
+                    (_, Err(err)) => Err(err),
+                    (None, Ok(index)) => Ok(Some(index)),
+                    (Some(current_min), Ok(index)) => Ok(Some(current_min.min(index))),
+                }
+            })?;
         self.write()?;
 
-        Ok(first_pending_exercise_ind)
+        Ok(first_fail)
-    }
-
-    // Return the exercise index of the first pending exercise found.
-    pub fn check_all_exercises(&mut self, stdout: &mut StdoutLock) -> Result<Option<usize>> {
-        stdout.queue(cursor::Hide)?;
-        let res = self.check_all_exercises_impl(stdout);
-        stdout.queue(cursor::Show)?;
-
-        res
     }
 
     /// Mark the current exercise as done and move on to the next pending exercise if one exists.
@@ -542,12 +596,18 @@ impl AppState {
             stdout.write_all(b"\n")?;
         }
 
-        if let Some(first_pending_exercise_ind) = self.check_all_exercises(stdout)? {
+        if let Some(pending_exercise_ind) = self.check_all_exercises(stdout, true)? {
-            self.set_current_exercise_ind(first_pending_exercise_ind)?;
+            stdout.write_all(b"\n\n")?;
+
+            self.current_exercise_ind = pending_exercise_ind;
+            self.exercises[pending_exercise_ind].done = false;
 
             return Ok(ExercisesProgress::NewPending);
         }
 
+        // Write that the last exercise is done.
+        self.write()?;
+
         self.render_final_message(stdout)?;
 
         Ok(ExercisesProgress::AllDone)
@@ -569,6 +629,11 @@ impl AppState {
 
 const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
 const STATE_FILE_HEADER: &[u8] = b"DON'T EDIT THIS FILE!\n\n";
+const INTERMEDIATE_CHECK_MSG: &[u8] = b"Checking all exercises
+";
+const FINAL_CHECK_MSG: &[u8] = b"All exercises seem to be done.
+Recompiling and running all exercises to make sure that all of them are actually done.
+";
 const FENISH_LINE: &str = "+----------------------------------------------------+
 |          You made it to the Fe-nish line!          |
 +--------------------------  ------------------------+

src/main.rs

@@ -1,10 +1,14 @@
 use anyhow::{bail, Context, Result};
 use app_state::StateFileStatus;
 use clap::{Parser, Subcommand};
+use crossterm::{
+    style::{Color, Print, ResetColor, SetForegroundColor},
+    QueueableCommand,
+};
 use std::{
     io::{self, IsTerminal, Write},
     path::Path,
-    process::ExitCode,
+    process::exit,
 };
 use term::{clear_terminal, press_enter_prompt};
 
@@ -47,8 +51,8 @@ enum Subcommands {
         /// The name of the exercise
         name: Option<String>,
     },
-    /// Check all the exercises, marking them as done or pending accordingly.
+    /// Run all the exercises, marking them as done or pending accordingly.
-    CheckAll,
+    RunAll,
     /// Reset a single exercise
     Reset {
         /// The name of the exercise
@@ -64,26 +68,22 @@ enum Subcommands {
     Dev(DevCommands),
 }
 
-fn main() -> Result<ExitCode> {
+fn main() -> Result<()> {
     let args = Args::parse();
 
     if cfg!(not(debug_assertions)) && Path::new("dev/rustlings-repo.txt").exists() {
         bail!("{OLD_METHOD_ERR}");
     }
 
-    'priority_cmd: {
+    match args.command {
-        match args.command {
+        Some(Subcommands::Init) => return init::init().context("Initialization failed"),
-            Some(Subcommands::Init) => init::init().context("Initialization failed")?,
+        Some(Subcommands::Dev(dev_command)) => return dev_command.run(),
-            Some(Subcommands::Dev(dev_command)) => dev_command.run()?,
+        _ => (),
-            _ => break 'priority_cmd,
-        }
-
-        return Ok(ExitCode::SUCCESS);
     }
 
     if !Path::new("exercises").is_dir() {
         println!("{PRE_INIT_MSG}");
-        return Ok(ExitCode::FAILURE);
+        exit(1);
     }
 
     let info_file = InfoFile::parse()?;
@@ -142,32 +142,34 @@ fn main() -> Result<ExitCode> {
             if let Some(name) = name {
                 app_state.set_current_exercise_by_name(&name)?;
             }
-            return run::run(&mut app_state);
+            run::run(&mut app_state)?;
         }
-        Some(Subcommands::CheckAll) => {
+        Some(Subcommands::RunAll) => {
             let mut stdout = io::stdout().lock();
-            if let Some(first_pending_exercise_ind) = app_state.check_all_exercises(&mut stdout)? {
+            if let Some(first_fail) = app_state.check_all_exercises(&mut stdout, false)? {
+                let pending = app_state
+                    .exercises()
+                    .iter()
+                    .filter(|exercise| !exercise.done)
+                    .count();
                 if app_state.current_exercise().done {
-                    app_state.set_current_exercise_ind(first_pending_exercise_ind)?;
+                    app_state.set_current_exercise_ind(first_fail)?;
                 }
-
+                stdout
-                stdout.write_all(b"\n\n")?;
+                    .queue(Print("\n"))?
-                let pending = app_state.n_pending();
+                    .queue(SetForegroundColor(Color::Red))?
+                    .queue(Print(format!("{pending}")))?
+                    .queue(ResetColor)?;
                 if pending == 1 {
-                    stdout.write_all(b"One exercise pending: ")?;
+                    stdout.queue(Print(" exercise has some errors: "))?;
                 } else {
-                    write!(
+                    stdout.queue(Print(" exercises have errors, including "))?;
-                        stdout,
-                        "{pending}/{} exercises pending. The first: ",
-                        app_state.exercises().len(),
-                    )?;
                 }
                 app_state
                     .current_exercise()
                     .terminal_file_link(&mut stdout)?;
-                stdout.write_all(b"\n")?;
+                stdout.write_all(b".\n")?;
-
+                exit(1);
-                return Ok(ExitCode::FAILURE);
             } else {
                 app_state.render_final_message(&mut stdout)?;
             }
@@ -187,7 +189,7 @@ fn main() -> Result<ExitCode> {
         Some(Subcommands::Init | Subcommands::Dev(_)) => (),
     }
 
-    Ok(ExitCode::SUCCESS)
+    Ok(())
 }
 
 const OLD_METHOD_ERR: &str =

src/run.rs

@@ -5,7 +5,7 @@ use crossterm::{
 };
 use std::{
     io::{self, Write},
-    process::ExitCode,
+    process::exit,
 };
 
 use crate::{
@@ -13,7 +13,7 @@ use crate::{
     exercise::{solution_link_line, RunnableExercise, OUTPUT_CAPACITY},
 };
 
-pub fn run(app_state: &mut AppState) -> Result<ExitCode> {
+pub fn run(app_state: &mut AppState) -> Result<()> {
     let exercise = app_state.current_exercise();
     let mut output = Vec::with_capacity(OUTPUT_CAPACITY);
     let success = exercise.run_exercise(Some(&mut output), app_state.cmd_runner())?;
@@ -29,8 +29,7 @@ pub fn run(app_state: &mut AppState) -> Result<ExitCode> {
             .current_exercise()
             .terminal_file_link(&mut stdout)?;
         stdout.write_all(b" with errors\n")?;
-
+        exit(1);
-        return Ok(ExitCode::FAILURE);
     }
 
     stdout.queue(SetForegroundColor(Color::Green))?;
@@ -56,5 +55,5 @@ pub fn run(app_state: &mut AppState) -> Result<ExitCode> {
         ExercisesProgress::AllDone => (),
     }
 
-    Ok(ExitCode::SUCCESS)
+    Ok(())
 }

src/term.rs

@@ -1,6 +1,6 @@
 use crossterm::{
     cursor::MoveTo,
-    style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor},
+    style::{Attribute, Color, SetAttribute, SetForegroundColor},
     terminal::{Clear, ClearType},
     Command, QueueableCommand,
 };
@@ -9,7 +9,9 @@ use std::{
     io::{self, BufRead, StdoutLock, Write},
 };
 
-use crate::app_state::CheckProgress;
+pub const PROGRESS_FAILED_COLOR: Color = Color::Red;
+pub const PROGRESS_SUCCESS_COLOR: Color = Color::Green;
+pub const PROGRESS_PENDING_COLOR: Color = Color::Blue;
 
 pub struct MaxLenWriter<'a, 'b> {
     pub stdout: &'a mut StdoutLock<'b>,
@@ -87,87 +89,26 @@ impl<'a> CountedWrite<'a> for StdoutLock<'a> {
     }
 }
 
-pub struct CheckProgressVisualizer<'a, 'b> {
+/// Simple terminal progress bar
-    stdout: &'a mut StdoutLock<'b>,
-    n_cols: usize,
-}
-
-impl<'a, 'b> CheckProgressVisualizer<'a, 'b> {
-    const CHECKING_COLOR: Color = Color::Blue;
-    const DONE_COLOR: Color = Color::Green;
-    const PENDING_COLOR: Color = Color::Red;
-
-    pub fn build(stdout: &'a mut StdoutLock<'b>, term_width: u16) -> io::Result<Self> {
-        clear_terminal(stdout)?;
-        stdout.write_all("Checking all exercises…\n".as_bytes())?;
-
-        // Legend
-        stdout.write_all(b"Color of exercise number: ")?;
-        stdout.queue(SetForegroundColor(Self::CHECKING_COLOR))?;
-        stdout.write_all(b"Checking")?;
-        stdout.queue(ResetColor)?;
-        stdout.write_all(b" - ")?;
-        stdout.queue(SetForegroundColor(Self::DONE_COLOR))?;
-        stdout.write_all(b"Done")?;
-        stdout.queue(ResetColor)?;
-        stdout.write_all(b" - ")?;
-        stdout.queue(SetForegroundColor(Self::PENDING_COLOR))?;
-        stdout.write_all(b"Pending")?;
-        stdout.queue(ResetColor)?;
-        stdout.write_all(b"\n")?;
-
-        // Exercise numbers with up to 3 digits.
-        // +1 because the last column doesn't end with a whitespace.
-        let n_cols = usize::from(term_width + 1) / 4;
-
-        Ok(Self { stdout, n_cols })
-    }
-
-    pub fn update(&mut self, progresses: &[CheckProgress]) -> io::Result<()> {
-        self.stdout.queue(MoveTo(0, 2))?;
-
-        let mut exercise_num = 1;
-        for exercise_progress in progresses {
-            match exercise_progress {
-                CheckProgress::None => (),
-                CheckProgress::Checking => {
-                    self.stdout
-                        .queue(SetForegroundColor(Self::CHECKING_COLOR))?;
-                }
-                CheckProgress::Done => {
-                    self.stdout.queue(SetForegroundColor(Self::DONE_COLOR))?;
-                }
-                CheckProgress::Pending => {
-                    self.stdout.queue(SetForegroundColor(Self::PENDING_COLOR))?;
-                }
-            }
-
-            write!(self.stdout, "{exercise_num:<3}")?;
-            self.stdout.queue(ResetColor)?;
-
-            if exercise_num != progresses.len() {
-                if exercise_num % self.n_cols == 0 {
-                    self.stdout.write_all(b"\n")?;
-                } else {
-                    self.stdout.write_all(b" ")?;
-                }
-
-                exercise_num += 1;
-            }
-        }
-
-        self.stdout.flush()
-    }
-}
-
 pub fn progress_bar<'a>(
     writer: &mut impl CountedWrite<'a>,
     progress: u16,
     total: u16,
-    term_width: u16,
+    line_width: u16,
+) -> io::Result<()> {
+    progress_bar_with_success(writer, 0, 0, progress, total, line_width)
+}
+/// Terminal progress bar with three states (pending + failed + success)
+pub fn progress_bar_with_success<'a>(
+    writer: &mut impl CountedWrite<'a>,
+    pending: u16,
+    failed: u16,
+    success: u16,
+    total: u16,
+    line_width: u16,
 ) -> io::Result<()> {
     debug_assert!(total < 1000);
-    debug_assert!(progress <= total);
+    debug_assert!((pending + failed + success) <= total);
 
     const PREFIX: &[u8] = b"Progress: [";
     const PREFIX_WIDTH: u16 = PREFIX.len() as u16;
@@ -175,28 +116,70 @@ pub fn progress_bar<'a>(
     const WRAPPER_WIDTH: u16 = PREFIX_WIDTH + POSTFIX_WIDTH;
     const MIN_LINE_WIDTH: u16 = WRAPPER_WIDTH + 4;
 
-    if term_width < MIN_LINE_WIDTH {
+    if line_width < MIN_LINE_WIDTH {
         writer.write_ascii(b"Progress: ")?;
         // Integers are in ASCII.
-        return writer.write_ascii(format!("{progress}/{total}").as_bytes());
+        return writer.write_ascii(format!("{}/{total}", failed + success).as_bytes());
     }
 
     let stdout = writer.stdout();
     stdout.write_all(PREFIX)?;
 
-    let width = term_width - WRAPPER_WIDTH;
+    let width = line_width - WRAPPER_WIDTH;
-    let filled = (width * progress) / total;
+    let mut failed_end = (width * failed) / total;
+    let mut success_end = (width * (failed + success)) / total;
+    let mut pending_end = (width * (failed + success + pending)) / total;
 
-    stdout.queue(SetForegroundColor(Color::Green))?;
+    // In case the range boundaries overlap, "pending" has priority over both
-    for _ in 0..filled {
+    // "failed" and "success" (don't show the bar as "complete" when we are
+    // still checking some things).
+    // "Failed" has priority over "success" (don't show 100% success if we
+    // have some failures, at the risk of showing 100% failures even with
+    // a few successes).
+    //
+    // "Failed" already has priority over "success" because it's displayed
+    // first. But "pending" is last so we need to fix "success"/"failed".
+    if pending > 0 {
+        pending_end = pending_end.max(1);
+        if pending_end == success_end {
+            success_end -= 1;
+        }
+        if pending_end == failed_end {
+            failed_end -= 1;
+        }
+
+        // This will replace the last character of the "pending" range with
+        // the arrow char ('>'). This ensures that even if the progress bar
+        // is filled (everything either done or pending), we'll still see
+        // the '>' as long as we are not fully done.
+        pending_end -= 1;
+    }
+
+    if failed > 0 {
+        stdout.queue(SetForegroundColor(PROGRESS_FAILED_COLOR))?;
+        for _ in 0..failed_end {
+            stdout.write_all(b"#")?;
+        }
+    }
+
+    stdout.queue(SetForegroundColor(PROGRESS_SUCCESS_COLOR))?;
+    for _ in failed_end..success_end {
         stdout.write_all(b"#")?;
     }
 
-    if filled < width {
+    if pending > 0 {
+        stdout.queue(SetForegroundColor(PROGRESS_PENDING_COLOR))?;
+
+        for _ in success_end..pending_end {
+            stdout.write_all(b"#")?;
+        }
+    }
+
+    if pending_end < width {
         stdout.write_all(b">")?;
     }
 
-    let width_minus_filled = width - filled;
+    let width_minus_filled = width - pending_end;
     if width_minus_filled > 1 {
         let red_part_width = width_minus_filled - 1;
         stdout.queue(SetForegroundColor(Color::Red))?;
@@ -207,7 +190,7 @@ pub fn progress_bar<'a>(
 
     stdout.queue(SetForegroundColor(Color::Reset))?;
 
-    write!(stdout, "] {progress:>3}/{total}")
+    write!(stdout, "] {:>3}/{}", failed + success, total)
 }
 
 pub fn clear_terminal(stdout: &mut StdoutLock) -> io::Result<()> {

src/watch.rs

@@ -108,7 +108,7 @@ fn run_watch(
             {
                 ExercisesProgress::AllDone => break,
                 ExercisesProgress::NewPending => watch_state.run_current_exercise(&mut stdout)?,
-                ExercisesProgress::CurrentPending => watch_state.render(&mut stdout)?,
+                ExercisesProgress::CurrentPending => (),
             },
             WatchEvent::Input(InputEvent::Reset) => watch_state.reset_exercise(&mut stdout)?,
             WatchEvent::Input(InputEvent::Quit) => {

src/watch/state.rs

@@ -157,9 +157,8 @@ impl<'a> WatchState<'a> {
 
     /// Move on to the next exercise if the current one is done.
     pub fn next_exercise(&mut self, stdout: &mut StdoutLock) -> Result<ExercisesProgress> {
-        match self.done_status {
+        if self.done_status == DoneStatus::Pending {
-            DoneStatus::DoneWithSolution(_) | DoneStatus::DoneWithoutSolution => (),
+            return Ok(ExercisesProgress::CurrentPending);
-            DoneStatus::Pending => return Ok(ExercisesProgress::CurrentPending),
         }
 
         self.app_state.done_current_exercise::<true>(stdout)
@@ -281,15 +280,16 @@ impl<'a> WatchState<'a> {
     }
 
     pub fn check_all_exercises(&mut self, stdout: &mut StdoutLock) -> Result<ExercisesProgress> {
-        if let Some(first_pending_exercise_ind) = self.app_state.check_all_exercises(stdout)? {
+        stdout.write_all(b"\n")?;
-            // Only change exercise if the current one is done.
+
+        if let Some(first_fail) = self.app_state.check_all_exercises(stdout, false)? {
+            // Only change exercise if the current one is done...
             if self.app_state.current_exercise().done {
-                self.app_state
+                self.app_state.set_current_exercise_ind(first_fail)?;
-                    .set_current_exercise_ind(first_pending_exercise_ind)?;
-                Ok(ExercisesProgress::NewPending)
-            } else {
-                Ok(ExercisesProgress::CurrentPending)
             }
+            // ...but always pretend it's a "new" anyway because that refreshes
+            // the display
+            Ok(ExercisesProgress::NewPending)
         } else {
             self.app_state.render_final_message(stdout)?;
             Ok(ExercisesProgress::AllDone)