batbox-derive 0.13.0

Batteries useful for projects (derive macros)
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

use super::*;

enum DiffMode {
    Diff,
    Clone,
    Eq,
}

pub fn derive(input: TokenStream) -> TokenStream {
    let s = input.to_string();
    let ast: syn::DeriveInput = syn::parse_str(&s).unwrap();
    let input_type = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let generics = &ast.generics;
    match ast.data {
        syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
            let field_tys: Vec<_> = fields.iter().map(|field| &field.ty).collect();
            let field_tys = &field_tys;
            let field_names: Vec<_> = fields
                .iter()
                .map(|field| field.ident.as_ref().unwrap())
                .collect();
            let field_names = &field_names;
            let delta_type = syn::Ident::new(
                &format!("{}Delta", input_type),
                proc_macro2::Span::call_site(),
            );

            let field_diff_modes: Vec<DiffMode> = fields
                .iter()
                .map(|field| {
                    let mut diff_type = DiffMode::Diff;
                    for attr in &field.attrs {
                        if let Ok(syn::Meta::NameValue(syn::MetaNameValue {
                            path: ref meta_path,
                            lit: syn::Lit::Str(ref s),
                            ..
                        })) = attr.parse_meta()
                        {
                            if meta_path.is_ident("diff") {
                                diff_type = match s.value().as_str() {
                                    "eq" => DiffMode::Eq,
                                    "diff" => DiffMode::Diff,
                                    "clone" => DiffMode::Clone,
                                    _ => panic!("Unexpected diff type"),
                                }
                            }
                        }
                    }
                    diff_type
                })
                .collect();

            let field_diff_types =
                field_tys
                    .iter()
                    .zip(field_diff_modes.iter())
                    .map(|(field_ty, field_diff_mode)| match field_diff_mode {
                        DiffMode::Diff => quote! {
                            <#field_ty as Diff>::Delta
                        },
                        DiffMode::Clone => quote! {
                            #field_ty
                        },
                        DiffMode::Eq => quote! {
                            Option<#field_ty>
                        },
                    });

            let field_diffs = field_names.iter().zip(field_diff_modes.iter()).map(
                |(field_name, field_diff_mode)| match field_diff_mode {
                    DiffMode::Diff => quote! {
                        Diff::diff(&self.#field_name, &to.#field_name)
                    },
                    DiffMode::Clone => quote! {
                        to.#field_name.clone()
                    },
                    DiffMode::Eq => quote! {
                        if self.#field_name == to.#field_name {
                            None
                        } else {
                            Some(to.#field_name.clone())
                        }
                    },
                },
            );

            let field_updates = field_names.iter().zip(field_diff_modes.iter()).map(
                |(field_name, field_diff_mode)| match field_diff_mode {
                    DiffMode::Diff => quote! {
                        Diff::update(&mut self.#field_name, &delta.#field_name);
                    },
                    DiffMode::Clone => quote! {
                        self.#field_name = delta.#field_name.clone();
                    },
                    DiffMode::Eq => quote! {
                        if let Some(value) = &delta.#field_name {
                            self.#field_name = value.clone();
                        }
                    },
                },
            );

            let expanded = quote! {
                #[derive(Debug, Serialize, Deserialize, Clone)]
                pub struct #delta_type #generics {
                    #(#field_names: #field_diff_types,)*
                }

                impl #impl_generics Diff for #input_type #ty_generics #where_clause {
                    type Delta = #delta_type;
                    fn diff(&self, to: &Self) -> Self::Delta {
                        #delta_type {
                            #(#field_names: #field_diffs,)*
                        }
                    }
                    fn update(&mut self, delta: &Self::Delta) {
                        #(#field_updates)*
                    }
                }
            };
            expanded
        }
        _ => panic!("Diff can only be derived by structs"),
    }
}