Improvements to watch mode

Cargo.lock

@@ -536,6 +536,7 @@ dependencies = [
  "regex",
  "serde",
  "serde_json",
+ "shlex",
  "toml",
 ]
 
@@ -594,6 +595,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "strsim"
 version = "0.11.0"

Cargo.toml

@@ -18,6 +18,7 @@ notify-debouncer-mini = "0.4.1"
 regex = "1.10.3"
 serde_json = "1.0.114"
 serde = { version = "1.0.197", features = ["derive"] }
+shlex = "1.3.0"
 toml = "0.8.10"
 
 [[bin]]

src/main.rs

@@ -6,6 +6,7 @@ use clap::{Parser, Subcommand};
 use console::Emoji;
 use notify_debouncer_mini::notify::{self, RecursiveMode};
 use notify_debouncer_mini::{new_debouncer, DebouncedEventKind};
+use shlex::Shlex;
 use std::ffi::OsStr;
 use std::fs;
 use std::io::{self, prelude::*};
@@ -25,6 +26,16 @@ mod project;
 mod run;
 mod verify;
 
+const WATCH_MODE_HELP_MESSAGE: &str = "Commands available to you in watch mode:
+  hint   - prints the current exercise's hint
+  clear  - clears the screen
+  quit   - quits watch mode
+  !<cmd> - executes a command, like `!rustc --explain E0381`
+  help   - displays this help message
+
+Watch mode automatically re-evaluates the current exercise
+when you edit a file's contents.";
+
 /// Rustlings is a collection of small exercises to get you used to writing and reading Rust code
 #[derive(Parser)]
 #[command(version)]
@@ -246,47 +257,49 @@ fn main() {
 }
 
 fn spawn_watch_shell(
-    failed_exercise_hint: &Arc<Mutex<Option<String>>>,
+    failed_exercise_hint: Arc<Mutex<Option<String>>>,
     should_quit: Arc<AtomicBool>,
 ) {
-    let failed_exercise_hint = Arc::clone(failed_exercise_hint);
     println!("Welcome to watch mode! You can type 'help' to get an overview of the commands you can use here.");
-    thread::spawn(move || loop {
+
+    thread::spawn(move || {
         let mut input = String::new();
-        match io::stdin().read_line(&mut input) {
+        let mut stdin = io::stdin().lock();
-            Ok(_) => {
+
-                let input = input.trim();
+        loop {
-                if input == "hint" {
+            // Recycle input buffer.
-                    if let Some(hint) = &*failed_exercise_hint.lock().unwrap() {
+            input.clear();
-                        println!("{hint}");
+
-                    }
+            if let Err(e) = stdin.read_line(&mut input) {
-                } else if input == "clear" {
+                println!("error reading command: {e}");
-                    println!("\x1B[2J\x1B[1;1H");
+            }
-                } else if input.eq("quit") {
+
-                    should_quit.store(true, Ordering::SeqCst);
+            let input = input.trim();
-                    println!("Bye!");
+            if input == "hint" {
-                } else if input.eq("help") {
+                if let Some(hint) = &*failed_exercise_hint.lock().unwrap() {
-                    println!("Commands available to you in watch mode:");
+                    println!("{hint}");
-                    println!("  hint   - prints the current exercise's hint");
+                }
-                    println!("  clear  - clears the screen");
+            } else if input == "clear" {
-                    println!("  quit   - quits watch mode");
+                println!("\x1B[2J\x1B[1;1H");
-                    println!("  !<cmd> - executes a command, like `!rustc --explain E0381`");
+            } else if input == "quit" {
-                    println!("  help   - displays this help message");
+                should_quit.store(true, Ordering::SeqCst);
-                    println!();
+                println!("Bye!");
-                    println!("Watch mode automatically re-evaluates the current exercise");
+            } else if input == "help" {
-                    println!("when you edit a file's contents.")
+                println!("{WATCH_MODE_HELP_MESSAGE}");
-                } else if let Some(cmd) = input.strip_prefix('!') {
+            } else if let Some(cmd) = input.strip_prefix('!') {
-                    let parts: Vec<&str> = cmd.split_whitespace().collect();
+                let mut parts = Shlex::new(cmd);
-                    if parts.is_empty() {
+
-                        println!("no command provided");
+                let Some(program) = parts.next() else {
-                    } else if let Err(e) = Command::new(parts[0]).args(&parts[1..]).status() {
+                    println!("no command provided");
-                        println!("failed to execute command `{}`: {}", cmd, e);
+                    continue;
-                    }
+                };
-                } else {
+
-                    println!("unknown command: {input}");
+                if let Err(e) = Command::new(program).args(parts).status() {
-                }
+                    println!("failed to execute command `{cmd}`: {e}");
+                }
+            } else {
+                println!("unknown command: {input}\n{WATCH_MODE_HELP_MESSAGE}");
             }
-            Err(error) => println!("error reading command: {error}"),
         }
     });
 }
@@ -348,7 +361,7 @@ fn watch(
         Ok(_) => return Ok(WatchStatus::Finished),
         Err(exercise) => Arc::new(Mutex::new(Some(to_owned_hint(exercise)))),
     };
-    spawn_watch_shell(&failed_exercise_hint, Arc::clone(&should_quit));
+    spawn_watch_shell(Arc::clone(&failed_exercise_hint), Arc::clone(&should_quit));
     loop {
         match rx.recv_timeout(Duration::from_secs(1)) {
             Ok(event) => match event {