timesource-derive 0.1.3

Macros for Timesource crate
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

use proc_macro2::TokenStream;
use syn::{Attribute, Error, Lit};

use crate::encoding::PayloadEncoding;

pub struct EventMeta {
    pub encoding: PayloadEncoding,
    pub version: Option<String>,
}

impl Default for EventMeta {
    fn default() -> Self {
        Self {
            encoding: PayloadEncoding::Json,
            version: None,
        }
    }
}

impl TryFrom<Option<&Attribute>> for EventMeta {
    type Error = TokenStream;

    fn try_from(attr: Option<&Attribute>) -> Result<Self, Self::Error> {
        let mut event_attrs = EventMeta::default();

        if let Some(attr) = attr {
            let meta = attr.parse_meta().unwrap();

            match meta {
                syn::Meta::List(list) => {
                    for nested in list.nested {
                        match nested {
                            syn::NestedMeta::Meta(meta) => match meta {
                                syn::Meta::NameValue(nv) => {
                                    if nv.path.is_ident("encoding") {
                                        if let Lit::Str(lit) = nv.lit {
                                            event_attrs.encoding =
                                                PayloadEncoding::try_from(lit.value().as_ref())
                                                    .unwrap();
                                        }
                                    } else if nv.path.is_ident("version") {
                                        if let Lit::Str(lit) = nv.lit {
                                            event_attrs.version = Some(lit.value());
                                        }
                                    }
                                }
                                meta_type => {
                                    return Err(Error::new_spanned(
                                        meta_type,
                                        "Unexpected meta type",
                                    )
                                    .to_compile_error());
                                }
                            },
                            meta_type => {
                                return Err(Error::new_spanned(
                                    meta_type,
                                    "Unexpected nested meta type",
                                )
                                .to_compile_error());
                            }
                        }
                    }
                }
                meta_type => {
                    return Err(
                        Error::new_spanned(meta_type, "Unexpected meta type").to_compile_error()
                    )
                }
            }
        }

        Ok(event_attrs)
    }
}

impl quote::ToTokens for EventMeta {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let version_token = match self.version.clone() {
            Some(version) => quote!(std::option::Option::Some(#version)),
            None => quote!(std::option::Option::None),
        };

        let payload_kind_token = match self.encoding {
            PayloadEncoding::Json => quote!(timesource::PayloadEncoding::Json),
            PayloadEncoding::Cbor => quote!(timesource::PayloadEncoding::Cbor),
            PayloadEncoding::ProtoBuf => quote!(timesource::PayloadEncoding::ProtoBuf),
        };

        let mut encoding_token = TokenStream::new();
        self.encoding.to_tokens(&mut encoding_token);

        tokens.extend(quote! {
            fn version() -> Option<&'static str> {
                #version_token
            }

            fn encoding() -> timesource::PayloadEncoding {
                #payload_kind_token
            }

            #encoding_token
        });
    }
}