strum_macros/helpers/
variant_props.rs

1use std::default::Default;
2use syn::{Ident, LitStr, Variant};
3
4use super::case_style::{CaseStyle, CaseStyleHelpers};
5use super::metadata::{kw, VariantExt, VariantMeta};
6use super::occurrence_error;
7
8pub trait HasStrumVariantProperties {
9    fn get_variant_properties(&self) -> syn::Result<StrumVariantProperties>;
10}
11
12#[derive(Clone, Eq, PartialEq, Debug, Default)]
13pub struct StrumVariantProperties {
14    pub disabled: Option<kw::disabled>,
15    pub default: Option<kw::default>,
16    pub ascii_case_insensitive: Option<bool>,
17    pub message: Option<LitStr>,
18    pub detailed_message: Option<LitStr>,
19    pub documentation: Vec<LitStr>,
20    pub string_props: Vec<(LitStr, LitStr)>,
21    serialize: Vec<LitStr>,
22    pub to_string: Option<LitStr>,
23    ident: Option<Ident>,
24}
25
26impl StrumVariantProperties {
27    fn ident_as_str(&self, case_style: Option<CaseStyle>) -> LitStr {
28        let ident = self.ident.as_ref().expect("identifier");
29        LitStr::new(&ident.convert_case(case_style), ident.span())
30    }
31
32    pub fn get_preferred_name(&self, case_style: Option<CaseStyle>) -> LitStr {
33        self.to_string.as_ref().cloned().unwrap_or_else(|| {
34            self.serialize
35                .iter()
36                .max_by_key(|s| s.value().len())
37                .cloned()
38                .unwrap_or_else(|| self.ident_as_str(case_style))
39        })
40    }
41
42    pub fn get_serializations(&self, case_style: Option<CaseStyle>) -> Vec<LitStr> {
43        let mut attrs = self.serialize.clone();
44        if let Some(to_string) = &self.to_string {
45            attrs.push(to_string.clone());
46        }
47
48        if attrs.is_empty() {
49            attrs.push(self.ident_as_str(case_style));
50        }
51
52        attrs
53    }
54}
55
56impl HasStrumVariantProperties for Variant {
57    fn get_variant_properties(&self) -> syn::Result<StrumVariantProperties> {
58        let mut output = StrumVariantProperties {
59            ident: Some(self.ident.clone()),
60            ..Default::default()
61        };
62
63        let mut message_kw = None;
64        let mut detailed_message_kw = None;
65        let mut to_string_kw = None;
66        let mut disabled_kw = None;
67        let mut default_kw = None;
68        let mut ascii_case_insensitive_kw = None;
69        for meta in self.get_metadata()? {
70            match meta {
71                VariantMeta::Message { value, kw } => {
72                    if let Some(fst_kw) = message_kw {
73                        return Err(occurrence_error(fst_kw, kw, "message"));
74                    }
75
76                    message_kw = Some(kw);
77                    output.message = Some(value);
78                }
79                VariantMeta::DetailedMessage { value, kw } => {
80                    if let Some(fst_kw) = detailed_message_kw {
81                        return Err(occurrence_error(fst_kw, kw, "detailed_message"));
82                    }
83
84                    detailed_message_kw = Some(kw);
85                    output.detailed_message = Some(value);
86                }
87                VariantMeta::Documentation { value } => {
88                    output.documentation.push(value);
89                }
90                VariantMeta::Serialize { value, .. } => {
91                    output.serialize.push(value);
92                }
93                VariantMeta::ToString { value, kw } => {
94                    if let Some(fst_kw) = to_string_kw {
95                        return Err(occurrence_error(fst_kw, kw, "to_string"));
96                    }
97
98                    to_string_kw = Some(kw);
99                    output.to_string = Some(value);
100                }
101                VariantMeta::Disabled(kw) => {
102                    if let Some(fst_kw) = disabled_kw {
103                        return Err(occurrence_error(fst_kw, kw, "disabled"));
104                    }
105
106                    disabled_kw = Some(kw);
107                    output.disabled = Some(kw);
108                }
109                VariantMeta::Default(kw) => {
110                    if let Some(fst_kw) = default_kw {
111                        return Err(occurrence_error(fst_kw, kw, "default"));
112                    }
113
114                    default_kw = Some(kw);
115                    output.default = Some(kw);
116                }
117                VariantMeta::AsciiCaseInsensitive { kw, value } => {
118                    if let Some(fst_kw) = ascii_case_insensitive_kw {
119                        return Err(occurrence_error(fst_kw, kw, "ascii_case_insensitive"));
120                    }
121
122                    ascii_case_insensitive_kw = Some(kw);
123                    output.ascii_case_insensitive = Some(value);
124                }
125                VariantMeta::Props { props, .. } => {
126                    output.string_props.extend(props);
127                }
128            }
129        }
130
131        Ok(output)
132    }
133}
strum_macros/helpers/variant_props.rs

strum_macros/helpers/
variant_props.rs
