drylib-procs 0.1.13

Rust macro-library for Don't Repeating Yourself
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

use proc_macro::{
    Span,
    Ident,
    Punct,
    Spacing,
    Delimiter,
    Group,
    TokenTree,
    TokenStream
};

fn get_getters(fields: Vec::<TokenTree>, types: Vec::<Vec::<TokenTree>>, vis: Vec::<TokenTree>, muts: bool) -> Vec::<TokenTree> {
    let mut braces_group = Vec::new();
    let fn_params = vec![TokenTree::Punct(Punct::new('&', Spacing::Joint)),
                         TokenTree::Ident(Ident::new("self", Span::call_site()))];
            
    let mut_fn_params = vec![TokenTree::Punct(Punct::new('&', Spacing::Joint)),
                             TokenTree::Ident(Ident::new("mut", Span::call_site())),
                             TokenTree::Ident(Ident::new("self", Span::call_site()))];

    let arrow = vec![TokenTree::Punct(Punct::new('-', Spacing::Joint)),
                     TokenTree::Punct(Punct::new('>', Spacing::Alone))];

    for (field, types) in fields.iter().zip(types.iter()) {
        braces_group.extend(vis.clone());
        braces_group.push(TokenTree::Ident(Ident::new("fn", Span::call_site())));
        if muts {
            braces_group.push(TokenTree::Ident(Ident::new(&format!("mut_{field}"), Span::call_site())));
        } else {
            braces_group.push(field.clone());
        }
        if muts {
            braces_group.push(TokenTree::Group(Group::new(Delimiter::Parenthesis,
                                                          TokenStream::from_iter(mut_fn_params.clone()))));
        } else {
            braces_group.push(TokenTree::Group(Group::new(Delimiter::Parenthesis,
                                                          TokenStream::from_iter(fn_params.clone()))));
        }

        braces_group.extend(arrow.clone());
        braces_group.push(TokenTree::Punct(Punct::new('&', Spacing::Joint)));
        if muts { braces_group.push(TokenTree::Ident(Ident::new("mut", Span::call_site()))); }
        braces_group.extend(types.clone());

        let mut fn_body = Vec::new();
        if muts { fn_body.extend(mut_fn_params.clone()); }
        else    { fn_body.extend(fn_params.clone());     }
        fn_body.push(TokenTree::Punct(Punct::new('.', Spacing::Joint)));
        fn_body.push(field.clone());

        braces_group.push(TokenTree::Group(Group::new(Delimiter::Brace,
                                                      TokenStream::from_iter(fn_body.clone()))));
    }

    braces_group
}

pub(crate) fn getters(input: TokenStream, muts: bool) -> Vec::<TokenTree> {
    let tokens = input.into_iter().collect::<Vec<_>>();

    let mut vis = Vec::<TokenTree>::new();
    let mut name = None;
    let mut vis_flag = false;
    let mut fields = Vec::<TokenTree>::new();
    let mut types = Vec::<Vec<TokenTree>>::new();
    
    let mut iter = tokens.iter();
    while let Some(token) = iter.next() {
        if let TokenTree::Ident(ident) = token {
            if &ident.to_string() == "pub" {
                vis.push(ident.clone().into());
            } else { name = Some(ident.clone()); }
        } else if let TokenTree::Group(group) = token {
            let mut group_iter = group.stream().into_iter();
            if !vis_flag {
                let ident = group_iter.next().unwrap();
                let ident_string = ident.to_string();
                if &ident_string == "self" || &ident_string == "crate" {
                    let tokens: Vec::<TokenTree> = vec![ident.clone().into()];
                    let group = Group::new(Delimiter::Parenthesis, TokenStream::from_iter(tokens));
                    vis.push(TokenTree::Group(group));
                } vis_flag = true;
            } else {
                let mut next_field = true;
                let mut next_type = false;
                let mut temp = Vec::new();
                while let Some(tt) = group_iter.next() {
                    if next_type {
                        temp.push(tt.clone());
                    } else if next_field {
                        fields.push(tt.clone());
                        next_field = false;
                    } if let TokenTree::Punct(p) = tt {
                        match p.as_char() {
                            ':' => next_type = true,
                            ';' => {
                                next_field = true;
                                next_type = false;
                                let temp_ = temp.iter().take(temp.len() - 1).cloned().collect::<Vec<_>>();
                                types.push(temp_);
                                temp.clear()
                            }
                            _   => {}
                        }
                    }
                }
            }
        }
    }
    
    let braces_group = get_getters(fields, types, vis, muts);

    let ts = vec![TokenTree::from(Ident::new("impl", Span::call_site())),
         name.expect("Failed to find structure's name").into(),
                  TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::from_iter(braces_group)))];
    ts
}