rust_json_derive 0.1.2

ToJson and FromJson derive for rust-json
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use proc_macro2::Span;
use quote::quote;
use syn::{Data, DataEnum, DataStruct, DeriveInput, Error, Fields, Ident, Index, Result, Variant};

use crate::attrs;

pub fn expand_serialize(input: DeriveInput) -> Result<proc_macro2::TokenStream> {
    let ident = &input.ident;
    match input.data {
        Data::Struct(struct_data) => Ok(serialize_struct(ident, struct_data)),
        Data::Enum(enum_data) => Ok(serialize_enum(ident, enum_data)),
        Data::Union(_) => Err(Error::new(
            ident.span(),
            "rust_json_derive not support union!",
        )),
    }
}

fn serialize_struct(ident: &Ident, struct_data: DataStruct) -> proc_macro2::TokenStream {
    let s = serialize_fields(ident, struct_data.fields);
    quote!(
        impl rust_json::ToJson for #ident {
            fn to_json(&self) -> rust_json::JsonElem {
                #s
            }
        }
    )
}

fn serialize_enum(ident: &Ident, enum_data: DataEnum) -> proc_macro2::TokenStream {
    let variants = enum_data.variants;
    let s = variants.iter().map(|v| serialize_varient(ident, v));
    quote!(
        impl rust_json::ToJson for #ident {
            fn to_json(&self) -> rust_json::JsonElem {
                match self {
                    #(#s),*
                }
            }
        }
    )
}

fn serialize_fields(ident: &Ident, fields: Fields) -> proc_macro2::TokenStream {
    match fields {
        Fields::Named(_) => {
            let s = fields
                .iter()
                .map(|f| {
                    (
                        attrs::get_name_from_attrs(&f.attrs, f.ident.as_ref().unwrap().to_string()),
                        f.ident.as_ref(),
                    )
                })
                .map(|(name, i)| quote!(hm.insert(#name.to_string(), self.#i.to_json());));
            quote!(
                {
                    let mut hm = std::collections::HashMap::<String, rust_json::JsonElem>::new();
                    #(#s)*
                    rust_json::JsonElem::Object(hm)
                }
            )
        }
        Fields::Unnamed(_) if fields.len() == 1 => {
            quote!(self.0.to_json())
        }
        Fields::Unnamed(_) => {
            let s = fields
                .iter()
                .enumerate()
                .map(|(i, _)| Index::from(i))
                .map(|i| quote!(vec.push(self.#i.to_json());));
            quote!(
                {
                    let mut vec = Vec::<rust_json::JsonElem>::new();
                    #(#s)*
                    rust_json::JsonElem::Array(vec)
                }
            )
        }
        Fields::Unit => {
            quote!({ rust_json::JsonElem::Str(stringify!(#ident).to_string()) })
        }
    }
}

fn serialize_varient(ident: &Ident, variant: &Variant) -> proc_macro2::TokenStream {
    let fields = &variant.fields;
    let var_ident = &variant.ident;
    let var_name = attrs::get_name_from_attrs(&variant.attrs, var_ident.to_string());
    match fields {
        Fields::Unit => {
            quote!(#ident::#var_ident => rust_json::JsonElem::Str(#var_name.to_string()))
        }
        Fields::Unnamed(_) if fields.len() == 1 => {
            quote!(#ident::#var_ident(__field) => {
                let mut hm = std::collections::HashMap::<String, rust_json::JsonElem>::new();
                hm.insert(#var_name.to_string(), __field.to_json());
                rust_json::JsonElem::Object(hm)
            })
        }
        Fields::Unnamed(_) => {
            let field_names =
                (0..fields.len()).map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
            let s = (0..fields.len())
                .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()))
                .map(|i| quote!(vec.push(#i.to_json());));
            quote! {
                #ident::#var_ident(#(#field_names),*) => {
                    let mut vec = Vec::<rust_json::JsonElem>::new();
                    #(#s)*
                    let mut hm = std::collections::HashMap::<String, rust_json::JsonElem>::new();
                    hm.insert(#var_name.to_string(), rust_json::JsonElem::Array(vec));
                    rust_json::JsonElem::Object(hm)
                }
            }
        }
        Fields::Named(_) => {
            let field_names = fields.iter().map(|f| f.ident.as_ref());
            let s = fields
                .iter()
                .map(|f| {
                    (
                        attrs::get_name_from_attrs(&f.attrs, f.ident.as_ref().unwrap().to_string()),
                        f.ident.as_ref(),
                    )
                })
                .map(|(name, i)| quote!(hm.insert(#name.to_string(), #i.to_json());));
            quote! {
                #ident::#var_ident{#(#field_names),*} => {
                    let mut hm = std::collections::HashMap::<String, rust_json::JsonElem>::new();
                    #(#s)*
                    let mut hm_wrap = std::collections::HashMap::<String, rust_json::JsonElem>::new();
                    hm_wrap.insert(#var_name.to_string(), rust_json::JsonElem::Object(hm));
                    rust_json::JsonElem::Object(hm_wrap)
                }
            }
        }
    }
}