toql_fields_macro 0.4.0

Library with fields macro for Toql
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

use syn::parse::{Parse, ParseStream};

use syn::{Ident, LitStr, Result, Token, Type};

use heck::SnakeCase;
use proc_macro2::{Span, TokenStream};
use toql_field_list_parser::PestFieldListParser;

use pest::Parser;

use toql_field_list_parser::Rule;

#[derive(Debug)]
pub enum FieldsMacro {
    FieldList { struct_type: Type, query: LitStr },
    Top,
}

fn parse_fieldlist(input: ParseStream) -> Result<FieldsMacro> {
    Ok(FieldsMacro::FieldList {
        struct_type: { (input.parse()?, input.parse::<Token![,]>()?).0 },
        query: input.parse()?,
    })
}

fn parse_top(input: ParseStream) -> Result<FieldsMacro> {
    let top: Ident = input.parse()?;
    if top == "top" {
        Ok(FieldsMacro::Top)
    } else {
        println!("Found {}", top);
        Err(syn::Error::new(Span::call_site(), "Keyword `top` expected"))
    }
}

impl Parse for FieldsMacro {
    fn parse(input: ParseStream) -> Result<Self> {
        let alt = input.fork();
        let f = parse_fieldlist(input);
        match f {
            Ok(_) => f,
            Err(_) => parse_top(&alt),
        }
    }
}

pub fn parse(
    field_list_string: &LitStr,
    struct_type: Type,
) -> std::result::Result<TokenStream, TokenStream> {
    let mut output_stream: TokenStream = TokenStream::new();

    match PestFieldListParser::parse(Rule::query, &field_list_string.value()) {
        Ok(pairs) => {
            output_stream.extend(evaluate_pair(&mut pairs.flatten(), &struct_type));
        }
        Err(e) => {
            let msg = e.to_string();
            return Err(quote_spanned!(field_list_string.span() => compile_error!(#msg)));
        }
    };

    Ok(output_stream)
}

fn evaluate_pair(
    pairs: &mut pest::iterators::FlatPairs<toql_field_list_parser::Rule>,
    struct_type: &Type,
) -> TokenStream {
    let mut methods = Vec::new();

    for pair in pairs {
        let span = pair.clone().as_span();

        match pair.as_rule() {
            Rule::wildcard => {
                let method_names = span
                    .as_str()
                    .split('_')
                    .filter(|p| !p.is_empty())
                    .filter(|p| *p != "*")
                    .map(|p| {
                        let name = Ident::new(&p.to_snake_case(), Span::call_site());
                        quote!( .#name ())
                    })
                    .collect::<Vec<_>>();

                methods.push( quote!(toql::query_path::QueryPath::wildcard(<#struct_type as toql::query_fields::QueryFields>::fields() #(#method_names)*).into_string()) )
            }
            Rule::field_path => {
                let method_names = span
                    .as_str()
                    .split('_')
                    .filter(|p| !p.is_empty())
                    .map(|p| {
                        let raw_string = format!("r#{}", &p.to_snake_case());
                        let mut raw_ident: Ident = syn::parse_str(&raw_string).unwrap();
                        raw_ident.set_span(Span::call_site());
                        //let name = Ident::new(&format!("r#{}", &p.to_snake_case()),Span::call_site());
                        //  let p = proc_macro2::Punct::new('#', proc_macro2::Spacing::Joint);

                        quote!( .  #raw_ident ())
                    })
                    .collect::<Vec<_>>();
                //methods.push(  quote!(toql::update_field::UpdateField::into_field(  <#struct_type as toql::query_fields::QueryFields>::fields() #(#method_names)*  )))
                methods.push(  quote!( <#struct_type as toql::query_fields::QueryFields>::fields() #(#method_names)*  .into_name()))
            }
            _ => {}
        }
    }

    quote!(
        //  toql::fields::Fields::<#struct_type>::from(vec![#(#methods),* ])
        toql::toql_api::fields::Fields::from(vec![#(#methods),* ])
    )
}