channel-protocol 0.3.0

Enable function-based communication instead of enum message sending. All based on channels.
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

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use syn::{parse::Parse, punctuated::Punctuated};

use crate::{client, enum_message, handler};

#[derive(Debug)]
pub struct Protocol {
    pub vis: syn::Visibility,
    pub ident: syn::Ident,
    pub messages: Vec<ProtocolMessage>,
}

impl Parse for Protocol {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let vis: syn::Visibility = input.parse()?;
        let _: syn::Token![trait] = input.parse()?;
        let ident: syn::Ident = input.parse()?;
        let content;
        let _ = syn::braced!(content in input);
        let mut messages = Vec::new();
        while !content.is_empty() {
            messages.push(content.parse()?);
        }
        Ok(Self {
            vis,
            ident,
            messages,
        })
    }
}

#[derive(Debug)]
pub struct ProtocolMessage {
    pub ident: syn::Ident,
    pub args: syn::punctuated::Punctuated<ProtocolMessageFnArg, syn::Token![,]>,
    pub output: syn::ReturnType,
}

impl Parse for ProtocolMessage {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let _: syn::Token![fn] = input.parse()?;
        let ident: syn::Ident = input.parse()?;
        let content;
        let _ = syn::parenthesized!(content in input);
        let args = Punctuated::parse_terminated(&content)?;
        let output: syn::ReturnType = input.parse()?;
        let _: syn::Token![;] = input.parse()?;
        Ok(Self {
            ident,
            args,
            output,
        })
    }
}

impl ToTokens for ProtocolMessage {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            ident,
            args,
            output,
        } = self;
        tokens.extend(quote! {
            fn #ident(#args) #output;
        });
    }
}

#[derive(Debug)]
pub struct ProtocolMessageFnArg {
    pub ident: syn::Ident,
    pub ty: syn::Type,
}

impl Parse for ProtocolMessageFnArg {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let ident: syn::Ident = input.parse()?;
        let _: syn::Token![:] = input.parse()?;
        let ty: syn::Type = input.parse()?;
        Ok(Self { ident, ty })
    }
}

impl ToTokens for ProtocolMessageFnArg {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self { ident, ty, .. } = self;
        tokens.extend(quote! {
            #ident: #ty
        });
    }
}

pub fn build(input: TokenStream) -> TokenStream {
    let protocol = syn::parse2::<Protocol>(input)
        .expect("Wrong syntax. An fully valid trait declaration is expected");

    let message_enum = enum_message::build(&protocol);
    let client = client::build(&protocol);
    let handler = handler::build(&protocol);

    quote! {
        #message_enum
        #client
        #handler
    }
}