pipederive 0.2.1

Proc macros for data integration app using pipebase framework
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

use proc_macro2::{Ident, TokenStream};
use quote::{quote, quote_spanned};
use syn::{spanned::Spanned, Attribute, Data, Field, Generics};

use crate::constants::{RENDER_EXPR, RENDER_POSITION, RENDER_TEMPLATE};

use crate::utils::{
    get_any_attribute_by_meta_prefix, get_meta, get_meta_number_value_by_meta_path,
    get_meta_string_value_by_meta_path, meta_not_found_in_all_fields, resolve_all_fields,
};

pub fn impl_render(
    ident: &Ident,
    attributes: &[Attribute],
    data: &Data,
    generics: &Generics,
) -> TokenStream {
    let ident_location = ident.to_string();
    let attribute = get_any_render_template_attribute(attributes, &ident_location);
    let template = get_render_template(&attribute, &ident_location);
    let mut fields = resolve_all_fields(
        data,
        true,
        &is_render_param,
        &meta_not_found_in_all_fields(RENDER_POSITION, &ident_location),
    );
    sort_render_params(&mut fields, &ident_location);
    let parameter_tokens = resolve_render_params(&fields, &ident_location);
    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
    quote! {
        impl #impl_generics Render for #ident #type_generics #where_clause {
            fn render(&self) -> String {
                format!(#template, #parameter_tokens)
            }
        }
    }
}

fn get_any_render_template_attribute(attributes: &[Attribute], ident_location: &str) -> Attribute {
    get_any_attribute_by_meta_prefix(RENDER_TEMPLATE, attributes, true, ident_location).unwrap()
}

fn get_render_template(attribute: &Attribute, ident_location: &str) -> String {
    get_meta_string_value_by_meta_path(RENDER_TEMPLATE, &get_meta(attribute), true, ident_location)
        .unwrap()
}

fn is_render_param(field: &Field) -> bool {
    get_any_attribute_by_meta_prefix(RENDER_POSITION, &field.attrs, false, "").is_some()
}

fn sort_render_params(fields: &mut Vec<Field>, ident_location: &str) {
    fields.sort_by(|f0, f1| {
        get_field_pos(f0, ident_location)
            .partial_cmp(&get_field_pos(f1, ident_location))
            .unwrap()
    })
}

fn get_field_pos(field: &Field, ident_location: &str) -> usize {
    let ident_location = format!("{}.{}", ident_location, field.ident.as_ref().unwrap(),);
    let attribute = get_pos_attribute(&field.attrs, &ident_location);
    let number = get_meta_number_value_by_meta_path(
        RENDER_POSITION,
        &get_meta(&attribute),
        true,
        &ident_location,
    )
    .unwrap();
    number
        .parse()
        .unwrap_or_else(|_| panic!("parse number '{}' failed at '{}'", number, ident_location))
}

fn get_pos_attribute(attributes: &[Attribute], ident_location: &str) -> Attribute {
    get_any_attribute_by_meta_prefix(RENDER_POSITION, attributes, true, ident_location).unwrap()
}

fn resolve_render_params(fields: &[Field], ident_location: &str) -> TokenStream {
    let params = fields
        .iter()
        .map(|field| resolve_render_param(field, ident_location));
    quote! {
        #(#params),*
    }
}

fn resolve_render_param(field: &Field, ident_location: &str) -> TokenStream {
    let span = field.span();
    let tokens = get_render_param_tokens(field, ident_location);
    quote_spanned! { span =>
        #tokens
    }
}

fn get_render_param_tokens(field: &Field, ident_location: &str) -> TokenStream {
    let expr = get_any_render_expr(field, ident_location);
    let ident = &field.ident;
    let ty = &field.ty;
    match expr {
        Some(expr) => {
            let expression: TokenStream = expr.parse().unwrap();
            let expression_closure = quote! {
                |#ident: &#ty| { #expression }
            };
            quote! {
                {
                    let eval = #expression_closure;
                    eval(&self.#ident)
                }
            }
        }
        None => quote! { self.#ident },
    }
}

fn get_any_render_expr(field: &Field, ident_location: &str) -> Option<String> {
    let attribute = get_any_attribute_by_meta_prefix(RENDER_EXPR, &field.attrs, false, "");
    match attribute {
        Some(attribute) => {
            let ident_location = match field.ident {
                Some(ref field_ident) => format!("{}.{}", ident_location, field_ident),
                None => ident_location.to_owned(),
            };
            get_meta_string_value_by_meta_path(
                RENDER_EXPR,
                &get_meta(&attribute),
                true,
                &ident_location,
            )
        }
        None => None,
    }
}