human-time-macros 0.1.8

This is a library for human readable elapsed time string
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

use std::collections::BTreeMap;

use proc_macro::TokenStream;
use quote::{__private::Span, quote};
use syn::{
    parse::Parse, parse_macro_input, punctuated::Punctuated, Error, Ident, Lit, Meta,
    MetaNameValue, Token,
};
use syn::{parse::ParseStream, ItemFn};
use syn::{parse::Result, NestedMeta};

#[derive(Debug)]
struct Args {
    attributes: BTreeMap<String, String>,
}

impl Parse for Args {
    fn parse(input: ParseStream) -> Result<Self> {
        try_parse(input)
    }
}

fn try_parse(input: ParseStream) -> Result<Args> {
    let args = Punctuated::<NestedMeta, Token![,]>::parse_terminated(input)?;

    let attributes = args
        .iter()
        .map(|arg| match arg {
            NestedMeta::Meta(Meta::NameValue(MetaNameValue {
                lit: Lit::Str(lit_str),
                path,
                ..
            })) => (
                path.segments.first().unwrap().ident.to_string(),
                lit_str.value(),
            ),
            _ => panic!("illegal arguments, example: output=\"eprintln\""),
        })
        .collect::<BTreeMap<_, _>>();
    if attributes.get("output").map(|x| x.trim().is_empty()) == Some(true) {
        return Err(error("output must be specified"));
    }
    Ok(Args { attributes })
}

fn error(msg: &str) -> Error {
    Error::new(Span::call_site(), msg)
}

#[proc_macro_attribute]
pub fn elapsed(args: TokenStream, func: TokenStream) -> TokenStream {
    let args: Args = parse_macro_input!(args as Args);

    let output_target = match args.attributes.get("output") {
        Some(s) => s.to_string(),
        _ => "println".to_string(),
    };

    let output_target = Ident::new(output_target.as_str(), Span::call_site());

    let func = parse_macro_input!(func as ItemFn);
    let vis = &func.vis;
    let block = &func.block;

    let signature = func.sig;
    let asyncness = &signature.asyncness;
    let constness = &signature.constness;
    let unsafety = &signature.unsafety;
    let abi = &signature.abi;
    let ident = &signature.ident;
    let name_str = ident.to_string();
    let generics = &signature.generics;
    let inputs = &signature.inputs;
    let output = &signature.output;
    let where_clause = &signature.generics.where_clause;

    let new_fn = quote! {

        #vis #constness #asyncness #unsafety #abi fn #ident #generics(#inputs) #output #where_clause {
            use std::time;

            let start = time::Instant::now();
            let fn_return_value = #block;
            #output_target!("fn {} costs {}", #name_str, human_time::human_time(start.elapsed()));
            fn_return_value
        }
    };

    new_fn.into()
}