nacos-macro 0.1.1

Nacos's proc macros.
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

use syn::parse::Parser;
use syn::{parse_quote, ItemStruct, Path};

use quote::quote;

use super::{Crates, MacroArgs};

const SUCCESS_RESPONSE: (i32, &str) = (200, "Response ok");
const FAIL_RESPONSE: (i32, &str) = (500, "Response fail");

pub(crate) fn grpc_response(
    macro_args: MacroArgs,
    mut item_struct: ItemStruct,
) -> proc_macro2::TokenStream {
    let identity = macro_args.identity;
    let name = &item_struct.ident;

    let Crates { serde, .. } = macro_args.crates;

    // add derive GrpcMessageBody
    let grpc_message_body = quote! {
        impl crate::common::remote::grpc::message::GrpcMessageData for #name {
            fn identity<'a>() -> std::borrow::Cow<'a, str> {
                #identity.into()
            }
        }
    };

    let (success_code, success_message) = SUCCESS_RESPONSE;
    let (fail_code, fail_message) = FAIL_RESPONSE;

    let impl_message_response = quote! {

        impl #name {

            pub fn ok() -> Self {
                #name {
                    result_code: #success_code,
                    message: Some(#success_message.to_owned()),
                    ..Default::default()
                }
            }

            pub fn fail() -> Self {
                #name {
                    result_code: #fail_code,
                    message: Some(#fail_message.to_owned()),
                    ..Default::default()
                }
            }

        }

    };

    let grpc_message_response = quote! {

        impl crate::common::remote::grpc::message::GrpcResponseMessage for #name {
            fn request_id(&self) -> Option<&String> {
                self.request_id.as_ref()
            }

            fn result_code(&self) -> i32 {
                self.result_code
            }

            fn error_code(&self) -> i32 {
                self.error_code
            }

            fn message(&self) -> Option<&String> {
                self.message.as_ref()
            }

            fn is_success(&self) -> bool {
                self.result_code == #success_code
            }
        }
    };

    if let syn::Fields::Named(ref mut fields) = item_struct.fields {
        let result_code_field = syn::Field::parse_named
            .parse2(quote! {
                pub result_code: i32
            })
            .unwrap();
        let error_code_field = syn::Field::parse_named
            .parse2(quote! {
                pub error_code: i32
            })
            .unwrap();
        let message_field = syn::Field::parse_named
            .parse2(quote! {
                pub message: Option<String>
            })
            .unwrap();
        let request_id_field = syn::Field::parse_named
            .parse2(quote! {
                pub request_id: Option<String>
            })
            .unwrap();

        fields.named.push(result_code_field);
        fields.named.push(error_code_field);
        fields.named.push(message_field);
        fields.named.push(request_id_field);
    }

    let derive_paths: Vec<Path> = vec![
        syn::parse_quote! { #serde::Deserialize },
        syn::parse_quote! { #serde::Serialize },
        syn::parse_quote! { Clone },
        syn::parse_quote! { Debug },
        syn::parse_quote! { Default },
    ];
    // add derive
    item_struct.attrs.push(parse_quote! {
        #[derive(#(#derive_paths),*)]

    });
    item_struct.attrs.push(parse_quote!(
        #[serde(rename_all = "camelCase")]
    ));

    quote! {
        #item_struct
        #grpc_message_response
        #grpc_message_body
        #impl_message_response
    }
}