From fa1f239a702eb2c0b7e0115e986481156961bbc8 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Thu, 11 Apr 2024 02:51:02 +0200
Subject: Remove "I AM NOT DONE" and the verify mode and add AppState

---
 src/app_state.rs | 185 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 185 insertions(+)
 create mode 100644 src/app_state.rs

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
new file mode 100644
index 0000000..4a0912e
--- /dev/null
+++ b/src/app_state.rs
@@ -0,0 +1,185 @@
+use anyhow::{bail, Context, Result};
+use serde::{Deserialize, Serialize};
+use std::fs;
+
+use crate::exercise::Exercise;
+
+const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct StateFile {
+    current_exercise_ind: usize,
+    progress: Vec<bool>,
+}
+
+impl StateFile {
+    fn read(exercises: &[Exercise]) -> Option<Self> {
+        let file_content = fs::read(".rustlings-state.json").ok()?;
+
+        let slf: Self = serde_json::de::from_slice(&file_content).ok()?;
+
+        if slf.progress.len() != exercises.len() || slf.current_exercise_ind >= exercises.len() {
+            return None;
+        }
+
+        Some(slf)
+    }
+
+    fn read_or_default(exercises: &[Exercise]) -> Self {
+        Self::read(exercises).unwrap_or_else(|| Self {
+            current_exercise_ind: 0,
+            progress: vec![false; exercises.len()],
+        })
+    }
+
+    fn write(&self) -> Result<()> {
+        let mut buf = Vec::with_capacity(1024);
+        serde_json::ser::to_writer(&mut buf, self).context("Failed to serialize the state")?;
+        fs::write(".rustlings-state.json", buf)
+            .context("Failed to write the state file `.rustlings-state.json`")?;
+
+        Ok(())
+    }
+}
+
+pub struct AppState {
+    state_file: StateFile,
+    exercises: &'static [Exercise],
+    n_done: u16,
+    current_exercise: &'static Exercise,
+}
+
+#[must_use]
+pub enum ExercisesProgress {
+    AllDone,
+    Pending,
+}
+
+impl AppState {
+    pub fn new(exercises: Vec<Exercise>) -> Self {
+        // Leaking for sending the exercises to the debounce event handler.
+        // Leaking is not a problem since the exercises' slice is used until the end of the program.
+        let exercises = exercises.leak();
+
+        let state_file = StateFile::read_or_default(exercises);
+        let n_done = state_file
+            .progress
+            .iter()
+            .fold(0, |acc, done| acc + u16::from(*done));
+        let current_exercise = &exercises[state_file.current_exercise_ind];
+
+        Self {
+            state_file,
+            exercises,
+            n_done,
+            current_exercise,
+        }
+    }
+
+    #[inline]
+    pub fn current_exercise_ind(&self) -> usize {
+        self.state_file.current_exercise_ind
+    }
+
+    #[inline]
+    pub fn progress(&self) -> &[bool] {
+        &self.state_file.progress
+    }
+
+    #[inline]
+    pub fn exercises(&self) -> &'static [Exercise] {
+        self.exercises
+    }
+
+    #[inline]
+    pub fn n_done(&self) -> u16 {
+        self.n_done
+    }
+
+    #[inline]
+    pub fn current_exercise(&self) -> &'static Exercise {
+        self.current_exercise
+    }
+
+    pub fn set_current_exercise_ind(&mut self, ind: usize) -> Result<()> {
+        if ind >= self.exercises.len() {
+            bail!(BAD_INDEX_ERR);
+        }
+
+        self.state_file.current_exercise_ind = ind;
+        self.current_exercise = &self.exercises[ind];
+
+        self.state_file.write()
+    }
+
+    pub fn set_current_exercise_by_name(&mut self, name: &str) -> Result<()> {
+        let (ind, exercise) = self
+            .exercises
+            .iter()
+            .enumerate()
+            .find(|(_, exercise)| exercise.name == name)
+            .with_context(|| format!("No exercise found for '{name}'!"))?;
+
+        self.state_file.current_exercise_ind = ind;
+        self.current_exercise = exercise;
+
+        self.state_file.write()
+    }
+
+    pub fn set_pending(&mut self, ind: usize) -> Result<()> {
+        let done = self
+            .state_file
+            .progress
+            .get_mut(ind)
+            .context(BAD_INDEX_ERR)?;
+
+        if *done {
+            *done = false;
+            self.n_done -= 1;
+            self.state_file.write()?;
+        }
+
+        Ok(())
+    }
+
+    fn next_exercise_ind(&self) -> Option<usize> {
+        let current_ind = self.state_file.current_exercise_ind;
+
+        if current_ind == self.state_file.progress.len() - 1 {
+            // The last exercise is done.
+            // Search for exercises not done from the start.
+            return self.state_file.progress[..current_ind]
+                .iter()
+                .position(|done| !done);
+        }
+
+        // The done exercise isn't the last one.
+        // Search for a pending exercise after the current one and then from the start.
+        match self.state_file.progress[current_ind + 1..]
+            .iter()
+            .position(|done| !done)
+        {
+            Some(ind) => Some(current_ind + 1 + ind),
+            None => self.state_file.progress[..current_ind]
+                .iter()
+                .position(|done| !done),
+        }
+    }
+
+    pub fn done_current_exercise(&mut self) -> Result<ExercisesProgress> {
+        let done = &mut self.state_file.progress[self.state_file.current_exercise_ind];
+        if !*done {
+            *done = true;
+            self.n_done += 1;
+        }
+
+        let Some(ind) = self.next_exercise_ind() else {
+            return Ok(ExercisesProgress::AllDone);
+        };
+
+        self.set_current_exercise_ind(ind)?;
+
+        Ok(ExercisesProgress::Pending)
+    }
+}
-- 
cgit v1.2.3


From d5a6dee1b329f68d00bee61c6b6c7a0adbf8bab5 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Fri, 12 Apr 2024 18:57:04 +0200
Subject: Handle the case when all exercises are done

---
 src/app_state.rs   | 52 +++++++++++++++++++++++++++++++++++++++++++++++-----
 src/run.rs         | 24 ++++++++++--------------
 src/watch.rs       | 17 ++++++++++-------
 src/watch/state.rs | 34 +++++++++++++++++-----------------
 4 files changed, 84 insertions(+), 43 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index 4a0912e..b1440e8 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -1,8 +1,16 @@
 use anyhow::{bail, Context, Result};
+use crossterm::{
+    style::Stylize,
+    terminal::{Clear, ClearType},
+    ExecutableCommand,
+};
 use serde::{Deserialize, Serialize};
-use std::fs;
+use std::{
+    fs,
+    io::{StdoutLock, Write},
+};
 
-use crate::exercise::Exercise;
+use crate::{exercise::Exercise, FENISH_LINE};
 
 const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
 
@@ -143,7 +151,7 @@ impl AppState {
         Ok(())
     }
 
