django-query_derive 0.2.1

Macros for the django-query crate
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use proc_macro2 as pm2;

// This really belogs in the persian_rug crate, but it can't
// be in the macro crate, so for now it's here

pub enum ConstraintItem {
    Context {
        context: syn::Ident,
        equals: syn::Token![=],
        value: syn::Ident,
    },
    Access {
        access: syn::Ident,
        paren: syn::token::Paren,
        items: syn::punctuated::Punctuated<syn::Type, syn::Token![,]>,
    },
}

impl syn::parse::Parse for ConstraintItem {
    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
        let attr: syn::Ident = input.parse()?;
        match attr.to_string().as_str() {
            "context" => {
                let equals = input.parse()?;
                let value = input.parse()?;
                Ok(ConstraintItem::Context {
                    context: attr,
                    equals,
                    value,
                })
            }
            "access" => {
                let content;
                let paren = syn::parenthesized!(content in input);
                let items =
                    syn::punctuated::Punctuated::<syn::Type, syn::Token![,]>::parse_terminated(
                        &content,
                    )?;
                Ok(ConstraintItem::Access {
                    access: attr,
                    paren,
                    items,
                })
            }
            _ => Err(syn::Error::new_spanned(
                attr,
                "unsupported persian-rug constraint",
            )),
        }
    }
}

impl quote::ToTokens for ConstraintItem {
    fn to_tokens(&self, tokens: &mut pm2::TokenStream) {
        match self {
            Self::Context {
                context,
                equals,
                value,
            } => {
                tokens.extend(quote::quote! {
                    #context #equals #value
                });
            }
            Self::Access {
                access,
                paren,
                items,
            } => {
                access.to_tokens(tokens);
                paren.surround(tokens, |tokens| items.to_tokens(tokens))
            }
        }
    }
}

// End of portion that doesn't really belong in this crate

// This doesn't really belong so deep in the tree
/// Top level attributes for the django derives
pub enum DjangoTypeAttr {
    PersianRugConstraints {
        persian_rug: syn::Ident,
        paren: syn::token::Paren,
        constraints: syn::punctuated::Punctuated<ConstraintItem, syn::Token![,]>,
    },
}

impl syn::parse::Parse for DjangoTypeAttr {
    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
        let attr: syn::Ident = input.parse()?;
        match attr.to_string().as_str() {
            "persian_rug" => {
                let content;
                let paren: syn::token::Paren = syn::parenthesized!(content in input);
                let punc = syn::punctuated::Punctuated::<ConstraintItem, syn::Token![,]>::parse_terminated(&content)?;
                Ok(DjangoTypeAttr::PersianRugConstraints {
                    persian_rug: attr,
                    paren,
                    constraints: punc,
                })
            }
            _ => Err(syn::Error::new_spanned(
                attr,
                "unsupported django attribute",
            )),
        }
    }
}

pub fn get_persian_rug_constraints(
    attrs: &Vec<syn::Attribute>,
) -> syn::Result<(syn::Ident, Vec<syn::Type>)> {
    let mut context = None;
    // let mut accessor = None;
    let mut used_types = Vec::new();

    for attr in attrs {
        if attr.path.is_ident("django") {
            let items = attr
                .parse_args_with(
                    syn::punctuated::Punctuated::<DjangoTypeAttr, syn::Token![,]>::parse_terminated,
                )
                .map_err(|e| {
                    syn::Error::new(e.span(), format!("failed to parse django attribute: {}", e))
                })?;

            for item in items.iter() {
                match item {
                    DjangoTypeAttr::PersianRugConstraints { constraints, .. } => {
                        for constraint in constraints {
                            match constraint {
                                ConstraintItem::Context { value, .. } => {
                                    context = Some(value.clone());
                                }
                                ConstraintItem::Access { items, .. } => {
                                    used_types.extend(items.iter().cloned());
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let context = context.ok_or_else(|| {
        syn::Error::new(
            pm2::Span::call_site(),
            "no persian-rug context annotation provided.",
        )
    })?;
    Ok((context, used_types))
}