educe/trait_handlers/partial_eq/models/
field_attribute.rs

1use syn::{punctuated::Punctuated, Attribute, Meta, Path, Token};
2
3use crate::{
4    common::{
5        ident_bool::{meta_2_bool_allow_path, meta_name_value_2_bool},
6        path::meta_2_path,
7    },
8    panic,
9    supported_traits::Trait,
10};
11
12pub(crate) struct FieldAttribute {
13    pub(crate) ignore: bool,
14    pub(crate) method: Option<Path>,
15}
16
17pub(crate) struct FieldAttributeBuilder {
18    pub(crate) enable_ignore: bool,
19    pub(crate) enable_method: bool,
20}
21
22impl FieldAttributeBuilder {
23    pub(crate) fn build_from_partial_eq_meta(&self, meta: &Meta) -> syn::Result<FieldAttribute> {
24        debug_assert!(meta.path().is_ident("PartialEq") || meta.path().is_ident("Eq"));
25
26        let mut ignore = false;
27        let mut method = None;
28
29        let correct_usage_for_partial_eq_attribute = {
30            let mut usage = vec![];
31
32            if self.enable_ignore {
33                usage.push(stringify!(#[educe(PartialEq = false)]));
34                usage.push(stringify!(#[educe(PartialEq(ignore))]));
35            }
36
37            if self.enable_method {
38                usage.push(stringify!(#[educe(PartialEq(method(path_to_method)))]));
39            }
40
41            usage
42        };
43
44        match meta {
45            Meta::Path(_) => {
46                return Err(panic::attribute_incorrect_format(
47                    meta.path().get_ident().unwrap(),
48                    &correct_usage_for_partial_eq_attribute,
49                ));
50            },
51            Meta::NameValue(name_value) => {
52                if self.enable_ignore {
53                    ignore = !meta_name_value_2_bool(name_value)?;
54                } else {
55                    return Err(panic::attribute_incorrect_format(
56                        meta.path().get_ident().unwrap(),
57                        &correct_usage_for_partial_eq_attribute,
58                    ));
59                }
60            },
61            Meta::List(list) => {
62                let result =
63                    list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;
64
65                let mut ignore_is_set = false;
66                let mut method_is_set = false;
67
68                let mut handler = |meta: Meta| -> syn::Result<bool> {
69                    if let Some(ident) = meta.path().get_ident() {
70                        match ident.to_string().as_str() {
71                            "ignore" => {
72                                if !self.enable_ignore {
73                                    return Ok(false);
74                                }
75
76                                let v = meta_2_bool_allow_path(&meta)?;
77
78                                if ignore_is_set {
79                                    return Err(panic::parameter_reset(ident));
80                                }
81
82                                ignore_is_set = true;
83
84                                ignore = v;
85
86                                return Ok(true);
87                            },
88                            "method" => {
89                                if !self.enable_method {
90                                    return Ok(false);
91                                }
92
93                                let v = meta_2_path(&meta)?;
94
95                                if method_is_set {
96                                    return Err(panic::parameter_reset(ident));
97                                }
98
99                                method_is_set = true;
100
101                                method = Some(v);
102
103                                return Ok(true);
104                            },
105                            _ => (),
106                        }
107                    }
108
109                    Ok(false)
110                };
111
112                for p in result {
113                    if !handler(p)? {
114                        return Err(panic::attribute_incorrect_format(
115                            meta.path().get_ident().unwrap(),
116                            &correct_usage_for_partial_eq_attribute,
117                        ));
118                    }
119                }
120            },
121        }
122
123        Ok(FieldAttribute {
124            ignore,
125            method,
126        })
127    }
128
129    pub(crate) fn build_from_attributes(
130        &self,
131        attributes: &[Attribute],
132        traits: &[Trait],
133    ) -> syn::Result<FieldAttribute> {
134        let mut output = None;
135
136        for attribute in attributes.iter() {
137            let path = attribute.path();
138
139            if path.is_ident("educe") {
140                if let Meta::List(list) = &attribute.meta {
141                    let result =
142                        list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;
143
144                    for meta in result {
145                        let path = meta.path();
146
147                        let t = match Trait::from_path(path) {
148                            Some(t) => t,
149                            None => return Err(panic::unsupported_trait(meta.path())),
150                        };
151
152                        if !traits.contains(&t) {
153                            return Err(panic::trait_not_used(path.get_ident().unwrap()));
154                        }
155
156                        if t == Trait::PartialEq {
157                            if output.is_some() {
158                                return Err(panic::reuse_a_trait(path.get_ident().unwrap()));
159                            }
160
161                            output = Some(self.build_from_partial_eq_meta(&meta)?);
162                        }
163
164                        #[cfg(feature = "Eq")]
165                        if traits.contains(&Trait::Eq) && t == Trait::Eq {
166                            if output.is_some() {
167                                return Err(panic::reuse_a_trait(path.get_ident().unwrap()));
168                            }
169
170                            output = Some(self.build_from_partial_eq_meta(&meta)?);
171                        }
172                    }
173                }
174            }
175        }
176
177        Ok(output.unwrap_or(FieldAttribute {
178            ignore: false, method: None
179        }))
180    }
181}
educe/trait_handlers/partial_eq/models/field_attribute.rs

educe/trait_handlers/partial_eq/models/
field_attribute.rs
