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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
use std::process::exit;

use crate::{actions::Action, eusage};

#[derive(Default)]
pub struct Config {
    pub action: Option<Action>,
}
impl Config {
    pub fn parse(args: &[String]) -> Self {
        let mut config = Config::default();
        let mut args = args.iter();

        if let Some(action) = args.next() {
            match action.as_str() {
                "init" => {
                    let name = args
                        .next()
                        .unwrap_or_else(|| {
                            eusage();
                            exit(1);
                        })
                        .to_string();
                    let dependencies = if let Some(deps_flag) = args.next() {
                        if deps_flag == "-d" || deps_flag == "--deps" {
                            let mut deps = vec![];
                            for dep in args.by_ref() {
                                deps.push(dep.to_string());
                            }
                            Some(deps)
                        } else {
                            None
                        }
                    } else {
                        None
                    };
                    config.action = Some(Action::Init { name, dependencies })
                }
                "new" | "add" => {
                    let name = args
                        .next()
                        .unwrap_or_else(|| {
                            eusage();
                            exit(1);
                        })
                        .to_string();

                    let mut version = None;
                    let mut path_to_snippet = None;
                    let mut features = None;
                    while let Some(arg) = args.next() {
                        match arg.as_str() {
                            "-v" | "--version" => {
                                if let Some(ver) = args.next() {
                                    version = Some(ver.to_string());
                                }
                            }
                            "-p" | "--path" => {
                                if let Some(pts) = args.next() {
                                    path_to_snippet = Some(pts.to_string());
                                }
                            }
                            "-f" | "--features" => {
                                let mut fs = vec![];
                                for feature in args.by_ref() {
                                    fs.push(feature.to_string())
                                }
                                if !fs.is_empty() {
                                    features = Some(fs);
                                }
                            }
                            _ => {}
                        }
                    }
                    config.action = Some(Action::NewDependency {
                        name,
                        version,
                        features,
                        path_to_snippet,
                    })
                }
                "list" | "all" | "show-all" => config.action = Some(Action::List),
                "h" | "-h" | "help" | "--help" => config.action = Some(Action::Help),
                _ => {
                    eusage();
                    exit(1);
                }
            }
        }
        config
    }
    pub fn make_action(&self) {
        if let Some(act) = &self.action {
            match act {
                Action::Init { name, dependencies } => Action::init(name, dependencies),
                Action::NewDependency {
                    name,
                    version,
                    features,
                    path_to_snippet,
                } => Action::add_new(name, version, features, path_to_snippet),
                Action::List => Action::list(),
                Action::Help => eusage(),
            }
        }
    }
}