Restructured how commands like list, help, quit are parsed to implement save

.gitignore

@@ -1 +1,2 @@
 /target
+.DS_Store

numbat-cli/src/main.rs

@@ -10,12 +10,14 @@ use config::{ColorMode, Config, ExchangeRateFetchingPolicy, IntroBanner, PrettyP
 use highlighter::NumbatHighlighter;
 
 use itertools::Itertools;
+use numbat::command::{CommandParser, SourcelessCommandParser};
 use numbat::diagnostic::ErrorDiagnostic;
 use numbat::help::help_markup;
 use numbat::markup as m;
 use numbat::module_importer::{BuiltinModuleImporter, ChainedImporter, FileSystemImporter};
 use numbat::pretty_print::PrettyPrint;
 use numbat::resolver::CodeSource;
+use numbat::{command, RuntimeError};
 use numbat::{Context, NumbatError};
 use numbat::{InterpreterSettings, NameResolutionError};
 
@@ -347,95 +349,93 @@ impl Cli {
                     if !line.trim().is_empty() {
                         rl.add_history_entry(&line)?;
 
-                        match line.trim() {
-                            "list" | "ls" => {
-                                println!(
-                                    "{}",
-                                    ansi_format(
-                                        &self.context.lock().unwrap().print_environment(),
-                                        false
-                                    )
-                                );
-                            }
-                            "list functions" | "ls functions" => {
-                                println!(
-                                    "{}",
-                                    ansi_format(
-                                        &self.context.lock().unwrap().print_functions(),
-                                        false
-                                    )
-                                );
-                            }
-                            "list dimensions" | "ls dimensions" => {
-                                println!(
-                                    "{}",
-                                    ansi_format(
-                                        &self.context.lock().unwrap().print_dimensions(),
-                                        false
-                                    )
-                                );
-                            }
-                            "list variables" | "ls variables" => {
-                                println!(
-                                    "{}",
-                                    ansi_format(
-                                        &self.context.lock().unwrap().print_variables(),
-                                        false
-                                    )
-                                );
-                            }
-                            "list units" | "ls units" => {
-                                println!(
-                                    "{}",
-                                    ansi_format(&self.context.lock().unwrap().print_units(), false)
-                                );
-                            }
-                            "clear" => {
-                                rl.clear_screen()?;
-                            }
-                            "quit" | "exit" => {
-                                return Ok(());
-                            }
-                            "help" | "?" => {
-                                let help = help_markup();
-                                print!("{}", ansi_format(&help, true));
-                                // currently, the ansi formatter adds indents
-                                // _after_ each newline and so we need to manually
-                                // add an extra blank line to absorb this indent
-                                println!();
-                            }
-                            _ => {
-                                if let Some(keyword) = line.strip_prefix("info ") {
-                                    let help = self
-                                        .context
-                                        .lock()
-                                        .unwrap()
-                                        .print_info_for_keyword(keyword.trim());
-                                    println!("{}", ansi_format(&help, true));
-                                    continue;
-                                }
-                                let result = self.parse_and_evaluate(
-                                    &line,
-                                    CodeSource::Text,
-                                    if interactive {
-                                        ExecutionMode::Interactive
-                                    } else {
-                                        ExecutionMode::Normal
-                                    },
-                                    self.config.pretty_print,
-                                );
-
-                                match result {
-                                    std::ops::ControlFlow::Continue(()) => {}
-                                    std::ops::ControlFlow::Break(ExitStatus::Success) => {
-                                        return Ok(());
+                        // if we enter here, the line looks like a command
+                        if let Some(sourceless_parser) = SourcelessCommandParser::new(&line) {
+                            let mut parser = CommandParser::new(
+                                sourceless_parser,
+                                self.context
+                                    .lock()
+                                    .unwrap()
+                                    .resolver_mut()
+                                    .add_code_source(CodeSource::Text, &line),
+                            );
+
+                            match parser.parse_command() {
+                                Ok(command) => match command {
+                                    command::Command::Help => {
+                                        let help = help_markup();
+                                        print!("{}", ansi_format(&help, true));
+                                        // currently, the ansi formatter adds indents
+                                        // _after_ each newline and so we need to manually
+                                        // add an extra blank line to absorb this indent
+                                        println!();
+                                    }
+                                    command::Command::Info { item } => {
+                                        let help = self
+                                            .context
+                                            .lock()
+                                            .unwrap()
+                                            .print_info_for_keyword(item);
+                                        println!("{}", ansi_format(&help, true));
+                                    }
+                                    command::Command::List { items } => {
+                                        let context = self.context.lock().unwrap();
+                                        let m = match items {
+                                            None => context.print_environment(),
+                                            Some(command::ListItems::Functions) => {
+                                                context.print_functions()
+                                            }
+                                            Some(command::ListItems::Dimensions) => {
+                                                context.print_dimensions()
+                                            }
+                                            Some(command::ListItems::Variables) => {
+                                                context.print_variables()
+                                            }
+                                            Some(command::ListItems::Units) => {
+                                                context.print_units()
+                                            }
+                                        };
+                                        println!("{}", ansi_format(&m, false));
                                     }
-                                    std::ops::ControlFlow::Break(ExitStatus::Error) => {
-                                        bail!("Interpreter stopped due to error")
+                                    command::Command::Clear => rl.clear_screen()?,
+                                    command::Command::Save { dst } => {
+                                        if rl.save_history(dst).is_err() {
+                                            let error = RuntimeError::FileWrite(PathBuf::from(dst));
+                                            self.print_diagnostic(error);
+                                            continue;
+                                        };
                                     }
+                                    command::Command::Quit => return Ok(()),
+                                },
+                                Err(e) => {
+                                    self.print_diagnostic(e);
+                                    continue;
                                 }
                             }
+
+                            continue;
                         }
+
+                        let result = self.parse_and_evaluate(
+                            &line,
+                            CodeSource::Text,
+                            if interactive {
+                                ExecutionMode::Interactive
+                            } else {
+                                ExecutionMode::Normal
+                            },
+                            self.config.pretty_print,
+                        );
+
+                        match result {
+                            std::ops::ControlFlow::Continue(()) => {}
+                            std::ops::ControlFlow::Break(ExitStatus::Success) => {
+                                return Ok(());
+                            }
+                            std::ops::ControlFlow::Break(ExitStatus::Error) => {
+                                bail!("Interpreter stopped due to error")
+                            }
+                        };
                     }
                 }
                 Err(ReadlineError::Interrupted) => {}