taskman 0.1.0

Cli for the task management.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::commands::{Command, CreateTask, DeleteTask, GetTasks};

pub(crate) fn parse(args: Vec<String>) -> Result<Command, ParseError> {
    let str_cmd = args.get(1).unwrap();
    match str_cmd.as_str() {
        "create" => match args.get(2).unwrap().as_str() {
            "task" => Ok(Command::CreateTask(CreateTask)),
            _ => Err(ParseError::ParseCommandError(
                "Parse command error!".to_string(),
            )),
        },
        "get" => match args.get(2).unwrap().as_str() {
            "tasks" => Ok(Command::GetTasks(GetTasks::from(None, None))),
            _ => Err(ParseError::ParseCommandError(
                "This command does not exist!".to_string(),
            )),
        },
        "delete" => match args.get(2).unwrap().as_str() {
            "task" => {
                let id = args
                    .iter()
                    .filter(|s| "-id=" == &s[0..=3])
                    .map(|x| String::from(&x[4..]))
                    .collect::<Vec<String>>()
                    .get(0)
                    .unwrap()
                    .parse::<u64>()
                    .unwrap();

                Ok(Command::DeleteTask(DeleteTask { id }))
            }
            _ => todo!(),
        },
        _ => todo!(),
    }
}

#[derive(Debug)]
pub(crate) enum ParseError {
    ParseCommandError(String),
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::commands::{Command, CreateTask, DeleteTask, GetTasks};
    use std::matches;

    #[test]
    fn parse_create_task_command() {
        let test_args = vec!["path".to_string(), "create".to_string(), "task".to_string()];
        let command = parse(test_args);
        assert!(matches!(Command::CreateTask(CreateTask), command));
    }
    #[test]
    fn parse_get_tasks_command_with_none_values() {
        let test_args = vec!["path".to_string(), "get".to_string(), "tasks".to_string()];
        let command = parse(test_args).unwrap();
        assert!(matches!(
            Command::GetTasks(GetTasks::from(None, None)),
            command
        ));
        match command {
            Command::GetTasks(get_tasks) => {
                assert_eq!(get_tasks.page_number, None);
                assert_eq!(get_tasks.page_size, None);
            }
            _ => panic!("Command must be GetTasks"),
        }
    }
}