kutil-cli-macros 0.0.7

Procedural macros for kutil::cli
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

use super::{super::attributes::*, generator::*};

use {proc_macro2::*, quote::*};

impl EnumGenerator {
    /// Generate variant handler.
    pub fn generate_handle_variant(&self, variant: &Variant) -> TokenStream {
        let variant_name = &variant.name;

        let write_variant = if self.enum_attribute.variant {
            let quoted_enum_name = self.enum_name.to_string().to_token_stream();
            let quoted_variant_name = variant.name.to_string().to_token_stream();
            quote! {
                if match context.configuration.get("variant") {
                    Some(variant) => variant == "true",
                    None => true,
                } {
                    context.separate(writer)?;
                    ::std::write!(writer, "{}{}{}",
                        context.theme.symbol(#quoted_enum_name),
                        context.theme.delimiter("::"),
                        context.theme.symbol(#quoted_variant_name),
                    )?;
                }
            }
        } else {
            Default::default()
        };

        let write_value = variant.attribute.value_as.generate_write_value(&variant.attribute.value_style);

        let mut write = match &variant.attribute.iter {
            Iter::None => quote! {
                let child_context = context;
                #write_value
            },

            Iter::Item => quote! {
                let child_context = context;
                let mut empty = true;

                for item in value {
                    empty = false;

                    child_context.indent_into(writer, ::kutil::cli::depict::utils::DEPICT_INTO_LIST_ITEM)?;
                    let value = item;
                    #write_value
                }

                if empty {
                    context.separate(writer)?;
                    context.theme.write_delimiter(writer, "[]")?;
                }
            },

            Iter::KeyValue => {
                let write_key = variant.attribute.key_as.generate_write_value(&variant.attribute.key_style);
                quote! {
                    let item_context = context;
                    let mut empty = true;

                    {
                        use ::kutil::cli::depict::DepictionFormatUtilities;
                        match item_context.get_format() {
                            ::kutil::cli::depict::DepictionFormat::Optimized => {
                                let key_context = item_context.child().with_separator(true).with_format(::kutil::cli::depict::DepictionFormat::Compact);
                                let value_context = item_context.child().with_inline(true).with_separator(true).increase_indentation();

                                for (k, v) in value {
                                    empty = false;

                                    item_context.indent_into(writer, ::kutil::cli::depict::utils::DEPICT_INTO_MAP_ENTRY)?;
                                    let value = k;
                                    let child_context = key_context;
                                    #write_key

                                    context.theme.write_delimiter(writer, ::kutil::cli::depict::utils::DEPICT_MAP_ENTRY_SEPARATOR)?;
                                    let value = v;
                                    let child_context = value_context;
                                    #write_value
                                }
                            }

                            _ => {
                                let child_context = item_context;

                                for (k, v) in value {
                                    empty = false;

                                    item_context.indent_into(writer, ::kutil::cli::depict::utils::DEPICT_INTO_MAP_KEY)?;
                                    let value = k;
                                    #write_key

                                    item_context.indent_into(writer, ::kutil::cli::depict::utils::DEPICT_INTO_MAP_VALUE)?;
                                    let value = v;
                                    #write_value
                                }
                            }
                        }
                    }

                    if empty {
                        context.separate(writer)?;
                        context.theme.write_delimiter(writer, "{}")?;
                    }
                }
            }
        };

        write = match &variant.attribute.option {
            true => quote! {
                match value {
                    ::std::option::Option::Some(value) => {
                        context.separate(writer)?;
                        context.theme.write_symbol(writer, "Some")?;
                        #write
                    },

                    ::std::option::Option::None => {
                        context.separate(writer)?;
                        context.theme.write_symbol(writer, "None")?;
                    },
                }
            },

            false => quote! {
                #write
            },
        };

        if variant.has_fields {
            quote! {
                Self::#variant_name(value) => {
                    #write_variant
                    #write
                },
            }
        } else {
            quote! {
                Self::#variant_name => {
                    #write_variant
                },
            }
        }
    }
}