dnet-macros 0.1.0

Macros for dnet
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use syn::Path;

use crate::utils::{crate_path, js_path, rpc_path};

pub mod api;
pub mod consumer;
pub mod producer;
pub mod request;
pub mod response;

pub(crate) struct Paths {
    pub dnet_rpc: Path,
    pub dnet_js: Path,
    pub serde: Path,
}

impl Paths {
    fn default() -> syn::Result<Self> {
        Ok(Paths {
            dnet_rpc: rpc_path()?,
            dnet_js: js_path()?,
            serde: crate_path("serde")?,
        })
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum SerializationConfig {
    Serde(SerdeConfig),
    IntoTransferable,
}

impl Default for SerializationConfig {
    fn default() -> Self {
        SerializationConfig::Serde(SerdeConfig::default())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct SerdeConfig {
    pub serialize: bool,
    pub deserialize: bool,
}

impl SerdeConfig {
    pub const fn all() -> Self {
        Self {
            serialize: true,
            deserialize: true,
        }
    }

    pub const fn none() -> Self {
        Self {
            serialize: false,
            deserialize: false,
        }
    }
}

impl Default for SerdeConfig {
    fn default() -> Self {
        Self::all()
    }
}

#[cfg(test)]
mod tests {
    use proc_macro2::TokenStream;
    use quote::quote;
    use syn::{parse2, ItemTrait};

    use crate::{rpc::Paths, utils::make_path};

    pub fn paths() -> Paths {
        Paths {
            dnet_rpc: make_path(&["dnet_rpc"]),
            dnet_js: make_path(&["dnet_js"]),
            serde: make_path(&["serde"]),
        }
    }

    pub fn parsed_api() -> ItemTrait {
        parse2::<ItemTrait>(api()).unwrap()
    }

    pub fn parsed_api_with_transferable() -> ItemTrait {
        parse2::<ItemTrait>(api_with_transferable()).unwrap()
    }

    fn api() -> TokenStream {
        quote! {
            /// Public api.
            pub trait Api {
                /// Print "Hello World!" message on the server.
                #[no_ack]
                async fn hello_world(&self);

                /// Wait for an acknowledgement from the producer.
                async fn wait_for_ack(&self);

                /// Add two integers.
                async fn add_numbers(&self, a: i32, b: i32) -> i32;

                /// Concatenate two strings.
                async fn concatenate_strings(&self, a: String, b: String) -> String;

                /// Create stream of consequent natural numbers.
                async fn stream_natural_numbers(&self) -> impl Stream<Item = usize>;

                /// Keep sending server time at given interval.
                async fn stream_time(&self, interval: Duration) -> impl Stream<Item = NaiveTime>;

                /// Abortable long-running task.
                #[abortable]
                async fn long_running_task(&self, input: u32) -> String;
            }
        }
    }

    fn api_with_transferable() -> TokenStream {
        quote! {
            /// Public api.
            pub trait Api {
                /// Send OffscreenCanvas to the worker.
                async fn send_transferable(&self, #[transferable] data: OffscreenCanvas);

                /// Get data from worker.
                #[into_transferable]
                async fn get_data(&self) -> Data;
            }
        }
    }
}