add method_not_allowed_fallback to router

axum/src/docs/routing/method_not_allowed_fallback.md

@@ -0,0 +1,38 @@
+Add a fallback [`Handler`] for the case where a route exists, but the method of the request is not supported.
+
+Sets the Fallback on the underlying [`MethodRouter`] to be called when it
+matches no method.
+
+```rust,no_run
+use axum::{response::IntoResponse, routing::get, Router};
+
+async fn hello_world() -> impl IntoResponse {
+    "Hello, world!\n"
+}
+
+async fn default_fallback() -> impl IntoResponse {
+    "Default fallback\n"
+}
+
+async fn handle_405() -> impl IntoResponse {
+    "Method not allowed fallback"
+}
+
+#[tokio::main]
+async fn main() {
+    let router = Router::new()
+        .route("/", get(hello_world))
+        .fallback(default_fallback)
+        .method_not_allowed_fallback(handle_405);
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+
+    axum::serve(listener, router).await.unwrap();
+}
+```
+
+The Fallback only applies if there is a MethodRouter registered for the given Route, 
+but the method used in the Request is not specified. In the example, a GET on 
+`http://localhost:3000` causes the `hello_world` handler to react, while issueing a 
+POST triggers `handle_405`. Calling an entirely different route, like `http://localhost:3000/hello` 
+causes `handle_405` to run.

axum/src/routing/mod.rs

@@ -342,6 +342,18 @@ where
         .fallback_endpoint(Endpoint::Route(route))
     }
 
+    #[doc = include_str!("../docs/routing/method_not_allowed_fallback.md")]
+    pub fn method_not_allowed_fallback<H, T>(self, handler: H) -> Self
+    where
+        H: Handler<T, S>,
+        T: 'static,
+    {
+        self.tap_inner_mut(|this| {
+            this.path_router
+                .method_not_allowed_fallback(handler.clone())
+        })
+    }
+
     fn fallback_endpoint(self, endpoint: Endpoint<S>) -> Self {
         self.tap_inner_mut(|this| {
             this.fallback_router.set_fallback(endpoint);

axum/src/routing/path_router.rs

@@ -1,4 +1,7 @@
-use crate::extract::{nested_path::SetNestedPath, Request};
+use crate::{
+    extract::{nested_path::SetNestedPath, Request},
+    handler::Handler,
+};
 use axum_core::response::IntoResponse;
 use matchit::MatchError;
 use std::{borrow::Cow, collections::HashMap, convert::Infallible, fmt, sync::Arc};
@@ -79,6 +82,18 @@ where
         Ok(())
     }
 
+    pub(super) fn method_not_allowed_fallback<H, T>(&mut self, handler: H)
+    where
+        H: Handler<T, S>,
+        T: 'static,
+    {
+        for (_, endpoint) in self.routes.iter_mut() {
+            if let Endpoint::MethodRouter(rt) = endpoint {
+                *rt = rt.clone().fallback(handler.clone());
+            }
+        }
+    }
+
     pub(super) fn route_service<T>(
         &mut self,
         path: &str,