Scope macro (#3136)

* add scope proc macro

* Update scope macro code to work with current HttpServiceFactory

* started some test code

* add some unit tests

* code formatting cleanup

* add another test for combining and calling 2 scopes

* format code with formatter

* Update actix-web-codegen/src/lib.rs with comment documentation fix

Co-authored-by: oliver <151407407+kwfn@users.noreply.github.com>

* work in progress. revised procedural macro to change othe macro call

* add tests again. refactor nested code.

* clean up code. fix bugs with route and method attributes with parameters

* clean up for rust fmt

* clean up for rust fmt

* fix out of date comment for scope macro

* sync to master branch by adding test_wrap

* needed to format code

* test: split out scope tests

* test: add negative tests

* chore: move imports back inside (?)

* docs: tweak scope docs

* fix: prevent trailing slashes in scope prefixes

* chore: address clippy lints

---------

Co-authored-by: oliver <151407407+kwfn@users.noreply.github.com>
Co-authored-by: Rob Ede <robjtede@icloud.com>

.github/workflows/ci-post-merge.yml

@@ -49,7 +49,7 @@ jobs:
           toolchain: ${{ matrix.version.version }}
 
       - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
-        uses: taiki-e/install-action@v2.33.22
+        uses: taiki-e/install-action@v2.34.0
         with:
           tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
 
@@ -80,7 +80,7 @@ jobs:
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
 
       - name: Install cargo-hack
-        uses: taiki-e/install-action@v2.33.22
+        uses: taiki-e/install-action@v2.34.0
         with:
           tool: cargo-hack
 

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ concurrency:
 jobs:
   read_msrv:
     name: Read MSRV
-    uses: actions-rust-lang/msrv/.github/workflows/msrv.yml@main
+    uses: actions-rust-lang/msrv/.github/workflows/msrv.yml@v0.1.0
 
   build_and_test:
     needs: read_msrv
@@ -54,13 +54,17 @@ jobs:
           echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' >> $GITHUB_ENV
           echo "RUSTFLAGS=-C target-feature=+crt-static" >> $GITHUB_ENV
 
+      - name: Setup mold linker
+        if: matrix.target.os == 'ubuntu-latest'
+        uses: rui314/setup-mold@v1
+
       - name: Install Rust (${{ matrix.version.name }})
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
         with:
           toolchain: ${{ matrix.version.version }}
 
       - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
-        uses: taiki-e/install-action@v2.33.22
+        uses: taiki-e/install-action@v2.34.0
         with:
           tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
 
@@ -109,7 +113,7 @@ jobs:
           toolchain: nightly
 
       - name: Install just
-        uses: taiki-e/install-action@v2.33.22
+        uses: taiki-e/install-action@v2.34.0
         with:
           tool: just
 

.github/workflows/coverage.yml

@@ -22,16 +22,16 @@ jobs:
         with:
           components: llvm-tools-preview
 
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@v2.33.22
+      - name: Install just,cargo-llvm-cov
+        uses: taiki-e/install-action@v2.34.0
         with:
-          tool: cargo-llvm-cov
+          tool: just,cargo-llvm-cov
 
       - name: Generate code coverage
         run: cargo llvm-cov --workspace --all-features --codecov --output-path codecov.json
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4.3.1
+        uses: codecov/codecov-action@v4.4.1
         with:
           files: codecov.json
           fail_ci_if_error: true

.github/workflows/lint.yml

@@ -79,10 +79,10 @@ jobs:
       - name: Install Rust
         uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
         with:
-          toolchain: nightly-2024-04-26
+          toolchain: nightly-2024-06-07
 
       - name: Install cargo-public-api
-        uses: taiki-e/install-action@v2.33.22
+        uses: taiki-e/install-action@v2.34.0
         with:
           tool: cargo-public-api
 

.github/workflows/upload-doc.yml

@@ -1,41 +0,0 @@
-name: Upload Documentation
-
-on:
-  push:
-    branches: [master]
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    permissions:
-      contents: write
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: actions-rust-lang/setup-rust-toolchain@v1.8.0
-        with:
-          toolchain: nightly
-
-      - name: Build Docs
-        run: cargo +nightly doc --no-deps --workspace --all-features
-        env:
-          RUSTDOCFLAGS: --cfg=docsrs
-
-      - name: Tweak HTML
-        run: echo '<meta http-equiv="refresh" content="0;url=actix_web/index.html">' > target/doc/index.html
-
-      - name: Deploy to GitHub Pages
-        uses: JamesIves/github-pages-deploy-action@v4.6.0
-        with:
-          folder: target/doc
-          single-commit: true

actix-http/src/ws/frame.rs

@@ -178,14 +178,14 @@ impl Parser {
         };
 
         if payload_len < 126 {
-            dst.reserve(p_len + 2 + if mask { 4 } else { 0 });
+            dst.reserve(p_len + 2);
             dst.put_slice(&[one, two | payload_len as u8]);
         } else if payload_len <= 65_535 {
-            dst.reserve(p_len + 4 + if mask { 4 } else { 0 });
+            dst.reserve(p_len + 4);
             dst.put_slice(&[one, two | 126]);
             dst.put_u16(payload_len as u16);
         } else {
-            dst.reserve(p_len + 10 + if mask { 4 } else { 0 });
+            dst.reserve(p_len + 10);
             dst.put_slice(&[one, two | 127]);
             dst.put_u64(payload_len as u64);
         };

actix-multipart/README.md

@@ -15,7 +15,6 @@
 
 <!-- prettier-ignore-end -->
 
-
 ## Example
 
 Dependencies:
@@ -65,6 +64,7 @@ async fn main() -> std::io::Result<()> {
 ```
 
 Curl request :
+
 ```bash
 curl -v --request POST \
   --url http://localhost:8080/videos \
@@ -72,7 +72,6 @@ curl -v --request POST \
   -F file=@./Cargo.lock
 ```
 
-
 ### Examples
 
 https://github.com/actix/examples/tree/master/forms/multipart

actix-test/CHANGES.md

@@ -3,8 +3,9 @@
 ## Unreleased
 
 - Add `TestServerConfig::rustls_0_23()` method for Rustls v0.23 support behind new `rustls-0_23` crate feature.
-- Minimum supported Rust version (MSRV) is now 1.72.
+- Add `TestServerConfig::disable_redirects()` method.
 - Various types from `awc`, such as `ClientRequest` and `ClientResponse`, are now re-exported.
+- Minimum supported Rust version (MSRV) is now 1.72.
 
 ## 0.1.3
 

actix-test/src/lib.rs

@@ -149,6 +149,8 @@ where
         StreamType::Rustls023(_) => true,
     };
 
+    let client_cfg = cfg.clone();
+
     // run server in separate orphaned thread
     thread::spawn(move || {
         rt::System::new().block_on(async move {
@@ -460,7 +462,13 @@ where
             }
         };
 
-        Client::builder().connector(connector).finish()
+        let mut client_builder = Client::builder().connector(connector);
+
+        if client_cfg.disable_redirects {
+            client_builder = client_builder.disable_redirects();
+        }
+
+        client_builder.finish()
     };
 
     TestServer {
@@ -480,6 +488,7 @@ enum HttpVer {
     Both,
 }
 
+#[allow(clippy::large_enum_variant)]
 #[derive(Clone)]
 enum StreamType {
     Tcp,
@@ -507,6 +516,7 @@ pub struct TestServerConfig {
     client_request_timeout: Duration,
     port: u16,
     workers: usize,
+    disable_redirects: bool,
 }
 
 impl Default for TestServerConfig {
@@ -524,6 +534,7 @@ impl TestServerConfig {
             client_request_timeout: Duration::from_secs(5),
             port: 0,
             workers: 1,
+            disable_redirects: false,
         }
     }
 
@@ -611,6 +622,15 @@ impl TestServerConfig {
         self.workers = workers;
         self
     }
+
+    /// Instruct the client to not follow redirects.
+    ///
+    /// By default, the client will follow up to 10 consecutive redirects
+    /// before giving up.
+    pub fn disable_redirects(mut self) -> Self {
+        self.disable_redirects = true;
+        self
+    }
 }
 
 /// A basic HTTP server controller that simplifies the process of writing integration tests for

actix-web-codegen/CHANGES.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add `#[scope]` macro.
+- Prevent inclusion of default `actix-router` features.
 - Minimum supported Rust version (MSRV) is now 1.72.
 
 ## 4.2.2

actix-web-codegen/Cargo.toml

@@ -16,7 +16,7 @@ rust-version.workspace = true
 proc-macro = true
 
 [dependencies]
-actix-router = "0.5"
+actix-router = { version = "0.5", default-features = false }
 proc-macro2 = "1"
 quote = "1"
 syn = { version = "2", features = ["full", "extra-traits"] }

actix-web-codegen/src/lib.rs

@@ -83,6 +83,7 @@ use proc_macro::TokenStream;
 use quote::quote;
 
 mod route;
+mod scope;
 
 /// Creates resource handler, allowing multiple HTTP method guards.
 ///
@@ -197,6 +198,43 @@ method_macro!(Options, options);
 method_macro!(Trace, trace);
 method_macro!(Patch, patch);
 
+/// Prepends a path prefix to all handlers using routing macros inside the attached module.
+///
+/// # Syntax
+///
+/// ```
+/// # use actix_web_codegen::scope;
+/// #[scope("/prefix")]
+/// mod api {
+///     // ...
+/// }
+/// ```
+///
+/// # Arguments
+///
+/// - `"/prefix"` - Raw literal string to be prefixed onto contained handlers' paths.
+///
+/// # Example
+///
+/// ```
+/// # use actix_web_codegen::{scope, get};
+/// # use actix_web::Responder;
+/// #[scope("/api")]
+/// mod api {
+///     # use super::*;
+///     #[get("/hello")]
+///     pub async fn hello() -> impl Responder {
+///         // this has path /api/hello
+///         "Hello, world!"
+///     }
+/// }
+/// # fn main() {}
+/// ```
+#[proc_macro_attribute]
+pub fn scope(args: TokenStream, input: TokenStream) -> TokenStream {
+    scope::with_scope(args, input)
+}
+
 /// Marks async main function as the Actix Web system entry-point.
 ///
 /// Note that Actix Web also works under `#[tokio::main]` since version 4.0. However, this macro is
@@ -240,3 +278,15 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
     output.extend(item);
     output
 }
+
+/// Converts the error to a token stream and appends it to the original input.
+///
+/// Returning the original input in addition to the error is good for IDEs which can gracefully
+/// recover and show more precise errors within the macro body.
+///
+/// See <https://github.com/rust-analyzer/rust-analyzer/issues/10468> for more info.
+fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> TokenStream {
+    let compile_err = TokenStream::from(err.to_compile_error());
+    item.extend(compile_err);
+    item
+}

actix-web-codegen/src/route.rs

@@ -6,10 +6,12 @@ use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{punctuated::Punctuated, Ident, LitStr, Path, Token};
 
+use crate::input_and_compile_error;
+
 #[derive(Debug)]
 pub struct RouteArgs {
-    path: syn::LitStr,
-    options: Punctuated<syn::MetaNameValue, Token![,]>,
+    pub(crate) path: syn::LitStr,
+    pub(crate) options: Punctuated<syn::MetaNameValue, Token![,]>,
 }
 
 impl syn::parse::Parse for RouteArgs {
@@ -78,7 +80,7 @@ macro_rules! standard_method_type {
                 }
             }
 
-            fn from_path(method: &Path) -> Result<Self, ()> {
+            pub(crate) fn from_path(method: &Path) -> Result<Self, ()> {
                 match () {
                     $(_ if method.is_ident(stringify!($lower)) => Ok(Self::$variant),)+
                     _ => Err(()),
@@ -542,15 +544,3 @@ pub(crate) fn with_methods(input: TokenStream) -> TokenStream {
         Err(err) => input_and_compile_error(input, err),
     }
 }
-
-/// Converts the error to a token stream and appends it to the original input.
-///
-/// Returning the original input in addition to the error is good for IDEs which can gracefully
-/// recover and show more precise errors within the macro body.
-///
-/// See <https://github.com/rust-analyzer/rust-analyzer/issues/10468> for more info.
-fn input_and_compile_error(mut item: TokenStream, err: syn::Error) -> TokenStream {
-    let compile_err = TokenStream::from(err.to_compile_error());
-    item.extend(compile_err);
-    item
-}

actix-web-codegen/src/scope.rs

@@ -0,0 +1,103 @@
+use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{quote, ToTokens as _};
+
+use crate::{
+    input_and_compile_error,
+    route::{MethodType, RouteArgs},
+};
+
+pub fn with_scope(args: TokenStream, input: TokenStream) -> TokenStream {
+    match with_scope_inner(args, input.clone()) {
+        Ok(stream) => stream,
+        Err(err) => input_and_compile_error(input, err),
+    }
+}
+
+fn with_scope_inner(args: TokenStream, input: TokenStream) -> syn::Result<TokenStream> {
+    if args.is_empty() {
+        return Err(syn::Error::new(
+            Span::call_site(),
+            "missing arguments for scope macro, expected: #[scope(\"/prefix\")]",
+        ));
+    }
+
+    let scope_prefix = syn::parse::<syn::LitStr>(args.clone()).map_err(|err| {
+        syn::Error::new(
+            err.span(),
+            "argument to scope macro is not a string literal, expected: #[scope(\"/prefix\")]",
+        )
+    })?;
+
+    let scope_prefix_value = scope_prefix.value();
+
+    if scope_prefix_value.ends_with('/') {
+        // trailing slashes cause non-obvious problems
+        // it's better to point them out to developers rather than
+
+        return Err(syn::Error::new(
+            scope_prefix.span(),
+            "scopes should not have trailing slashes; see https://docs.rs/actix-web/4/actix_web/struct.Scope.html#avoid-trailing-slashes",
+        ));
+    }
+
+    let mut module = syn::parse::<syn::ItemMod>(input).map_err(|err| {
+        syn::Error::new(err.span(), "#[scope] macro must be attached to a module")
+    })?;
+
+    // modify any routing macros (method or route[s]) attached to
+    // functions by prefixing them with this scope macro's argument
+    if let Some((_, items)) = &mut module.content {
+        for item in items {
+            if let syn::Item::Fn(fun) = item {
+                fun.attrs = fun
+                    .attrs
+                    .iter()
+                    .map(|attr| modify_attribute_with_scope(attr, &scope_prefix_value))
+                    .collect();
+            }
+        }
+    }
+
+    Ok(module.to_token_stream().into())
+}
+
+/// Checks if the attribute is a method type and has a route path, then modifies it.
+fn modify_attribute_with_scope(attr: &syn::Attribute, scope_path: &str) -> syn::Attribute {
+    match (attr.parse_args::<RouteArgs>(), attr.clone().meta) {
+        (Ok(route_args), syn::Meta::List(meta_list)) if has_allowed_methods_in_scope(attr) => {
+            let modified_path = format!("{}{}", scope_path, route_args.path.value());
+
+            let options_tokens: Vec<TokenStream2> = route_args
+                .options
+                .iter()
+                .map(|option| {
+                    quote! { ,#option }
+                })
+                .collect();
+
+            let combined_options_tokens: TokenStream2 =
+                options_tokens
+                    .into_iter()
+                    .fold(TokenStream2::new(), |mut acc, ts| {
+                        acc.extend(std::iter::once(ts));
+                        acc
+                    });
+
+            syn::Attribute {
+                meta: syn::Meta::List(syn::MetaList {
+                    tokens: quote! { #modified_path #combined_options_tokens },
+                    ..meta_list.clone()
+                }),
+                ..attr.clone()
+            }
+        }
+        _ => attr.clone(),
+    }
+}
+
+fn has_allowed_methods_in_scope(attr: &syn::Attribute) -> bool {
+    MethodType::from_path(attr.path()).is_ok()
+        || attr.path().is_ident("route")
+        || attr.path().is_ident("ROUTE")
+}

actix-web-codegen/tests/scopes.rs

@@ -0,0 +1,200 @@
+use actix_web::{guard::GuardContext, http, http::header, web, App, HttpResponse, Responder};
+use actix_web_codegen::{delete, get, post, route, routes, scope};
+
+pub fn image_guard(ctx: &GuardContext) -> bool {
+    ctx.header::<header::Accept>()
+        .map(|h| h.preference() == "image/*")
+        .unwrap_or(false)
+}
+
+#[scope("/test")]
+mod scope_module {
+    // ensure that imports can be brought into the scope
+    use super::*;
+
+    #[get("/test/guard", guard = "image_guard")]
+    pub async fn guard() -> impl Responder {
+        HttpResponse::Ok()
+    }
+
+    #[get("/test")]
+    pub async fn test() -> impl Responder {
+        HttpResponse::Ok().finish()
+    }
+
+    #[get("/twice-test/{value}")]
+    pub async fn 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))
+    }
+
+    #[post("/test")]
+    pub async fn post() -> impl Responder {
+        HttpResponse::Ok().body("post works")
+    }
+
+    #[delete("/test")]
+    pub async fn delete() -> impl Responder {
+        "delete works"
+    }
+
+    #[route("/test", method = "PUT", method = "PATCH", method = "CUSTOM")]
+    pub async fn multiple_shared_path() -> impl Responder {
+        HttpResponse::Ok().finish()
+    }
+
+    #[routes]
+    #[head("/test1")]
+    #[connect("/test2")]
+    #[options("/test3")]
+    #[trace("/test4")]
+    async fn multiple_separate_paths() -> impl Responder {
+        HttpResponse::Ok().finish()
+    }
+
+    // test calling this from other mod scope with scope attribute...
+    pub fn mod_common(message: String) -> impl actix_web::Responder {
+        HttpResponse::Ok().body(message)
+    }
+}
+
+/// Scope doc string to check in cargo expand.
+#[scope("/v1")]
+mod mod_scope_v1 {
+    use super::*;
+
+    /// Route doc string to check in cargo expand.
+    #[get("/test")]
+    pub async fn test() -> impl Responder {
+        scope_module::mod_common("version1 works".to_string())
+    }
+}
+
+#[scope("/v2")]
+mod mod_scope_v2 {
+    use super::*;
+
+    // check to make sure non-function tokens in the scope block are preserved...
+    enum TestEnum {
+        Works,
+    }
+
+    #[get("/test")]
+    pub async fn test() -> impl Responder {
+        // make sure this type still exists...
+        let test_enum = TestEnum::Works;
+
+        match test_enum {
+            TestEnum::Works => scope_module::mod_common("version2 works".to_string()),
+        }
+    }
+}
+
+#[actix_rt::test]
+async fn scope_get_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::test));
+
+    let request = srv.request(http::Method::GET, srv.url("/test/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
+
+#[actix_rt::test]
+async fn scope_get_param_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::twice));
+
+    let request = srv.request(http::Method::GET, srv.url("/test/twice-test/4"));
+    let mut response = request.send().await.unwrap();
+    let body = response.body().await.unwrap();
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert_eq!(body_str, "Twice value: 8");
+}
+
+#[actix_rt::test]
+async fn scope_post_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::post));
+
+    let request = srv.request(http::Method::POST, srv.url("/test/test"));
+    let mut response = request.send().await.unwrap();
+    let body = response.body().await.unwrap();
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert_eq!(body_str, "post works");
+}
+
+#[actix_rt::test]
+async fn multiple_shared_path_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::multiple_shared_path));
+
+    let request = srv.request(http::Method::PUT, srv.url("/test/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::PATCH, srv.url("/test/test"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
+
+#[actix_rt::test]
+async fn multiple_multi_path_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::multiple_separate_paths));
+
+    let request = srv.request(http::Method::HEAD, srv.url("/test/test1"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::CONNECT, srv.url("/test/test2"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::OPTIONS, srv.url("/test/test3"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::TRACE, srv.url("/test/test4"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
+
+#[actix_rt::test]
+async fn scope_delete_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::delete));
+
+    let request = srv.request(http::Method::DELETE, srv.url("/test/test"));
+    let mut response = request.send().await.unwrap();
+    let body = response.body().await.unwrap();
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert_eq!(body_str, "delete works");
+}
+
+#[actix_rt::test]
+async fn scope_get_with_guard_async() {
+    let srv = actix_test::start(|| App::new().service(scope_module::guard));
+
+    let request = srv
+        .request(http::Method::GET, srv.url("/test/test/guard"))
+        .insert_header(("Accept", "image/*"));
+    let response = request.send().await.unwrap();
+    assert!(response.status().is_success());
+}
+
+#[actix_rt::test]
+async fn scope_v1_v2_async() {
+    let srv = actix_test::start(|| {
+        App::new()
+            .service(mod_scope_v1::test)
+            .service(mod_scope_v2::test)
+    });
+
+    let request = srv.request(http::Method::GET, srv.url("/v1/test"));
+    let mut response = request.send().await.unwrap();
+    let body = response.body().await.unwrap();
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert_eq!(body_str, "version1 works");
+
+    let request = srv.request(http::Method::GET, srv.url("/v2/test"));
+    let mut response = request.send().await.unwrap();
+    let body = response.body().await.unwrap();
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert_eq!(body_str, "version2 works");
+}

actix-web-codegen/tests/trybuild.rs

@@ -18,6 +18,11 @@ fn compile_macros() {
     t.compile_fail("tests/trybuild/routes-missing-method-fail.rs");
     t.compile_fail("tests/trybuild/routes-missing-args-fail.rs");
 
+    t.compile_fail("tests/trybuild/scope-on-handler.rs");
+    t.compile_fail("tests/trybuild/scope-missing-args.rs");
+    t.compile_fail("tests/trybuild/scope-invalid-args.rs");
+    t.compile_fail("tests/trybuild/scope-trailing-slash.rs");
+
     t.pass("tests/trybuild/docstring-ok.rs");
 
     t.pass("tests/trybuild/test-runtime.rs");

actix-web-codegen/tests/trybuild/route-malformed-path-fail.stderr

@@ -20,10 +20,7 @@ error: custom attribute panicked
 13 | #[get("/{}")]
    | ^^^^^^^^^^^^^
    |
-   = help: message: Wrong path pattern: "/{}" regex parse error:
-               ((?s-m)^/(?P<>[^/]+))$
-                            ^
-           error: empty capture group name
+   = help: message: Wrong path pattern: "/{}" empty capture group names are not allowed
 
 error: custom attribute panicked
   --> $DIR/route-malformed-path-fail.rs:23:1

actix-web-codegen/tests/trybuild/scope-invalid-args.rs

@@ -0,0 +1,14 @@
+use actix_web_codegen::scope;
+
+const PATH: &str = "/api";
+
+#[scope(PATH)]
+mod api_const {}
+
+#[scope(true)]
+mod api_bool {}
+
+#[scope(123)]
+mod api_num {}
+
+fn main() {}

actix-web-codegen/tests/trybuild/scope-invalid-args.stderr

@@ -0,0 +1,17 @@
+error: argument to scope macro is not a string literal, expected: #[scope("/prefix")]
+ --> tests/trybuild/scope-invalid-args.rs:5:9
+  |
+5 | #[scope(PATH)]
+  |         ^^^^
+
+error: argument to scope macro is not a string literal, expected: #[scope("/prefix")]
+ --> tests/trybuild/scope-invalid-args.rs:8:9
+  |
+8 | #[scope(true)]
+  |         ^^^^
+
+error: argument to scope macro is not a string literal, expected: #[scope("/prefix")]
+  --> tests/trybuild/scope-invalid-args.rs:11:9
+   |
+11 | #[scope(123)]
+   |         ^^^

actix-web-codegen/tests/trybuild/scope-missing-args.rs

@@ -0,0 +1,6 @@
+use actix_web_codegen::scope;
+
+#[scope]
+mod api {}
+
+fn main() {}

actix-web-codegen/tests/trybuild/scope-missing-args.stderr

@@ -0,0 +1,7 @@
+error: missing arguments for scope macro, expected: #[scope("/prefix")]
+ --> tests/trybuild/scope-missing-args.rs:3:1
+  |
+3 | #[scope]
+  | ^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `scope` (in Nightly builds, run with -Z macro-backtrace for more info)

actix-web-codegen/tests/trybuild/scope-on-handler.rs

@@ -0,0 +1,8 @@
+use actix_web_codegen::scope;
+
+#[scope("/api")]
+async fn index() -> &'static str {
+    "Hello World!"
+}
+
+fn main() {}

actix-web-codegen/tests/trybuild/scope-on-handler.stderr

@@ -0,0 +1,5 @@
+error: #[scope] macro must be attached to a module
+ --> tests/trybuild/scope-on-handler.rs:4:1
+  |
+4 | async fn index() -> &'static str {
+  | ^^^^^

actix-web-codegen/tests/trybuild/scope-trailing-slash.rs

@@ -0,0 +1,6 @@
+use actix_web_codegen::scope;
+
+#[scope("/api/")]
+mod api {}
+
+fn main() {}

actix-web-codegen/tests/trybuild/scope-trailing-slash.stderr

@@ -0,0 +1,5 @@
+error: scopes should not have trailing slashes; see https://docs.rs/actix-web/4/actix_web/struct.Scope.html#avoid-trailing-slashes
+ --> tests/trybuild/scope-trailing-slash.rs:3:9
+  |
+3 | #[scope("/api/")]
+  |         ^^^^^^^

actix-web/CHANGES.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+### Added
+
+- Add `CustomizeResponder::add_cookie()` method.
+- Add `guard::GuardContext::app_data()` method.
+- Implement `From<Box<dyn ResponseError>>` for `Error`.
+
 ## 4.6.0
 
 ### Added

actix-web/Cargo.toml

@@ -35,7 +35,6 @@ features = [
     "secure-cookies",
 ]
 
-
 [lib]
 name = "actix_web"
 path = "src/lib.rs"
@@ -130,6 +129,7 @@ awc = { version = "3", features = ["openssl"] }
 
 brotli = "6"
 const-str = "0.5"
+core_affinity = "0.8"
 criterion = { version = "0.5", features = ["html_reports"] }
 env_logger = "0.11"
 flate2 = "1.0.13"

actix-web/examples/worker-cpu-pin.rs

@@ -0,0 +1,41 @@
+use std::{
+    io,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+    thread,
+};
+
+use actix_web::{middleware, web, App, HttpServer};
+
+async fn hello() -> &'static str {
+    "Hello world!"
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    let core_ids = core_affinity::get_core_ids().unwrap();
+    let n_core_ids = core_ids.len();
+    let next_core_id = Arc::new(AtomicUsize::new(0));
+
+    HttpServer::new(move || {
+        let pin = Arc::clone(&next_core_id).fetch_add(1, Ordering::AcqRel);
+        log::info!(
+            "setting CPU affinity for worker {}: pinning to core {}",
+            thread::current().name().unwrap(),
+            pin,
+        );
+        core_affinity::set_for_current(core_ids[pin]);
+
+        App::new()
+            .wrap(middleware::Logger::default())
+            .service(web::resource("/").get(hello))
+    })
+    .bind(("127.0.0.1", 8080))?
+    .workers(n_core_ids)
+    .run()
+    .await
+}

actix-web/src/app.rs

@@ -112,8 +112,8 @@ where
     /// })
     /// ```
     #[doc(alias = "manage")]
-    pub fn app_data<U: 'static>(mut self, ext: U) -> Self {
-        self.extensions.insert(ext);
+    pub fn app_data<U: 'static>(mut self, data: U) -> Self {
+        self.extensions.insert(data);
         self
     }
 

