vesperi-derive 0.1.0

macros for vesperi
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{DeriveInput, DataEnum, Fields, Type};

pub fn derive_command_for_enum(ast: &DeriveInput, enum_data: &DataEnum) -> TokenStream {
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let tname = &ast.ident;

    let event_matches = enum_data
        .variants
        .iter()
        .map(|variant| {
            let vname = match &variant.fields {
                Fields::Unnamed(f) => {
                    match &f.unnamed[0].ty {
                        Type::Path(p) => &p.path.segments[0].ident,
                        _ => panic!("#[derive(Command) operates on wrapped struct, such as CommandName(CommandStruct), but none was found")
                    }
                },
                _ => panic!("#[derive(Command) operates on wrapped struct, such as CommandName(CommandStruct), but none was found")
            };
            let ename = &variant.ident;
            let evtype = &format!("{}", vname);
            match variant.fields {
                Fields::Unit => quote! {
                    #tname::#ename => #evtype.into(),
                },
                Fields::Unnamed(ref fields) => {
                    let field_names = fields
                        .unnamed
                        .pairs()
                        .map(|p| p.value().ident.as_ref())
                        .collect::<Vec<_>>();
                    quote! {
                        #tname::#ename( #(_ #field_names,)* ) => #evtype.into(),
                    }
                }
                Fields::Named(ref fields) => {
                    let field_names = fields
                        .named
                        .pairs()
                        .map(|p| p.value().ident.as_ref())
                        .collect::<Vec<_>>();
                    quote! {
                        #tname::#ename { #(#field_names: _,)* } => #evtype.into(),
                    }
                }
            }
        })
        .collect::<Vec<_>>();

    (quote! {
        #[allow(unused_qualifications, unused_parens)]
        #[automatically_derived]
        impl #impl_generics ::common::domain::entity::command::Command for #tname #ty_generics #where_clause {
            fn to_string(&self) -> String {
                match self {
                    #(#event_matches)*
                }
            }
        }
    })
    .into()
}