cote-derive 0.12.2

Quickly build your command line utils
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

use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{Ident, Path};

use super::Kind;
use super::Style;

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum ArgKind {
    Name,

    Type,

    Hint,

    Help,

    Value,

    Values,

    SCValues,

    Alias,

    Index,

    Force,

    Action,

    Validator,

    On,

    Fallback,

    Then,

    NoDelay,

    Fetch,

    Append,

    Count,

    MethodCall(String),
}

impl Kind for ArgKind {
    fn parse(input: &mut syn::parse::ParseStream) -> syn::Result<(Self, Style)> {
        let path: Path = input.parse()?;

        if let Some(ident) = path.get_ident() {
            let kind_str = ident.to_string();

            Ok(match kind_str.as_str() {
                "name" => (Self::Name, Style::Value),
                "ty" => (Self::Type, Style::Value),
                "hint" => (Self::Hint, Style::Value),
                "help" => (Self::Help, Style::Value),
                "value" => (Self::Value, Style::Value),
                "values" => (Self::Values, Style::Value),
                "scvalues" => (Self::SCValues, Style::Value),
                "alias" => (Self::Alias, Style::Value),
                "index" => (Self::Index, Style::Value),
                "force" => (Self::Force, Style::Value),
                "action" => (Self::Action, Style::Value),
                "valid" => (Self::Validator, Style::Value),
                "on" => (Self::On, Style::Value),
                "fallback" => (Self::Fallback, Style::Value),
                "then" => (Self::Then, Style::Value),
                "nodelay" => (Self::NoDelay, Style::Flag),
                "fetch" => (Self::Fetch, Style::Value),
                "append" => (Self::Append, Style::Flag),
                "count" => (Self::Count, Style::Flag),
                method => (Self::MethodCall(method.to_owned()), Style::Value),
            })
        } else {
            let method = path.to_token_stream().to_string();
            let method = method.replace(char::is_whitespace, "");

            Ok((Self::MethodCall(method), Style::Value))
        }
    }
}

impl ArgKind {
    pub fn simple(&self, ident: &Ident, val: TokenStream) -> syn::Result<TokenStream> {
        match self {
            ArgKind::Name => Ok(quote! {
                cote::prelude::ConfigValue::set_name(&mut #ident, #val);
            }),
            ArgKind::Hint => Ok(quote! {
                cote::prelude::ConfigValue::set_hint(&mut #ident, #val);
            }),

            ArgKind::Help => Ok(quote! {
                cote::prelude::ConfigValue::set_help(&mut #ident, #val);
            }),
            ArgKind::Value => Ok(quote! {
                cote::prelude::ConfigValue::set_initializer(&mut #ident, cote::prelude::ValInitializer::new_value(#val));
            }),
            ArgKind::Values => Ok(quote! {
                cote::prelude::ConfigValue::set_initializer(&mut #ident, cote::prelude::ValInitializer::new_values(#val));
            }),
            ArgKind::Alias => Ok(quote! {
                cote::prelude::ConfigValue::add_alias(&mut #ident, #val);
            }),
            ArgKind::Index => Ok(quote! {
                cote::prelude::ConfigValue::set_index(&mut #ident, <cote::prelude::Index as std::convert::TryFrom::<_>>::try_from(#val)?);
            }),
            ArgKind::Force => Ok(quote! {
                cote::prelude::ConfigValue::set_force(&mut #ident, #val);
            }),
            ArgKind::Action => Ok(quote! {
                cote::prelude::ConfigValue::set_action(&mut #ident, #val);
            }),
            ArgKind::Validator => Ok(quote! {
                cote::prelude::ConfigValue::set_storer(&mut #ident, #val);
            }),
            ArgKind::Append => Ok(quote! {
                cote::prelude::ConfigValue::set_action(&mut #ident, cote::prelude::Action::App);
            }),
            ArgKind::Count => Ok(quote! {
                cote::prelude::ConfigValue::set_action(&mut #ident, cote::prelude::Action::Cnt);
            }),
            _ => Err(crate::error(ident.span(), "")),
        }
    }
}