actix-web/src/error/error.rs

@@ -60,6 +60,12 @@ impl<T: ResponseError + 'static> From<T> for Error {
     }
 }
 
+impl From<Box<dyn ResponseError>> for Error {
+    fn from(value: Box<dyn ResponseError>) -> Self {
+        Error { cause: value }
+    }
+}
+
 impl From<Error> for Response<BoxBody> {
     fn from(err: Error) -> Response<BoxBody> {
         err.error_response().into()

actix-web/src/guard/mod.rs

@@ -110,6 +110,12 @@ impl<'a> GuardContext<'a> {
     pub fn header<H: Header>(&self) -> Option<H> {
         H::parse(self.req).ok()
     }
+
+    /// Counterpart to [HttpRequest::app_data](crate::HttpRequest::app_data).
+    #[inline]
+    pub fn app_data<T: 'static>(&self) -> Option<&T> {
+        self.req.app_data()
+    }
 }
 
 /// Interface for routing guards.
@@ -512,4 +518,18 @@ mod tests {
             .to_srv_request();
         assert!(guard.check(&req.guard_ctx()));
     }
+
+    #[test]
+    fn app_data() {
+        const TEST_VALUE: u32 = 42;
+        let guard = fn_guard(|ctx| dbg!(ctx.app_data::<u32>()) == Some(&TEST_VALUE));
+
+        let req = TestRequest::default().app_data(TEST_VALUE).to_srv_request();
+        assert!(guard.check(&req.guard_ctx()));
+
+        let req = TestRequest::default()
+            .app_data(TEST_VALUE * 2)
+            .to_srv_request();
+        assert!(!guard.check(&req.guard_ctx()));
+    }
 }

