argos-macros 0.1.0

Argos's proc macros.
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


use syn::parse::{Parse, ParseStream};
use syn::{ Ident, Token, token, LitStr, Error, LitInt};

#[derive(Debug, PartialEq, Clone)]
pub(crate) struct RouteAttribute {
    pub(crate) http_method: Ident,
    pub(crate) path: LitStr,
    pub(crate) formatter: LitStr,
}

impl Parse for RouteAttribute {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let methods = vec!["GET", "POST", "OPTIONS", "HEAD", "DELETE", "PUT", "TRACE", "CONNECT", "PATCH"];
        let http_method: Ident = input.parse()?;
        
        if methods.iter().find(|m| m.to_string() == http_method.to_string()).is_none() {
            return Err(Error::new(http_method.span(), "expected http method"));
        }
        let _comma = input.parse::<Token![,]>()?;
        let path_ident: Ident = input.parse()?;
        if path_ident != "path" || !input.peek(token::Eq) {
            return Err(Error::new(path_ident.span(), "expected path"));
        }
        let _eq = input.parse::<Token![=]>()?;
        let path = input.parse::<LitStr>()?;
        let _comma = input.parse::<Token![,]>()?;
        let formatter_ident: Ident = input.parse()?;
        if formatter_ident != "formatter" || !input.peek(token::Eq) {
            return Err(Error::new(formatter_ident.span(), "expected formatter"));
        }
        let _eq = input.parse::<Token![=]>()?;
        let formatter = input.parse::<LitStr>()?;
        let formatters = vec!["json", "text", "html"];
        if formatters.iter().find(|f| f.to_string() == formatter.value()).is_none() {
            return Err(Error::new(formatter.span(), "formatter only support json, text, html"));
        }
        Ok(RouteAttribute {
            http_method,
            path,
            formatter,
        })
    }
}

#[derive(Debug, PartialEq, Clone)]
pub(crate) struct FilterAttribute {
    pub(crate) predicate_type: Ident,
    pub(crate) predicate_value: LitStr,
    pub(crate) order: LitInt,
}


impl Parse for FilterAttribute {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let predicate_ident: Ident = input.parse()?;
        if predicate_ident == "path_pattern" && input.peek(token::Eq) {
            let _eq = input.parse::<Token![=]>()?;
            let path_pattern: LitStr = input.parse()?;
            let _comma = input.parse::<Token![,]>()?;
            let order_ident: Ident = input.parse()?;
            if order_ident == "order" && input.peek(token::Eq) {
                let _eq = input.parse::<Token![=]>()?;
                let order = input.parse::<LitInt>()?;
                Ok(FilterAttribute {
                    predicate_type: predicate_ident,
                    predicate_value: path_pattern,
                    order,
                })
            } else {
                Err(Error::new(order_ident.span(), "expected order"))
            }
        } else {
            Err(Error::new(predicate_ident.span(), "expected path_pattern"))
        }
    }
}