Scope macro

actix-web-codegen/CHANGES.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 4.2.3
+
+- Add a scope macro that takes a path
+
 ## 4.2.2
 
 - Fix regression when declaring `wrap` attribute using an expression.

actix-web-codegen/src/lib.rs

@@ -240,3 +240,92 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
     output.extend(item);
     output
 }
+
+/// Generates scope
+///
+/// Syntax: `#[scope("path")]`
+///
+/// Due to current limitation it cannot be applied to modules themself.
+/// Instead one should create const variable that contains module code.
+///
+/// ## Attributes:
+///
+/// - `"path"` - Raw literal string with path for which to register handler. Mandatory.
+///
+/// # Example
+///
+/// ```rust
+/// use actix_web_codegen::{scope};
+///
+/// #[scope("/test")]
+/// const mod_inner: () = {
+/// use actix_web::{HttpResponse, HttpRequest, Responder, put, head, connect, options, trace, patch, delete, web };
+/// use actix_web::web::Json;
+///
+/// #[actix_web::get("/test")]
+/// pub async fn test() -> impl Responder {
+///    mod_test2()
+/// }
+///
+/// #[actix_web::get("/twicetest/{value}")]
+/// pub async fn test_twice(value: web::Path<String>) -> impl actix_web::Responder {
+///    let int_value: i32 = value.parse().unwrap_or(0);
+///    let doubled = int_value * 2;
+///    HttpResponse::Ok().body(format!("Twice value: {}", doubled))
+/// }
+///
+/// #[actix_web::post("/test")]
+/// pub async fn test_post() -> impl Responder {
+///    HttpResponse::Ok().body(format!("post works"))
+/// }    
+///
+/// #[put("/test")]
+/// pub async fn test_put() -> impl Responder {
+///    HttpResponse::Ok().body(format!("put works"))
+/// }    
+///
+/// #[head("/test")]
+/// pub async fn test_head() -> impl Responder {
+///    HttpResponse::Ok().finish()
+/// }
+///
+/// #[connect("/test")]
+/// pub async fn test_connect() -> impl Responder {
+///    HttpResponse::Ok().body("CONNECT works")
+/// }
+///
+/// #[options("/test")]
+/// pub async fn test_options() -> impl Responder {
+///    HttpResponse::Ok().body("OPTIONS works")
+/// }
+///
+/// #[trace("/test")]
+/// pub async fn test_trace(req: HttpRequest) -> impl Responder {
+///    HttpResponse::Ok().body(format!("TRACE works: {:?}", req))
+/// }
+///
+/// #[patch("/test")]
+/// pub async fn test_patch() -> impl Responder {
+///    HttpResponse::Ok().body(format!("patch works"))
+/// }
+///
+/// #[delete("/test")]
+/// pub async fn test_delete() -> impl Responder {
+///    HttpResponse::Ok().body("DELETE works")
+/// }
+///
+/// pub fn mod_test2() -> impl actix_web::Responder {
+///    actix_web::HttpResponse::Ok().finish()
+/// }
+///};
+/// ```
+///
+/// # Note
+///
+/// Internally the macro generate struct with name of scope (e.g. `mod_inner`)
+/// And create public module as `<name>_scope`
+///
+#[proc_macro_attribute]
+pub fn scope(args: TokenStream, input: TokenStream) -> TokenStream {
+    route::ScopeArgs::new(args, input).generate()
+}

actix-web-codegen/src/route.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::{collections::HashSet, fmt};
 
 use actix_router::ResourceDef;
 use proc_macro::TokenStream;
@@ -554,3 +554,143 @@ fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> TokenStrea
     item.extend(compile_err);
     item
 }
+
+/// Implements scope proc macro
+///
+
+struct ScopeItems {
+    handlers: Vec<String>,
+}
+
+impl ScopeItems {
+    pub fn from_items(items: &[syn::Item]) -> Self {
+        let mut handlers = Vec::new();
+
+        for item in items {
+            match item {
+                syn::Item::Fn(ref fun) => {
+                    for attr in fun.attrs.iter() {
+                        for bound in attr.path().segments.iter() {
+                            if bound.ident == "get"
+                                || bound.ident == "post"
+                                || bound.ident == "put"
+                                || bound.ident == "head"
+                                || bound.ident == "connect"
+                                || bound.ident == "options"
+                                || bound.ident == "trace"
+                                || bound.ident == "patch"
+                                || bound.ident == "delete"
+                            {
+                                handlers.push(format!("{}", fun.sig.ident));
+                                break;
+                            }
+                        }
+                    }
+                }
+                _ => continue,
+            }
+        }
+
+        Self { handlers }
+    }
+}
+
+pub struct ScopeArgs {
+    ast: syn::ItemConst,
+    name: syn::Ident,
+    path: String,
+    scope_items: ScopeItems,
+}
+
+impl ScopeArgs {
+    pub fn new(args: TokenStream, input: TokenStream) -> Self {
+        if args.is_empty() {
+            panic!("invalid server definition, expected: #[scope(\"some path\")]");
+        }
+
+        let ast: syn::ItemConst = syn::parse(input).expect("Parse input as module");
+        //TODO: we should change it to mod once supported on stable
+        //let ast: syn::ItemMod = syn::parse(input).expect("Parse input as module");
+        let name = ast.ident.clone();
+
+        let mut items = Vec::new();
+        match ast.expr.as_ref() {
+            syn::Expr::Block(expr) => {
+                for item in expr.block.stmts.iter() {
+                    match item {
+                        syn::Stmt::Item(ref item) => items.push(item.clone()),
+                        _ => continue,
+                    }
+                }
+            }
+            _ => panic!("Scope should containt only code block"),
+        }
+
+        let scope_items = ScopeItems::from_items(&items);
+
+        let mut path = None;
+        if let Ok(parsed) = syn::parse::<syn::LitStr>(args) {
+            path = Some(parsed.value());
+        }
+
+        let path = path.expect("Scope's path is not specified!");
+
+        Self {
+            ast,
+            name,
+            path,
+            scope_items,
+        }
+    }
+
+    pub fn generate(&self) -> TokenStream {
+        let text = self.to_string();
+
+        match text.parse() {
+            Ok(res) => res,
+            Err(error) => panic!("Error: {:?}\nGenerated code: {}", error, text),
+        }
+    }
+}
+
+impl fmt::Display for ScopeArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ast = &self.ast;
+
+        let module_name = format!("{}_scope", self.name);
+        let module_name = syn::Ident::new(&module_name, ast.ident.span());
+        let ast = match ast.expr.as_ref() {
+            syn::Expr::Block(expr) => quote!(pub mod #module_name #expr),
+            _ => panic!("Unexpect non-block ast in scope macro"),
+        };
+
+        writeln!(f, "{}\n", ast)?;
+        writeln!(f, "#[allow(non_camel_case_types)]")?;
+        writeln!(f, "struct {};\n", self.name)?;
+        writeln!(
+            f,
+            "impl actix_web::dev::HttpServiceFactory for {} {{",
+            self.name
+        )?;
+        writeln!(
+            f,
+            "    fn register(self, __config: &mut actix_web::dev::AppService) {{"
+        )?;
+        write!(
+            f,
+            "        let scope = actix_web::Scope::new(\"{}\")",
+            self.path
+        )?;
+
+        for handler in self.scope_items.handlers.iter() {
+            write!(f, ".service({}::{})", module_name, handler)?;
+        }
+
+        writeln!(f, ";\n")?;
+        writeln!(
+            f,
+            "        actix_web::dev::HttpServiceFactory::register(scope, __config)"
+        )?;
+        writeln!(f, "    }}\n}}")
+    }
+}