kf-protocol-derive 0.2.0

Procedure macro to encode/decode rust structure/enum using kafka protocol
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

use syn::{
    Expr, Fields, FieldsNamed, FieldsUnnamed, Generics, Ident, ItemEnum, Lit, Meta, NestedMeta,
    Variant, ExprLit, ExprUnary, Error
};
use syn::spanned::Spanned;
use proc_macro2::TokenStream;
use quote::quote;

pub(crate) struct KfEnum {
    pub enum_ident: Ident,
    pub props: Vec<EnumProp>,
    pub generics: Generics,
}

impl KfEnum {
    pub fn from_ast(item: ItemEnum) -> syn::Result<Self> {
        
        let enum_ident = item.ident;
        
        let mut props = vec![];
        for variant in item.variants {
            props.push(EnumProp::from_ast(variant)?);
        }

        let generics = item.generics;

        Ok(KfEnum {
            enum_ident,
            props,
            generics,
        })
    }
}


pub(crate) enum DiscrimantExpr {
    Lit(ExprLit),
    Unary(ExprUnary)
}

impl DiscrimantExpr {

    pub fn as_token_stream(&self) -> TokenStream {
        match self {
            Self::Lit(exp) => quote! { #exp },
            Self::Unary(exp) => quote! { #exp }
        }
    }
}



#[derive(Default)]
pub(crate) struct EnumProp {
    pub variant_name: String,
    pub tag: Option<String>,
    pub discriminant: Option<DiscrimantExpr>,
    pub kind: FieldKind,
}
impl EnumProp {
    pub fn from_ast(variant: Variant) -> syn::Result<Self> {
        
        let mut prop = EnumProp::default();
        let variant_ident = variant.ident.clone();
        prop.variant_name = variant_ident.to_string();
        // Find all supported field level attributes in one go.
        for attribute in &variant.attrs {
            if attribute.path.is_ident("fluvio_kf") {
                if let Ok(Meta::List(list)) = attribute.parse_meta() {
                    for kf_attr in list.nested {
                        if let NestedMeta::Meta(Meta::NameValue(name_value)) = kf_attr {
                            if name_value.path.is_ident("tag") {
                                // if let Lit::Str(lit_str) = name_value.lit {
                                //     prop.tag = Some(lit_str.value());
                                // }
                                if let Lit::Int(lit_int) = name_value.lit {
                                    prop.tag = Some(lit_int.base10_digits().to_owned());
                                }
                            }
                        }
                    }
                }
            }
        }
        prop.discriminant = if let Some((_,discriminant)) = variant.discriminant {
            match discriminant {
                Expr::Lit(elit) =>  {
                    Some(DiscrimantExpr::Lit(elit))
                },
                Expr::Unary(elit) => {
                    Some(DiscrimantExpr::Unary(elit))
                },
                _ => {
                    return Err(Error::new(discriminant.span(), "not supported discriminant type"))
                }
            }
        } else {
            None
        };
        
        /*
        if let Some((_, Expr::Lit(elit))) = &variant.discriminant {
            if let Lit::Int(lit_int) = &elit.lit {
                Some(lit_int.base10_digits().to_owned())
            } else {
                None
            }
        } else {
            None
        };
        */
        prop.kind = match &variant.fields {
            Fields::Named(struct_like) => FieldKind::Named(struct_like.clone()),
            Fields::Unnamed(tuple_like) => FieldKind::Unnamed(tuple_like.clone()),
            _ => FieldKind::Unit,
        };
        Ok(prop)
    }
}

pub(crate) enum FieldKind {
    Named(FieldsNamed),
    Unnamed(FieldsUnnamed),
    Unit,
}
impl Default for FieldKind {
    fn default() -> Self {
        Self::Unit
    }
}