blockz_derive 0.2.1

Blockz is an opinionated library that aims to make it a pleasure to develop networked applications in Rust.
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

//! Direct configuration factory.

use quote::quote;

use syn::DeriveInput;

use crate::factory::ReusableFactory;
use crate::paths;

use super::ConfigurationOpts;
use super::DynFactory;
use super::DynFactoryProduct;

/// Factory that builds a Configuration implementation based on DirectConfiguration.
pub(super) struct DirectConfigurationFactory {
    input: DeriveInput,
}

impl DirectConfigurationFactory {
    /// Create a new direct configuration factory.
    pub fn new_dyn(input: DeriveInput, _: &mut ConfigurationOpts) -> DynFactory {
        Box::new(Self { input })
    }
}

impl ReusableFactory for DirectConfigurationFactory {
    type Product = DynFactoryProduct;

    fn build(&mut self) -> Self::Product {
        // gather paths to dependencies
        let blockz = paths::blockz_path();

        // return the implementation
        let type_name = &self.input.ident;
        Ok(quote! {
            #[automatically_derived]
            #[async_trait::async_trait]
            impl #blockz::configuration::Configuration for #type_name {
                type Opts = #type_name;
                type Result = <#blockz::configuration::DirectConfiguration<#type_name> as #blockz::configuration::Configuration>::Result;

                async fn load(opts: Self::Opts) -> Self::Result {
                    <#blockz::configuration::DirectConfiguration<#type_name> as #blockz::configuration::Configuration>::load(opts).await
                }
            }
        })
    }
}