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

mod index;
mod locks;
mod primary_key;
pub mod queries;
mod row;
mod table;
mod wrapper;

use proc_macro2::{Ident, TokenStream};
use quote::quote;

use crate::common::model::{Columns, Config, PrimaryKey, Queries};

pub struct InMemoryGenerator {
    pub name: Ident,
    pub pk: Option<PrimaryKey>,
    pub queries: Option<Queries>,
    pub config: Option<Config>,
    pub columns: Columns,
}

impl InMemoryGenerator {
    pub fn new(name: Ident, columns: Columns) -> Self {
        Self {
            name,
            pk: None,
            queries: None,
            config: None,
            columns,
        }
    }

    pub fn set_queries(&mut self, queries: Queries) {
        self.queries = Some(queries);
    }

    pub fn set_config(&mut self, config: Config) {
        self.config = Some(config);
    }
}

#[allow(dead_code)]
pub fn expand(input: TokenStream) -> syn::Result<TokenStream> {
    let mut parser = crate::common::parser::Parser::new(input);
    let mut columns = None;
    let mut queries = None;
    let mut indexes = None;
    let mut config = None;

    let name = parser.parse_name()?;
    while let Some(ident) = parser.peek_next() {
        match ident.to_string().as_str() {
            "columns" => {
                let res = parser.parse_columns()?;
                columns = Some(res)
            }
            "indexes" => {
                let res = parser.parse_indexes()?;
                indexes = Some(res);
            }
            "queries" => {
                let res = parser.parse_queries()?;
                queries = Some(res)
            }
            "config" => {
                let res = parser.parse_configs()?;
                config = Some(res)
            }
            "persist" => {
                // Skip persist flag for in_memory - it's always false
                parser.parse_persist()?;
            }
            _ => return Err(syn::Error::new(ident.span(), "Unexpected identifier")),
        }
    }

    let mut columns = columns.expect("defined");
    if let Some(i) = indexes {
        columns.indexes = i
    }

    expand_from_parsed(name, columns, queries, config)
}

pub fn expand_from_parsed(
    name: proc_macro2::Ident,
    columns: crate::common::model::Columns,
    queries: Option<crate::common::model::Queries>,
    config: Option<crate::common::model::Config>,
) -> syn::Result<TokenStream> {
    let mut generator = InMemoryGenerator::new(name, columns);
    if let Some(q) = queries {
        generator.set_queries(q);
    }
    if let Some(c) = config {
        generator.set_config(c);
    }

    let pk_def = generator.gen_primary_key_def()?;
    let row_def = generator.gen_row_def();
    let wrapper_def = generator.gen_wrapper_def();
    let locks_def = generator.gen_locks_def();
    let index_def = generator.gen_index_def()?;
    let table_def = generator.gen_table_def()?;
    let query_types_def = generator.gen_result_types_def()?;
    let query_available_def = generator.gen_available_types_def()?;
    let query_locks_impls = generator.gen_query_locks_impl()?;
    let select_impls = generator.gen_query_select_impl()?;
    let update_impls = generator.gen_query_update_impl()?;
    let update_in_place_impls = generator.gen_query_in_place_impl()?;
    let delete_impls = generator.gen_query_delete_impl()?;
    let unsized_impl = generator.gen_unsized_impls();

    Ok(quote! {
        #pk_def
        #row_def
        #query_available_def
        #wrapper_def
        #locks_def
        #index_def
        #table_def
        #query_types_def
        #query_locks_impls
        #select_impls
        #update_impls
        #update_in_place_impls
        #delete_impls
        #unsized_impl
    })
}