debugger/src/main.rs (2)

131-132: Partial command matching logic is reversed but valid.

Using "help".starts_with(help) is unusual but still works because "help".starts_with("h" | "he" | "hel" | "help") will evaluate correctly. Nonetheless, consider reversing the logic (help.starts_with("help")), which generally reads more naturally.

- help if "help".starts_with(help) => Cli::help(),
+ help if help.starts_with("help") => Cli::help(),

---

137-151: Repeated code blocks for extracting filenames and rules can be DRYed up.

Repeated usage of .find(" ") and .and_then(...) to extract the argument after a space could be refactored into a small helper function. This would make your command parsing more consistent and maintainable. Additionally, consider if you need to handle filenames containing spaces.

fn extract_arg(cmd: &str) -> Option<&str> {
    cmd.find(' ').map(|pos| &cmd[pos + 1..])
}

// Then each usage:
if let Some(arg) = extract_arg(grammar) {
    self.grammar(PathBuf::from(arg))?;
} else {
    println!("expected filename, usage: g(grammar) <filename>");
}

Also applies to: 157-165, 167-173, 175-180

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

debugger/src/main.rs (3)

109-119: Consider aligning command descriptions for better readability.

While the help text is more descriptive with parameter names in parentheses, the descriptions could be better aligned for improved readability.

-             g(grammar)     <grammar filename>      - load .pest grammar\n\
-             i(input)       <input filename>        - load input from a file\n\
+             g(grammar)      <grammar filename>     - load .pest grammar\n\
+             i(input)        <input filename>       - load input from a file\n\

---

135-137: Consider using constants for command names.

Commands like "help", "list", and "continue" could be defined as constants to avoid string literals and ensure consistency.

+const CMD_HELP: &str = "help";
+const CMD_LIST: &str = "list";
+const CMD_CONTINUE: &str = "continue";
+
 fn execute_command(&mut self, command: &str) -> Result<(), DebuggerError> {
     match command {
         "" => (),
-        help if "help".starts_with(help) => Cli::help(),
-        list if "list".starts_with(list) => self.list(),
-        cont if "continue".starts_with(cont) => self.cont()?,
+        help if CMD_HELP.starts_with(help) => Cli::help(),
+        list if CMD_LIST.starts_with(list) => self.list(),
+        cont if CMD_CONTINUE.starts_with(cont) => self.cont()?,

---

140-182: Consider extracting common argument validation pattern.

The pattern of extracting and validating arguments is repeated across multiple commands. Consider extracting this into a helper method to reduce duplication.

fn validate_arg<F>(&mut self, cmd: &str, usage: &str, f: F) -> Result<(), DebuggerError>
where
    F: FnOnce(&mut Self, &str) -> Result<(), DebuggerError>,
{
    if let Some(arg) = Self::extract_arg(cmd) {
        f(self, arg)
    } else {
        println!("expected argument, usage: {}", usage);
        Ok(())
    }
}

Usage example:

-            grammar if "grammar".starts_with(grammar) => {
-                let grammar_file = Self::extract_arg(grammar);
-                if let Some(grammar_file) = grammar_file {
-                    self.grammar(PathBuf::from(grammar_file))?;
-                } else {
-                    println!("expected filename, usage: g(grammar) <filename>");
-                }
-            }
+            grammar if "grammar".starts_with(grammar) => {
+                self.validate_arg(grammar, "g(grammar) <filename>", |s, arg| {
+                    s.grammar(PathBuf::from(arg))
+                })?
+            }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro