restep 0.3.0

Simple and useful REST API endpoint generator
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use darling::FromMeta;
use proc_macro::TokenStream;
use quote::quote;
use std::collections::VecDeque;
use syn::{AttributeArgs, ImplItemMethod, Stmt, TypePath};

macro_rules! unwrap_darling {
    ($condition:expr) => {
        match $condition {
            Ok(v) => v,
            Err(e) => return TokenStream::from(e.write_errors()).into(),
        }
    };
}

#[derive(Default, FromMeta)]
struct EndpointArgs {
    #[darling(default)]
    params: Option<TypePath>,
    #[darling(default = "default_name")]
    name: String,
}

fn default_name() -> String {
    "endpoint".to_string()
}

pub fn parse_attr(args: AttributeArgs, item: BodyItem) -> proc_macro2::TokenStream {
    embed(quote_fn_endpoint(args), item)
}

pub enum BodyItem {
    ItemFn(syn::ItemFn),
    ItemImpl(syn::ItemImpl),
}

fn quote_fn_endpoint(args: AttributeArgs) -> proc_macro2::TokenStream {
    let endpoint = unwrap_darling!(parse_endpoint(&args));
    let path_params = unwrap_darling!(extract_path_params(&endpoint));
    let path_params = path_params
        .iter()
        .map(|d| syn::Ident::from_string(d).unwrap());
    let path_params2 = path_params.clone();
    let args = unwrap_darling!(EndpointArgs::from_list(&args));
    let fn_name = syn::Ident::from_string(&args.name).unwrap();

    if let Some(params) = args.params {
        let params_ty = params.path.get_ident().unwrap();
        quote! {
            fn #fn_name(params: &#params_ty) -> String {
                #(
                    let #path_params = &params.#path_params;
                )*
                format!(#endpoint, #(#path_params2 = #path_params2),*)
            }
        }
    } else {
        quote! {
            fn #fn_name() -> String {
                format!(#endpoint)
            }
        }
    }
}

fn embed(fn_endpoint: proc_macro2::TokenStream, item: BodyItem) -> proc_macro2::TokenStream {
    match item {
        BodyItem::ItemFn(mut item) => {
            // e.g.
            // fn something() {
            //     fn endpoint() { ... }
            // }
            let fn_endpoint = syn::parse::<Stmt>(fn_endpoint.into()).unwrap();
            item.block.stmts.insert(0, fn_endpoint);
            quote!(#item)
        }
        BodyItem::ItemImpl(mut item) => {
            // e.g)
            // impl Something {
            //     fn endpoint() { ... }
            // }
            let fn_endpoint = syn::parse::<ImplItemMethod>(fn_endpoint.into()).unwrap();
            item.items.push(syn::ImplItem::Method(fn_endpoint));
            quote!(#item)
        }
    }
}

fn parse_endpoint(args: &AttributeArgs) -> darling::Result<String> {
    let endpoint = args
        .first()
        .ok_or_else(|| darling::Error::missing_field("endpoint"))
        .map(String::from_nested_meta)??;
    Ok(endpoint)
}

fn extract_path_params(endpoint: &str) -> darling::Result<Vec<String>> {
    let mut result = Vec::new();
    let mut current = VecDeque::new();
    let mut is_dyn = false;
    for char in endpoint.chars() {
        match char {
            '{' => {
                is_dyn = true;
            }
            '}' => {
                is_dyn = false;
                result.push(current.drain(0..).collect());
            }
            _ if is_dyn => {
                current.push_back(char);
            }
            _ => {}
        }
    }
    Ok(result)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_endpoint() {
        assert_eq!(
            extract_path_params("/static").unwrap(),
            Vec::<String>::new()
        );
        assert_eq!(extract_path_params("/static/{id}").unwrap(), vec!["id"]);
        assert_eq!(
            extract_path_params("/static/{id}/{second}").unwrap(),
            vec!["id", "second"]
        );
    }
}