mikros 0.3.0

An optionated crate to help building multi-purpose applications.
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#[derive(Debug)]
pub(crate) struct Args {
    pub config_path: Option<String>,
    help: bool,
    service_name: String,
}

impl Args {
    pub fn load() -> Self {
        let args: Vec<String> = std::env::args().collect();
        match Self::parse(&args) {
            Ok(args) => {
                if args.help {
                    Self::usage(&args.service_name);
                    std::process::exit(0);
                }

                args
            }
            Err(msg) => {
                eprintln!("{msg}");
                std::process::exit(1);
            }
        }
    }

    fn parse(args: &[String]) -> Result<Self, String> {
        let mut config = Args {
            help: false,
            config_path: None,
            service_name: args[0].clone(),
        };

        let mut iter = args.iter().enumerate().peekable();

        // Skips the service name
        iter.next();

        // Parse other arguments
        while let Some((_, arg)) = iter.next() {
            match arg.as_str() {
                "-h" | "--help" => {
                    config.help = true;
                }
                "--config" => match iter.peek() {
                    None => return Err("error: --config option requires a file path".to_string()),
                    Some((_, next_arg)) => {
                        config.config_path = Some((*next_arg).to_string());
                        iter.next();
                    }
                },
                _ => {
                    return Err(format!("unknown argument: {arg}"));
                }
            }
        }

        Ok(config)
    }

    fn usage(service_name: &str) {
        println!("Usage: {service_name} [OPTIONS]");
        println!();
        println!("Options:");
        println!("  -h, --help      Print this help menu.");
        println!("  --config <path> Specify an alternative 'service.toml' config file.");
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_no_args() {
        let args = vec!["service".to_string()];
        let result = Args::parse(&args);
        assert!(result.is_ok());
        assert_eq!(result.unwrap().help, false);
    }

    #[test]
    fn test_help() {
        let args = vec!["service".to_string(), "--help".to_string()];
        let result = Args::parse(&args);
        assert!(result.is_ok());
        assert_eq!(result.unwrap().help, true);
    }

    #[test]
    fn test_config_option() {
        let args = vec![
            "service".to_string(),
            "--config".to_string(),
            "/path/to/service.toml".to_string(),
        ];
        let result = Args::parse(&args);
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap().config_path.unwrap(),
            "/path/to/service.toml"
        );
    }

    #[test]
    fn test_missing_config_path_option() {
        let args = vec!["service".to_string(), "--config".to_string()];
        let result = Args::parse(&args);
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err(),
            "error: --config option requires a file path"
        );
    }

    #[test]
    fn test_unknown_option() {
        let args = vec!["service".to_string(), "--unknown".to_string()];
        let result = Args::parse(&args);
        assert!(result.is_err());
        assert_eq!(result.err().unwrap(), "unknown argument: --unknown");
    }
}