Added UnknownCommand error; Refactored RELP, SQL and MetaCommand modules; Refactored main.rs to be cleaner and moremodular also. Started Parser implementation. Still working in progress, since I am still experimenting with the design

Author: joaoh82

src/error.rs

@@ -17,6 +17,7 @@ pub enum SQLRiteError {
     General(String),
     Internal(String),
     SqlError(ParserError),
+    UnknownCommand(String),
     // IoError(io::Error),
 }
 
@@ -57,6 +58,7 @@ impl Display for SQLRiteError {
             SQLRiteError::SqlError(ref desc) => write!(f, "SQL error: {:?}", desc),
             // SQLRiteError::IoError(ref desc) => write!(f, "IO error: {}", desc),
             SQLRiteError::Internal(desc) => write!(f, "Internal SQLRite error: {}", desc),
+            SQLRiteError::UnknownCommand(desc) => write!(f, "Unknown command error: {}", desc),
         }
     }
 }

src/main.rs

@@ -1,12 +1,13 @@
 extern crate clap;
 
+mod meta_command;
 mod repl;
 mod sql;
 mod error;
 
-use repl::{REPLHelper, get_config};
-use repl::meta_command::*;
-use sql::*;
+use repl::{REPLHelper, get_config, get_command_type, CommandType};
+use meta_command::{handle_meta_command};
+use sql::{process_command};
 
 use rustyline::error::ReadlineError;
 use rustyline::{Editor};
@@ -47,11 +48,8 @@ fn main() -> rustyline::Result<()> {
     "Connected to a transient in-memory database.\n",
     "Use '.open FILENAME' to reopen on a persistent database.");
 
