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
45fn 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
59fn 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}