config-manager 0.4.5

Crate to build config from environment, command line and files
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

use std::collections::HashMap;

use config_manager::config;
use serde::Deserialize;

use crate::{assert_ok_and_compare, test_env};

fn simple_field() {
    #[derive(Debug, PartialEq)]
    #[config(__debug_cmd_input__("--plain=1", "--long=2", "--specified-long=3", "-u=4", "-q=5"))]
    struct Simple {
        #[source(clap)]
        plain: i32,
        #[source(clap)]
        long: i32,
        #[source(clap(long = "specified-long"))]
        long2: i32,
        #[source(clap(short))]
        unspecified_short: i32,
        #[source(clap(short = 'q'))]
        short2: i32,
    }

    assert_ok_and_compare(&Simple {
        plain: 1,
        long: 2,
        long2: 3,
        unspecified_short: 4,
        short2: 5,
    })
}

fn complex_field() {
    #[derive(Debug, PartialEq, Deserialize)]
    enum Foo {
        Simple,
        Struct(Person),
        Map(HashMap<i32, bool>),
    }

    #[derive(Debug, PartialEq, Deserialize)]
    struct Person {
        name: String,
        last_name: Option<String>,
        age: Option<i32>,
    }

    #[derive(Debug, PartialEq)]
    #[config(__debug_cmd_input__(
        "--field=[
            \"Simple\",
            {\"Struct\": {
                \"name\": \"Mike\",
                \"last_name\": null,
                \"age\": 22
            }},
            {\"Map\": {
                1: false,
                2: false,
                42: true
            }}
        ]"
    ))]
    struct Complex {
        #[source(clap)]
        field: Vec<Foo>,
    }

    assert_ok_and_compare(&Complex {
        field: vec![
            Foo::Simple,
            Foo::Struct(Person {
                name: "Mike".into(),
                last_name: None,
                age: Some(22),
            }),
            Foo::Map(HashMap::from_iter([(1, false), (2, false), (42, true)])),
        ],
    })
}

fn flags() {
    #[derive(Debug, PartialEq)]
    #[config(__debug_cmd_input__("--flag_setted", "-e=false"))]
    struct Flags {
        #[source(clap(flag))]
        flag_setted: bool,
        #[source(clap(flag), default = false)]
        flag_unsetted: bool,
        #[source(clap(short, flag), default = true)]
        explicit_flag: bool,
    }

    assert_ok_and_compare(&Flags {
        flag_setted: true,
        flag_unsetted: false,
        explicit_flag: false,
    })
}

#[test]
fn clap() {
    test_env(vec![simple_field, complex_field, flags]);
}