-    fn next_exercise_ind(&self) -> Option<usize> {
+    fn next_pending_exercise_ind(&self) -> Option<usize> {
         let current_ind = self.state_file.current_exercise_ind;
 
         if current_ind == self.state_file.progress.len() - 1 {
@@ -167,14 +175,41 @@ impl AppState {
         }
     }
 
-    pub fn done_current_exercise(&mut self) -> Result<ExercisesProgress> {
+    pub fn done_current_exercise(&mut self, writer: &mut StdoutLock) -> Result<ExercisesProgress> {
         let done = &mut self.state_file.progress[self.state_file.current_exercise_ind];
         if !*done {
             *done = true;
             self.n_done += 1;
         }
 
-        let Some(ind) = self.next_exercise_ind() else {
+        let Some(ind) = self.next_pending_exercise_ind() else {
+            writer.write_all(RERUNNING_ALL_EXERCISES_MSG)?;
+
+            for (exercise_ind, exercise) in self.exercises().iter().enumerate() {
+                writer.write_fmt(format_args!("Running {exercise} ... "))?;
+                writer.flush()?;
+
+                if !exercise.run()?.status.success() {
+                    self.state_file.current_exercise_ind = exercise_ind;
+                    self.current_exercise = exercise;
+
+                    // No check if the exercise is done before setting it to pending
+                    // because no pending exercise was found.
+                    self.state_file.progress[exercise_ind] = false;
+                    self.n_done -= 1;
+
+                    self.state_file.write()?;
+
+                    return Ok(ExercisesProgress::Pending);
+                }
+
+                writer.write_fmt(format_args!("{}\n", "ok".green()))?;
+            }
+
+            writer.execute(Clear(ClearType::All))?;
+            writer.write_all(FENISH_LINE.as_bytes())?;
+            // TODO: Show final message.
+
             return Ok(ExercisesProgress::AllDone);
         };
 
@@ -183,3 +218,10 @@ impl AppState {
         Ok(ExercisesProgress::Pending)
     }
 }
+
+const RERUNNING_ALL_EXERCISES_MSG: &[u8] = b"
+All exercises seem to be done.
+Recompiling and running all exercises to make sure that all of them are actually done.
+This might take some minutes.
+
+";
diff --git a/src/run.rs b/src/run.rs
index 18da193..ea790e9 100644
--- a/src/run.rs
+++ b/src/run.rs
@@ -1,6 +1,6 @@
 use anyhow::{bail, Result};
 use crossterm::style::Stylize;
-use std::io::{stdout, Write};
+use std::io::{self, Write};
 
 use crate::app_state::{AppState, ExercisesProgress};
 
@@ -8,28 +8,24 @@ pub fn run(app_state: &mut AppState) -> Result<()> {
     let exercise = app_state.current_exercise();
     let output = exercise.run()?;
 
-    {
-        let mut stdout = stdout().lock();
-        stdout.write_all(&output.stdout)?;
-        stdout.write_all(&output.stderr)?;
-        stdout.flush()?;
-    }
+    let mut stdout = io::stdout().lock();
+    stdout.write_all(&output.stdout)?;
+    stdout.write_all(b"\n")?;
+    stdout.write_all(&output.stderr)?;
+    stdout.flush()?;
 
     if !output.status.success() {
         bail!("Ran {exercise} with errors");
     }
 
-    println!(
+    stdout.write_fmt(format_args!(
         "{}{}",
         "✓ Successfully ran ".green(),
         exercise.path.to_string_lossy().green(),
-    );
+    ))?;
 
-    match app_state.done_current_exercise()? {
-        ExercisesProgress::AllDone => println!(
-            "🎉 Congratulations! You have done all the exercises!
-🔚 There are no more exercises to do next!"
-        ),
+    match app_state.done_current_exercise(&mut stdout)? {
+        ExercisesProgress::AllDone => (),
         ExercisesProgress::Pending => println!("Next exercise: {}", app_state.current_exercise()),
     }
 
diff --git a/src/watch.rs b/src/watch.rs
index 357b5c7..beb69b3 100644
--- a/src/watch.rs
+++ b/src/watch.rs
@@ -15,7 +15,7 @@ mod debounce_event;
 mod state;
 mod terminal_event;
 
-use crate::app_state::AppState;
+use crate::app_state::{AppState, ExercisesProgress};
 
 use self::{
     debounce_event::DebounceEventHandler,
@@ -32,6 +32,7 @@ enum WatchEvent {
 }
 
 /// Returned by the watch mode to indicate what to do afterwards.
+#[must_use]
 pub enum WatchExit {
     /// Exit the program.
     Shutdown,
@@ -60,16 +61,20 @@ pub fn watch(app_state: &mut AppState) -> Result<WatchExit> {
 
     while let Ok(event) = rx.recv() {
         match event {
-            WatchEvent::Input(InputEvent::Next) => {
-                watch_state.next_exercise()?;
-            }
+            WatchEvent::Input(InputEvent::Next) => match watch_state.next_exercise()? {
+                ExercisesProgress::AllDone => break,
+                ExercisesProgress::Pending => watch_state.run_current_exercise()?,
+            },
             WatchEvent::Input(InputEvent::Hint) => {
                 watch_state.show_hint()?;
             }
             WatchEvent::Input(InputEvent::List) => {
                 return Ok(WatchExit::List);
             }
-            WatchEvent::Input(InputEvent::Quit) => break,
+            WatchEvent::Input(InputEvent::Quit) => {
+                watch_state.into_writer().write_all(QUIT_MSG)?;
+                break;
+            }
             WatchEvent::Input(InputEvent::Unrecognized(cmd)) => {
                 watch_state.handle_invalid_cmd(&cmd)?;
             }
@@ -88,8 +93,6 @@ pub fn watch(app_state: &mut AppState) -> Result<WatchExit> {
         }
     }
 
-    watch_state.into_writer().write_all(QUIT_MSG)?;
-
     Ok(WatchExit::Shutdown)
 }
 
diff --git a/src/watch/state.rs b/src/watch/state.rs
index 462633d..70b6ae4 100644
--- a/src/watch/state.rs
+++ b/src/watch/state.rs
@@ -4,7 +4,10 @@ use crossterm::{
     terminal::{size, Clear, ClearType},
     ExecutableCommand,
 };
-use std::io::{self, StdoutLock, Write};
+use std::{
+    io::{self, StdoutLock, Write},
+    process::Output,
+};
 
 use crate::{
     app_state::{AppState, ExercisesProgress},
@@ -49,6 +52,9 @@ impl<'a> WatchState<'a> {
             self.stderr = None;
             self.show_done = true;
         } else {
+            self.app_state
+                .set_pending(self.app_state.current_exercise_ind())?;
+
             self.stderr = Some(output.stderr);
             self.show_done = false;
         }
@@ -61,18 +67,15 @@ impl<'a> WatchState<'a> {
         self.run_current_exercise()
     }
 
-    pub fn next_exercise(&mut self) -> Result<()> {
+    pub fn next_exercise(&mut self) -> Result<ExercisesProgress> {
         if !self.show_done {
             self.writer
                 .write_all(b"The current exercise isn't done yet\n")?;
             self.show_prompt()?;
-            return Ok(());
+            return Ok(ExercisesProgress::Pending);
         }
 
-        match self.app_state.done_current_exercise()? {
-            ExercisesProgress::AllDone => todo!(),
-            ExercisesProgress::Pending => self.run_current_exercise(),
-        }
+        self.app_state.done_current_exercise(&mut self.writer)
     }
 
     fn show_prompt(&mut self) -> io::Result<()> {
@@ -93,7 +96,7 @@ impl<'a> WatchState<'a> {
     }
 
     pub fn render(&mut self) -> Result<()> {
-        // Prevent having the first line shifted after clearing because of the prompt.
+        // Prevent having the first line shifted.
         self.writer.write_all(b"\n")?;
 
         self.writer.execute(Clear(ClearType::All))?;
@@ -111,11 +114,11 @@ impl<'a> WatchState<'a> {
         self.writer.write_all(b"\n")?;
 
         if self.show_hint {
-            self.writer
-                .write_fmt(format_args!("{}\n", "Hint".bold().cyan().underlined()))?;
-            self.writer
-                .write_all(self.app_state.current_exercise().hint.as_bytes())?;
-            self.writer.write_all(b"\n\n")?;
+            self.writer.write_fmt(format_args!(
+                "{}\n{}\n\n",
+                "Hint".bold().cyan().underlined(),
+                self.app_state.current_exercise().hint,
+            ))?;
         }
 
         if self.show_done {
@@ -134,11 +137,8 @@ When you are done experimenting, enter `n` or `next` to go to the next exercise
             self.app_state.exercises().len() as u16,
             line_width,
         )?;
-        self.writer.write_all(progress_bar.as_bytes())?;
-
-        self.writer.write_all(b"Current exercise: ")?;
         self.writer.write_fmt(format_args!(
-            "{}\n",
+            "{progress_bar}Current exercise: {}\n",
             self.app_state
                 .current_exercise()
                 .path
-- 
cgit v1.2.3


From 6e827da570278b6ff282f3b5c23e2ab95624117e Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Fri, 12 Apr 2024 19:18:16 +0200
Subject: It doesn't take minutes :P

---
 src/app_state.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index b1440e8..18d9e2a 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -222,6 +222,5 @@ impl AppState {
 const RERUNNING_ALL_EXERCISES_MSG: &[u8] = b"
 All exercises seem to be done.
 Recompiling and running all exercises to make sure that all of them are actually done.
-This might take some minutes.
 
 ";
-- 
cgit v1.2.3


From ff4c7529846ba13ecb2e90616ff8fd7a9ee87164 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Fri, 12 Apr 2024 19:30:29 +0200
Subject: Print FAILED

---
 src/app_state.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index 18d9e2a..cb7debe 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -190,6 +190,8 @@ impl AppState {
                 writer.flush()?;
 
                 if !exercise.run()?.status.success() {
+                    writer.write_fmt(format_args!("{}\n\n", "FAILED".red()))?;
+
                     self.state_file.current_exercise_ind = exercise_ind;
                     self.current_exercise = exercise;
 
-- 
cgit v1.2.3


From 24539666afb0e8c80fbccbca7ad212ba8fbd1189 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Fri, 12 Apr 2024 20:06:56 +0200
Subject: Show the final message

---
 info.toml        |  3 ++-
 src/app_state.rs | 27 +++++++++++++++++----------
 src/exercise.rs  |  1 -
 src/main.rs      |  6 ++++--
 4 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/info.toml b/info.toml
index d35b570..b6b6800 100644
--- a/info.toml
+++ b/info.toml
@@ -20,7 +20,8 @@ started, here's a couple of notes about how Rustlings operates:
    and sometimes, other learners do too so you can help each other out!
 
 Got all that? Great! To get started, run `rustlings watch` in order to get the first exercise.
-Make sure to have your editor open in the `rustlings` directory!"""
+Make sure to have your editor open in the `rustlings` directory!
+"""
 
 final_message = """We hope you enjoyed learning about the various aspects of Rust!
 If you noticed any issues, please don't hesitate to report them to our repo.
diff --git a/src/app_state.rs b/src/app_state.rs
index cb7debe..2ea3db4 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -51,24 +51,29 @@ impl StateFile {
     }
 }
 
+#[must_use]
+pub enum ExercisesProgress {
+    AllDone,
+    Pending,
+}
+
 pub struct AppState {
     state_file: StateFile,
     exercises: &'static [Exercise],
     n_done: u16,
     current_exercise: &'static Exercise,
-}
-
-#[must_use]
-pub enum ExercisesProgress {
-    AllDone,
-    Pending,
+    final_message: &'static str,
 }
 
 impl AppState {
-    pub fn new(exercises: Vec<Exercise>) -> Self {
-        // Leaking for sending the exercises to the debounce event handler.
-        // Leaking is not a problem since the exercises' slice is used until the end of the program.
+    pub fn new(mut exercises: Vec<Exercise>, mut final_message: String) -> Self {
+        // Leaking especially for sending the exercises to the debounce event handler.
+        // Leaking is not a problem because the `AppState` instance lives until
+        // the end of the program.
+        exercises.shrink_to_fit();
         let exercises = exercises.leak();
+        final_message.shrink_to_fit();
+        let final_message = final_message.leak();
 
         let state_file = StateFile::read_or_default(exercises);
         let n_done = state_file
@@ -82,6 +87,7 @@ impl AppState {
             exercises,
             n_done,
             current_exercise,
+            final_message,
         }
     }
 
@@ -210,7 +216,8 @@ impl AppState {
 
             writer.execute(Clear(ClearType::All))?;
             writer.write_all(FENISH_LINE.as_bytes())?;
-            // TODO: Show final message.
+            writer.write_all(self.final_message.as_bytes())?;
+            writer.write_all(b"\n")?;
 
             return Ok(ExercisesProgress::AllDone);
         };
diff --git a/src/exercise.rs b/src/exercise.rs
index a9dcce3..a29b83a 100644
--- a/src/exercise.rs
+++ b/src/exercise.rs
@@ -26,7 +26,6 @@ pub enum Mode {
 pub struct InfoFile {
     // TODO
     pub welcome_message: Option<String>,
-    // TODO
     pub final_message: Option<String>,
     pub exercises: Vec<Exercise>,
 }
diff --git a/src/main.rs b/src/main.rs
index fdbb710..cdfa21f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -68,7 +68,7 @@ fn main() -> Result<()> {
         exit(1);
     }
 
-    let mut app_state = AppState::new(exercises);
+    let mut app_state = AppState::new(exercises, info_file.final_message.unwrap_or_default());
 
     match args.command {
         None => loop {
@@ -144,4 +144,6 @@ const FENISH_LINE: &str = "+----------------------------------------------------
          ▒▒    ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒    ▒▒
        ▒▒    ▒▒    ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒    ▒▒    ▒▒
        ▒▒  ▒▒    ▒▒                  ▒▒    ▒▒  ▒▒
-           ▒▒  ▒▒                      ▒▒  ▒▒\x1b[0m";
+           ▒▒  ▒▒                      ▒▒  ▒▒\x1b[0m
+
+";
-- 
cgit v1.2.3


From 5c0073a9485c4226e58b657cb49628919a28a942 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 01:15:43 +0200
Subject: Tolerate changes in the state file

---
 Cargo.lock                   |   1 +
 Cargo.toml                   |   1 +
 exercises/00_intro/intro1.rs |   1 -
 info.toml                    | 272 +++++++++++++++++++++----------------------
 src/app_state.rs             | 207 +++++++++++++++-----------------
 src/app_state/state_file.rs  | 112 ++++++++++++++++++
 src/exercise.rs              |  72 +++---------
 src/info_file.rs             |  81 +++++++++++++
 src/init.rs                  |  23 ++--
 src/list.rs                  |  11 +-
 src/list/state.rs            |  35 +++---
 src/main.rs                  |  40 ++++---
 src/run.rs                   |   2 +-
 src/watch.rs                 |  15 ++-
 src/watch/debounce_event.rs  |  44 -------
 src/watch/notify_event.rs    |  42 +++++++
 16 files changed, 552 insertions(+), 407 deletions(-)
 create mode 100644 src/app_state/state_file.rs
 create mode 100644 src/info_file.rs
 delete mode 100644 src/watch/debounce_event.rs
 create mode 100644 src/watch/notify_event.rs

(limited to 'src/app_state.rs')

diff --git a/Cargo.lock b/Cargo.lock
index 6c64661..dbf1923 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -684,6 +684,7 @@ dependencies = [
  "assert_cmd",
  "clap",
  "crossterm",
+ "hashbrown",
  "notify-debouncer-mini",
  "predicates",
  "ratatui",
diff --git a/Cargo.toml b/Cargo.toml
index 285e7df..14ae9a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,6 +37,7 @@ edition.workspace = true
 anyhow.workspace = true
 clap = { version = "4.5.4", features = ["derive"] }
 crossterm = "0.27.0"
+hashbrown = "0.14.3"
 notify-debouncer-mini = "0.4.1"
 ratatui = "0.26.1"
 rustlings-macros = { path = "rustlings-macros" }
diff --git a/exercises/00_intro/intro1.rs b/exercises/00_intro/intro1.rs
index e4e0444..170d195 100644
--- a/exercises/00_intro/intro1.rs
+++ b/exercises/00_intro/intro1.rs
@@ -1,6 +1,5 @@
 // intro1.rs
 //
-// TODO: Update comment
 // We sometimes encourage you to keep trying things on a given exercise, even
 // after you already figured it out. If you got everything working and feel
 // ready for the next exercise, remove the `I AM NOT DONE` comment below.
diff --git a/info.toml b/info.toml
index b6b6800..fa90ad7 100644
--- a/info.toml
+++ b/info.toml
@@ -33,10 +33,11 @@ https://github.com/rust-lang/rustlings/blob/main/CONTRIBUTING.md
 
 # INTRO
 
+# TODO: Update exercise
 [[exercises]]
 name = "intro1"
-path = "exercises/00_intro/intro1.rs"
-mode = "compile"
+dir = "00_intro"
+mode = "run"
 # TODO: Fix hint
 hint = """
 Remove the `I AM NOT DONE` comment in the `exercises/intro00/intro1.rs` file
@@ -44,8 +45,8 @@ to move on to the next exercise."""
 
 [[exercises]]
 name = "intro2"
-path = "exercises/00_intro/intro2.rs"
-mode = "compile"
+dir = "00_intro"
+mode = "run"
 hint = """
 The compiler is informing us that we've got the name of the print macro wrong, and has suggested an alternative."""
 
@@ -53,16 +54,16 @@ The compiler is informing us that we've got the name of the print macro wrong, a
 
 [[exercises]]
 name = "variables1"
-path = "exercises/01_variables/variables1.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 The declaration in the first line in the main function is missing a keyword
 that is needed in Rust to create a new variable binding."""
 
 [[exercises]]
 name = "variables2"
-path = "exercises/01_variables/variables2.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 The compiler message is saying that Rust cannot infer the type that the
 variable binding `x` has with what is given here.
@@ -80,8 +81,8 @@ What if `x` is the same type as `10`? What if it's a different type?"""
 
 [[exercises]]
 name = "variables3"
-path = "exercises/01_variables/variables3.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 Oops! In this exercise, we have a variable binding that we've created on in the
 first line in the `main` function, and we're trying to use it in the next line,
@@ -94,8 +95,8 @@ programming language -- thankfully the Rust compiler has caught this for us!"""
 
 [[exercises]]
 name = "variables4"
-path = "exercises/01_variables/variables4.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 In Rust, variable bindings are immutable by default. But here we're trying
 to reassign a different value to `x`! There's a keyword we can use to make
@@ -103,8 +104,8 @@ a variable binding mutable instead."""
 
 [[exercises]]
 name = "variables5"
-path = "exercises/01_variables/variables5.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 In `variables4` we already learned how to make an immutable variable mutable
 using a special keyword. Unfortunately this doesn't help us much in this
@@ -121,8 +122,8 @@ Try to solve this exercise afterwards using this technique."""
 
 [[exercises]]
 name = "variables6"
-path = "exercises/01_variables/variables6.rs"
-mode = "compile"
+dir = "01_variables"
+mode = "run"
 hint = """
 We know about variables and mutability, but there is another important type of
 variable available: constants.
@@ -141,8 +142,8 @@ https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#constants
 
 [[exercises]]
 name = "functions1"
-path = "exercises/02_functions/functions1.rs"
-mode = "compile"
+dir = "02_functions"
+mode = "run"
 hint = """
 This main function is calling a function that it expects to exist, but the
 function doesn't exist. It expects this function to have the name `call_me`.
@@ -151,24 +152,24 @@ Sounds a lot like `main`, doesn't it?"""
 
 [[exercises]]
 name = "functions2"
-path = "exercises/02_functions/functions2.rs"
-mode = "compile"
+dir = "02_functions"
+mode = "run"
 hint = """
 Rust requires that all parts of a function's signature have type annotations,
 but `call_me` is missing the type annotation of `num`."""
 
 [[exercises]]
 name = "functions3"
-path = "exercises/02_functions/functions3.rs"
-mode = "compile"
+dir = "02_functions"
+mode = "run"
 hint = """
 This time, the function *declaration* is okay, but there's something wrong
 with the place where we're calling the function."""
 
 [[exercises]]
 name = "functions4"
-path = "exercises/02_functions/functions4.rs"
-mode = "compile"
+dir = "02_functions"
+mode = "run"
 hint = """
 The error message points to the function `sale_price` and says it expects a type
 after the `->`. This is where the function's return type should be -- take a
@@ -179,8 +180,8 @@ for the inputs of the functions here, since the original prices shouldn't be neg
 
 [[exercises]]
 name = "functions5"
-path = "exercises/02_functions/functions5.rs"
-mode = "compile"
+dir = "02_functions"
+mode = "run"
 hint = """
 This is a really common error that can be fixed by removing one character.
 It happens because Rust distinguishes between expressions and statements:
@@ -198,7 +199,7 @@ They are not the same. There are two solutions:
 
 [[exercises]]
 name = "if1"
-path = "exercises/03_if/if1.rs"
+dir = "03_if"
 mode = "test"
 hint = """
 It's possible to do this in one line if you would like!
@@ -214,7 +215,7 @@ Remember in Rust that:
 
 [[exercises]]
 name = "if2"
-path = "exercises/03_if/if2.rs"
+dir = "03_if"
 mode = "test"
 hint = """
 For that first compiler error, it's important in Rust that each conditional
@@ -223,7 +224,7 @@ conditions checking different input values."""
 
 [[exercises]]
 name = "if3"
-path = "exercises/03_if/if3.rs"
+dir = "03_if"
 mode = "test"
 hint = """
 In Rust, every arm of an `if` expression has to return the same type of value.
@@ -233,7 +234,6 @@ Make sure the type is consistent across all arms."""
 
 [[exercises]]
 name = "quiz1"
-path = "exercises/quiz1.rs"
 mode = "test"
 hint = "No hints this time ;)"
 
@@ -241,20 +241,20 @@ hint = "No hints this time ;)"
 
 [[exercises]]
 name = "primitive_types1"
-path = "exercises/04_primitive_types/primitive_types1.rs"
-mode = "compile"
+dir = "04_primitive_types"
+mode = "run"
 hint = "No hints this time ;)"
 
 [[exercises]]
 name = "primitive_types2"
-path = "exercises/04_primitive_types/primitive_types2.rs"
-mode = "compile"
+dir = "04_primitive_types"
+mode = "run"
 hint = "No hints this time ;)"
 
 [[exercises]]
 name = "primitive_types3"
-path = "exercises/04_primitive_types/primitive_types3.rs"
-mode = "compile"
+dir = "04_primitive_types"
+mode = "run"
 hint = """
 There's a shorthand to initialize Arrays with a certain size that does not
 require you to type in 100 items (but you certainly can if you want!).
@@ -269,7 +269,7 @@ for `a.len() >= 100`?"""
 
 [[exercises]]
 name = "primitive_types4"
-path = "exercises/04_primitive_types/primitive_types4.rs"
+dir = "04_primitive_types"
 mode = "test"
 hint = """
 Take a look at the 'Understanding Ownership -> Slices -> Other Slices' section
@@ -284,8 +284,8 @@ https://doc.rust-lang.org/nomicon/coercions.html"""
 
 [[exercises]]
 name = "primitive_types5"
-path = "exercises/04_primitive_types/primitive_types5.rs"
-mode = "compile"
+dir = "04_primitive_types"
+mode = "run"
 hint = """
 Take a look at the 'Data Types -> The Tuple Type' section of the book:
 https://doc.rust-lang.org/book/ch03-02-data-types.html#the-tuple-type
@@ -297,7 +297,7 @@ of the tuple. You can do it!!"""
 
 [[exercises]]
 name = "primitive_types6"
-path = "exercises/04_primitive_types/primitive_types6.rs"
+dir = "04_primitive_types"
 mode = "test"
 hint = """
 While you could use a destructuring `let` for the tuple here, try
@@ -310,7 +310,7 @@ Now you have another tool in your toolbox!"""
 
 [[exercises]]
 name = "vecs1"
-path = "exercises/05_vecs/vecs1.rs"
+dir = "05_vecs"
 mode = "test"
 hint = """
 In Rust, there are two ways to define a Vector.
@@ -325,7 +325,7 @@ of the Rust book to learn more.
 
 [[exercises]]
 name = "vecs2"
-path = "exercises/05_vecs/vecs2.rs"
+dir = "05_vecs"
 mode = "test"
 hint = """
 In the first function we are looping over the Vector and getting a reference to
@@ -348,7 +348,7 @@ What do you think is the more commonly used pattern under Rust developers?
 
 [[exercises]]
 name = "move_semantics1"
-path = "exercises/06_move_semantics/move_semantics1.rs"
+dir = "06_move_semantics"
 mode = "test"
 hint = """
 So you've got the "cannot borrow immutable local variable `vec` as mutable"
@@ -362,7 +362,7 @@ happens!"""
 
 [[exercises]]
 name = "move_semantics2"
-path = "exercises/06_move_semantics/move_semantics2.rs"
+dir = "06_move_semantics"
 mode = "test"
 hint = """
 When running this exercise for the first time, you'll notice an error about
@@ -383,7 +383,7 @@ try them all:
 
 [[exercises]]
 name = "move_semantics3"
-path = "exercises/06_move_semantics/move_semantics3.rs"
+dir = "06_move_semantics"
 mode = "test"
 hint = """
 The difference between this one and the previous ones is that the first line
@@ -393,7 +393,7 @@ an existing binding to be a mutable binding instead of an immutable one :)"""
 
 [[exercises]]
 name = "move_semantics4"
-path = "exercises/06_move_semantics/move_semantics4.rs"
+dir = "06_move_semantics"
 mode = "test"
 hint = """
 Stop reading whenever you feel like you have enough direction :) Or try
@@ -407,7 +407,7 @@ So the end goal is to:
 
 [[exercises]]
 name = "move_semantics5"
-path = "exercises/06_move_semantics/move_semantics5.rs"
+dir = "06_move_semantics"
 mode = "test"
 hint = """
 Carefully reason about the range in which each mutable reference is in
@@ -419,8 +419,8 @@ https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-ref
 
 [[exercises]]
 name = "move_semantics6"
-path = "exercises/06_move_semantics/move_semantics6.rs"
-mode = "compile"
+dir = "06_move_semantics"
+mode = "run"
 hint = """
 To find the answer, you can consult the book section "References and Borrowing":
 https://doc.rust-lang.org/stable/book/ch04-02-references-and-borrowing.html
@@ -440,7 +440,7 @@ Another hint: it has to do with the `&` character."""
 
 [[exercises]]
 name = "structs1"
-path = "exercises/07_structs/structs1.rs"
+dir = "07_structs"
 mode = "test"
 hint = """
 Rust has more than one type of struct. Three actually, all variants are used to
@@ -460,7 +460,7 @@ https://doc.rust-lang.org/book/ch05-01-defining-structs.html"""
 
 [[exercises]]
 name = "structs2"
-path = "exercises/07_structs/structs2.rs"
+dir = "07_structs"
 mode = "test"
 hint = """
 Creating instances of structs is easy, all you need to do is assign some values
@@ -472,7 +472,7 @@ https://doc.rust-lang.org/stable/book/ch05-01-defining-structs.html#creating-ins
 
 [[exercises]]
 name = "structs3"
-path = "exercises/07_structs/structs3.rs"
+dir = "07_structs"
 mode = "test"
 hint = """
 For `is_international`: What makes a package international? Seems related to
@@ -488,21 +488,21 @@ https://doc.rust-lang.org/book/ch05-03-method-syntax.html"""
 
 [[exercises]]
 name = "enums1"
-path = "exercises/08_enums/enums1.rs"
-mode = "compile"
+dir = "08_enums"
+mode = "run"
 hint = "No hints this time ;)"
 
 [[exercises]]
 name = "enums2"
-path = "exercises/08_enums/enums2.rs"
-mode = "compile"
+dir = "08_enums"
+mode = "run"
 hint = """
 You can create enumerations that have different variants with different types
 such as no data, anonymous structs, a single string, tuples, ...etc"""
 
 [[exercises]]
 name = "enums3"
-path = "exercises/08_enums/enums3.rs"
+dir = "08_enums"
 mode = "test"
 hint = """
 As a first step, you can define enums to compile this code without errors.
@@ -516,8 +516,8 @@ to get value in the variant."""
 
 [[exercises]]
 name = "strings1"
-path = "exercises/09_strings/strings1.rs"
-mode = "compile"
+dir = "09_strings"
+mode = "run"
 hint = """
 The `current_favorite_color` function is currently returning a string slice
 with the `'static` lifetime. We know this because the data of the string lives
@@ -530,8 +530,8 @@ another way that uses the `From` trait."""
 
 [[exercises]]
 name = "strings2"
-path = "exercises/09_strings/strings2.rs"
-mode = "compile"
+dir = "09_strings"
+mode = "run"
 hint = """
 Yes, it would be really easy to fix this by just changing the value bound to
 `word` to be a string slice instead of a `String`, wouldn't it?? There is a way
@@ -545,7 +545,7 @@ https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercion
 
 [[exercises]]
 name = "strings3"
-path = "exercises/09_strings/strings3.rs"
+dir = "09_strings"
 mode = "test"
 hint = """
 There's tons of useful standard library functions for strings. Let's try and use some of them:
@@ -556,16 +556,16 @@ the string slice into an owned string, which you can then freely extend."""
 
 [[exercises]]
 name = "strings4"
-path = "exercises/09_strings/strings4.rs"
-mode = "compile"
+dir = "09_strings"
+mode = "run"
 hint = "No hints this time ;)"
 
 # MODULES
 
 [[exercises]]
 name = "modules1"
-path = "exercises/10_modules/modules1.rs"
-mode = "compile"
+dir = "10_modules"
+mode = "run"
 hint = """
 Everything is private in Rust by default-- but there's a keyword we can use
 to make something public! The compiler error should point to the thing that
@@ -573,8 +573,8 @@ needs to be public."""
 
 [[exercises]]
 name = "modules2"
-path = "exercises/10_modules/modules2.rs"
-mode = "compile"
+dir = "10_modules"
+mode = "run"
 hint = """
 The delicious_snacks module is trying to present an external interface that is
 different than its internal structure (the `fruits` and `veggies` modules and
@@ -585,8 +585,8 @@ Learn more at https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-w
 
 [[exercises]]
 name = "modules3"
-path = "exercises/10_modules/modules3.rs"
-mode = "compile"
+dir = "10_modules"
+mode = "run"
 hint = """
 `UNIX_EPOCH` and `SystemTime` are declared in the `std::time` module. Add a
 `use` statement for these two to bring them into scope. You can use nested
@@ -596,7 +596,7 @@ paths or the glob operator to bring these two in using only one line."""
 
 [[exercises]]
 name = "hashmaps1"
-path = "exercises/11_hashmaps/hashmaps1.rs"
+dir = "11_hashmaps"
 mode = "test"
 hint = """
 Hint 1: Take a look at the return type of the function to figure out
@@ -608,7 +608,7 @@ Hint 2: Number of fruits should be at least 5. And you have to put
 
 [[exercises]]
 name = "hashmaps2"
-path = "exercises/11_hashmaps/hashmaps2.rs"
+dir = "11_hashmaps"
 mode = "test"
 hint = """
 Use the `entry()` and `or_insert()` methods of `HashMap` to achieve this.
@@ -617,7 +617,7 @@ Learn more at https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-
 
 [[exercises]]
 name = "hashmaps3"
-path = "exercises/11_hashmaps/hashmaps3.rs"
+dir = "11_hashmaps"
 mode = "test"
 hint = """
 Hint 1: Use the `entry()` and `or_insert()` methods of `HashMap` to insert
@@ -635,7 +635,6 @@ Learn more at https://doc.rust-lang.org/book/ch08-03-hash-maps.html#updating-a-v
 
 [[exercises]]
 name = "quiz2"
-path = "exercises/quiz2.rs"
 mode = "test"
 hint = "No hints this time ;)"
 
@@ -643,7 +642,7 @@ hint = "No hints this time ;)"
 
 [[exercises]]
 name = "options1"
-path = "exercises/12_options/options1.rs"
+dir = "12_options"
 mode = "test"
 hint = """
 Options can have a `Some` value, with an inner value, or a `None` value,
@@ -655,7 +654,7 @@ it doesn't panic in your face later?"""
 
 [[exercises]]
 name = "options2"
-path = "exercises/12_options/options2.rs"
+dir = "12_options"
 mode = "test"
 hint = """
 Check out:
@@ -672,8 +671,8 @@ Also see `Option::flatten`
 
 [[exercises]]
 name = "options3"
-path = "exercises/12_options/options3.rs"
-mode = "compile"
+dir = "12_options"
+mode = "run"
 hint = """
 The compiler says a partial move happened in the `match` statement. How can
 this be avoided? The compiler shows the correction needed.
@@ -685,7 +684,7 @@ https://doc.rust-lang.org/std/keyword.ref.html"""
 
 [[exercises]]
 name = "errors1"
-path = "exercises/13_error_handling/errors1.rs"
+dir = "13_error_handling"
 mode = "test"
 hint = """
 `Ok` and `Err` are the two variants of `Result`, so what the tests are saying
@@ -701,7 +700,7 @@ To make this change, you'll need to:
 
 [[exercises]]
 name = "errors2"
-path = "exercises/13_error_handling/errors2.rs"
+dir = "13_error_handling"
 mode = "test"
 hint = """
 One way to handle this is using a `match` statement on
@@ -717,8 +716,8 @@ and give it a try!"""
 
 [[exercises]]
 name = "errors3"
-path = "exercises/13_error_handling/errors3.rs"
-mode = "compile"
+dir = "13_error_handling"
+mode = "run"
 hint = """
 If other functions can return a `Result`, why shouldn't `main`? It's a fairly
 common convention to return something like `Result<(), ErrorType>` from your
@@ -729,7 +728,7 @@ positive results."""
 
 [[exercises]]
 name = "errors4"
-path = "exercises/13_error_handling/errors4.rs"
+dir = "13_error_handling"
 mode = "test"
 hint = """
 `PositiveNonzeroInteger::new` is always creating a new instance and returning
@@ -741,8 +740,8 @@ everything is... okay :)"""
 
 [[exercises]]
 name = "errors5"
-path = "exercises/13_error_handling/errors5.rs"
-mode = "compile"
+dir = "13_error_handling"
+mode = "run"
 hint = """
 There are two different possible `Result` types produced within `main()`, which
 are propagated using `?` operators. How do we declare a return type from
@@ -765,7 +764,7 @@ https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reen
 
 [[exercises]]
 name = "errors6"
-path = "exercises/13_error_handling/errors6.rs"
+dir = "13_error_handling"
 mode = "test"
 hint = """
 This exercise uses a completed version of `PositiveNonzeroInteger` from
@@ -787,8 +786,8 @@ https://doc.rust-lang.org/std/result/enum.Result.html#method.map_err"""
 
 [[exercises]]
 name = "generics1"
-path = "exercises/14_generics/generics1.rs"
-mode = "compile"
+dir = "14_generics"
+mode = "run"
 hint = """
 Vectors in Rust make use of generics to create dynamically sized arrays of any
 type.
@@ -797,7 +796,7 @@ You need to tell the compiler what type we are pushing onto this vector."""
 
 [[exercises]]
 name = "generics2"
-path = "exercises/14_generics/generics2.rs"
+dir = "14_generics"
 mode = "test"
 hint = """
 Currently we are wrapping only values of type `u32`.
@@ -811,7 +810,7 @@ If you are still stuck https://doc.rust-lang.org/stable/book/ch10-01-syntax.html
 
 [[exercises]]
 name = "traits1"
-path = "exercises/15_traits/traits1.rs"
+dir = "15_traits"
 mode = "test"
 hint = """
 A discussion about Traits in Rust can be found at:
@@ -820,7 +819,7 @@ https://doc.rust-lang.org/book/ch10-02-traits.html
 
 [[exercises]]
 name = "traits2"
-path = "exercises/15_traits/traits2.rs"
+dir = "15_traits"
 mode = "test"
 hint = """
 Notice how the trait takes ownership of `self`, and returns `Self`.
@@ -833,7 +832,7 @@ the documentation at: https://doc.rust-lang.org/std/vec/struct.Vec.html"""
 
 [[exercises]]
 name = "traits3"
-path = "exercises/15_traits/traits3.rs"
+dir = "15_traits"
 mode = "test"
 hint = """
 Traits can have a default implementation for functions. Structs that implement
@@ -845,7 +844,7 @@ See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#def
 
 [[exercises]]
 name = "traits4"
-path = "exercises/15_traits/traits4.rs"
+dir = "15_traits"
 mode = "test"
 hint = """
 Instead of using concrete types as parameters you can use traits. Try replacing
@@ -856,8 +855,8 @@ See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#tra
 
 [[exercises]]
 name = "traits5"
-path = "exercises/15_traits/traits5.rs"
-mode = "compile"
+dir = "15_traits"
+mode = "run"
 hint = """
 To ensure a parameter implements multiple traits use the '+ syntax'. Try
 replacing the '??' with 'impl <> + <>'.
@@ -869,7 +868,6 @@ See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#spe
 
 [[exercises]]
 name = "quiz3"
-path = "exercises/quiz3.rs"
 mode = "test"
 hint = """
 To find the best solution to this challenge you're going to need to think back
@@ -881,16 +879,16 @@ You may also need this: `use std::fmt::Display;`."""
 
 [[exercises]]
 name = "lifetimes1"
-path = "exercises/16_lifetimes/lifetimes1.rs"
-mode = "compile"
+dir = "16_lifetimes"
+mode = "run"
 hint = """
 Let the compiler guide you. Also take a look at the book if you need help:
 https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html"""
 
 [[exercises]]
 name = "lifetimes2"
-path = "exercises/16_lifetimes/lifetimes2.rs"
-mode = "compile"
+dir = "16_lifetimes"
+mode = "run"
 hint = """
 Remember that the generic lifetime `'a` will get the concrete lifetime that is
 equal to the smaller of the lifetimes of `x` and `y`.
@@ -903,8 +901,8 @@ inner block:
 
 [[exercises]]
 name = "lifetimes3"
-path = "exercises/16_lifetimes/lifetimes3.rs"
-mode = "compile"
+dir = "16_lifetimes"
+mode = "run"
 hint = """
 If you use a lifetime annotation in a struct's fields, where else does it need
 to be added?"""
@@ -913,7 +911,7 @@ to be added?"""
 
 [[exercises]]
 name = "tests1"
-path = "exercises/17_tests/tests1.rs"
+dir = "17_tests"
 mode = "test"
 hint = """
 You don't even need to write any code to test -- you can just test values and
@@ -928,7 +926,7 @@ ones pass, and which ones fail :)"""
 
 [[exercises]]
 name = "tests2"
-path = "exercises/17_tests/tests2.rs"
+dir = "17_tests"
 mode = "test"
 hint = """
 Like the previous exercise, you don't need to write any code to get this test
@@ -941,7 +939,7 @@ argument comes first and which comes second!"""
 
 [[exercises]]
 name = "tests3"
-path = "exercises/17_tests/tests3.rs"
+dir = "17_tests"
 mode = "test"
 hint = """
 You can call a function right where you're passing arguments to `assert!`. So
@@ -952,7 +950,7 @@ what you're doing using `!`, like `assert!(!having_fun())`."""
 
 [[exercises]]
 name = "tests4"
-path = "exercises/17_tests/tests4.rs"
+dir = "17_tests"
 mode = "test"
 hint = """
 We expect method `Rectangle::new()` to panic for negative values.
@@ -966,7 +964,7 @@ https://doc.rust-lang.org/stable/book/ch11-01-writing-tests.html#checking-for-pa
 
 [[exercises]]
 name = "iterators1"
-path = "exercises/18_iterators/iterators1.rs"
+dir = "18_iterators"
 mode = "test"
 hint = """
 Step 1:
@@ -989,7 +987,7 @@ https://doc.rust-lang.org/std/iter/trait.Iterator.html for some ideas.
 
 [[exercises]]
 name = "iterators2"
-path = "exercises/18_iterators/iterators2.rs"
+dir = "18_iterators"
 mode = "test"
 hint = """
 Step 1:
@@ -1015,7 +1013,7 @@ powerful and very general. Rust just needs to know the desired type."""
 
 [[exercises]]
 name = "iterators3"
-path = "exercises/18_iterators/iterators3.rs"
+dir = "18_iterators"
 mode = "test"
 hint = """
 The `divide` function needs to return the correct error when even division is
@@ -1034,7 +1032,7 @@ powerful! It can make the solution to this exercise infinitely easier."""
 
 [[exercises]]
 name = "iterators4"
-path = "exercises/18_iterators/iterators4.rs"
+dir = "18_iterators"
 mode = "test"
 hint = """
 In an imperative language, you might write a `for` loop that updates a mutable
@@ -1046,7 +1044,7 @@ Hint 2: Check out the `fold` and `rfold` methods!"""
 
 [[exercises]]
 name = "iterators5"
-path = "exercises/18_iterators/iterators5.rs"
+dir = "18_iterators"
 mode = "test"
 hint = """
 The documentation for the `std::iter::Iterator` trait contains numerous methods
@@ -1065,7 +1063,7 @@ a different method that could make your code more compact than using `fold`."""
 
 [[exercises]]
 name = "box1"
-path = "exercises/19_smart_pointers/box1.rs"
+dir = "19_smart_pointers"
 mode = "test"
 hint = """
 Step 1:
@@ -1089,7 +1087,7 @@ definition and try other types!
 
 [[exercises]]
 name = "rc1"
-path = "exercises/19_smart_pointers/rc1.rs"
+dir = "19_smart_pointers"
 mode = "test"
 hint = """
 This is a straightforward exercise to use the `Rc<T>` type. Each `Planet` has
@@ -1108,8 +1106,8 @@ See more at: https://doc.rust-lang.org/book/ch15-04-rc.html
 
 [[exercises]]
 name = "arc1"
-path = "exercises/19_smart_pointers/arc1.rs"
-mode = "compile"
+dir = "19_smart_pointers"
+mode = "run"
 hint = """
 Make `shared_numbers` be an `Arc` from the numbers vector. Then, in order
 to avoid creating a copy of `numbers`, you'll need to create `child_numbers`
@@ -1126,7 +1124,7 @@ https://doc.rust-lang.org/stable/book/ch16-00-concurrency.html
 
 [[exercises]]
 name = "cow1"
-path = "exercises/19_smart_pointers/cow1.rs"
+dir = "19_smart_pointers"
 mode = "test"
 hint = """
 If `Cow` already owns the data it doesn't need to clone it when `to_mut()` is
@@ -1140,8 +1138,8 @@ on the `Cow` type.
 
 [[exercises]]
 name = "threads1"
-path = "exercises/20_threads/threads1.rs"
-mode = "compile"
+dir = "20_threads"
+mode = "run"
 hint = """
 `JoinHandle` is a struct that is returned from a spawned thread:
 https://doc.rust-lang.org/std/thread/fn.spawn.html
@@ -1158,8 +1156,8 @@ https://doc.rust-lang.org/std/thread/struct.JoinHandle.html
 
 [[exercises]]
 name = "threads2"
-path = "exercises/20_threads/threads2.rs"
-mode = "compile"
+dir = "20_threads"
+mode = "run"
 hint = """
 `Arc` is an Atomic Reference Counted pointer that allows safe, shared access
 to **immutable** data. But we want to *change* the number of `jobs_completed`
@@ -1180,7 +1178,7 @@ https://doc.rust-lang.org/book/ch16-03-shared-state.html#sharing-a-mutext-betwee
 
 [[exercises]]
 name = "threads3"
-path = "exercises/20_threads/threads3.rs"
+dir = "20_threads"
 mode = "test"
 hint = """
 An alternate way to handle concurrency between threads is to use an `mpsc`
@@ -1199,8 +1197,8 @@ See https://doc.rust-lang.org/book/ch16-02-message-passing.html for more info.
 
 [[exercises]]
 name = "macros1"
-path = "exercises/21_macros/macros1.rs"
-mode = "compile"
+dir = "21_macros"
+mode = "run"
 hint = """
 When you call a macro, you need to add something special compared to a
 regular function call. If you're stuck, take a look at what's inside
@@ -1208,8 +1206,8 @@ regular function call. If you're stuck, take a look at what's inside
 
 [[exercises]]
 name = "macros2"
-path = "exercises/21_macros/macros2.rs"
-mode = "compile"
+dir = "21_macros"
+mode = "run"
 hint = """
 Macros don't quite play by the same rules as the rest of Rust, in terms of
 what's available where.
@@ -1219,8 +1217,8 @@ Unlike other things in Rust, the order of "where you define a macro" versus
 
 [[exercises]]
 name = "macros3"
-path = "exercises/21_macros/macros3.rs"
-mode = "compile"
+dir = "21_macros"
+mode = "run"
 hint = """
 In order to use a macro outside of its module, you need to do something
 special to the module to lift the macro out into its parent.
@@ -1230,8 +1228,8 @@ exported macros, if you've seen any of those around."""
 
 [[exercises]]
 name = "macros4"
-path = "exercises/21_macros/macros4.rs"
-mode = "compile"
+dir = "21_macros"
+mode = "run"
 hint = """
 You only need to add a single character to make this compile.
 
@@ -1247,7 +1245,7 @@ https://veykril.github.io/tlborm/"""
 
 [[exercises]]
 name = "clippy1"
-path = "exercises/22_clippy/clippy1.rs"
+dir = "22_clippy"
 mode = "clippy"
 hint = """
 Rust stores the highest precision version of any long or infinite precision
@@ -1263,14 +1261,14 @@ appropriate replacement constant from `std::f32::consts`..."""
 
 [[exercises]]
 name = "clippy2"
-path = "exercises/22_clippy/clippy2.rs"
+dir = "22_clippy"
 mode = "clippy"
 hint = """
 `for` loops over `Option` values are more clearly expressed as an `if let`"""
 
 [[exercises]]
 name = "clippy3"
-path = "exercises/22_clippy/clippy3.rs"
+dir = "22_clippy"
 mode = "clippy"
 hint = "No hints this time!"
 
@@ -1278,7 +1276,7 @@ hint = "No hints this time!"
 
 [[exercises]]
 name = "using_as"
-path = "exercises/23_conversions/using_as.rs"
+dir = "23_conversions"
 mode = "test"
 hint = """
 Use the `as` operator to cast one of the operands in the last line of the
@@ -1286,14 +1284,14 @@ Use the `as` operator to cast one of the operands in the last line of the
 
 [[exercises]]
 name = "from_into"
-path = "exercises/23_conversions/from_into.rs"
+dir = "23_conversions"
 mode = "test"
 hint = """
 Follow the steps provided right before the `From` implementation"""
 
 [[exercises]]
 name = "from_str"
-path = "exercises/23_conversions/from_str.rs"
+dir = "23_conversions"
 mode = "test"
 hint = """
 The implementation of `FromStr` should return an `Ok` with a `Person` object,
@@ -1314,7 +1312,7 @@ https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reen
 
 [[exercises]]
 name = "try_from_into"
-path = "exercises/23_conversions/try_from_into.rs"
+dir = "23_conversions"
 mode = "test"
 hint = """
 Follow the steps provided right before the `TryFrom` implementation.
@@ -1337,7 +1335,7 @@ Challenge: Can you make the `TryFrom` implementations generic over many integer
 
 [[exercises]]
 name = "as_ref_mut"
-path = "exercises/23_conversions/as_ref_mut.rs"
+dir = "23_conversions"
 mode = "test"
 hint = """
 Add `AsRef<str>` or `AsMut<u32>` as a trait bound to the functions."""
diff --git a/src/app_state.rs b/src/app_state.rs
index 2ea3db4..1a051b9 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -4,52 +4,16 @@ use crossterm::{
     terminal::{Clear, ClearType},
     ExecutableCommand,
 };
-use serde::{Deserialize, Serialize};
-use std::{
-    fs,
-    io::{StdoutLock, Write},
-};
-
-use crate::{exercise::Exercise, FENISH_LINE};
-
-const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
-
-#[derive(Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-struct StateFile {
-    current_exercise_ind: usize,
-    progress: Vec<bool>,
-}
-
-impl StateFile {
-    fn read(exercises: &[Exercise]) -> Option<Self> {
-        let file_content = fs::read(".rustlings-state.json").ok()?;
+use std::io::{StdoutLock, Write};
 
-        let slf: Self = serde_json::de::from_slice(&file_content).ok()?;
+mod state_file;
 
-        if slf.progress.len() != exercises.len() || slf.current_exercise_ind >= exercises.len() {
-            return None;
-        }
-
-        Some(slf)
-    }
-
-    fn read_or_default(exercises: &[Exercise]) -> Self {
-        Self::read(exercises).unwrap_or_else(|| Self {
-            current_exercise_ind: 0,
-            progress: vec![false; exercises.len()],
-        })
-    }
+use crate::{exercise::Exercise, info_file::InfoFile, FENISH_LINE};
 
-    fn write(&self) -> Result<()> {
-        let mut buf = Vec::with_capacity(1024);
-        serde_json::ser::to_writer(&mut buf, self).context("Failed to serialize the state")?;
-        fs::write(".rustlings-state.json", buf)
-            .context("Failed to write the state file `.rustlings-state.json`")?;
+use self::state_file::{write, StateFileDeser};
 
-        Ok(())
-    }
-}
+const STATE_FILE_NAME: &str = ".rustlings-state.json";
+const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
 
 #[must_use]
 pub enum ExercisesProgress {
@@ -58,52 +22,85 @@ pub enum ExercisesProgress {
 }
 
 pub struct AppState {
-    state_file: StateFile,
-    exercises: &'static [Exercise],
+    current_exercise_ind: usize,
+    exercises: Vec<Exercise>,
     n_done: u16,
-    current_exercise: &'static Exercise,
-    final_message: &'static str,
+    welcome_message: String,
+    final_message: String,
 }
 
 impl AppState {
-    pub fn new(mut exercises: Vec<Exercise>, mut final_message: String) -> Self {
-        // Leaking especially for sending the exercises to the debounce event handler.
-        // Leaking is not a problem because the `AppState` instance lives until
-        // the end of the program.
-        exercises.shrink_to_fit();
-        let exercises = exercises.leak();
-        final_message.shrink_to_fit();
-        let final_message = final_message.leak();
-
-        let state_file = StateFile::read_or_default(exercises);
-        let n_done = state_file
-            .progress
-            .iter()
-            .fold(0, |acc, done| acc + u16::from(*done));
-        let current_exercise = &exercises[state_file.current_exercise_ind];
+    pub fn new(info_file: InfoFile) -> Self {
+        let mut exercises = info_file
+            .exercises
+            .into_iter()
+            .map(|mut exercise_info| {
+                // Leaking to be able to borrow in the watch mode `Table`.
+                // Leaking is not a problem because the `AppState` instance lives until
+                // the end of the program.
+                let path = Box::leak(exercise_info.path().into_boxed_path());
+
+                exercise_info.name.shrink_to_fit();
+                let name = exercise_info.name.leak();
+
+                let hint = exercise_info.hint.trim().to_owned();
+
+                Exercise {
+                    name,
+                    path,
+                    mode: exercise_info.mode,
+                    hint,
+                    done: false,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let (current_exercise_ind, n_done) = StateFileDeser::read().map_or((0, 0), |state_file| {
+            let mut state_file_exercises =
+                hashbrown::HashMap::with_capacity(state_file.exercises.len());
+
+            for (ind, exercise_state) in state_file.exercises.into_iter().enumerate() {
+                state_file_exercises.insert(
+                    exercise_state.name,
+                    (ind == state_file.current_exercise_ind, exercise_state.done),
+                );
+            }
+
+            let mut current_exercise_ind = 0;
+            let mut n_done = 0;
+            for (ind, exercise) in exercises.iter_mut().enumerate() {
+                if let Some((current, done)) = state_file_exercises.get(exercise.name) {
+                    if *done {
+                        exercise.done = true;
+                        n_done += 1;
+                    }
+
+                    if *current {
+                        current_exercise_ind = ind;
+                    }
+                }
+            }
+
+            (current_exercise_ind, n_done)
+        });
 
         Self {
-            state_file,
+            current_exercise_ind,
             exercises,
             n_done,
-            current_exercise,
-            final_message,
+            welcome_message: info_file.welcome_message.unwrap_or_default(),
+            final_message: info_file.final_message.unwrap_or_default(),
         }
     }
 
     #[inline]
     pub fn current_exercise_ind(&self) -> usize {
-        self.state_file.current_exercise_ind
-    }
-
-    #[inline]
-    pub fn progress(&self) -> &[bool] {
-        &self.state_file.progress
+        self.current_exercise_ind
     }
 
     #[inline]
-    pub fn exercises(&self) -> &'static [Exercise] {
-        self.exercises
+    pub fn exercises(&self) -> &[Exercise] {
+        &self.exercises
     }
 
     #[inline]
@@ -112,8 +109,8 @@ impl AppState {
     }
 
     #[inline]
-    pub fn current_exercise(&self) -> &'static Exercise {
-        self.current_exercise
+    pub fn current_exercise(&self) -> &Exercise {
+        &self.exercises[self.current_exercise_ind]
     }
 
     pub fn set_current_exercise_ind(&mut self, ind: usize) -> Result<()> {
@@ -121,70 +118,61 @@ impl AppState {
             bail!(BAD_INDEX_ERR);
         }
 
-        self.state_file.current_exercise_ind = ind;
-        self.current_exercise = &self.exercises[ind];
+        self.current_exercise_ind = ind;
 
-        self.state_file.write()
+        write(self)
     }
 
     pub fn set_current_exercise_by_name(&mut self, name: &str) -> Result<()> {
-        let (ind, exercise) = self
+        // O(N) is fine since this method is used only once until the program exits.
+        // Building a hashmap would have more overhead.
+        self.current_exercise_ind = self
             .exercises
             .iter()
-            .enumerate()
-            .find(|(_, exercise)| exercise.name == name)
+            .position(|exercise| exercise.name == name)
             .with_context(|| format!("No exercise found for '{name}'!"))?;
 
-        self.state_file.current_exercise_ind = ind;
-        self.current_exercise = exercise;
-
-        self.state_file.write()
+        write(self)
     }
 
     pub fn set_pending(&mut self, ind: usize) -> Result<()> {
-        let done = self
-            .state_file
-            .progress
-            .get_mut(ind)
-            .context(BAD_INDEX_ERR)?;
-
-        if *done {
-            *done = false;
+        let exercise = self.exercises.get_mut(ind).context(BAD_INDEX_ERR)?;
+
+        if exercise.done {
+            exercise.done = false;
             self.n_done -= 1;
-            self.state_file.write()?;
+            write(self)?;
         }
 
         Ok(())
     }
 
     fn next_pending_exercise_ind(&self) -> Option<usize> {
-        let current_ind = self.state_file.current_exercise_ind;
-
-        if current_ind == self.state_file.progress.len() - 1 {
+        if self.current_exercise_ind == self.exercises.len() - 1 {
             // The last exercise is done.
             // Search for exercises not done from the start.
-            return self.state_file.progress[..current_ind]
+            return self.exercises[..self.current_exercise_ind]
                 .iter()
-                .position(|done| !done);
+                .position(|exercise| !exercise.done);
         }
 
         // The done exercise isn't the last one.
         // Search for a pending exercise after the current one and then from the start.
-        match self.state_file.progress[current_ind + 1..]
+        match self.exercises[self.current_exercise_ind + 1..]
             .iter()
-            .position(|done| !done)
+            .position(|exercise| !exercise.done)
         {
-            Some(ind) => Some(current_ind + 1 + ind),
-            None => self.state_file.progress[..current_ind]
+            Some(ind) => Some(self.current_exercise_ind + 1 + ind),
+            None => self.exercises[..self.current_exercise_ind]
                 .iter()
-                .position(|done| !done),
+                .position(|exercise| !exercise.done),
         }
     }
 
     pub fn done_current_exercise(&mut self, writer: &mut StdoutLock) -> Result<ExercisesProgress> {
-        let done = &mut self.state_file.progress[self.state_file.current_exercise_ind];
-        if !*done {
-            *done = true;
+        let exercise = &mut self.exercises[self.current_exercise_ind];
+        if !exercise.done {
+            exercise.done = true;
             self.n_done += 1;
         }
 
@@ -198,15 +186,14 @@ impl AppState {
                 if !exercise.run()?.status.success() {
                     writer.write_fmt(format_args!("{}\n\n", "FAILED".red()))?;
 
-                    self.state_file.current_exercise_ind = exercise_ind;
-                    self.current_exercise = exercise;
+                    self.current_exercise_ind = exercise_ind;
 
                     // No check if the exercise is done before setting it to pending
                     // because no pending exercise was found.
-                    self.state_file.progress[exercise_ind] = false;
+                    self.exercises[exercise_ind].done = false;
                     self.n_done -= 1;
 
-                    self.state_file.write()?;
+                    write(self)?;
 
                     return Ok(ExercisesProgress::Pending);
                 }
diff --git a/src/app_state/state_file.rs b/src/app_state/state_file.rs
new file mode 100644
index 0000000..364a1fa
--- /dev/null
+++ b/src/app_state/state_file.rs
@@ -0,0 +1,112 @@
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::fs;
+
+use crate::exercise::Exercise;
+
+use super::{AppState, STATE_FILE_NAME};
+
+#[derive(Deserialize)]
+pub struct ExerciseStateDeser {
+    pub name: String,
+    pub done: bool,
+}
+
+#[derive(Serialize)]
+struct ExerciseStateSer<'a> {
+    name: &'a str,
+    done: bool,
+}
+
+struct ExercisesStateSerializer<'a>(&'a [Exercise]);
+
+impl<'a> Serialize for ExercisesStateSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let iter = self.0.iter().map(|exercise| ExerciseStateSer {
+            name: exercise.name,
+            done: exercise.done,
+        });
+
+        serializer.collect_seq(iter)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct StateFileDeser {
+    pub current_exercise_ind: usize,
+    pub exercises: Vec<ExerciseStateDeser>,
+}
+
+#[derive(Serialize)]
+struct StateFileSer<'a> {
+    current_exercise_ind: usize,
+    exercises: ExercisesStateSerializer<'a>,
+}
+
+impl StateFileDeser {
+    pub fn read() -> Option<Self> {
+        let file_content = fs::read(STATE_FILE_NAME).ok()?;
+        serde_json::de::from_slice(&file_content).ok()
+    }
+}
+
+pub fn write(app_state: &AppState) -> Result<()> {
+    let content = StateFileSer {
+        current_exercise_ind: app_state.current_exercise_ind,
+        exercises: ExercisesStateSerializer(&app_state.exercises),
+    };
+
+    let mut buf = Vec::with_capacity(1024);
+    serde_json::ser::to_writer(&mut buf, &content).context("Failed to serialize the state")?;
+    fs::write(STATE_FILE_NAME, buf)
+        .with_context(|| format!("Failed to write the state file `{STATE_FILE_NAME}`"))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use crate::info_file::Mode;
+
+    use super::*;
+
+    #[test]
+    fn ser_deser_sync() {
+        let current_exercise_ind = 1;
+        let exercises = [
+            Exercise {
+                name: "1",
+                path: Path::new("exercises/1.rs"),
+                mode: Mode::Run,
+                hint: String::new(),
+                done: true,
+            },
+            Exercise {
+                name: "2",
+                path: Path::new("exercises/2.rs"),
+                mode: Mode::Test,
+                hint: String::new(),
+                done: false,
+            },
+        ];
+
+        let ser = StateFileSer {
+            current_exercise_ind,
+            exercises: ExercisesStateSerializer(&exercises),
+        };
+        let deser: StateFileDeser =
+            serde_json::de::from_slice(&serde_json::ser::to_vec(&ser).unwrap()).unwrap();
+
+        assert_eq!(deser.current_exercise_ind, current_exercise_ind);
+        assert!(deser
+            .exercises
+            .iter()
+            .zip(exercises)
+            .all(|(deser, ser)| deser.name == ser.name && deser.done == ser.done));
+    }
+}
diff --git a/src/exercise.rs b/src/exercise.rs
index 6aa3b82..c5ece5f 100644
--- a/src/exercise.rs
+++ b/src/exercise.rs
@@ -1,66 +1,25 @@
 use anyhow::{Context, Result};
-use serde::Deserialize;
 use std::{
-    fmt::{self, Debug, Display, Formatter},
-    fs::{self},
-    path::PathBuf,
+    fmt::{self, Display, Formatter},
+    path::Path,
     process::{Command, Output},
 };
 
-use crate::embedded::{WriteStrategy, EMBEDDED_FILES};
-
-// The mode of the exercise.
-#[derive(Deserialize, Copy, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum Mode {
-    // The exercise should be compiled as a binary
-    Compile,
-    // The exercise should be compiled as a test harness
-    Test,
-    // The exercise should be linted with clippy
-    Clippy,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct InfoFile {
-    // TODO
-    pub welcome_message: Option<String>,
-    pub final_message: Option<String>,
-    pub exercises: Vec<Exercise>,
-}
-
-impl InfoFile {
-    pub fn parse() -> Result<Self> {
-        // Read a local `info.toml` if it exists.
-        // Mainly to let the tests work for now.
-        let slf: Self = if let Ok(file_content) = fs::read_to_string("info.toml") {
-            toml_edit::de::from_str(&file_content)
-        } else {
-            toml_edit::de::from_str(include_str!("../info.toml"))
-        }
-        .context("Failed to parse `info.toml`")?;
-
-        if slf.exercises.is_empty() {
-            panic!("{NO_EXERCISES_ERR}");
-        }
-
-        Ok(slf)
-    }
-}
+use crate::{
+    embedded::{WriteStrategy, EMBEDDED_FILES},
+    info_file::Mode,
+};
 
-// Deserialized from the `info.toml` file.
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
 pub struct Exercise {
-    // Name of the exercise
-    pub name: String,
-    // The path to the file containing the exercise's source code
-    pub path: PathBuf,
+    // Exercise's unique name
+    pub name: &'static str,
+    // Exercise's path
+    pub path: &'static Path,
     // The mode of the exercise
     pub mode: Mode,
     // The hint text associated with the exercise
     pub hint: String,
+    pub done: bool,
 }
 
 impl Exercise {
@@ -79,7 +38,7 @@ impl Exercise {
             .arg("always")
             .arg("-q")
             .arg("--bin")
-            .arg(&self.name)
+            .arg(self.name)
             .args(args)
             .output()
             .context("Failed to run Cargo")
@@ -87,7 +46,7 @@ impl Exercise {
 
     pub fn run(&self) -> Result<Output> {
         match self.mode {
-            Mode::Compile => self.cargo_cmd("run", &[]),
+            Mode::Run => self.cargo_cmd("run", &[]),
             Mode::Test => self.cargo_cmd("test", &["--", "--nocapture", "--format", "pretty"]),
             Mode::Clippy => self.cargo_cmd(
                 "clippy",
@@ -98,7 +57,7 @@ impl Exercise {
 
     pub fn reset(&self) -> Result<()> {
         EMBEDDED_FILES
-            .write_exercise_to_disk(&self.path, WriteStrategy::Overwrite)
+            .write_exercise_to_disk(self.path, WriteStrategy::Overwrite)
             .with_context(|| format!("Failed to reset the exercise {self}"))
     }
 }
@@ -108,6 +67,3 @@ impl Display for Exercise {
         Display::fmt(&self.path.display(), f)
     }
 }
-
-const NO_EXERCISES_ERR: &str = "There are no exercises yet!
-If you are developing third-party exercises, add at least one exercise before testing.";
diff --git a/src/info_file.rs b/src/info_file.rs
new file mode 100644
index 0000000..dc97b92
--- /dev/null
+++ b/src/info_file.rs
@@ -0,0 +1,81 @@
+use anyhow::{bail, Context, Error, Result};
+use serde::Deserialize;
+use std::{fs, path::PathBuf};
+
+// The mode of the exercise.
+#[derive(Deserialize, Copy, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum Mode {
+    // The exercise should be compiled as a binary
+    Run,
+    // The exercise should be compiled as a test harness
+    Test,
+    // The exercise should be linted with clippy
+    Clippy,
+}
+
+// Deserialized from the `info.toml` file.
+#[derive(Deserialize)]
+pub struct ExerciseInfo {
+    // Name of the exercise
+    pub name: String,
+    // The exercise's directory inside the `exercises` directory
+    pub dir: Option<String>,
+    // The mode of the exercise
+    pub mode: Mode,
+    // The hint text associated with the exercise
+    pub hint: String,
+}
+
+impl ExerciseInfo {
+    pub fn path(&self) -> PathBuf {
+        let path = if let Some(dir) = &self.dir {
+            format!("exercises/{dir}/{}.rs", self.name)
+        } else {
+            format!("exercises/{}.rs", self.name)
+        };
+
+        PathBuf::from(path)
+    }
+}
+
+#[derive(Deserialize)]
+pub struct InfoFile {
+    pub welcome_message: Option<String>,
+    pub final_message: Option<String>,
+    pub exercises: Vec<ExerciseInfo>,
+}
+
+impl InfoFile {
+    pub fn parse() -> Result<Self> {
+        // Read a local `info.toml` if it exists.
+        let slf: Self = match fs::read_to_string("info.toml") {
+            Ok(file_content) => toml_edit::de::from_str(&file_content)
+                .context("Failed to parse the `info.toml` file")?,
+            Err(e) => match e.kind() {
+                std::io::ErrorKind::NotFound => {
+                    toml_edit::de::from_str(include_str!("../info.toml"))
+                        .context("Failed to parse the embedded `info.toml` file")?
+                }
+                _ => return Err(Error::from(e).context("Failed to read the `info.toml` file")),
+            },
+        };
+
+        if slf.exercises.is_empty() {
+            bail!("{NO_EXERCISES_ERR}");
+        }
+
+        let mut names_set = hashbrown::HashSet::with_capacity(slf.exercises.len());
+        for exercise in &slf.exercises {
+            if !names_set.insert(exercise.name.as_str()) {
+                bail!("Exercise names must all be unique!")
+            }
+        }
+        drop(names_set);
+
+        Ok(slf)
+    }
+}
+
+const NO_EXERCISES_ERR: &str = "There are no exercises yet!
+If you are developing third-party exercises, add at least one exercise before testing.";
diff --git a/src/init.rs b/src/init.rs
index 093610a..2badf37 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -6,17 +6,21 @@ use std::{
     path::Path,
 };
 
-use crate::{embedded::EMBEDDED_FILES, exercise::Exercise};
+use crate::{embedded::EMBEDDED_FILES, info_file::ExerciseInfo};
 
-fn create_cargo_toml(exercises: &[Exercise]) -> io::Result<()> {
+fn create_cargo_toml(exercise_infos: &[ExerciseInfo]) -> io::Result<()> {
     let mut cargo_toml = Vec::with_capacity(1 << 13);
     cargo_toml.extend_from_slice(b"bin = [\n");
-    for exercise in exercises {
+    for exercise_info in exercise_infos {
         cargo_toml.extend_from_slice(b"  { name = \"");
-        cargo_toml.extend_from_slice(exercise.name.as_bytes());
-        cargo_toml.extend_from_slice(b"\", path = \"");
-        cargo_toml.extend_from_slice(exercise.path.to_str().unwrap().as_bytes());
-        cargo_toml.extend_from_slice(b"\" },\n");
+        cargo_toml.extend_from_slice(exercise_info.name.as_bytes());
+        cargo_toml.extend_from_slice(b"\", path = \"exercises/");
+        if let Some(dir) = &exercise_info.dir {
+            cargo_toml.extend_from_slice(dir.as_bytes());
+            cargo_toml.extend_from_slice(b"/");
+        }
+        cargo_toml.extend_from_slice(exercise_info.name.as_bytes());
+        cargo_toml.extend_from_slice(b".rs\" },\n");
     }
 
     cargo_toml.extend_from_slice(
@@ -54,7 +58,7 @@ fn create_vscode_dir() -> Result<()> {
     Ok(())
 }
 
-pub fn init(exercises: &[Exercise]) -> Result<()> {
+pub fn init(exercise_infos: &[ExerciseInfo]) -> Result<()> {
     if Path::new("exercises").is_dir() && Path::new("Cargo.toml").is_file() {
         bail!(PROBABLY_IN_RUSTLINGS_DIR_ERR);
     }
@@ -74,7 +78,8 @@ pub fn init(exercises: &[Exercise]) -> Result<()> {
         .init_exercises_dir()
         .context("Failed to initialize the `rustlings/exercises` directory")?;
 
-    create_cargo_toml(exercises).context("Failed to create the file `rustlings/Cargo.toml`")?;
+    create_cargo_toml(exercise_infos)
+        .context("Failed to create the file `rustlings/Cargo.toml`")?;
 
     create_gitignore().context("Failed to create the file `rustlings/.gitignore`")?;
 
diff --git a/src/list.rs b/src/list.rs
index de120ea..2bb813d 100644
--- a/src/list.rs
+++ b/src/list.rs
@@ -5,7 +5,7 @@ use crossterm::{
     ExecutableCommand,
 };
 use ratatui::{backend::CrosstermBackend, Terminal};
-use std::{fmt::Write, io};
+use std::io;
 
 mod state;
 
@@ -72,14 +72,7 @@ pub fn list(app_state: &mut AppState) -> Result<()> {
                 ui_state.message.push_str(message);
             }
             KeyCode::Char('r') => {
-                let Some(exercise) = ui_state.reset_selected()? else {
-                    continue;
-                };
-
-                ui_state = ui_state.with_updated_rows();
-                ui_state
-                    .message
-                    .write_fmt(format_args!("The exercise {exercise} has been reset!"))?;
+                ui_state = ui_state.with_reset_selected()?;
             }
             KeyCode::Char('c') => {
                 ui_state.selected_to_current_exercise()?;
diff --git a/src/list/state.rs b/src/list/state.rs
index 0dcfe88..38391a4 100644
--- a/src/list/state.rs
+++ b/src/list/state.rs
@@ -6,8 +6,9 @@ use ratatui::{
     widgets::{Block, Borders, HighlightSpacing, Paragraph, Row, Table, TableState},
     Frame,
 };
+use std::fmt::Write;
 
-use crate::{app_state::AppState, exercise::Exercise, progress_bar::progress_bar_ratatui};
+use crate::{app_state::AppState, progress_bar::progress_bar_ratatui};
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Filter {
@@ -34,10 +35,9 @@ impl<'a> UiState<'a> {
             .app_state
             .exercises()
             .iter()
-            .zip(self.app_state.progress().iter().copied())
             .enumerate()
-            .filter_map(|(ind, (exercise, done))| {
-                let exercise_state = if done {
+            .filter_map(|(ind, exercise)| {
+                let exercise_state = if exercise.done {
                     if self.filter == Filter::Pending {
                         return None;
                     }
@@ -62,7 +62,7 @@ impl<'a> UiState<'a> {
                 Some(Row::new([
                     next,
                     exercise_state,
-                    Span::raw(&exercise.name),
+                    Span::raw(exercise.name),
                     Span::raw(exercise.path.to_string_lossy()),
                 ]))
             });
@@ -212,29 +212,30 @@ impl<'a> UiState<'a> {
         Ok(())
     }
 
-    pub fn reset_selected(&mut self) -> Result<Option<&'static Exercise>> {
+    pub fn with_reset_selected(mut self) -> Result<Self> {
         let Some(selected) = self.table_state.selected() else {
-            return Ok(None);
+            return Ok(self);
         };
 
         let (ind, exercise) = self
             .app_state
             .exercises()
             .iter()
-            .zip(self.app_state.progress())
             .enumerate()
-            .filter_map(|(ind, (exercise, done))| match self.filter {
-                Filter::Done => done.then_some((ind, exercise)),
-                Filter::Pending => (!done).then_some((ind, exercise)),
+            .filter_map(|(ind, exercise)| match self.filter {
+                Filter::Done => exercise.done.then_some((ind, exercise)),
+                Filter::Pending => (!exercise.done).then_some((ind, exercise)),
                 Filter::None => Some((ind, exercise)),
             })
             .nth(selected)
             .context("Invalid selection index")?;
 
-        self.app_state.set_pending(ind)?;
         exercise.reset()?;
+        self.message
+            .write_fmt(format_args!("The exercise {exercise} has been reset!"))?;
+        self.app_state.set_pending(ind)?;
 
-        Ok(Some(exercise))
+        Ok(self.with_updated_rows())
     }
 
     pub fn selected_to_current_exercise(&mut self) -> Result<()> {
@@ -244,12 +245,12 @@ impl<'a> UiState<'a> {
 
         let ind = self
             .app_state
-            .progress()
+            .exercises()
             .iter()
             .enumerate()
-            .filter_map(|(ind, done)| match self.filter {
-                Filter::Done => done.then_some(ind),
-                Filter::Pending => (!done).then_some(ind),
+            .filter_map(|(ind, exercise)| match self.filter {
+                Filter::Done => exercise.done.then_some(ind),
+                Filter::Pending => (!exercise.done).then_some(ind),
                 Filter::None => Some(ind),
             })
             .nth(selected)
diff --git a/src/main.rs b/src/main.rs
index cdfa21f..a96e323 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,6 +5,7 @@ use std::{path::Path, process::exit};
 mod app_state;
 mod embedded;
 mod exercise;
+mod info_file;
 mod init;
 mod list;
 mod progress_bar;
@@ -13,7 +14,7 @@ mod watch;
 
 use self::{
     app_state::AppState,
-    exercise::InfoFile,
+    info_file::InfoFile,
     init::init,
     list::list,
     run::run,
@@ -54,12 +55,10 @@ fn main() -> Result<()> {
 
     which::which("cargo").context(CARGO_NOT_FOUND_ERR)?;
 
-    let mut info_file = InfoFile::parse()?;
-    info_file.exercises.shrink_to_fit();
-    let exercises = info_file.exercises;
+    let info_file = InfoFile::parse()?;
 
     if matches!(args.command, Some(Subcommands::Init)) {
-        init(&exercises).context("Initialization failed")?;
+        init(&info_file.exercises).context("Initialization failed")?;
 
         println!("{POST_INIT_MSG}");
         return Ok(());
@@ -68,18 +67,29 @@ fn main() -> Result<()> {
         exit(1);
     }
 
-    let mut app_state = AppState::new(exercises, info_file.final_message.unwrap_or_default());
+    let mut app_state = AppState::new(info_file);
 
     match args.command {
-        None => loop {
-            match watch(&mut app_state)? {
-                WatchExit::Shutdown => break,
-                // It is much easier to exit the watch mode, launch the list mode and then restart
-                // the watch mode instead of trying to pause the watch threads and correct the
-                // watch state.
-                WatchExit::List => list(&mut app_state)?,
+        None => {
+            // For the the notify event handler thread.
+            // Leaking is not a problem because the slice lives until the end of the program.
+            let exercise_paths = app_state
+                .exercises()
+                .iter()
+                .map(|exercise| exercise.path)
+                .collect::<Vec<_>>()
+                .leak();
+
+            loop {
+                match watch(&mut app_state, exercise_paths)? {
+                    WatchExit::Shutdown => break,
+                    // It is much easier to exit the watch mode, launch the list mode and then restart
+                    // the watch mode instead of trying to pause the watch threads and correct the
+                    // watch state.
+                    WatchExit::List => list(&mut app_state)?,
+                }
             }
-        },
+        }
         // `Init` is handled above.
         Some(Subcommands::Init) => (),
         Some(Subcommands::Run { name }) => {
@@ -90,10 +100,10 @@ fn main() -> Result<()> {
         }
         Some(Subcommands::Reset { name }) => {
             app_state.set_current_exercise_by_name(&name)?;
-            app_state.set_pending(app_state.current_exercise_ind())?;
             let exercise = app_state.current_exercise();
             exercise.reset()?;
             println!("The exercise {exercise} has been reset!");
+            app_state.set_pending(app_state.current_exercise_ind())?;
         }
         Some(Subcommands::Hint { name }) => {
             app_state.set_current_exercise_by_name(&name)?;
diff --git a/src/run.rs b/src/run.rs
index 4748549..9c504b5 100644
--- a/src/run.rs
+++ b/src/run.rs
@@ -17,7 +17,7 @@ pub fn run(app_state: &mut AppState) -> Result<()> {
     if !output.status.success() {
         app_state.set_pending(app_state.current_exercise_ind())?;
 
-        bail!("Ran {exercise} with errors");
+        bail!("Ran {} with errors", app_state.current_exercise());
     }
 
     stdout.write_fmt(format_args!(
diff --git a/src/watch.rs b/src/watch.rs
index beb69b3..58e829f 100644
--- a/src/watch.rs
+++ b/src/watch.rs
@@ -11,14 +11,14 @@ use std::{
     time::Duration,
 };
 
-mod debounce_event;
+mod notify_event;
 mod state;
 mod terminal_event;
 
 use crate::app_state::{AppState, ExercisesProgress};
 
 use self::{
-    debounce_event::DebounceEventHandler,
+    notify_event::DebounceEventHandler,
     state::WatchState,
     terminal_event::{terminal_event_handler, InputEvent},
 };
@@ -40,13 +40,16 @@ pub enum WatchExit {
     List,
 }
 
-pub fn watch(app_state: &mut AppState) -> Result<WatchExit> {
+pub fn watch(
+    app_state: &mut AppState,
+    exercise_paths: &'static [&'static Path],
+) -> Result<WatchExit> {
     let (tx, rx) = channel();
     let mut debouncer = new_debouncer(
         Duration::from_secs(1),
         DebounceEventHandler {
             tx: tx.clone(),
-            exercises: app_state.exercises(),
+            exercise_paths,
         },
     )?;
     debouncer
@@ -85,10 +88,10 @@ pub fn watch(app_state: &mut AppState) -> Result<WatchExit> {
                 watch_state.render()?;
             }
             WatchEvent::NotifyErr(e) => {
-                return Err(Error::from(e).context("Exercise file watcher failed"))
+                return Err(Error::from(e).context("Exercise file watcher failed"));
             }
             WatchEvent::TerminalEventErr(e) => {
-                return Err(Error::from(e).context("Terminal event listener failed"))
+                return Err(Error::from(e).context("Terminal event listener failed"));
             }
         }
     }
diff --git a/src/watch/debounce_event.rs b/src/watch/debounce_event.rs
deleted file mode 100644
index 1dc92cb..0000000
--- a/src/watch/debounce_event.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use notify_debouncer_mini::{DebounceEventResult, DebouncedEventKind};
-use std::sync::mpsc::Sender;
-
-use crate::exercise::Exercise;
-
-use super::WatchEvent;
-
-pub struct DebounceEventHandler {
-    pub tx: Sender<WatchEvent>,
-    pub exercises: &'static [Exercise],
-}
-
-impl notify_debouncer_mini::DebounceEventHandler for DebounceEventHandler {
-    fn handle_event(&mut self, event: DebounceEventResult) {
-        let event = match event {
-            Ok(event) => {
-                let Some(exercise_ind) = event
-                    .iter()
-                    .filter_map(|event| {
-                        if event.kind != DebouncedEventKind::Any
-                            || !event.path.extension().is_some_and(|ext| ext == "rs")
-                        {
-                            return None;
-                        }
-
-                        self.exercises
-                            .iter()
-                            .position(|exercise| event.path.ends_with(&exercise.path))
-                    })
-                    .min()
-                else {
-                    return;
-                };
-
-                WatchEvent::FileChange { exercise_ind }
-            }
-            Err(e) => WatchEvent::NotifyErr(e),
-        };
-
-        // An error occurs when the receiver is dropped.
-        // After dropping the receiver, the debouncer guard should also be dropped.
-        let _ = self.tx.send(event);
-    }
-}
diff --git a/src/watch/notify_event.rs b/src/watch/notify_event.rs
new file mode 100644
index 0000000..0c8d669
--- /dev/null
+++ b/src/watch/notify_event.rs
@@ -0,0 +1,42 @@
+use notify_debouncer_mini::{DebounceEventResult, DebouncedEventKind};
+use std::{path::Path, sync::mpsc::Sender};
+
+use super::WatchEvent;
+
+pub struct DebounceEventHandler {
+    pub tx: Sender<WatchEvent>,
+    pub exercise_paths: &'static [&'static Path],
+}
+
+impl notify_debouncer_mini::DebounceEventHandler for DebounceEventHandler {
+    fn handle_event(&mut self, event: DebounceEventResult) {
+        let event = match event {
+            Ok(event) => {
+                let Some(exercise_ind) = event
+                    .iter()
+                    .filter_map(|event| {
+                        if event.kind != DebouncedEventKind::Any
+                            || !event.path.extension().is_some_and(|ext| ext == "rs")
+                        {
+                            return None;
+                        }
+
+                        self.exercise_paths
+                            .iter()
+                            .position(|path| event.path.ends_with(path))
+                    })
+                    .min()
+                else {
+                    return;
+                };
+
+                WatchEvent::FileChange { exercise_ind }
+            }
+            Err(e) => WatchEvent::NotifyErr(e),
+        };
+
+        // An error occurs when the receiver is dropped.
+        // After dropping the receiver, the debouncer guard should also be dropped.
+        let _ = self.tx.send(event);
+    }
+}
-- 
cgit v1.2.3


From bee62c89de09fdd9823cba81e07f0f8528fe8ef9 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 02:41:19 +0200
Subject: Add terminal links

---
 src/app_state.rs            |  2 +-
 src/app_state/state_file.rs |  8 +++-----
 src/embedded.rs             |  7 ++++++-
 src/exercise.rs             | 34 +++++++++++++++++++++++++++++++---
 src/info_file.rs            | 10 ++++------
 src/list/state.rs           |  2 +-
 src/run.rs                  | 12 +++++++++---
 src/watch.rs                |  2 +-
 src/watch/notify_event.rs   |  4 ++--
 src/watch/state.rs          |  6 +-----
 10 files changed, 59 insertions(+), 28 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index 1a051b9..98c6384 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -38,7 +38,7 @@ impl AppState {
                 // Leaking to be able to borrow in the watch mode `Table`.
                 // Leaking is not a problem because the `AppState` instance lives until
                 // the end of the program.
-                let path = Box::leak(exercise_info.path().into_boxed_path());
+                let path = exercise_info.path().leak();
 
                 exercise_info.name.shrink_to_fit();
                 let name = exercise_info.name.leak();
diff --git a/src/app_state/state_file.rs b/src/app_state/state_file.rs
index 364a1fa..4e4a0e1 100644
--- a/src/app_state/state_file.rs
+++ b/src/app_state/state_file.rs
@@ -59,7 +59,7 @@ pub fn write(app_state: &AppState) -> Result<()> {
         exercises: ExercisesStateSerializer(&app_state.exercises),
     };
 
-    let mut buf = Vec::with_capacity(1024);
+    let mut buf = Vec::with_capacity(4096);
     serde_json::ser::to_writer(&mut buf, &content).context("Failed to serialize the state")?;
     fs::write(STATE_FILE_NAME, buf)
         .with_context(|| format!("Failed to write the state file `{STATE_FILE_NAME}`"))?;
@@ -69,8 +69,6 @@ pub fn write(app_state: &AppState) -> Result<()> {
 
 #[cfg(test)]
 mod tests {
-    use std::path::Path;
-
     use crate::info_file::Mode;
 
     use super::*;
@@ -81,14 +79,14 @@ mod tests {
         let exercises = [
             Exercise {
                 name: "1",
-                path: Path::new("exercises/1.rs"),
+                path: "exercises/1.rs",
                 mode: Mode::Run,
                 hint: String::new(),
                 done: true,
             },
             Exercise {
                 name: "2",
-                path: Path::new("exercises/2.rs"),
+                path: "exercises/2.rs",
                 mode: Mode::Test,
                 hint: String::new(),
                 done: false,
diff --git a/src/embedded.rs b/src/embedded.rs
index 1e2d677..866b12b 100644
--- a/src/embedded.rs
+++ b/src/embedded.rs
@@ -91,7 +91,12 @@ impl EmbeddedFiles {
         Ok(())
     }
 
-    pub fn write_exercise_to_disk(&self, path: &Path, strategy: WriteStrategy) -> io::Result<()> {
+    pub fn write_exercise_to_disk<P>(&self, path: P, strategy: WriteStrategy) -> io::Result<()>
+    where
+        P: AsRef<Path>,
+    {
+        let path = path.as_ref();
+
         if let Some(file) = self
             .exercises_dir
             .files
diff --git a/src/exercise.rs b/src/exercise.rs
index c5ece5f..2ec8d97 100644
--- a/src/exercise.rs
+++ b/src/exercise.rs
@@ -1,7 +1,8 @@
 use anyhow::{Context, Result};
+use crossterm::style::{style, StyledContent, Stylize};
 use std::{
     fmt::{self, Display, Formatter},
-    path::Path,
+    fs,
     process::{Command, Output},
 };
 
@@ -10,11 +11,32 @@ use crate::{
     info_file::Mode,
 };
 
+pub struct TerminalFileLink<'a> {
+    path: &'a str,
+}
+
+impl<'a> Display for TerminalFileLink<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if let Ok(Some(canonical_path)) = fs::canonicalize(self.path)
+            .as_deref()
+            .map(|path| path.to_str())
+        {
+            write!(
+                f,
+                "\x1b]8;;file://{}\x1b\\{}\x1b]8;;\x1b\\",
+                canonical_path, self.path,
+            )
+        } else {
+            write!(f, "{}", self.path,)
+        }
+    }
+}
+
 pub struct Exercise {
     // Exercise's unique name
     pub name: &'static str,
     // Exercise's path
-    pub path: &'static Path,
+    pub path: &'static str,
     // The mode of the exercise
     pub mode: Mode,
     // The hint text associated with the exercise
@@ -60,10 +82,16 @@ impl Exercise {
             .write_exercise_to_disk(self.path, WriteStrategy::Overwrite)
             .with_context(|| format!("Failed to reset the exercise {self}"))
     }
+
+    pub fn terminal_link(&self) -> StyledContent<TerminalFileLink<'_>> {
+        style(TerminalFileLink { path: self.path })
+            .underlined()
+            .blue()
+    }
 }
 
 impl Display for Exercise {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        Display::fmt(&self.path.display(), f)
+        self.path.fmt(f)
     }
 }
diff --git a/src/info_file.rs b/src/info_file.rs
index dc97b92..2a45e02 100644
--- a/src/info_file.rs
+++ b/src/info_file.rs
@@ -1,6 +1,6 @@
 use anyhow::{bail, Context, Error, Result};
 use serde::Deserialize;
-use std::{fs, path::PathBuf};
+use std::fs;
 
 // The mode of the exercise.
 #[derive(Deserialize, Copy, Clone)]
@@ -28,14 +28,12 @@ pub struct ExerciseInfo {
 }
 
 impl ExerciseInfo {
-    pub fn path(&self) -> PathBuf {
-        let path = if let Some(dir) = &self.dir {
+    pub fn path(&self) -> String {
+        if let Some(dir) = &self.dir {
             format!("exercises/{dir}/{}.rs", self.name)
         } else {
             format!("exercises/{}.rs", self.name)
-        };
-
-        PathBuf::from(path)
+        }
     }
 }
 
diff --git a/src/list/state.rs b/src/list/state.rs
index 38391a4..2a1fef1 100644
--- a/src/list/state.rs
+++ b/src/list/state.rs
@@ -63,7 +63,7 @@ impl<'a> UiState<'a> {
                     next,
                     exercise_state,
                     Span::raw(exercise.name),
-                    Span::raw(exercise.path.to_string_lossy()),
+                    Span::raw(exercise.path),
                 ]))
             });
 
diff --git a/src/run.rs b/src/run.rs
index 9c504b5..863b584 100644
--- a/src/run.rs
+++ b/src/run.rs
@@ -17,18 +17,24 @@ pub fn run(app_state: &mut AppState) -> Result<()> {
     if !output.status.success() {
         app_state.set_pending(app_state.current_exercise_ind())?;
 
-        bail!("Ran {} with errors", app_state.current_exercise());
+        bail!(
+            "Ran {} with errors",
+            app_state.current_exercise().terminal_link(),
+        );
     }
 
     stdout.write_fmt(format_args!(
         "{}{}\n",
         "✓ Successfully ran ".green(),
-        exercise.path.to_string_lossy().green(),
+        exercise.path.green(),
     ))?;
 
     match app_state.done_current_exercise(&mut stdout)? {
         ExercisesProgress::AllDone => (),
-        ExercisesProgress::Pending => println!("Next exercise: {}", app_state.current_exercise()),
+        ExercisesProgress::Pending => println!(
+            "Next exercise: {}",
+            app_state.current_exercise().terminal_link(),
+        ),
     }
 
     Ok(())
diff --git a/src/watch.rs b/src/watch.rs
index 58e829f..bab64ae 100644
--- a/src/watch.rs
+++ b/src/watch.rs
@@ -42,7 +42,7 @@ pub enum WatchExit {
 
 pub fn watch(
     app_state: &mut AppState,
-    exercise_paths: &'static [&'static Path],
+    exercise_paths: &'static [&'static str],
 ) -> Result<WatchExit> {
     let (tx, rx) = channel();
     let mut debouncer = new_debouncer(
diff --git a/src/watch/notify_event.rs b/src/watch/notify_event.rs
index 0c8d669..fb9a8c0 100644
--- a/src/watch/notify_event.rs
+++ b/src/watch/notify_event.rs
@@ -1,11 +1,11 @@
 use notify_debouncer_mini::{DebounceEventResult, DebouncedEventKind};
-use std::{path::Path, sync::mpsc::Sender};
+use std::sync::mpsc::Sender;
 
 use super::WatchEvent;
 
 pub struct DebounceEventHandler {
     pub tx: Sender<WatchEvent>,
-    pub exercise_paths: &'static [&'static Path],
+    pub exercise_paths: &'static [&'static str],
 }
 
 impl notify_debouncer_mini::DebounceEventHandler for DebounceEventHandler {
diff --git a/src/watch/state.rs b/src/watch/state.rs
index 6a97637..1a79573 100644
--- a/src/watch/state.rs
+++ b/src/watch/state.rs
@@ -136,11 +136,7 @@ When you are done experimenting, enter `n` or `next` to go to the next exercise
         )?;
         self.writer.write_fmt(format_args!(
             "{progress_bar}Current exercise: {}\n",
-            self.app_state
-                .current_exercise()
-                .path
-                .to_string_lossy()
-                .bold(),
+            self.app_state.current_exercise().terminal_link(),
         ))?;
 
         self.show_prompt()?;
-- 
cgit v1.2.3


From 9dcc4b7df5f539b10117e97870a9f1cb01ca040d Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 05:13:27 +0200
Subject: Simplify the state file

---
 .gitignore                  |   2 +-
 Cargo.lock                  |  12 -----
 Cargo.toml                  |   1 -
 src/app_state.rs            | 128 +++++++++++++++++++++++++++++---------------
 src/app_state/state_file.rs | 110 -------------------------------------
 src/init.rs                 |   2 +-
 6 files changed, 86 insertions(+), 169 deletions(-)
 delete mode 100644 src/app_state/state_file.rs

(limited to 'src/app_state.rs')

diff --git a/.gitignore b/.gitignore
index c9172e0..80f9092 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,7 @@ target/
 /dev/Cargo.lock
 
 # State file
-.rustlings-state.json
+.rustlings-state.txt
 
 # oranda
 public/
diff --git a/Cargo.lock b/Cargo.lock
index dbf1923..6bc68f0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -690,7 +690,6 @@ dependencies = [
  "ratatui",
  "rustlings-macros",
  "serde",
- "serde_json",
  "toml_edit",
  "which",
 ]
@@ -749,17 +748,6 @@ dependencies = [
  "syn 2.0.58",
 ]
 
-[[package]]
-name = "serde_json"
-version = "1.0.115"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
 [[package]]
 name = "serde_spanned"
 version = "0.6.5"
diff --git a/Cargo.toml b/Cargo.toml
index 14ae9a1..07865ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,6 @@ hashbrown = "0.14.3"
 notify-debouncer-mini = "0.4.1"
 ratatui = "0.26.1"
 rustlings-macros = { path = "rustlings-macros" }
-serde_json = "1.0.115"
 serde.workspace = true
 toml_edit.workspace = true
 which = "6.0.1"
diff --git a/src/app_state.rs b/src/app_state.rs
index 98c6384..9a378de 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -4,15 +4,14 @@ use crossterm::{
     terminal::{Clear, ClearType},
     ExecutableCommand,
 };
-use std::io::{StdoutLock, Write};
-
-mod state_file;
+use std::{
+    fs::{self, File},
+    io::{Read, StdoutLock, Write},
+};
 
 use crate::{exercise::Exercise, info_file::InfoFile, FENISH_LINE};
 
-use self::state_file::{write, StateFileDeser};
-
-const STATE_FILE_NAME: &str = ".rustlings-state.json";
+const STATE_FILE_NAME: &str = ".rustlings-state.txt";
 const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
 
 #[must_use]
@@ -27,11 +26,51 @@ pub struct AppState {
     n_done: u16,
     welcome_message: String,
     final_message: String,
+    file_buf: Vec<u8>,
 }
 
 impl AppState {
+    fn update_from_file(&mut self) {
+        self.file_buf.clear();
+        self.n_done = 0;
+
+        if File::open(STATE_FILE_NAME)
+            .and_then(|mut file| file.read_to_end(&mut self.file_buf))
+            .is_ok()
+        {
+            let mut lines = self.file_buf.split(|c| *c == b'\n');
+            let Some(current_exercise_name) = lines.next() else {
+                return;
+            };
+
+            if lines.next().is_none() {
+                return;
+            }
+
+            let mut done_exercises = hashbrown::HashSet::with_capacity(self.exercises.len());
+
+            for done_exerise_name in lines {
+                if done_exerise_name.is_empty() {
+                    break;
+                }
+                done_exercises.insert(done_exerise_name);
+            }
+
+            for (ind, exercise) in self.exercises.iter_mut().enumerate() {
+                if done_exercises.contains(exercise.name.as_bytes()) {
+                    exercise.done = true;
+                    self.n_done += 1;
+                }
+
+                if exercise.name.as_bytes() == current_exercise_name {
+                    self.current_exercise_ind = ind;
+                }
+            }
+        }
+    }
+
     pub fn new(info_file: InfoFile) -> Self {
-        let mut exercises = info_file
+        let exercises = info_file
             .exercises
             .into_iter()
             .map(|mut exercise_info| {
@@ -55,42 +94,18 @@ impl AppState {
             })
             .collect::<Vec<_>>();
 
-        let (current_exercise_ind, n_done) = StateFileDeser::read().map_or((0, 0), |state_file| {
-            let mut state_file_exercises =
-                hashbrown::HashMap::with_capacity(state_file.exercises.len());
-
-            for (ind, exercise_state) in state_file.exercises.into_iter().enumerate() {
-                state_file_exercises.insert(
-                    exercise_state.name,
-                    (ind == state_file.current_exercise_ind, exercise_state.done),
-                );
-            }
-
-            let mut current_exercise_ind = 0;
-            let mut n_done = 0;
-            for (ind, exercise) in exercises.iter_mut().enumerate() {
-                if let Some((current, done)) = state_file_exercises.get(exercise.name) {
-                    if *done {
-                        exercise.done = true;
-                        n_done += 1;
-                    }
-
-                    if *current {
-                        current_exercise_ind = ind;
-                    }
-                }
-            }
-
-            (current_exercise_ind, n_done)
-        });
-
-        Self {
-            current_exercise_ind,
+        let mut slf = Self {
+            current_exercise_ind: 0,
             exercises,
-            n_done,
+            n_done: 0,
             welcome_message: info_file.welcome_message.unwrap_or_default(),
             final_message: info_file.final_message.unwrap_or_default(),
-        }
+            file_buf: Vec::with_capacity(2048),
+        };
+
+        slf.update_from_file();
+
+        slf
     }
 
     #[inline]
@@ -120,7 +135,7 @@ impl AppState {
 
         self.current_exercise_ind = ind;
 
-        write(self)
+        self.write()
     }
 
     pub fn set_current_exercise_by_name(&mut self, name: &str) -> Result<()> {
@@ -132,7 +147,7 @@ impl AppState {
             .position(|exercise| exercise.name == name)
             .with_context(|| format!("No exercise found for '{name}'!"))?;
 
-        write(self)
+        self.write()
     }
 
     pub fn set_pending(&mut self, ind: usize) -> Result<()> {
@@ -141,7 +156,7 @@ impl AppState {
         if exercise.done {
             exercise.done = false;
             self.n_done -= 1;
-            write(self)?;
+            self.write()?;
         }
 
         Ok(())
@@ -193,7 +208,7 @@ impl AppState {
                     self.exercises[exercise_ind].done = false;
                     self.n_done -= 1;
 
-                    write(self)?;
+                    self.write()?;
 
                     return Ok(ExercisesProgress::Pending);
                 }
@@ -213,6 +228,31 @@ impl AppState {
 
         Ok(ExercisesProgress::Pending)
     }
+
+    // Write the state file.
+    // The file's format is very simple:
+    // - The first line is the name of the current exercise.
+    // - The second line is an empty line.
+    // - All remaining lines are the names of done exercises.
+    fn write(&mut self) -> Result<()> {
+        self.file_buf.clear();
+
+        self.file_buf
+            .extend_from_slice(self.current_exercise().name.as_bytes());
+        self.file_buf.extend_from_slice(b"\n\n");
+
+        for exercise in &self.exercises {
+            if exercise.done {
+                self.file_buf.extend_from_slice(exercise.name.as_bytes());
+                self.file_buf.extend_from_slice(b"\n");
+            }
+        }
+
+        fs::write(STATE_FILE_NAME, &self.file_buf)
+            .with_context(|| format!("Failed to write the state file {STATE_FILE_NAME}"))?;
+
+        Ok(())
+    }
 }
 
 const RERUNNING_ALL_EXERCISES_MSG: &[u8] = b"
diff --git a/src/app_state/state_file.rs b/src/app_state/state_file.rs
deleted file mode 100644
index 4e4a0e1..0000000
--- a/src/app_state/state_file.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use anyhow::{Context, Result};
-use serde::{Deserialize, Serialize};
-use std::fs;
-
-use crate::exercise::Exercise;
-
-use super::{AppState, STATE_FILE_NAME};
-
-#[derive(Deserialize)]
-pub struct ExerciseStateDeser {
-    pub name: String,
-    pub done: bool,
-}
-
-#[derive(Serialize)]
-struct ExerciseStateSer<'a> {
-    name: &'a str,
-    done: bool,
-}
-
-struct ExercisesStateSerializer<'a>(&'a [Exercise]);
-
-impl<'a> Serialize for ExercisesStateSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let iter = self.0.iter().map(|exercise| ExerciseStateSer {
-            name: exercise.name,
-            done: exercise.done,
-        });
-
-        serializer.collect_seq(iter)
-    }
-}
-
-#[derive(Deserialize)]
-pub struct StateFileDeser {
-    pub current_exercise_ind: usize,
-    pub exercises: Vec<ExerciseStateDeser>,
-}
-
-#[derive(Serialize)]
-struct StateFileSer<'a> {
-    current_exercise_ind: usize,
-    exercises: ExercisesStateSerializer<'a>,
-}
-
-impl StateFileDeser {
-    pub fn read() -> Option<Self> {
-        let file_content = fs::read(STATE_FILE_NAME).ok()?;
-        serde_json::de::from_slice(&file_content).ok()
-    }
-}
-
-pub fn write(app_state: &AppState) -> Result<()> {
-    let content = StateFileSer {
-        current_exercise_ind: app_state.current_exercise_ind,
-        exercises: ExercisesStateSerializer(&app_state.exercises),
-    };
-
-    let mut buf = Vec::with_capacity(4096);
-    serde_json::ser::to_writer(&mut buf, &content).context("Failed to serialize the state")?;
-    fs::write(STATE_FILE_NAME, buf)
-        .with_context(|| format!("Failed to write the state file `{STATE_FILE_NAME}`"))?;
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::info_file::Mode;
-
-    use super::*;
-
-    #[test]
-    fn ser_deser_sync() {
-        let current_exercise_ind = 1;
-        let exercises = [
-            Exercise {
-                name: "1",
-                path: "exercises/1.rs",
-                mode: Mode::Run,
-                hint: String::new(),
-                done: true,
-            },
-            Exercise {
-                name: "2",
-                path: "exercises/2.rs",
-                mode: Mode::Test,
-                hint: String::new(),
-                done: false,
-            },
-        ];
-
-        let ser = StateFileSer {
-            current_exercise_ind,
-            exercises: ExercisesStateSerializer(&exercises),
-        };
-        let deser: StateFileDeser =
-            serde_json::de::from_slice(&serde_json::ser::to_vec(&ser).unwrap()).unwrap();
-
-        assert_eq!(deser.current_exercise_ind, current_exercise_ind);
-        assert!(deser
-            .exercises
-            .iter()
-            .zip(exercises)
-            .all(|(deser, ser)| deser.name == ser.name && deser.done == ser.done));
-    }
-}
diff --git a/src/init.rs b/src/init.rs
index 2badf37..4ee503a 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -89,7 +89,7 @@ pub fn init(exercise_infos: &[ExerciseInfo]) -> Result<()> {
 }
 
 const GITIGNORE: &[u8] = b"/target
-/.rustlings-state.json
+/.rustlings-state.txt
 ";
 
 const VS_CODE_EXTENSIONS_JSON: &[u8] = br#"{"recommendations":["rust-lang.rust-analyzer"]}"#;
-- 
cgit v1.2.3


From 3da860927d131eacc288764672ed8799a6a8cfca Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 14:53:32 +0200
Subject: Use push instead of extend_from_slice on chars

---
 gen-dev-cargo-toml/src/main.rs | 2 +-
 src/app_state.rs               | 2 +-
 src/init.rs                    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/gen-dev-cargo-toml/src/main.rs b/gen-dev-cargo-toml/src/main.rs
index 792fe5f..43b4ebd 100644
--- a/gen-dev-cargo-toml/src/main.rs
+++ b/gen-dev-cargo-toml/src/main.rs
@@ -42,7 +42,7 @@ bin = [\n",
         buf.extend_from_slice(b"\", path = \"../exercises/");
         if let Some(dir) = &exercise_info.dir {
             buf.extend_from_slice(dir.as_bytes());
-            buf.extend_from_slice(b"/");
+            buf.push(b'/');
         }
         buf.extend_from_slice(exercise_info.name.as_bytes());
         buf.extend_from_slice(b".rs\" },\n");
diff --git a/src/app_state.rs b/src/app_state.rs
index 9a378de..31cb2cb 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -244,7 +244,7 @@ impl AppState {
         for exercise in &self.exercises {
             if exercise.done {
                 self.file_buf.extend_from_slice(exercise.name.as_bytes());
-                self.file_buf.extend_from_slice(b"\n");
+                self.file_buf.push(b'\n');
             }
         }
 
diff --git a/src/init.rs b/src/init.rs
index 4ee503a..459519d 100644
--- a/src/init.rs
+++ b/src/init.rs
@@ -17,7 +17,7 @@ fn create_cargo_toml(exercise_infos: &[ExerciseInfo]) -> io::Result<()> {
         cargo_toml.extend_from_slice(b"\", path = \"exercises/");
         if let Some(dir) = &exercise_info.dir {
             cargo_toml.extend_from_slice(dir.as_bytes());
-            cargo_toml.extend_from_slice(b"/");
+            cargo_toml.push(b'/');
         }
         cargo_toml.extend_from_slice(exercise_info.name.as_bytes());
         cargo_toml.extend_from_slice(b".rs\" },\n");
-- 
cgit v1.2.3


From 8aef915ee732af1480cd7b93818f7d71c3ba178c Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 16:03:49 +0200
Subject: Show the welcome message

---
 src/app_state.rs | 81 ++++++++++++++++++++++++++++++++------------------------
 src/main.rs      | 32 ++++++++++++++++++++--
 2 files changed, 76 insertions(+), 37 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index 31cb2cb..fb4b92e 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -9,7 +9,7 @@ use std::{
     io::{Read, StdoutLock, Write},
 };
 
-use crate::{exercise::Exercise, info_file::InfoFile, FENISH_LINE};
+use crate::{exercise::Exercise, info_file::ExerciseInfo, FENISH_LINE};
 
 const STATE_FILE_NAME: &str = ".rustlings-state.txt";
 const BAD_INDEX_ERR: &str = "The current exercise index is higher than the number of exercises";
@@ -20,58 +20,69 @@ pub enum ExercisesProgress {
     Pending,
 }
 
+pub enum StateFileStatus {
+    Read,
+    NotRead,
+}
+
 pub struct AppState {
     current_exercise_ind: usize,
     exercises: Vec<Exercise>,
     n_done: u16,
-    welcome_message: String,
     final_message: String,
     file_buf: Vec<u8>,
 }
 
 impl AppState {
-    fn update_from_file(&mut self) {
+    fn update_from_file(&mut self) -> StateFileStatus {
         self.file_buf.clear();
         self.n_done = 0;
 
         if File::open(STATE_FILE_NAME)
             .and_then(|mut file| file.read_to_end(&mut self.file_buf))
-            .is_ok()
+            .is_err()
         {
-            let mut lines = self.file_buf.split(|c| *c == b'\n');
-            let Some(current_exercise_name) = lines.next() else {
-                return;
-            };
+            return StateFileStatus::NotRead;
+        }
 
-            if lines.next().is_none() {
-                return;
-            }
+        // See `Self::write` for more information about the file format.
+        let mut lines = self.file_buf.split(|c| *c == b'\n');
+        let Some(current_exercise_name) = lines.next() else {
+            return StateFileStatus::NotRead;
+        };
+
+        if current_exercise_name.is_empty() || lines.next().is_none() {
+            return StateFileStatus::NotRead;
+        }
 
-            let mut done_exercises = hashbrown::HashSet::with_capacity(self.exercises.len());
+        let mut done_exercises = hashbrown::HashSet::with_capacity(self.exercises.len());
 
-            for done_exerise_name in lines {
-                if done_exerise_name.is_empty() {
-                    break;
-                }
-                done_exercises.insert(done_exerise_name);
+        for done_exerise_name in lines {
+            if done_exerise_name.is_empty() {
+                break;
             }
+            done_exercises.insert(done_exerise_name);
+        }
 
-            for (ind, exercise) in self.exercises.iter_mut().enumerate() {
-                if done_exercises.contains(exercise.name.as_bytes()) {
-                    exercise.done = true;
-                    self.n_done += 1;
-                }
+        for (ind, exercise) in self.exercises.iter_mut().enumerate() {
+            if done_exercises.contains(exercise.name.as_bytes()) {
+                exercise.done = true;
+                self.n_done += 1;
+            }
 
-                if exercise.name.as_bytes() == current_exercise_name {
-                    self.current_exercise_ind = ind;
-                }
+            if exercise.name.as_bytes() == current_exercise_name {
+                self.current_exercise_ind = ind;
             }
         }
+
+        StateFileStatus::Read
     }
 
-    pub fn new(info_file: InfoFile) -> Self {
-        let exercises = info_file
-            .exercises
+    pub fn new(
+        exercise_infos: Vec<ExerciseInfo>,
+        final_message: String,
+    ) -> (Self, StateFileStatus) {
+        let exercises = exercise_infos
             .into_iter()
             .map(|mut exercise_info| {
                 // Leaking to be able to borrow in the watch mode `Table`.
@@ -98,14 +109,13 @@ impl AppState {
             current_exercise_ind: 0,
             exercises,
             n_done: 0,
-            welcome_message: info_file.welcome_message.unwrap_or_default(),
-            final_message: info_file.final_message.unwrap_or_default(),
+            final_message,
             file_buf: Vec::with_capacity(2048),
         };
 
-        slf.update_from_file();
+        let state_file_status = slf.update_from_file();
 
-        slf
+        (slf, state_file_status)
     }
 
     #[inline]
@@ -231,7 +241,8 @@ impl AppState {
 
     // Write the state file.
     // The file's format is very simple:
-    // - The first line is the name of the current exercise.
+    // - The first line is the name of the current exercise. It must end with `\n` even if there
+    // are no done exercises.
     // - The second line is an empty line.
     // - All remaining lines are the names of done exercises.
     fn write(&mut self) -> Result<()> {
@@ -239,12 +250,12 @@ impl AppState {
 
         self.file_buf
             .extend_from_slice(self.current_exercise().name.as_bytes());
-        self.file_buf.extend_from_slice(b"\n\n");
+        self.file_buf.push(b'\n');
 
         for exercise in &self.exercises {
             if exercise.done {
-                self.file_buf.extend_from_slice(exercise.name.as_bytes());
                 self.file_buf.push(b'\n');
+                self.file_buf.extend_from_slice(exercise.name.as_bytes());
             }
         }
 
diff --git a/src/main.rs b/src/main.rs
index a96e323..aeb9432 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,15 @@
 use anyhow::{Context, Result};
+use app_state::StateFileStatus;
 use clap::{Parser, Subcommand};
-use std::{path::Path, process::exit};
+use crossterm::{
+    terminal::{Clear, ClearType},
+    ExecutableCommand,
+};
+use std::{
+    io::{self, BufRead, Write},
+    path::Path,
+    process::exit,
+};
 
 mod app_state;
 mod embedded;
@@ -67,7 +76,26 @@ fn main() -> Result<()> {
         exit(1);
     }
 
-    let mut app_state = AppState::new(info_file);
+    let (mut app_state, state_file_status) = AppState::new(
+        info_file.exercises,
+        info_file.final_message.unwrap_or_default(),
+    );
+
+    if let Some(welcome_message) = info_file.welcome_message {
+        match state_file_status {
+            StateFileStatus::NotRead => {
+                let mut stdout = io::stdout().lock();
+                stdout.execute(Clear(ClearType::All))?;
+
+                let welcome_message = welcome_message.trim();
+                write!(stdout, "{welcome_message}\n\nPress ENTER to continue ")?;
+                stdout.flush()?;
+
+                io::stdin().lock().read_until(b'\n', &mut Vec::new())?;
+            }
+            StateFileStatus::Read => (),
+        }
+    }
 
     match args.command {
         None => {
-- 
cgit v1.2.3


From 070a780d7f7ca4ef03ab29898ec553933994bfab Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Sun, 14 Apr 2024 16:04:05 +0200
Subject: Trim the final message

---
 src/app_state.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'src/app_state.rs')

diff --git a/src/app_state.rs b/src/app_state.rs
index fb4b92e..432a9a2 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -228,8 +228,12 @@ impl AppState {
 
             writer.execute(Clear(ClearType::All))?;
             writer.write_all(FENISH_LINE.as_bytes())?;
-            writer.write_all(self.final_message.as_bytes())?;
-            writer.write_all(b"\n")?;
+
+            let final_message = self.final_message.trim();
+            if !final_message.is_empty() {
+                writer.write_all(self.final_message.as_bytes())?;
+                writer.write_all(b"\n")?;
+            }
 
             return Ok(ExercisesProgress::AllDone);
         };
-- 
cgit v1.2.3