ora-macros 0.12.7

Part of the Ora scheduler framework.
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

//! Macros for the ora crate.
#![allow(clippy::needless_continue)]

use proc_macro::TokenStream;

use quote::{quote, ToTokens};
use syn::{parse_macro_input, DeriveInput, LitStr};

use darling::FromDeriveInput;

#[derive(FromDeriveInput)]
#[darling(attributes(ora))]
struct JobType {
    #[darling(default = default_output)]
    output: syn::Type,
    namespace: Option<LitStr>,
    name: Option<LitStr>,

    ident: syn::Ident,
}

fn default_output() -> syn::Type {
    syn::parse_quote! { () }
}

impl ToTokens for JobType {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let output = &self.output;

        let job_type_str = match (&self.name, &self.namespace) {
            (None, None) => {
                panic!(r#"#[ora(name = "..")] or #[ora(namespace = "..")] attributes are required"#)
            }
            (Some(_), Some(_)) => {
                panic!(
                    r#"#[ora(name = "..")] and #[ora(namespace = "..")] attributes are mutually exclusive"#
                )
            }
            (None, Some(ns)) => {
                let mut job_type_str = ns.value();

                if !job_type_str.is_empty() {
                    job_type_str.push('.');
                }

                job_type_str.push_str(&self.ident.to_string());
                job_type_str
            }
            (Some(name), None) => name.value(),
        };

        let ident = &self.ident;
        tokens.extend(quote! {
            impl ora::JobType for #ident {
                type Output = #output;

                fn job_type_id() -> ora::JobTypeId {
                    const ID: ora::JobTypeId = ora::JobTypeId::new_const(#job_type_str);
                    ID
                }
            }
        });
    }
}

/// Derive macro for the `JobType` trait.
#[allow(clippy::missing_panics_doc)]
#[proc_macro_derive(JobType, attributes(ora))]
pub fn job_type_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let job_type = JobType::from_derive_input(&input).unwrap();

    quote! {#job_type}.into()
}