feat: Better error handling

Instead of capturing errors from the REPL and restarting it (from
main.rs), we now attempt to capture all errors inside the REPL. This
should keep the REPL's state even if something were to go wrong.

src/main.rs

@@ -8,11 +8,9 @@ pub use crate::engine::{Engine, ExitStatus};
 pub use crate::error::{Error, Result};
 
 fn main() {
-    loop {
-        let mut repl = repl::Repl::new();
+    let mut repl = repl::Repl::new();
 
-        if let Err(e) = repl.run() {
-            eprintln!("rush: Encountered an error: {e}");
-        }
+    if let Err(e) = repl.run() {
+        eprintln!("rush: Unrecoverable error occurred: {e}");
     }
 }

src/repl/input.rs

@@ -145,7 +145,7 @@ fn read_line<W: Write>(engine: &mut Engine<W>) -> Result<String> {
                 execute!(engine.writer, cursor::MoveRight(1))?;
             }
 
-            (KeyCode::Char(' '), KeyModifiers::NONE) => {
+            (KeyCode::Char(' '), KeyModifiers::NONE | KeyModifiers::SHIFT) => {
                 let (mut x, y) = cursor::position()?;
 
                 if let Some((expanded_line, diff)) = expand_abbreviation(&line) {

src/repl/mod.rs

@@ -1,7 +1,7 @@
 pub mod input;
 
 use std::env;
-use std::io::Stdout;
+use std::io::{Stdout, Write};
 use std::process;
 
 use crossterm::{execute, style, terminal};
@@ -26,11 +26,36 @@ impl Repl {
 
     pub fn run(&mut self) -> Result<()> {
         loop {
-            self.prompt()?;
-
-            if let Some(command) = input::input(&mut self.engine)? {
-                self.last_status = Some(self.engine.execute(command)?);
+            if let Err(e) = self.prompt() {
+                writeln!(
+                    self.engine.writer,
+                    "rush: Error occurred when computing the prompt: {e}"
+                )?;
             }
+
+            match input::input(&mut self.engine) {
+                Ok(Some(command)) => match self.engine.execute(command) {
+                    Ok(status) => {
+                        self.last_status = Some(status);
+                    }
+
+                    Err(e) => {
+                        writeln!(
+                            self.engine.writer,
+                            "rush: Error occurred when executing command: {e}"
+                        )?;
+                    }
+                },
+
+                Ok(None) => {}
+
+                Err(e) => {
+                    writeln!(
+                        self.engine.writer,
+                        "rush: Error occurred when reading input: {e}"
+                    )?;
+                }
+            };
         }
     }