worktable_macros 0.9.0

Proc-macro companion crate for worktable: the worktable! macro and its derives. Formerly published as worktable_codegen.
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

use crate::common::name_generator::WorktableNameGenerator;
use crate::generators::in_memory::InMemoryGenerator;
use convert_case::{Case, Casing};
use proc_macro2::{Ident, Span, TokenStream};
use quote::quote;

impl InMemoryGenerator {
    /// Generates row type and it's impls.
    pub fn gen_row_def(&mut self) -> TokenStream {
        let def = self.gen_row_type();
        let table_row_impl = self.gen_row_table_row_impl();
        let row_fields_enum = self.gen_row_fields_enum();
        let query_impl = self.gen_query_impl();

        quote! {
            #def
            #table_row_impl
            #row_fields_enum
            #query_impl
        }
    }

    /// Generates `TableRow` trait implementation for row.
    fn gen_row_table_row_impl(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let ident = name_generator.get_row_type_ident();
        let primary_key_ident = name_generator.get_primary_key_type_ident();

        let primary_key = self.pk.clone().expect("should be set in `Generator` at this point");
        let primary_key_columns_clone = if primary_key.values.len() == 1 {
            let pk_field = primary_key
                .values
                .keys()
                .next()
                .expect("should exist as length is checked");
            quote! {
                self.#pk_field.clone().into()
            }
        } else {
            let vals = primary_key
                .values
                .keys()
                .map(|i| {
                    quote! {
                        self.#i.clone()
                    }
                })
                .collect::<Vec<_>>();
            quote! {
                (#(#vals),*).into()
            }
        };

        quote! {
            impl TableRow<#primary_key_ident> for #ident {

                fn get_primary_key(&self) -> #primary_key_ident {
                    #primary_key_columns_clone
                }
            }
        }
    }

    /// Generates table's row struct definition. It has fields that were described in definition.
    fn gen_row_type(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let ident = name_generator.get_row_type_ident();

        let mut rows = vec![quote! {}; self.columns.field_positions.len()];
        for (i, pos) in &self.columns.field_positions {
            let type_ = self.columns.columns_map.get(i).unwrap();
            rows[*pos] = quote! {pub #i: #type_,}
        }

        let custom_derives = if let Some(custom_derives) = &self.config.as_ref().map(|c| &c.row_derives) {
            quote! {
                #[derive(#(#custom_derives),*)]
            }
        } else {
            quote! {}
        };

        quote! {
            #[derive(rkyv::Archive, Debug, rkyv::Deserialize, Clone, rkyv::Serialize, PartialEq, MemStat)]
            #custom_derives
            #[rkyv(derive(Debug))]
            #[repr(C)]
            pub struct #ident {
                #(#rows)*
            }
        }
    }

    fn gen_query_impl(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let ident = name_generator.get_row_type_ident();

        quote! {
            impl Query<#ident> for #ident {
                fn merge(self, row: #ident) -> #ident {
                    self
                }
            }
        }
    }

    /// Generates `RowFields` enum for row.
    fn gen_row_fields_enum(&self) -> TokenStream {
        let name_generator = WorktableNameGenerator::from_table_name(self.name.to_string());
        let ident = name_generator.get_row_type_ident();

        let enum_name = Ident::new(format!("{ident}Fields").as_str(), Span::mixed_site());

        let rows: Vec<_> = self
            .columns
            .columns_map
            .keys()
            .map(|name| {
                let name_pascal = Ident::new(name.to_string().to_case(Case::Pascal).as_str(), Span::mixed_site());
                quote! { #name_pascal, }
            })
            .collect();

        quote! {
            #[derive(rkyv::Archive, Debug, rkyv::Deserialize, Clone, rkyv::Serialize, PartialEq)]
            #[rkyv(derive(Debug))]
            #[repr(C)]
            pub enum #enum_name {
                #(#rows)*
            }
        }
    }
}

// TODO: tests...