actix-web/src/lib.rs

@@ -145,5 +145,6 @@ codegen_reexport!(delete);
 codegen_reexport!(trace);
 codegen_reexport!(connect);
 codegen_reexport!(options);
+codegen_reexport!(scope);
 
 pub(crate) type BoxError = Box<dyn std::error::Error>;

actix-web/src/response/customize_responder.rs

@@ -7,7 +7,7 @@ use actix_http::{
 
 use crate::{HttpRequest, HttpResponse, Responder};
 
-/// Allows overriding status code and headers for a [`Responder`].
+/// Allows overriding status code and headers (including cookies) for a [`Responder`].
 ///
 /// Created by calling the [`customize`](Responder::customize) method on a [`Responder`] type.
 pub struct CustomizeResponder<R> {
@@ -137,6 +137,29 @@ impl<R: Responder> CustomizeResponder<R> {
             Some(&mut self.inner)
         }
     }
+
+    /// Appends a `cookie` to the final response.
+    ///
+    /// # Errors
+    ///
+    /// Final response will be an error if `cookie` cannot be converted into a valid header value.
+    #[cfg(feature = "cookies")]
+    pub fn add_cookie(mut self, cookie: &crate::cookie::Cookie<'_>) -> Self {
+        use actix_http::header::{TryIntoHeaderValue as _, SET_COOKIE};
+
+        if let Some(inner) = self.inner() {
+            match cookie.to_string().try_into_value() {
+                Ok(val) => {
+                    inner.append_headers.append(SET_COOKIE, val);
+                }
+                Err(err) => {
+                    self.error = Some(err.into());
+                }
+            }
+        }
+
+        self
+    }
 }
 
 impl<T> Responder for CustomizeResponder<T>
