auto_http_derive/

lib.rs

use proc_macro::TokenStream;
use proc_macro2::{Delimiter::Parenthesis, Group, Ident, Literal, Punct, Spacing, Span};
use quote::*;
use regex::Regex;
use std::{fs::read_to_string, path::Path};

mod shared;

use shared::{append_module_as_str, walk_through_dir};

fn http_specs(module_path: &String) -> [String; 2] {
    let module_pattern =
        Regex::new("crate::app::(\\w+)::api::(\\w+)").expect("Is not possible to mount regexp");
    let mut spec = [String::from("get"), String::from("")];
    let caps = module_pattern.captures(&module_path).expect(&format!(
        "The module `{}` don't follow the convetion",
        module_path
    ));
    let module_domain = inflector::string::pluralize::to_plural(caps.get(1).unwrap().as_str());
    let module_name = caps.get(2).unwrap().as_str();

    if !module_name.starts_with("get") && !module_name.starts_with("post") {
        panic!(
            "{} - invalid module name, api modules should starts with `post` or `get`",
            module_path
        )
    }

    let mut module_pieces = module_name.split("_");
    spec[0] = module_pieces.next().unwrap().to_string();
    spec[1] = format!("/{}", module_domain);

    let mut set_param = false;
    while let Some(piece) = module_pieces.next() {
        // If the module name have piece name equal to module name don't set it on endpoint
        // This rule is for case where developer not feel comfortable with mod name like: get or
        // post, and give name to module like get_products where the domain of api is products too.
        if spec[1].ends_with(piece) {
            continue;
        }

        // When a piece of module name is uppercase or is called id in this case it is a parameter and need
        // to be setted on endpoint
        if piece.to_uppercase() == piece || piece == "id" {
            spec[1] = format!("{}/:{}", spec[1], piece.to_lowercase());
            // I don't have any idea about how determine if it have more piece to set a slash
            set_param = true;
            continue;
        }

        // It previne to append more data where it is url parameter
        if set_param {
            spec[1] += "/";
            set_param = false;
        }

        if spec[1].ends_with(&module_domain) {
            spec[1] += "/";
        }

        if spec[1].ends_with("/") {
            spec[1] = format!("{}{}", spec[1], piece);
            continue;
        }

        // In normal case it append module name piece with "-"
        // ex: module_name: get_profile_posts -> endpoint: profile-posts
        spec[1] = format!("{}-{}", spec[1], piece);
    }

    spec
}

#[derive(Debug)]
struct RouteToken {
    method: String,
    endpoint: String,
    handle: String,
}

impl RouteToken {
    fn new(module_path: String, fn_name: Option<&str>) -> Self {
        let spec = http_specs(&module_path);
        RouteToken {
            method: spec[0].clone(),
            endpoint: spec[1].clone(),
            handle: module_path + "::" + fn_name.unwrap_or("handle"),
        }
    }
}

impl ToTokens for RouteToken {
    fn to_tokens(&self, tokens: &mut __private::TokenStream) {
        let mut handle_token = proc_macro2::TokenStream::new();
        let mut route_call_tokens = proc_macro2::TokenStream::new();
        // "endpoint/here"
        route_call_tokens.append(Literal::string(&self.endpoint));
        route_call_tokens.append(Punct::new(',', Spacing::Alone));
        // ex: axum::routing::{get|post}
        append_module_as_str(
            format!("axum::routing::{}", self.method).as_str(),
            &mut route_call_tokens,
        );
        // ex: crate::products::api::get_products::handle
        append_module_as_str(&self.handle, &mut handle_token);
        route_call_tokens.append(Group::new(Parenthesis, handle_token));

        tokens.append(Punct::new('.', Spacing::Alone));
        tokens.append(Ident::new("route", Span::call_site()));
        tokens.append(Group::new(Parenthesis, route_call_tokens));
    }
}

fn read_code(path: &str) {
    let tokens: proc_macro2::TokenStream = read_to_string(path).unwrap().parse().unwrap();
    // for token in tokens {
    //     match token {
    //         proc_macro2::TokenTree::Ident(ident) => {
    //             if ident.to_string().eq("handle") {
    //                 println!("{:?}", ident)
    //             }
    //         }
    //         proc_macro2::TokenTree::Group(group) => {
    //             println!("{:?}", group);
    //         }
    //         _ => {}
    //     }
    // }
}

fn write_configure_router_function(
    container: &str,
    input: proc_macro2::TokenStream,
    routes: &Vec<RouteToken>,
) -> proc_macro2::TokenStream {
    let mut fn_name = String::new();

    if container.starts_with("crate::") && container.starts_with("super::") {
        panic!("The first attribute needs to have fully namespace, like crate::Container or super::Container.");
    }

    for token in input.clone() {
        match token {
            proc_macro2::TokenTree::Ident(ident) => {
                if !["pub", "async", "fn"].contains(&ident.to_string().as_str()) {
                    fn_name = ident.to_string();
                    break;
                }
            }
            _ => {}
        }
    }

    if fn_name.is_empty() {
        panic!("Cannot get name from token {:?}", input.to_string());
    }

    let founded_routes = routes.len();
    let ident = format_ident!("{}", fn_name);
    let mut container_type = quote! {};
    append_module_as_str(container, &mut container_type);
    quote! {
        pub struct Request {}

        pub fn #ident() -> axum::Router<#container_type> {
            println!("{} configured routes.", #founded_routes);
            let mut router = axum::Router::<#container_type>::new()
            #(#routes)*;
            router
        }
    }
}

