gel-derive 0.7.4

Derive macros for Gel database client. Formerly published as gel-derive.
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

use proc_macro2::TokenStream;
use quote::quote;

use crate::attrib::ContainerAttrs;

pub fn derive_enum(
    s: &syn::ItemEnum,
    container_attrs: &ContainerAttrs,
) -> syn::Result<TokenStream> {
    let gel_protocol = container_attrs.gel_protocol_path();
    let type_name = &s.ident;
    let (impl_generics, ty_generics, _) = s.generics.split_for_impl();
    let branches = s
        .variants
        .iter()
        .map(|v| match v.fields {
            syn::Fields::Unit => {
                let attrs = crate::attrib::FieldAttrs::from_syn(&v.attrs)?;
                let name = &v.ident;
                let name_bstr = if let Some(rename) = attrs.rename {
                    syn::LitByteStr::new(rename.value().as_bytes(), rename.span())
                } else {
                    syn::LitByteStr::new(name.to_string().as_bytes(), name.span())
                };
                Ok(quote!(#name_bstr => Ok(#type_name::#name)))
            }
            _ => Err(syn::Error::new_spanned(
                &v.fields,
                "fields are not allowed in enum variants",
            )),
        })
        .collect::<Result<Vec<_>, _>>()?;
    let expanded = quote! {
        impl #impl_generics #gel_protocol::queryable::Queryable
            for #type_name #ty_generics {
            type Args = ();

            fn decode(decoder: &#gel_protocol::queryable::Decoder, _args: &(), buf: &[u8])
                -> Result<Self, #gel_protocol::errors::DecodeError>
            {
                match buf {
                    #(#branches,)*
                    _ => Err(#gel_protocol::errors::ExtraEnumValue.build()),
                }
            }
            fn check_descriptor(
                ctx: &#gel_protocol::queryable::DescriptorContext,
                type_pos: #gel_protocol::descriptors::TypePos)
                -> Result<(), #gel_protocol::queryable::DescriptorMismatch>
            {
                use #gel_protocol::descriptors::Descriptor::Enumeration;
                let desc = ctx.get(type_pos)?;
                match desc {
                    // There is no need to check the members of the enumeration
                    // because schema updates can't be perfectly synchronized
                    // to app updates. And that means that extra variants
                    // might be added and only when they are really present in
                    // data we should issue an error. Removed variants are not a
                    // problem here.
                    Enumeration(_) => Ok(()),
                    _ => Err(ctx.wrong_type(desc, "str")),
                }
            }
        }
    };
    Ok(expanded)
}