conservator_macro 0.2.0

conservator macro
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

use darling::FromDeriveInput;
use itertools::Itertools;
use proc_macro_error::abort;
use quote::quote;
use syn::{parse2, Data, DeriveInput};

#[derive(Debug, FromDeriveInput)]
#[darling(attributes(crud))]
struct CreatableOpts {
    ident: syn::Ident,
}

pub(crate) fn handle_creatable(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
    let x1 = parse2::<DeriveInput>(input).unwrap();
    let creatable_opts: CreatableOpts = CreatableOpts::from_derive_input(&x1).unwrap();

    let ident = creatable_opts.ident;

    if let Data::Struct(ref body) = x1.data {
        let fields = body.fields.iter().map(|it| &it.ident).collect::<Vec<_>>();

        let field_list = fields
            .iter()
            .map(|it| {
                format!(
                    "\"{}\"",
                    it.as_ref()
                        .map(|ident| ident.to_string())
                        .expect("ident not found")
                )
            })
            .join(",");
        let param_list = fields
            .iter()
            .enumerate()
            .map(|it| it.0)
            .map(|it| format!("${}", it + 1))
            .join(",");

        let columns = format!("({})", field_list);
        let insert_sql = format!("({})", param_list);

        let fields_len = fields.len();

        let bind_list_for_query_as = fields.iter().map(|it| {
            quote! { .bind(self. #it)}
        });
        let bind_list_for_query = fields.iter().map(|it| {
            quote! { .bind(self. #it)}
        });
        let bind_list_for_query_scalar = fields.iter().map(|it| {
            quote! { .bind(self. #it)}
        });

        quote! {
            impl ::conservator::Creatable for #ident {

                fn get_columns(&self) -> &str {
                    #columns
                }

                fn get_insert_sql(&self) -> &str {
                    #insert_sql
                }
                fn get_batch_insert_sql(&self, idx: usize) -> String {
                    let mut ret = String::new();
                    ret.push_str("(");
                    for i in 0..#fields_len {
                        if i > 0 {
                            ret.push_str(",");
                        }
                        ret.push_str(&format!("${}", idx * #fields_len + i + 1));
                    }
                    ret.push_str(")");
                    ret
                }
                fn build_for_query_as<'q, O>(
                    self,
                    e: ::sqlx::query::QueryAs<'q, ::sqlx::Postgres, O, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments,>,
                ) -> ::sqlx::query::QueryAs<'q, ::sqlx::Postgres, O, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments,> {
                    e
                    #(#bind_list_for_query_as)*
                }
                fn build_for_query<'q>(
                    self,
                    e: ::sqlx::query::Query<'q, ::sqlx::Postgres, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments>,
                ) -> ::sqlx::query::Query<'q, ::sqlx::Postgres, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments> {
                    e
                    #(#bind_list_for_query)*
                }
                fn bind_to_query_scalar<'q, O>(
                    self,
                    e: ::sqlx::query::QueryScalar<'q, ::sqlx::Postgres, O, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments>,
                ) -> ::sqlx::query::QueryScalar<'q, ::sqlx::Postgres, O, <::sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::Arguments> {
                    e
                    #(#bind_list_for_query_scalar)*
                }
            }
        }
    } else {
        abort! { x1,
            "enum does not support"
        }
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn compile_fail() {
        let t = trybuild::TestCases::new();
        t.compile_fail("tests/fail/*.rs");
    }
}