/// This macro iterate through all matches directories, when it founds
/// some rs files it looks for function called handle and automatically
/// configure it on axum.
/// The first parameter is the file tree pattern
/// always use it with '*' wildcards patterns ex: /src/app/*/api/*.rs
/// The second parameter of this macro is the container struct name, container
/// means to state type that the router are going to receiver
/// example of usage
/// config/mod.rs
/// #[configure_routes("./src/app/*/api/*.rs", crate::Container)]
/// pub fn config_routes(){}
#[proc_macro_attribute]
pub fn configure_routes(input: TokenStream, body: TokenStream) -> TokenStream {
    let attrs_string = input.to_string().replace("\"", "");
    let (pattern, container) = attrs_string
        .split_once(",")
        .expect("This macro needs two attributes: file tree pattern and container mod.");

    if !pattern.ends_with(".rs") {
        panic!(
            "The provided: {} pattern needs to ends with `.rs` file extension.",
            pattern
        );
    }

    let root_directory = pattern
        .split_once("*")
        .expect("only `/src/*/path/*.rs` pattern is acceptable.")
        .0;

    let path = Path::new(root_directory);
    let regexp = Regex::new(&pattern.replace("*", "\\w+")).expect(&format!(
        "Impossibly to build the provided pattern {}",
        pattern
    ));

    if !path.is_dir() {
        panic!(
            "Directory {} not found.",
            path.as_os_str().to_str().unwrap()
        );
    }

    let mut routes = vec![];
    walk_through_dir(path, &mut |_, entry| {
        let str = entry.to_str().unwrap().replace("\\", "/");
        // If the current file is under DOMAIN_NAME/api/ tree set it as a route
        if regexp.is_match(&str) && !str.ends_with("mod.rs") {
            read_code(&str);
            let ident = format!(
                "crate::{}",
                str.trim_start_matches("./src/")
                    .trim_end_matches(".rs")
                    .replace("/", "::")
            );

            routes.push(RouteToken::new(ident, None));
        }
    });

    write_configure_router_function(container, body.into(), &routes).into()
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use proc_macro::TokenStream;
    use quote::*;

    use crate::{configure_routes, http_specs, write_configure_router_function, RouteToken};

    #[test]
    fn generate_routes() {
        let route_tokens = vec![
            RouteToken::new("crate::app::products::api::get_products".to_owned(), None),
            RouteToken::new("crate::app::products::api::get_id".to_owned(), None),
            RouteToken::new("crate::app::products::api::post_products".to_owned(), None),
        ];

        let expected = quote! {
            let mut router = Router::<Container>::new()
            .route("/products", axum::routing::get(crate::app::products::api::get_products::handle))
            .route("/products/:id", axum::routing::get(crate::app::products::api::get_id::handle))
            .route("/products", axum::routing::post(crate::app::products::api::post_products::handle));
        };

        let tokens = quote! {
            let mut router = Router::<Container>::new()
            #(#route_tokens)*;
        };

        assert_eq!(tokens.to_string(), expected.to_string())
    }

    #[test]
    fn route_token_to_token_stream() {
        let token = RouteToken::new("crate::app::products::api::get_products".to_owned(), None);
        let comp = quote! { .route("/products", axum::routing::get(crate::app::products::api::get_products::handle)) };
        assert_eq!(token.into_token_stream().to_string(), comp.to_string());
    }

    #[test]
    fn test_http_specs() {
        let expected = [String::from("get"), String::from("/products")];
        assert_eq!(
            expected,
            http_specs(&String::from("crate::app::products::api::get_products"))
        );
    }

    #[test]
    fn test_http_specs_with_id() {
        let expected = [String::from("get"), String::from("/products/:id")];
        assert_eq!(
            expected,
            http_specs(&String::from("crate::app::products::api::get_id"))
        );
    }

    #[test]
    fn test_http_specs_multiple_params() {
        let expected = [
            String::from("get"),
            String::from("/products/:id/order/:order"),
        ];
        assert_eq!(
            expected,
            http_specs(&String::from(
                "crate::app::products::api::get_id_order_ORDER"
            ))
        );
    }

    #[test]
    fn test_http_specs_post_method() {
        let expected = [String::from("post"), String::from("/products")];
        assert_eq!(
            expected,
            http_specs(&String::from("crate::app::products::api::post_products"))
        );
    }

    #[test]
    fn test_http_specs_only_module_method() {
        let expected = [String::from("post"), String::from("/products")];
        assert_eq!(
            expected,
            http_specs(&String::from("crate::app::products::api::post"))
        );
    }

    #[test]
    fn test_transform_configure_routes_fn() {
        // No routes
        let routes = vec![];

        let input = quote! {
            pub fn config_routes() {}
        };

        let generated =
            write_configure_router_function("crate::Container", input, &routes).to_string();

        let expected = quote! {
            pub fn config_routes() -> axum::Router<crate::Container> {
                println!("{} configured routes.", 0usize);
                let mut router = axum::Router::<crate::Container>::new();
                router
            }
        };

        assert_eq!(generated, expected.to_string());
    }
}