rustorm_codegen 0.20.0

code gen provides macro for generating code on data access objects on table metadata
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

use quote;
use syn;

pub fn impl_to_column_names(ast: &syn::MacroInput) -> quote::Tokens {
    let name = &ast.ident;
    let generics = &ast.generics;
    let fields: Vec<(&syn::Ident, &syn::Ty)> = match ast.body {
        syn::Body::Struct(ref data) => {
            match *data {
                syn::VariantData::Struct(ref fields) => {
                    fields
                        .iter()
                        .map(|f| {
                            let ident = f.ident.as_ref().unwrap();
                            let ty = &f.ty;
                            (ident, ty)
                        })
                        .collect::<Vec<_>>()
                }
                _ => panic!("Only struct is supported for #[derive(ToColumnNames)]"),
            }
        }
        syn::Body::Enum(_) => panic!("#[derive(ToColumnNames)] can only be used with structs"),
    };
    let from_fields: Vec<quote::Tokens> = fields
        .iter()
        .map(|&(field, _ty)| {
            quote! {
                rustorm_dao::ColumnName {
                    name: stringify!(#field).into(),
                    table: Some(stringify!(#name).to_lowercase().into()),
                    alias: None,
                },
            }
        })
        .collect();

    quote! {
        impl #generics rustorm_dao::ToColumnNames for #name #generics {
            fn to_column_names() -> Vec<rustorm_dao::ColumnName> {
                vec![
                    #(#from_fields)*
                ]
            }
        }
    }
}