From 1dc49ae0390ca6fc8f919c656e9be5c36fa33b99 Mon Sep 17 00:00:00 2001
From: David Pedersen <david.pdrsn@gmail.com>
Date: Tue, 16 Nov 2021 21:27:21 +0100
Subject: [PATCH] Remove unused file (#526)
This should have been removed as part of #521 but guess I missed it.
---
axum/src/routing/handler_method_routing.rs | 464 ---------------------
1 file changed, 464 deletions(-)
delete mode 100644 axum/src/routing/handler_method_routing.rs
diff --git a/axum/src/routing/handler_method_routing.rs b/axum/src/routing/handler_method_routing.rs
deleted file mode 100644
index 47c98d44..00000000
--- a/axum/src/routing/handler_method_routing.rs
+++ /dev/null
@@ -1,464 +0,0 @@
-//! Routing for handlers based on HTTP methods.
-
-use crate::{
- body::{box_body, BoxBody},
- handler::Handler,
- routing::{MethodFilter, MethodNotAllowed},
- util::{Either, EitherProj},
-};
-use futures_util::{future::BoxFuture, ready};
-use http::{Method, Request, Response};
-use http_body::Empty;
-use pin_project_lite::pin_project;
-use std::{
- convert::Infallible,
- fmt,
- future::Future,
- marker::PhantomData,
- pin::Pin,
- task::{Context, Poll},
-};
-use tower::{util::Oneshot, ServiceExt};
-use tower_service::Service;
-
-/// Route requests with any standard HTTP method to the given handler.
-///
-/// # Example
-///
-/// ```rust
-/// use axum::{
-/// routing::any,
-/// Router,
-/// };
-///
-/// async fn handler() {}
-///
-/// let app = Router::new().route("/", any(handler));
-/// # async {
-/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
-/// # };
-/// ```
-///
-/// Note that this only accepts the standard HTTP methods. If you need to
-/// support non-standard methods use [`Handler::into_service`]:
-///
-/// ```rust
-/// use axum::{
-/// handler::Handler,
-/// Router,
-/// };
-///
-/// async fn handler() {}
-///
-/// let app = Router::new().route("/", handler.into_service());
-/// # async {
-/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
-/// # };
-/// ```
-pub fn any<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::all(), handler)
-}
-
-/// Route `DELETE` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn delete<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::DELETE, handler)
-}
-
-/// Route `GET` requests to the given handler.
-///
-/// # Example
-///
-/// ```rust
-/// use axum::{
-/// routing::get,
-/// Router,
-/// };
-///
-/// async fn handler() {}
-///
-/// // Requests to `GET /` will go to `handler`.
-/// let app = Router::new().route("/", get(handler));
-/// # async {
-/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
-/// # };
-/// ```
-///
-/// Note that `get` routes will also be called for `HEAD` requests but will have
-/// the response body removed. Make sure to add explicit `HEAD` routes
-/// afterwards.
-pub fn get<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::GET | MethodFilter::HEAD, handler)
-}
-
-/// Route `HEAD` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn head<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::HEAD, handler)
-}
-
-/// Route `OPTIONS` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn options<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::OPTIONS, handler)
-}
-
-/// Route `PATCH` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn patch<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::PATCH, handler)
-}
-
-/// Route `POST` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn post<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::POST, handler)
-}
-
-/// Route `PUT` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn put<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::PUT, handler)
-}
-
-/// Route `TRACE` requests to the given handler.
-///
-/// See [`get`] for an example.
-pub fn trace<H, B, T>(handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- on(MethodFilter::TRACE, handler)
-}
-
-/// Route requests with the given method to the handler.
-///
-/// # Example
-///
-/// ```rust
-/// use axum::{
-/// routing::on,
-/// Router,
-/// routing::MethodFilter,
-/// };
-///
-/// async fn handler() {}
-///
-/// // Requests to `POST /` will go to `handler`.
-/// let app = Router::new().route("/", on(MethodFilter::POST, handler));
-/// # async {
-/// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
-/// # };
-/// ```
-pub fn on<H, B, T>(method: MethodFilter, handler: H) -> MethodRouter<H, B, T, MethodNotAllowed>
-where
- H: Handler<B, T>,
-{
- MethodRouter {
- method,
- handler,
- fallback: MethodNotAllowed::new(),
- _marker: PhantomData,
- }
-}
-
-/// A handler [`Service`] that accepts requests based on a [`MethodFilter`] and
-/// allows chaining additional handlers.
-pub struct MethodRouter<H, B, T, F> {
- pub(crate) method: MethodFilter,
- pub(crate) handler: H,
- pub(crate) fallback: F,
- pub(crate) _marker: PhantomData<fn() -> (B, T)>,
-}
-
-impl<H, B, T, F> fmt::Debug for MethodRouter<H, B, T, F>
-where
- T: fmt::Debug,
- F: fmt::Debug,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct("MethodRouter")
- .field("method", &self.method)
- .field("handler", &format_args!("{}", std::any::type_name::<H>()))
- .field("fallback", &self.fallback)
- .finish()
- }
-}
-
-impl<H, B, T, F> Clone for MethodRouter<H, B, T, F>
-where
- H: Clone,
- F: Clone,
-{
- fn clone(&self) -> Self {
- Self {
- method: self.method,
- handler: self.handler.clone(),
- fallback: self.fallback.clone(),
- _marker: PhantomData,
- }
- }
-}
-
-impl<H, B, T, F> Copy for MethodRouter<H, B, T, F>
-where
- H: Copy,
- F: Copy,
-{
-}
-
-impl<H, B, T, F> MethodRouter<H, B, T, F> {
- /// Chain an additional handler that will accept all requests regardless of
- /// its HTTP method.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn any<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::all(), handler)
- }
-
- /// Chain an additional handler that will only accept `DELETE` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn delete<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::DELETE, handler)
- }
-
- /// Chain an additional handler that will only accept `GET` requests.
- ///
- /// # Example
- ///
- /// ```rust
- /// use axum::{routing::post, Router};
- ///
- /// async fn handler() {}
- ///
- /// async fn other_handler() {}
- ///
- /// // Requests to `GET /` will go to `handler` and `POST /` will go to
- /// // `other_handler`.
- /// let app = Router::new().route("/", post(handler).get(other_handler));
- /// # async {
- /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
- /// # };
- /// ```
- ///
- /// Note that `get` routes will also be called for `HEAD` requests but will have
- /// the response body removed. Make sure to add explicit `HEAD` routes
- /// afterwards.
- pub fn get<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::GET | MethodFilter::HEAD, handler)
- }
-
- /// Chain an additional handler that will only accept `HEAD` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn head<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::HEAD, handler)
- }
-
- /// Chain an additional handler that will only accept `OPTIONS` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn options<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::OPTIONS, handler)
- }
-
- /// Chain an additional handler that will only accept `PATCH` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn patch<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::PATCH, handler)
- }
-
- /// Chain an additional handler that will only accept `POST` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn post<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::POST, handler)
- }
-
- /// Chain an additional handler that will only accept `PUT` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn put<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::PUT, handler)
- }
-
- /// Chain an additional handler that will only accept `TRACE` requests.
- ///
- /// See [`MethodRouter::get`] for an example.
- pub fn trace<H2, T2>(self, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- self.on(MethodFilter::TRACE, handler)
- }
-
- /// Chain an additional handler that will accept requests matching the given
- /// `MethodFilter`.
- ///
- /// # Example
- ///
- /// ```rust
- /// use axum::{
- /// routing::get,
- /// Router,
- /// routing::MethodFilter
- /// };
- ///
- /// async fn handler() {}
- ///
- /// async fn other_handler() {}
- ///
- /// // Requests to `GET /` will go to `handler` and `DELETE /` will go to
- /// // `other_handler`
- /// let app = Router::new().route("/", get(handler).on(MethodFilter::DELETE, other_handler));
- /// # async {
- /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
- /// # };
- /// ```
- pub fn on<H2, T2>(self, method: MethodFilter, handler: H2) -> MethodRouter<H2, B, T2, Self>
- where
- H2: Handler<B, T2>,
- {
- MethodRouter {
- method,
- handler,
- fallback: self,
- _marker: PhantomData,
- }
- }
-}
-
-impl<H, B, T, F> Service<Request<B>> for MethodRouter<H, B, T, F>
-where
- H: Handler<B, T>,
- F: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone,
- B: Send + 'static,
-{
- type Response = Response<BoxBody>;
- type Error = Infallible;
- type Future = MethodRouterFuture<F, B>;
-
- #[inline]
- fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
- Poll::Ready(Ok(()))
- }
-
- fn call(&mut self, req: Request<B>) -> Self::Future {
- let req_method = req.method().clone();
-
- let fut = if self.method.matches(req.method()) {
- let fut = Handler::call(self.handler.clone(), req);
- Either::A { inner: fut }
- } else {
- let fut = self.fallback.clone().oneshot(req);
- Either::B { inner: fut }
- };
-
- MethodRouterFuture {
- inner: fut,
- req_method,
- }
- }
-}
-
-pin_project! {
- /// The response future for [`MethodRouter`].
- pub struct MethodRouterFuture<F, B>
- where
- F: Service<Request<B>>
- {
- #[pin]
- pub(super) inner: Either<
- BoxFuture<'static, Response<BoxBody>>,
- Oneshot<F, Request<B>>,
- >,
- pub(super) req_method: Method,
- }
-}
-
-impl<F, B> Future for MethodRouterFuture<F, B>
-where
- F: Service<Request<B>, Response = Response<BoxBody>>,
-{
- type Output = Result<Response<BoxBody>, F::Error>;
-
- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
- let this = self.project();
- let response = match this.inner.project() {
- EitherProj::A { inner } => ready!(inner.poll(cx)),
- EitherProj::B { inner } => ready!(inner.poll(cx))?,
- };
-
- if this.req_method == &Method::HEAD {
- let response = response.map(|_| box_body(Empty::new()));
- Poll::Ready(Ok(response))
- } else {
- Poll::Ready(Ok(response))
- }
- }
-}
-
-impl<F, B> fmt::Debug for MethodRouterFuture<F, B>
-where
- F: Service<Request<B>>,
-{
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct("MethodRouterFuture").finish()
- }
-}