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
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
141
142
143
144
145
146

use super::{FieldType, StampType};
use quote::__private::TokenStream;
use quote::quote;
use syn::Ident;

/// The code for adding a field to a [neo4rs::Query::param].
///
/// Uses a [neo4rs::Query] named `query`, and may update its params with this field.
pub fn add_value_to_params(
    ident: &Ident,
    name: &str,
    typ: &FieldType,
    stamp: Option<StampType>,
) -> TokenStream {
    match typ {
        FieldType::DateTimeUtc(_ty) => {
            // Similar example: cypher-dto/lib/tests/common/entities/person.rs#L57
            if stamp.is_some() {
                match stamp.unwrap() {
                    StampType::Created => {
                        quote!(
                            match mode {
                                ::cypher_dto::StampMode::Create => query,
                                _ => query.param(
                                    &::cypher_dto::format_param(#name, prefix),
                                    self.#ident.fixed_offset()
                                )
                            }
                        )
                    }
                    StampType::Updated => {
                        quote!(
                            match mode {
                                ::cypher_dto::StampMode::Read => query.param(
                                    &::cypher_dto::format_param(#name, prefix),
                                    self.#ident.fixed_offset()
                                ),
                                _ => query,
                            }
                        )
                    }
                }
            } else {
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident.fixed_offset()
                    )
                )
            }
        }
        FieldType::OptionDateTimeUtc(_ty) => {
            // Example: cypher-dto/lib/tests/common/entities/person.rs#L57
            if stamp.is_some() {
                match stamp.unwrap() {
                    StampType::Created => {
                        quote!(
                            match mode {
                                ::cypher_dto::StampMode::Create => query,
                                _ => query.param(
                                    &::cypher_dto::format_param(#name, prefix),
                                    self.#ident.map(|v| v.fixed_offset())
                                )
                            }
                        )
                    }
                    StampType::Updated => {
                        quote!(
                            match mode {
                                ::cypher_dto::StampMode::Read => query.param(
                                    &::cypher_dto::format_param(#name, prefix),
                                    self.#ident.map(|v| v.fixed_offset())
                                ),
                                _ => query,
                            }
                        )
                    }
                }
            } else {
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident.map(|v| v.fixed_offset())
                    )
                )
            }
        }
        FieldType::Num(_ty, num) => {
            // Non-optional numbers that need a cast use `as X`.
            if let Some(cast) = num.param_cast() {
                // Example: cypher-dto/lib/src/entity.rs#L405
                let ty = cast.to_type();
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident as #ty
                    )
                )
            } else {
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident
                    )
                )
            }
        }
        FieldType::OptionNum(_ty, num) => {
            // Optional numbers that need a cast use `.map(T::from)`.
            if let Some(cast) = num.param_cast() {
                // Example: cypher-dto/lib/tests/common/entities/person.rs#L57
                let ty = cast.to_type();
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident.map(#ty::from)
                    )
                )
            } else {
                quote!(
                    query.param(
                        &::cypher_dto::format_param(#name, prefix),
                        self.#ident
                    )
                )
            }
        }
        FieldType::OptionOther(_ty) => {
            quote!(
                query.param(
                    &::cypher_dto::format_param(#name, prefix),
                    self.#ident.clone()
                )
            )
        }
        FieldType::Other(_ty) => {
            // Most fields are cloned.
            quote!(
                query.param(
                    &::cypher_dto::format_param(#name, prefix),
                    self.#ident.clone()
                )
            )
        }
    }
}