Skip to main content

isomdl_macros/
lib.rs

1mod from_json;
2mod to_cbor;
3
4use proc_macro::{self, TokenStream};
5use syn::{Attribute, Lit, Meta, NestedMeta, Type};
6
7#[proc_macro_derive(FromJson, attributes(isomdl))]
8pub fn derive_from_json(input: TokenStream) -> TokenStream {
9    from_json::derive(input)
10}
11
12#[proc_macro_derive(ToCbor, attributes(isomdl))]
13pub fn derive_to_cbor(input: TokenStream) -> TokenStream {
14    to_cbor::derive(input)
15}
16
17fn is_dynamic_parse(attr: &Attribute) -> bool {
18    match get_isomdl_attributes(attr) {
19        Some(ms) => ms,
20        None => return false,
21    }
22    .any(|nested_meta| {
23        let meta = match nested_meta {
24            NestedMeta::Meta(meta) => meta,
25            _ => return false,
26        };
27        meta.path().is_ident("dynamic_parse") || meta.path().is_ident("many")
28    })
29}
30
31fn is_many(attr: &Attribute) -> bool {
32    match get_isomdl_attributes(attr) {
33        Some(ms) => ms,
34        None => return false,
35    }
36    .any(|nested_meta| {
37        let meta = match nested_meta {
38            NestedMeta::Meta(meta) => meta,
39            _ => return false,
40        };
41        meta.path().is_ident("many")
42    })
43}
44
45// If the type is an `Option<T>` return true.
46fn is_optional(ty: &Type) -> bool {
47    let p = if let Type::Path(p) = ty {
48        p
49    } else {
50        return false;
51    };
52
53    match p.path.segments.last() {
54        Some(last) => last.ident == "Option",
55        None => false,
56    }
57}
58
59// Attribute for setting the path to the isomdl crate, mostly for use
60// internally in isomdl to refer to itself as 'crate'.
61fn crate_path(attr: &Attribute) -> Option<String> {
62    get_isomdl_attributes(attr)?
63        .filter_map(|nested_meta| {
64            let meta = match nested_meta {
65                NestedMeta::Meta(meta) => meta,
66                _ => return None,
67            };
68            match meta {
69                Meta::NameValue(pair) => {
70                    if !pair.path.is_ident("crate") {
71                        return None;
72                    }
73                    if let Lit::Str(s) = pair.lit {
74                        Some(s.value())
75                    } else {
76                        None
77                    }
78                }
79                _ => None,
80            }
81        })
82        .next()
83}
84
85fn rename(attr: &Attribute) -> Option<String> {
86    get_isomdl_attributes(attr)?
87        .filter_map(|nested_meta| {
88            let meta = match nested_meta {
89                NestedMeta::Meta(meta) => meta,
90                _ => return None,
91            };
92            match meta {
93                Meta::NameValue(pair) => {
94                    if !pair.path.is_ident("rename") {
95                        return None;
96                    }
97                    if let Lit::Str(s) = pair.lit {
98                        Some(s.value())
99                    } else {
100                        None
101                    }
102                }
103                _ => None,
104            }
105        })
106        .next()
107}
108
109fn get_isomdl_attributes(attr: &Attribute) -> Option<syn::punctuated::IntoIter<NestedMeta>> {
110    match attr.parse_meta().ok()? {
111        Meta::List(ml) => {
112            if !ml.path.is_ident("isomdl") {
113                return None;
114            }
115            Some(ml.nested.into_iter())
116        }
117        _ => None,
118    }
119}
120
121#[cfg(test)]
122mod test {
123    use syn::{parse_str, Data, DeriveInput};
124
125    #[test]
126    fn is_optional() {
127        let input: DeriveInput = parse_str(
128            r#"
129            struct S {
130                field: Option<String>,
131            }
132        "#,
133        )
134        .unwrap();
135
136        let ty = match input.data {
137            Data::Struct(s) => s,
138            _ => panic!("unexpected input"),
139        }
140        .fields
141        .iter_mut()
142        .next()
143        .unwrap()
144        .ty
145        .clone();
146
147        assert!(super::is_optional(&ty));
148
149        let input: DeriveInput = parse_str(
150            r#"
151            struct S {
152                field: Vec<Option<String>>,
153            }
154        "#,
155        )
156        .unwrap();
157
158        let ty = match input.data {
159            Data::Struct(s) => s,
160            _ => panic!("unexpected input"),
161        }
162        .fields
163        .iter_mut()
164        .next()
165        .unwrap()
166        .ty
167        .clone();
168
169        assert!(!super::is_optional(&ty))
170    }
171
172    #[test]
173    fn is_dynamic_parse() {
174        let input: DeriveInput = parse_str(
175            r#"
176            struct S {
177                #[isomdl(many)]
178                field: String,
179            }
180        "#,
181        )
182        .unwrap();
183
184        let attr = match input.data {
185            Data::Struct(s) => s,
186            _ => panic!("unexpected input"),
187        }
188        .fields
189        .iter_mut()
190        .next()
191        .unwrap()
192        .attrs
193        .pop()
194        .unwrap();
195
196        assert!(super::is_dynamic_parse(&attr));
197
198        let input: DeriveInput = parse_str(
199            r#"
200            struct S {
201                #[isomdl(dynamic_parse)]
202                field: String,
203            }
204        "#,
205        )
206        .unwrap();
207
208        let attr = match input.data {
209            Data::Struct(s) => s,
210            _ => panic!("unexpected input"),
211        }
212        .fields
213        .iter_mut()
214        .next()
215        .unwrap()
216        .attrs
217        .pop()
218        .unwrap();
219
220        assert!(super::is_dynamic_parse(&attr))
221    }
222
223    #[test]
224    fn is_many() {
225        let input: DeriveInput = parse_str(
226            r#"
227            struct S {
228                #[isomdl(many)]
229                field: String,
230            }
231        "#,
232        )
233        .unwrap();
234
235        let attr = match input.data {
236            Data::Struct(s) => s,
237            _ => panic!("unexpected input"),
238        }
239        .fields
240        .iter_mut()
241        .next()
242        .unwrap()
243        .attrs
244        .pop()
245        .unwrap();
246
247        assert!(super::is_many(&attr))
248    }
249
250    #[test]
251    fn rename() {
252        let input: DeriveInput = parse_str(
253            r#"
254            struct S {
255                #[isomdl(rename = "test")]
256                field: String,
257            }
258        "#,
259        )
260        .unwrap();
261
262        let attr = match input.data {
263            Data::Struct(s) => s,
264            _ => panic!("unexpected input"),
265        }
266        .fields
267        .iter_mut()
268        .next()
269        .unwrap()
270        .attrs
271        .pop()
272        .unwrap();
273
274        assert_eq!("test", super::rename(&attr).unwrap())
275    }
276
277    #[test]
278    fn multiple() {
279        let input: DeriveInput = parse_str(
280            r#"
281            struct S {
282                #[isomdl(many, rename = "test")]
283                field: String,
284            }
285        "#,
286        )
287        .unwrap();
288
289        let attr = match input.data {
290            Data::Struct(s) => s,
291            _ => panic!("unexpected input"),
292        }
293        .fields
294        .iter_mut()
295        .next()
296        .unwrap()
297        .attrs
298        .pop()
299        .unwrap();
300
301        assert_eq!("test", super::rename(&attr).unwrap());
302        assert!(super::is_many(&attr));
303        assert!(super::is_dynamic_parse(&attr))
304    }
305}