sweet_macros 0.2.0

macro crate for sweet
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

// use super::*;
use super::parse_test_case;
use super::TestCaseFlags;
use proc_macro2::Literal;
use proc_macro2::TokenStream;
use quote::quote;
use syn::ItemFn;
use syn::ReturnType;

pub struct TestCaseAttr {
    // pub out: TokenStream,
}

impl TestCaseAttr {
    pub fn parse(
        attr: proc_macro::TokenStream,
        input: proc_macro::TokenStream,
    ) -> syn::Result<TokenStream> {
        let func = syn::parse::<ItemFn>(input)?;

        // panic!("Not implemented, maybe never will");
        let func_out = func.clone();
        let ident = func.sig.ident;
        let attr: TokenStream = attr.into();
        let mut attr = attr.into_iter().peekable();

        let mut flags = TestCaseFlags::parse(&mut attr)?.checking_sub_attributes(&func.attrs);
        let name = ident.to_string().replace("_", " ");
        flags.name = Literal::string(&name);

        let is_async = func.sig.asyncness.is_some();
        let is_result = func.sig.output != ReturnType::Default;

        let wrapped = match (is_async, is_result) {
            (true, true) => quote! {#ident().await?;},
            (true, false) => quote! {#ident().await;},
            (false, true) => quote! {#ident()?;},
            (false, false) => quote! {#ident();},
        };

        let submit = parse_test_case(&wrapped, &flags);
        let out = quote! {
            #func_out
            #submit
        }
        .into();
        Ok(out)
    }
}