clargs 1.0.0

A command-line arguments parsing library.
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
124
125
126
127
128
129
130
131
132

extern crate clargs;

#[test]
fn a_test1() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);

    let args = ["clargs", "param=value"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::UnrecognizedOption(String::from("param")));
}

#[test]
fn a_test2() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.add_flag(String::from("flag"));

    let args = ["clargs", "flag=value"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::AssignmentToFlag(String::from("flag")));
}

#[test]
fn a_test3() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.add_flag(String::from("flag"));
    config.add_alias(String::from("alias"), String::from("flag"));

    let args = ["clargs", "alias=value"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::AssignmentToFlagAlias(String::from("flag"), String::from("alias")));
}

#[test]
fn a_test4() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.add_param(String::from("param"), true);

    let args = ["clargs"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::MissingRequiredParameters(vec![String::from("param")]));
}

#[test]
fn a_test5() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.set_parameter_duplication(false);
    config.add_param(String::from("param"), false);

    let args = ["clargs", "param=value1", "param=value2"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::ParameterDuplication(String::from("param")));
}

#[test]
fn a_test6() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.set_parameter_duplication(false);
    config.add_param(String::from("param"), false);
    config.add_alias(String::from("alias"), String::from("param"));

    let args = ["clargs", "param=value1", "alias=value2"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::ParameterDuplicationAlias(String::from("param"), String::from("alias")));
}

#[test]
fn a_test7() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.set_option_completion(true);
    config.add_param(String::from("param1"), false);
    config.add_param(String::from("param2"), false);

    let args = ["clargs", "par=value"];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).err().unwrap();
    assert_eq!(result, clargs::ParsingError::AmbiguousOption(String::from("par"), vec![String::from("param1"), String::from("param2")]));
}

#[test]
fn a_test8() {
    let mut config = clargs::ParsingConfig::new_all_disabled();
    config.set_assignment_syntax(true);
    config.set_parameter_duplication(true);
    config.set_option_completion(true);

    config.add_param(String::from("req1"), true);
    config.add_param(String::from("req2"), true);
    config.add_alias(String::from("req2_alias"), String::from("req2"));

    config.add_param(String::from("par1"), false);
    config.add_param(String::from("par2"), false);
    config.add_param(String::from("par3"), false);
    config.add_param(String::from("par4"), false);
    config.add_param(String::from("par5"), false);
    config.add_alias(String::from("par3_alias"), String::from("par3"));
    config.add_alias(String::from("par5_alias"), String::from("par5"));

    config.add_param(String::from("ab"), false);
    config.add_param(String::from("abcd"), false);
    config.add_param(String::from("abce"), false);
    config.add_param(String::from("completion"), false);


    let args = [
        "clargs",
        "req1=value_req1", "req2_alias=value_req2",
        "par1=value_par1", "par3_alias=value_par3",
        "par4=value_par4-1", "par4=value_par4-2", "par5=value_par5-1", "par5_alias=value_par5-2",
        "ab=value_ab", "abcd=value_abcd",
        "comp=value_completion"
    ];
    let result = clargs::parse(args.iter().map(|x| x.to_string()), &config).unwrap();

    assert_eq!(result.name(), "clargs");
    assert_eq!(result.get_param("req1"), Some("value_req1"));
    assert_eq!(result.get_param("req2"), Some("value_req2"));
    assert_eq!(result.get_param("par1"), Some("value_par1"));
    assert_eq!(result.get_param("par2"), None);
    assert_eq!(result.get_param("par3"), Some("value_par3"));
    assert_eq!(result.get_param("par4"), Some("value_par4-2"));
    assert_eq!(result.get_param("par5"), Some("value_par5-2"));
    assert_eq!(result.get_param("ab"), Some("value_ab"));
    assert_eq!(result.get_param("abcd"), Some("value_abcd"));
    assert_eq!(result.get_param("abce"), None);
    assert_eq!(result.get_param("completion"), Some("value_completion"));
}