1 files changed, 465 insertions, 49 deletions

diff --git a/src/command.rs b/src/command.rs
index 0372065..0ef5121 100644
--- a/src/command.rs
+++ b/src/command.rs
@@ -104,7 +104,7 @@ fn call_on_app(s: &mut Cursive, input: &str) {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Debug)]
 pub enum Command {
     Add(String, Option<u32>, bool),
     MonthPrev,
@@ -118,7 +118,22 @@ pub enum Command {
     Blank,
 }
 
-#[derive(Debug)]
+#[derive(PartialEq, Debug)]
+enum CommandName {
+    Add,
+    AddAuto,
+    MonthPrev,
+    MonthNext,
+    Delete,
+    TrackUp,
+    TrackDown,
+    Help,
+    Write,
+    Quit,
+    Blank,
+}
+
+#[derive(PartialEq, Debug)]
 pub enum CommandLineError {
     InvalidCommand(String),     // command name
     InvalidArg(u32),            // position
@@ -143,64 +158,465 @@ type Result<T> = std::result::Result<T, CommandLineError>;
 
 impl Command {
     pub fn from_string<P: AsRef<str>>(input: P) -> Result<Command> {
-        let mut strings: Vec<&str> = input.as_ref().trim().split(' ').collect();
-        if strings.is_empty() {
-            return Ok(Command::Blank);
+        let input_str = input.as_ref().trim();
+        let parsed = parse_command_name(input_str);
+        if let Ok((command_name, rest)) = parsed {
+            match command_name {
+                CommandName::Add => return parse_add(rest),
+                CommandName::AddAuto => return parse_add_auto(rest),
+                CommandName::Delete => return parse_delete(rest),
+                CommandName::TrackUp => return parse_track_up(rest),
+                CommandName::TrackDown => return parse_track_down(rest),
+                CommandName::Help => return parse_help(rest),
+                CommandName::MonthPrev => return Ok(Command::MonthPrev),
+                CommandName::MonthNext => return Ok(Command::MonthNext),
+                CommandName::Quit => return Ok(Command::Quit),
+                CommandName::Write => return Ok(Command::Write),
+                CommandName::Blank => return Ok(Command::Blank),
+            }
+        } else {
+            return Err(parsed.err().unwrap());
         }
+    }
+}
+
+fn parse_command_name(input: &str) -> Result<(CommandName, &str)> {
+    let pieces: Vec<&str> = input.trim().splitn(2, ' ').collect();
 
-        let first = strings.first().unwrap().to_string();
-        let mut args: Vec<String> = strings.iter_mut().skip(1).map(|s| s.to_string()).collect();
-        let mut _add = |auto: bool, first: String| {
-            if args.is_empty() {
-                return Err(CommandLineError::NotEnoughArgs(first, 1));
+    let command = pieces.first().unwrap();
+    let rest = pieces.iter().skip(1).next().map(|&x| x).unwrap_or("");
+
+    match command.as_ref() {
+        "add" | "a" => Ok((CommandName::Add, rest)),
+        "add-auto" | "aa" => Ok((CommandName::AddAuto, rest)),
+        "delete" | "d" => Ok((CommandName::Delete, rest)),
+        "track-up" | "tup" => Ok((CommandName::TrackUp, rest)),
+        "track-down" | "tdown" => Ok((CommandName::TrackDown, rest)),
+        "h" | "?" | "help" => Ok((CommandName::Help, rest)),
+        "mprev" => Ok((CommandName::MonthPrev, "")),
+        "mnext" => Ok((CommandName::MonthNext, "")),
+        "quit" | "q" => Ok((CommandName::Quit, "")),
+        "write" | "w" => Ok((CommandName::Write, "")),
+        "" => Ok((CommandName::Blank, "")),
+        c => Err(CommandLineError::InvalidCommand(c.to_string())),
+    }
+}
+
+fn parse_name(input: &str) -> (String, &str) {
+    let chars = input.trim().chars();
+    let mut name = "".to_owned();
+    let mut pos = 0;
+    let mut parenthesis = false;
+
+    for c in chars {
+        pos = pos + 1;
+        if c == '"' || c == '\"' {
+            if parenthesis {
+                return (name, &input[pos..]);
+            } else {
+                parenthesis = true;
+                continue;
             }
-            let goal = args
-                .get(1)
-                .map(|x| {
-                    x.parse::<u32>()
-                        .map_err(|_| CommandLineError::InvalidArg(2))
-                })
-                .transpose()?;
-            return Ok(Command::Add(
-                args.get_mut(0).unwrap().to_string(),
-                goal,
-                auto,
-            ));
-        };
-
-        match first.as_ref() {
-            "add" | "a" => _add(false, first),
-            "add-auto" | "aa" => _add(true, first),
-            "delete" | "d" => {
-                if args.is_empty() {
-                    return Err(CommandLineError::NotEnoughArgs(first, 1));
+        }
+
+        if parenthesis {
+            name.push(c);
+            continue;
+        }
+
+        if c == ' ' {
+            break;
+        }
+
+        name.push(c);
+    }
+
+    (name, &input[pos..])
+}
+
+fn parse_goal(input: &str) -> Option<(Option<u32>, &str)> {
+    let chars = input.trim().chars();
+    let mut goal_string = "".to_owned();
+    let mut pos = 0;
+
+    if input.is_empty() {
+        return Some((None, input));
+    }
+
+    for c in chars {
+        pos = pos + 1;
+        if c == ' ' {
+            break;
+        }
+
+        goal_string.push(c);
+    }
+
+    let parsed = goal_string.parse::<u32>();
+
+    if parsed.is_err() {
+        return None;
+    }
+
+    if pos + 1 > input.len() {
+        return Some((parsed.ok(), ""));
+    }
+
+    Some((parsed.ok(), &input[pos..]))
+}
+
+fn parse_add(input: &str) -> Result<Command> {
+    let (name, rest) = parse_name(input);
+
+    if name.is_empty() {
+        return Err(CommandLineError::NotEnoughArgs("add".to_owned(), 2));
+    }
+
+    let parsed_goal = parse_goal(rest);
+
+    if parsed_goal.is_none() {
+        return Err(CommandLineError::InvalidArg(2));
+    }
+
+    Ok(Command::Add(name, parsed_goal.unwrap().0, false))
+}
+
+fn parse_add_auto(input: &str) -> Result<Command> {
+    let (name, rest) = parse_name(input);
+
+    if name.is_empty() {
+        return Err(CommandLineError::NotEnoughArgs("add-auto".to_owned(), 2));
+    }
+
+    let parsed_goal = parse_goal(rest);
+
+    if parsed_goal.is_none() {
+        return Err(CommandLineError::InvalidArg(2));
+    }
+
+    Ok(Command::Add(name, parsed_goal.unwrap().0, true))
+}
+
+fn parse_delete(input: &str) -> Result<Command> {
+    let (name, _) = parse_name(input);
+
+    if name.is_empty() {
+        return Err(CommandLineError::NotEnoughArgs("delete".to_owned(), 1));
+    }
+
+    Ok(Command::Delete(name))
+}
+
+fn parse_track_up(input: &str) -> Result<Command> {
+    let (name, _) = parse_name(input);
+
+    if name.is_empty() {
+        return Err(CommandLineError::NotEnoughArgs("track-up".to_owned(), 1));
+    }
+
+    Ok(Command::TrackUp(name))
+}
+
+fn parse_track_down(input: &str) -> Result<Command> {
+    let (name, _) = parse_name(input);
+
+    if name.is_empty() {
+        return Err(CommandLineError::NotEnoughArgs("track-down".to_owned(), 1));
+    }
+
+    Ok(Command::TrackDown(name))
+}
+
+fn parse_help(input: &str) -> Result<Command> {
+    let (name, _) = parse_name(input);
+
+    if name.is_empty() {
+        return Ok(Command::Help(None));
+    }
+
+    Ok(Command::Help(Some(name)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_add_command() {
+        let inputs = ["add eat 2", "a eat 2"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Add(name, goal, auto) => {
+                    assert_eq!(name, "eat");
+                    assert_eq!(goal.unwrap(), 2);
+                    assert_eq!(auto, false);
                 }
-                return Ok(Command::Delete(args[0].to_string()));
+                _ => panic!(),
             }
-            "track-up" | "tup" => {
-                if args.is_empty() {
-                    return Err(CommandLineError::NotEnoughArgs(first, 1));
+        }
+    }
+
+    #[test]
+    fn parse_add_command_without_goal() {
+        let inputs = ["add eat", "a eat"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Add(name, goal, auto) => {
+                    assert_eq!(name, "eat");
+                    assert!(goal.is_none());
+                    assert_eq!(auto, false);
                 }
-                return Ok(Command::TrackUp(args[0].to_string()));
+                _ => panic!(),
             }
-            "track-down" | "tdown" => {
-                if args.is_empty() {
-                    return Err(CommandLineError::NotEnoughArgs(first, 1));
+        }
+    }
+
+    #[test]
+    fn parse_add_command_with_long_name() {
+        let inputs = ["add \"eat healthy\" 5", "a \"eat healthy\" 5"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Add(name, goal, auto) => {
+                    assert_eq!(name, "eat healthy");
+                    assert_eq!(goal.unwrap(), 5);
+                    assert_eq!(auto, false);
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_add_auto_command() {
+        let inputs = ["add-auto eat 2", "aa eat 2"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Add(name, goal, auto) => {
+                    assert_eq!(name, "eat");
+                    assert_eq!(goal.unwrap(), 2);
+                    assert_eq!(auto, true);
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_delete_command() {
+        let inputs = ["delete eat", "d eat"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Delete(name) => {
+                    assert_eq!(name, "eat");
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_delete_long_name_command() {
+        let inputs = ["delete \"eat healthy\"", "d \"eat healthy\""];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Delete(name) => {
+                    assert_eq!(name, "eat healthy");
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_track_up_command() {
+        let inputs = ["track-up eat", "tup eat"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::TrackUp(name) => {
+                    assert_eq!(name, "eat");
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_track_down_command() {
+        let inputs = ["track-down eat", "tdown eat"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::TrackDown(name) => {
+                    assert_eq!(name, "eat");
+                }
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn parse_help_command() {
+        let inputs = ["help add", "? add", "h add"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Help(name) => {
+                    assert_eq!(name.unwrap(), "add");
                 }
-                return Ok(Command::TrackDown(args[0].to_string()));
+                _ => panic!(),
             }
-            "h" | "?" | "help" => {
-                if args.is_empty() {
-                    return Ok(Command::Help(None));
+        }
+    }
+
+    #[test]
+    fn parse_help_global_command() {
+        let inputs = ["help", "?", "h"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            match result.unwrap() {
+                Command::Help(name) => {
+                    assert!(name.is_none());
                 }
-                return Ok(Command::Help(Some(args[0].to_string())));
+                _ => panic!(),
             }
-            "mprev" | "month-prev" => return Ok(Command::MonthPrev),
-            "mnext" | "month-next" => return Ok(Command::MonthNext),
-            "q" | "quit" => return Ok(Command::Quit),
-            "w" | "write" => return Ok(Command::Write),
-            "" => return Ok(Command::Blank),
-            s => return Err(CommandLineError::InvalidCommand(s.into())),
+        }
+    }
+
+    #[test]
+    fn parse_month_prev_command() {
+        let result = Command::from_string("mprev");
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Command::MonthPrev);
+    }
+
+    #[test]
+    fn parse_month_next_command() {
+        let result = Command::from_string("mnext");
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Command::MonthNext);
+    }
+
+    #[test]
+    fn parse_quit_command() {
+        let inputs = ["q", "quit"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), Command::Quit);
+        }
+    }
+
+    #[test]
+    fn parse_write_command() {
+        let inputs = ["w", "write"];
+
+        for input in inputs.iter() {
+            let result = Command::from_string(input);
+
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), Command::Write);
+        }
+    }
+
+    #[test]
+    fn parse_no_command() {
+        let result = Command::from_string("");
+
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), Command::Blank);
+    }
+
+    #[test]
+    fn parse_error_invalid_command() {
+        let input = "non-existing-command".to_owned();
+        let result = Command::from_string(&input);
+
+        assert!(result.is_err());
+        assert_eq!(
+            result.err().unwrap(),
+            CommandLineError::InvalidCommand(input)
+        );
+    }
+
+    #[test]
+    fn parse_error_not_enough_args() {
+        let test_cases = [
+            ("add", "add", 2),
+            ("add-auto", "add-auto", 2),
+            ("delete", "delete", 1),
+            ("track-up", "track-up", 1),
+            ("track-down", "track-down", 1),
+        ]
+        .iter()
+        .map(|(a, b, c)| (a.to_owned(), b.to_owned(), c));
+
+        for test_case in test_cases {
+            let result = Command::from_string(test_case.0);
+
+            assert!(result.is_err());
+            assert_eq!(
+                result.err().unwrap(),
+                CommandLineError::NotEnoughArgs(test_case.1.to_string(), *test_case.2)
+            );
+        }
+    }
+
+    #[test]
+    fn parse_error_invalid_arg() {
+        let test_cases = [
+            ("add habit n".to_owned(), 2),
+            ("add-auto habit n".to_owned(), 2),
+        ];
+
+        for test_case in test_cases.iter() {
+            let result = Command::from_string(&test_case.0);
+
+            assert!(result.is_err());
+            assert_eq!(
+                result.err().unwrap(),
+                CommandLineError::InvalidArg(test_case.1)
+            );
         }
     }
 }