fav_derive 0.0.4

Derive macros for fav
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

// The derive macros for `fav_core::api`

use proc_macro::TokenStream;
use quote::quote;
use syn::{parenthesized, parse_macro_input, DeriveInput, Expr, Ident, LitStr};

pub(crate) fn derive_api(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    let mut endpoint: LitStr = syn::parse_str("\"\"").unwrap();
    let mut params: Expr = syn::parse_str("&[]").unwrap();
    let mut method: Ident = syn::parse_str("GET").unwrap();
    let mut cookies: Expr = syn::parse_str("&[]").unwrap();

    if let Some(attr) = input.attrs.iter().find(|&attr| attr.path().is_ident("api")) {
        attr.parse_nested_meta(|meta| {
            if let Some(i) = meta.path.get_ident() {
                let content;
                parenthesized!(content in meta.input);
                match i.to_string().as_str() {
                    "endpoint" => {
                        endpoint = content.parse()?;
                    }
                    "params" => {
                        params = content.parse()?;
                    }
                    "method" => {
                        method = content.parse()?;
                    }
                    "cookies" => {
                        cookies = content.parse()?;
                    }
                    attr => return Err(meta.error(format!("unknown attribute {attr}"))),
                }
            }
            Ok(())
        })
        .unwrap();
    };

    let expanded = quote! {
        impl #impl_generics fav_core::api::Api for #name #ty_generics #where_clause {
            #[inline]
            fn endpoint(&self) -> &'static str {
                #endpoint
            }
            #[inline]
            fn params(&self) -> &[&str] {
                #params
            }
            #[inline]
            fn cookie_keys(&self) -> &[&str] {
                #cookies
            }
            #[inline]
            fn method(&self) -> reqwest::Method {
                reqwest::Method::#method
            }
        }
    };

    TokenStream::from(expanded)
}