sark-gen 0.21.0

Sark proc-macro generators
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

use decode::state;
use handle::decode;

use crate::{
    app::{serve::handle, spec},
    macros::tokens::local,
    runtime::paths::Paths,
};

pub(super) fn generate(
    paths: &Paths,
    ctx: &handle::Context<'_, '_, '_>,
    state: &state::State,
) -> Vec<proc_macro2::TokenStream> {
    let f_state = local("state");
    let symbols = &ctx.plan.spec.state_generics;
    let [n_body, n_call] = symbols.locals(["__body", "__call"]);
    let [n_sess, v_cause] = symbols.locals(["__session", "cause"]);
    let [v_len, v_head] = symbols.locals(["content_length", "head"]);
    use quote::{format_ident, quote};

    let ns_core = &paths.core;

    let prep = &state.prepared;
    let error = format_ident!("{}ProjectError", ctx.plan.spec.name);
    let state_ty = ctx.plan.spec.state.ty();
    let rejects = ctx
        .plan
        .entries
        .iter()
        .filter(|item| item.kind != spec::Kind::Duplex)
        .map(|item| {
            let variant = &item.prepared;
            quote! {
                #prep::#variant(_) =>
                    ::core::result::Result::Err(
                        #ns_core::duplex::OpenError::Unsupported,
                    )
            }
        });
    rejects
        .chain(ctx.exec.duplexes().iter().map(|(item, family)| {
            let entry = item.entry;
            let variant = &item.prepared;
            let slot = &item.request;
            let route = &entry.route;
            let wrapped = ctx.plan.duplex.wrap(*family, quote!(#n_sess));
            quote! {
                #prep::#variant(#slot {
                    head: #v_head,
                    content_length: #v_len,
                }) => {
                    match #v_len {
                        ::core::option::Option::Some(0)
                        | ::core::option::Option::None => {}
                        ::core::option::Option::Some(1..) => {
                            return ::core::result::Result::Err(
                                #ns_core::duplex::OpenError::Length,
                            );
                        }
                    }
                    let #n_body =
                        <<<#route as #ns_core::route::Spec>::Request
                            as #ns_core::route::Schema>::Body
                            as #ns_core::body::Project>::empty::<'_, 'd>();
                    let #n_call = #ns_core::decode::Call::new(
                        #v_head.borrow(),
                        #n_body,
                    );
                    let #n_sess = #n_call.try_open::<#route, #state_ty>(
                        self.#f_state,
                    ).map_err(|#v_cause| {
                        #ns_core::duplex::OpenError::InvalidRequest(
                            #error::#variant(#v_cause),
                        )
                    })?;
                    ::core::result::Result::Ok(#wrapped)
                }
            }
        }))
        .collect()
}