-    // Counter is set to improve user experience and show user how many 
-    // commands he has ran.
-    let mut count = 1;
     loop {
-        let p = format!("rust-sqlite | {}> ", count);
+        let p = format!("sqlrite> ");
         repl.helper_mut()
             .expect("No helper found")
             .colored_prompt = format!("\x1b[1;32m{}\x1b[0m", p);
@@ -62,17 +60,19 @@ fn main() -> rustyline::Result<()> {
         match readline {
             Ok(command) => {
                 repl.add_history_entry(command.as_str());
-                if command.starts_with(".") {
-                    let action = get_meta_command(&command);
-                    match action {
-                        Some(response) => println!("{}",response),
-                        None => break,
+                match get_command_type(&command.trim().to_owned()) {
+                    CommandType::SQLCommand(_cmd) => {
+                        let _ = match process_command(&command) {
+                            Ok(response) => println!("{}",response),
+                            Err(err) => println!("An error occured: {}", err),
+                        };
+                    }
+                    CommandType::MetaCommand(cmd) => {
+                        let _ = match handle_meta_command(cmd) {
+                            Ok(response) => println!("{}",response),
+                            Err(err) => println!("An error occured: {}", err),
+                        };
                     }
-                }else{
-                    let _ = match prepare_statement(&command) {
-                        Ok(response) => println!("{}",response),
-                        Err(err) => println!("An error occured: {}", err),
-                    };
                 }
             }
             Err(ReadlineError::Interrupted) => {
@@ -86,7 +86,6 @@ fn main() -> rustyline::Result<()> {
                 break;
             }
         }
-        count += 1;
     }
     repl.append_history("history").unwrap();
 

src/meta_command/mod.rs

@@ -0,0 +1,93 @@
+use crate::error::{Result, SQLRiteError};
+
+use std::fmt;
+
+#[derive(Debug, PartialEq)]
+pub enum MetaCommand {
+    Exit,
+    Help,
+    Open(String),
+    Unknown,
+}
+
+/// Trait responsible for translating type into a formated text.
+impl fmt::Display for MetaCommand {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            MetaCommand::Exit => f.write_str(".exit"),
+            MetaCommand::Help => f.write_str(".help"),
+            MetaCommand::Open(_) => f.write_str(".open"),
+            MetaCommand::Unknown => f.write_str("Unknown command"),
+        }
+    }
+}
+
+impl MetaCommand {
+    pub fn new(command: String) -> MetaCommand {
+        let args: Vec<&str> = command.split_whitespace().collect();
+        let cmd = args[0].to_owned();
+        match cmd.as_ref() {
+            ".exit" => MetaCommand::Exit,
+            ".help" => MetaCommand::Help,
+            ".open" => MetaCommand::Open(command),
+            _ => MetaCommand::Unknown,
+        }
+    }
+}
+
+pub fn handle_meta_command(command: MetaCommand) -> Result<String> {
+    match command {
+        MetaCommand::Exit => std::process::exit(0),
+        MetaCommand::Help => {
+            Ok(format!("{}{}{}{}{}","Special commands:\n",
+                            ".help - Display this message\n",
+                            ".open <FILENAME> - Reopens a persistent database.\n",
+                            ".ast <QUERY> - Show the abstract syntax tree for QUERY.\n",
+                            ".exit - Quits this application"))
+        },
+        MetaCommand::Open(args) => Ok(format!("To be implemented: {}", args)),
+        MetaCommand::Unknown => Err(SQLRiteError::UnknownCommand(format!("Unknown command or invalid arguments. Enter '.help'"))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_meta_command_exit_test() {
+        let inputed_command = MetaCommand::Help;
+
+        let result = handle_meta_command(inputed_command);
+        assert_eq!(result.is_ok(), true);
+    }
+
+    #[test]
+    fn get_meta_command_open_test() {
+        let inputed_command = MetaCommand::Open(".open database.db".to_string());
+
+        let result = handle_meta_command(inputed_command);
+        assert_eq!(result.is_ok(), true);
+    }
+
+    #[test]
+    fn get_meta_command_unknown_command_test() {
+        let inputed_command = MetaCommand::Unknown;
+
+        let result = handle_meta_command(inputed_command);
+        assert_eq!(result.is_err(), true);
+    }
+
+    #[test]
+    fn meta_command_display_trait_test() {
+        let exit = MetaCommand::Exit;
+        let help = MetaCommand::Help;
+        let open = MetaCommand::Open(".open database.db".to_string());
+        let unknown = MetaCommand::Unknown;
+
+        assert_eq!(format!("{}", exit), ".exit");
+        assert_eq!(format!("{}", help), ".help");
+        assert_eq!(format!("{}", open), ".open");
+        assert_eq!(format!("{}", unknown), "Unknown command");
+    }
+}

src/repl/meta_command.rs

@@ -1,4 +1,5 @@
-pub mod meta_command;
+use crate::meta_command::*;
+use crate::sql::*;
 
 use std::{borrow::Cow::{self, Borrowed, Owned}};
 
@@ -11,6 +12,21 @@ use rustyline::validate::{ValidationContext, ValidationResult};
 use rustyline::hint::{Hinter, HistoryHinter};
 use rustyline::highlight::{Highlighter, MatchingBracketHighlighter};
 
+/// We have two different types of commands MetaCommand and SQLCommand
+#[derive(Debug, PartialEq)]
+pub enum CommandType {
+    MetaCommand(MetaCommand),
+    SQLCommand(SQLCommand),
+}
+
+/// Returns the type of command inputed in the REPL
+pub fn get_command_type(command: &String) -> CommandType {
+    match command.starts_with(".") {
+        true => CommandType::MetaCommand(MetaCommand::new(command.to_owned())),
+        false => CommandType::SQLCommand(SQLCommand::new(command.to_owned())),
+    }
+}
+
 // REPL Helper Struct with all functionalities
 #[derive(Helper, Completer)]
 pub struct REPLHelper {
@@ -100,4 +116,28 @@ pub fn get_config() -> Config {
         .edit_mode(EditMode::Emacs)
         .output_stream(OutputStreamType::Stdout)
         .build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_command_type_meta_command_test() {
+        let input = String::from(".help");
+        let expected = CommandType::MetaCommand(MetaCommand::Help);
+
+        let result = get_command_type(&input);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn get_command_type_sql_command_test() {
+        let input = String::from("SELECT * from users;");
+        let expected = CommandType::SQLCommand(SQLCommand::Unknown(input.clone()));
+
+        let result = get_command_type(&input);
+        assert_eq!(result, expected);
+
+    }
 }