mocktoffel 0.1.0

easy to use mocking library with minimal boilerplate
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

use crate::branch::get_mocking_candidate;
use proc_macro::TokenStream;
use quote::quote;
use syn::{Field, Fields, ItemEnum, ItemStruct};

pub trait Toffelise {
    fn replace_mocks(self) -> TokenStream;
}

impl Toffelise for ItemStruct {
    fn replace_mocks(self) -> TokenStream {
        let struct_name = self.ident;
        let generics = self.generics;

        match self.fields {
            Fields::Named(named) => {
                let fields: Vec<Field> = named
                    .named
                    .into_iter()
                    .map(|mut field| {
                        if field
                            .attrs
                            .iter()
                            .any(|attr| attr.meta.path().is_ident("mocked"))
                        {
                            field.attrs = vec![];
                            field.ty = get_mocking_candidate(&field.ty).mocked_type;
                        }
                        field
                    })
                    .collect();

                TokenStream::from(quote! {
                       struct #struct_name #generics {
                             #(#fields),*
                       }
                })
            }

            Fields::Unnamed(un) => {
                let fields: Vec<Field> = un
                    .unnamed
                    .into_iter()
                    .map(|mut field| {
                        if field
                            .attrs
                            .iter()
                            .any(|attr| attr.meta.path().is_ident("mocked"))
                        {
                            field.attrs = vec![];
                            field.ty = get_mocking_candidate(&field.ty).mocked_type;
                        }
                        field
                    })
                    .collect();

                TokenStream::from(quote! {
                   struct #struct_name #generics(
                         #(#fields),*
                    );

                })
            }
            Fields::Unit => unreachable!(),
        }
    }
}

impl Toffelise for ItemEnum {
    fn replace_mocks(self) -> TokenStream {
        let enum_name = self.ident;
        let generics = self.generics;

        let variants = self
            .variants
            .into_iter()
            .fold(vec![], |mut var, mut variant| {
                match variant.fields {
                    Fields::Unnamed(ref mut un) => un.unnamed.iter_mut().for_each(|f| {
                        if f.attrs
                            .iter()
                            .any(|attr| attr.meta.path().is_ident("mocked"))
                        {
                            f.ty = get_mocking_candidate(&f.ty).mocked_type;
                            f.attrs = vec![];
                        }
                    }),
                    Fields::Unit => {}
                    Fields::Named(_) => unreachable!(),
                };

                var.push(variant);
                var
            });

        TokenStream::from(quote! {
            enum #enum_name #generics {
                #(#variants),*
            }
        })
    }
}