oxanus-macros 1.0.1

Macros for Oxanus.
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 darling::{FromDeriveInput, FromMeta};
use heck::ToSnakeCase;
use proc_macro_error2::abort;
use proc_macro2::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput, Fields, Path};

#[derive(Debug, FromDeriveInput)]
#[darling(attributes(oxanus), supports(struct_any))]
struct OxanusArgs {
    registry: Option<Path>,
    key: Option<String>,
    prefix: Option<String>,
    concurrency: Option<usize>,
    throttle: Option<ThrottleArgs>,
}

#[derive(Debug, FromMeta)]
struct ThrottleArgs {
    window_ms: i64,
    limit: u64,
}

pub fn expand_derive_queue(input: DeriveInput) -> TokenStream {
    let args = match OxanusArgs::from_derive_input(&input) {
        Ok(v) => v,
        Err(e) => {
            // darling::Error -> emit nice compile errors
            abort!(input.ident, "{}", e);
        }
    };

    let num_fields = match &input.data {
        Data::Struct(data_struct) => match &data_struct.fields {
            Fields::Named(named) => named.named.len(),
            Fields::Unnamed(unnamed) => unnamed.unnamed.len(),
            Fields::Unit => 0,
        },
        _ => 0,
    };

    let struct_ident = &input.ident;

    let kind = if args.prefix.is_some() {
        if num_fields == 0 {
            abort!(input.ident, "Dynamic queues must have struct fields.");
        }
        quote!(as_dynamic)
    } else {
        quote!(as_static)
    };

    let key = match (args.key, num_fields) {
        (Some(k), 0) => k,
        (Some(_), _) => abort!(input.ident, "Static queue cannot have struct fields."),
        (None, 0) => struct_ident.to_string().to_snake_case(),
        (None, _) => match args.prefix {
            Some(k) => k,
            None => abort!(
                input.ident,
                "`prefix` must be specified for dynamic queues."
            ),
        },
    };

    let concurrency = match args.concurrency {
        Some(v) => quote!(.concurrency(#v)),
        None => quote!(),
    };

    let throttle = match args.throttle {
        Some(ThrottleArgs { window_ms, limit }) => quote! {
            .throttle(oxanus::QueueThrottle {
                window_ms: #window_ms,
                limit: #limit,
            })
        },
        None => quote!(),
    };

    let component_registry = match args.registry {
        Some(registry) => quote!(#registry),
        None => quote!(ComponentRegistry),
    };

    let registry = if cfg!(feature = "registry") && component_registry.to_string() != "None" {
        quote! {
            oxanus::register_component! {
                #component_registry(oxanus::ComponentRegistry {
                    module_path: module_path!(),
                    type_name: stringify!(#struct_ident),
                    definition: || {
                        oxanus::ComponentDefinition::Queue(
                            <#struct_ident as oxanus::Queue>::to_config()
                        )
                    }
                })
            }
        }
    } else {
        quote!()
    };

    quote! {
        #[automatically_derived]
        impl oxanus::Queue for #struct_ident {
            fn to_config() -> oxanus::QueueConfig {
                oxanus::QueueConfig::#kind(#key)
                    #concurrency
                    #throttle
            }
        }

        #registry
    }
}