@@ -175,6 +198,7 @@ mod tests {
 
     use super::*;
     use crate::{
+        cookie::Cookie,
         http::header::{HeaderValue, CONTENT_TYPE},
         test::TestRequest,
     };
@@ -209,6 +233,22 @@ mod tests {
             to_bytes(res.into_body()).await.unwrap(),
             Bytes::from_static(b"test"),
         );
+
+        let res = "test"
+            .to_string()
+            .customize()
+            .add_cookie(&Cookie::new("name", "value"))
+            .respond_to(&req);
+
+        assert!(res.status().is_success());
+        assert_eq!(
+            res.cookies().collect::<Vec<Cookie<'_>>>(),
+            vec![Cookie::new("name", "value")],
+        );
+        assert_eq!(
+            to_bytes(res.into_body()).await.unwrap(),
+            Bytes::from_static(b"test"),
+        );
     }
 
     #[actix_rt::test]

awc/src/client/connector.rs

@@ -1080,7 +1080,7 @@ mod resolver {
 
         // resolver struct is cached in thread local so new clients can reuse the existing instance
         thread_local! {
-            static TRUST_DNS_RESOLVER: RefCell<Option<Resolver>> = RefCell::new(None);
+            static TRUST_DNS_RESOLVER: RefCell<Option<Resolver>> = const { RefCell::new(None) };
         }
 
         // get from thread local or construct a new trust-dns resolver.

justfile

@@ -4,7 +4,7 @@ _list:
 # Format workspace.
 fmt:
     cargo +nightly fmt
-    npx -y prettier --write $(fd --type=file --hidden --extension=md --extension=yml)
+    fd --hidden --type=file --extension=md --extension=yml --exec-batch npx -y prettier --write
 
 # Downgrade dev-dependencies necessary to run MSRV checks/tests.
 [private]
@@ -32,6 +32,10 @@ all_crate_features := if os() == "linux" {
     "--features='" + non_linux_all_features_list + "'"
 }
 
+# Run Clippy over workspace.
+clippy toolchain="":
+    cargo {{ toolchain }} clippy --workspace --all-targets {{ all_crate_features }}
+
 # Test workspace using MSRV.
 test-msrv: downgrade-for-msrv (test msrv_rustup)