clap-serde 0.5.0

Provides a wrapper to deserialize clap app using serde.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use clap::builder::ValueParser as VP;
use serde::Deserialize;

macro_rules! enum_de_value {
    ($basety : ident, $newty :ident,
        $(#[$derive_meta:meta])*
        {
            $( $(
                #[ $cfg_meta_ex:meta ] )?
                $var_ex: ident $( { $( $(#[$cfg_v:meta])* $vx: ident : $vt: ty ),* } )?
                    => $to_ex: expr
            ,)*
        }
        {
            $(($pty: ty, $pty_upper : tt $(, $ty_as: ty)?)),*
        }
    ) => {
        enum_de!($basety, $newty,
            $(#[$derive_meta])* {}
            {
                $( $(
                    #[ $cfg_meta_ex ] )?
                    $var_ex $( { $( $(#[$cfg_v])* $vx : $vt ),* } )?
                        => $to_ex
                ,)*
                $(
                $pty_upper {
                    #[serde(skip_serializing_if = "Option::is_none")]
                    min: Option<$pty>,
                    #[serde(skip_serializing_if = "Option::is_none")]
                    max: Option<$pty>,
                    #[serde(default = "get_true")]
                    max_inclusive: bool
                } => {
                    match (min, max, max_inclusive) {
                        (Some(s), Some(e), false) => clap::value_parser!($pty).range((s $(as $ty_as)*) ..(e $(as $ty_as)*)).into(),
                        (Some(s), Some(e), true) => clap::value_parser!($pty).range((s $(as $ty_as)*) ..=(e $(as $ty_as)*)).into(),
                        (Some(s), None, _) => clap::value_parser!($pty).range((s $(as $ty_as)*)..).into(),
                        (None, Some(e), false) => clap::value_parser!($pty).range(..(e $(as $ty_as)*)).into(),
                        (None, Some(e), true) => clap::value_parser!($pty).range(..=(e $(as $ty_as)*)).into(),
                        (None, None, _) => clap::value_parser!($pty).into(),
                    }
                },)*
            }
        );
    };
}

const fn get_true() -> bool {
    true
}

enum_de_value!(VP, ValueParser1,
    #[derive(Deserialize, Clone, Copy)]
    #[serde(tag = "type")]
    #[cfg_attr(feature = "kebab-case-key" ,serde(rename_all = "kebab-case"))]
    #[cfg_attr(feature = "snake-case-key" ,serde(rename_all = "snake_case"))]
    {
        Bool => {
            VP::bool()
        },
        String => {
            VP::string()
        },
        OsString => {
            VP::os_string()
        },
        PathBuf => {
            VP::path_buf()
        },
        Boolish => {
            clap::builder::BoolishValueParser::new().into()
        },
        Falsey => {
            clap::builder::FalseyValueParser::new().into()
        },
        NonEmptyString => {
            clap::builder::NonEmptyStringValueParser::new().into()
        },
    }
    {
        (i64, I64),
        (i32, I32, i64),
        (i16, I16, i64),
        (i8 , I8, i64),
        (u64, U64),
        (u32, U32, i64),
        (u16, U16, i64),
        (u8 , U8, i64)
    }
);

enum_de!(VP, ValueParser2,
    #[derive(Deserialize, Clone, Copy)]
    #[cfg_attr(feature = "kebab-case-key" ,serde(rename_all = "kebab-case"))]
    #[cfg_attr(feature = "snake-case-key" ,serde(rename_all = "snake_case"))]
    {}
    {
        Bool => {
            VP::bool()
        },
        String => {
            VP::string()
        },
        OsString => {
            VP::os_string()
        },
        PathBuf => {
            VP::path_buf()
        },
        Boolish => {
            clap::builder::BoolishValueParser::new().into()
        },
        Falsey => {
            clap::builder::FalseyValueParser::new().into()
        },
        NonEmptyString => {
            clap::builder::NonEmptyStringValueParser::new().into()
        },
        I64 => {
            clap::value_parser!(i64).into()
        },
        I32 => {
            clap::value_parser!(i32).into()
        },
        I16 => {
            clap::value_parser!(i16).into()
        },
        I8 => {
            clap::value_parser!(i8).into()
        },
        U64 => {
            clap::value_parser!(u64).into()
        },
        U32 => {
            clap::value_parser!(u32).into()
        },
        U16 => {
            clap::value_parser!(u16).into()
        },
        U8 => {
            clap::value_parser!(u8).into()
        },
    }
);

#[derive(Deserialize)]
#[serde(untagged)]
pub(crate) enum ValueParser {
    Value(ValueParser2),
    Tagged(ValueParser1),
}

impl From<ValueParser> for VP {
    fn from(v: ValueParser) -> Self {
        match v {
            ValueParser::Value(v) => v.into(),
            ValueParser::Tagged(t) => t.into(),
        }
    }
}