hpl-toolkit-derive-to-node 0.0.2

HPL attribute derive for defining a hashable
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

use quote::quote;
use std::str::FromStr;
use syn::Fields;

pub struct HashableEnum(syn::ItemEnum);

impl HashableEnum {
    pub fn new(input: syn::ItemEnum) -> Self {
        Self(input)
    }
}

impl HashableEnum {
    pub fn render(self) -> proc_macro::TokenStream {
        // User Defined Schema
        let mut enm = self.0.clone();
        let enum_name = &enm.ident;

        let mut schema_fn_to_node_stream: proc_macro2::TokenStream =
            proc_macro2::TokenStream::new();

        // Iterating through User Defined Schema Variants
        enm.variants.iter_mut().for_each(|variant| {
            // User Defined Schema Variat
            let variant_name = &variant.ident;

            let mut schema_fn_to_node_variant = vec![];

            if matches!(variant.fields, Fields::Unit) {
                schema_fn_to_node_variant.push(format!(
                    "Self::{} => keccak::hashv(&[\"{}\".as_bytes()]).to_bytes(),",
                    variant_name, variant_name
                ));
            } else {
                schema_fn_to_node_variant.push(format!("Self::{}  ", variant_name));
                schema_fn_to_node_variant
                    .push(format!("keccak::hashv(&[ \"{}\".as_bytes(),", variant_name));

                if let Fields::Named(fields) = &mut variant.fields {
                    schema_fn_to_node_variant[0].push_str("{");
                    fields.named.iter_mut().for_each(|field| {
                        // User Defined Schema Variant Fields
                        let ident = field.ident.as_ref().unwrap().to_string();

                        // Generated Implementation for fn to_node() for User Defined Schema
                        schema_fn_to_node_variant[0].push_str(&format!("{}, ", ident));
                        schema_fn_to_node_variant.push(format!("{}.to_node().as_ref(),", ident));
                    });

                    schema_fn_to_node_variant[0].push_str("} => ");
                } else if let Fields::Unnamed(fields) = &mut variant.fields {
                    schema_fn_to_node_variant[0].push_str("(");

                    fields.unnamed.iter_mut().enumerate().for_each(|(i, _)| {
                        schema_fn_to_node_variant[0].push_str(&format!("item_{}, ", i));
                        schema_fn_to_node_variant.push(format!("item_{}.to_node().as_ref(),", i));
                    });

                    schema_fn_to_node_variant[0].push_str(") => ");
                }

                schema_fn_to_node_variant.push("]).to_bytes(),".to_string());
            }

            schema_fn_to_node_stream.extend::<proc_macro2::TokenStream>(
                proc_macro2::TokenStream::from_str(&schema_fn_to_node_variant.join("")).unwrap(),
            );
        });

        let stream: proc_macro2::TokenStream = quote! {
            impl ToNode for #enum_name {
                fn to_node(&self) -> [u8; 32] {
                    match self {
                        #schema_fn_to_node_stream
                        _ => {
                            panic!("Unsupported version");
                        }
                    }
                }
            }
        };

        stream.into()
    }
}