cypher-dto-macros 0.3.0

The macros for cypher-dto.
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

use super::{ArgHelper, Entity};
use quote::{__private::TokenStream, quote};

pub fn impl_new_and_getters(entity: &Entity) -> TokenStream {
    let entity_ident = entity.ident();
    let mut idents = Vec::new();
    let mut types = Vec::new();
    let mut comments = Vec::new();
    let mut stamp_idents = Vec::new();
    let mut stamp_types = Vec::new();
    let mut stamp_comments = Vec::new();
    // Skip timestamp fields if they are optional.
    for field in entity.fields().inner() {
        if field.typ().is_option() && field.stamp_type().is_some() {
            stamp_idents.push(field.ident());
            stamp_types.push(field.typ().as_type());
            stamp_comments.push(field.comments());
        } else {
            idents.push(field.ident());
            types.push(field.typ().as_type());
            comments.push(field.comments());
        }
    }
    let (
        arg_type,
        arg_into_field_suffix,
        getter_return,
        field_into_getter_prefix_amp,
        field_into_getter_suffix,
    ) = ArgHelper::unzip(types.iter().map(|t| ArgHelper::new(t)).collect());
    let (
        _stamp_arg_type,
        _stamp_arg_into_field_suffix,
        stamp_getter_return,
        stamp_field_into_getter_prefix_amp,
        stamp_field_into_getter_suffix,
    ) = ArgHelper::unzip(stamp_types.iter().map(|t| ArgHelper::new(t)).collect());
    quote! {
       impl #entity_ident {
            pub fn new(#( #idents: #arg_type, )*) -> Self {
                Self {
                    #( #idents: #idents #arg_into_field_suffix, )*
                    #( #stamp_idents: None, )*
                }
            }

            #(
                #( #comments )*
                pub fn #idents(&self) -> #getter_return {
                    #field_into_getter_prefix_amp self.#idents #field_into_getter_suffix
                }
            )*
            #(
                #( #stamp_comments )*
                pub fn #stamp_idents(&self) -> #stamp_getter_return  {
                    #stamp_field_into_getter_prefix_amp self.#stamp_idents #stamp_field_into_getter_suffix
                }
            )*
       }
    }
}

// #[derive(Clone, Debug, PartialEq)]
// pub struct Person {
//     id: String,
//     name: String,
//     age: Option<u8>,
//     created_at: Option<DateTime<Utc>>,
//     updated_at: Option<DateTime<Utc>>,
// }
// impl Person {
//     pub fn new(id: &str, name: &str, age: Option<u8>) -> Self {
//         Self {
//             id: id.to_owned(),
//             name: name.to_owned(),
//             age,
//             created_at: None,
//             updated_at: None,
//         }
//     }
//     pub fn id(&self) -> &str {
//         &self.id
//     }
//     pub fn name(&self) -> &str {
//         &self.name
//     }
//     pub fn age(&self) -> Option<u8> {
//         self.age
//     }
//     pub fn created_at(&self) -> Option<DateTime<Utc>> {
//         self.created_at
//     }
//     pub fn updated_at(&self) -> Option<DateTime<Utc>> {
//         self.updated_at
//     }
// }