remove body reexports from dev

CHANGES.md

@@ -13,6 +13,7 @@
 
 ### Fixed
 * Accept wildcard `*` items in `AcceptLanguage`. [#2480]
+* Re-exports `dev::{BodySize, MessageBody, SizedStream}`. They are exposed through the `body` module. [#2468]
 * Typed headers containing lists that require one or more items now enforce this minimum. [#2482]
 
 [#2468]: https://github.com/actix/actix-web/pull/2468

actix-http/src/message.rs

@@ -46,8 +46,8 @@ pub trait Head: Default + 'static {
 
 #[derive(Debug)]
 pub struct RequestHead {
-    pub uri: Uri,
     pub method: Method,
+    pub uri: Uri,
     pub version: Version,
     pub headers: HeaderMap,
     pub extensions: RefCell<Extensions>,
@@ -58,13 +58,13 @@ pub struct RequestHead {
 impl Default for RequestHead {
     fn default() -> RequestHead {
         RequestHead {
-            uri: Uri::default(),
             method: Method::default(),
+            uri: Uri::default(),
             version: Version::HTTP_11,
             headers: HeaderMap::with_capacity(16),
-            flags: Flags::empty(),
-            peer_addr: None,
             extensions: RefCell::new(Extensions::new()),
+            peer_addr: None,
+            flags: Flags::empty(),
         }
     }
 }
@@ -192,6 +192,7 @@ impl RequestHead {
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum RequestHeadType {
     Owned(RequestHead),
     Rc(Rc<RequestHead>, Option<HeaderMap>),

actix-test/src/lib.rs

@@ -41,7 +41,8 @@ use actix_http::{
 };
 use actix_service::{map_config, IntoServiceFactory, ServiceFactory, ServiceFactoryExt as _};
 use actix_web::{
-    dev::{AppConfig, MessageBody, Server, ServerHandle, Service},
+    body::MessageBody,
+    dev::{AppConfig, Server, ServerHandle, Service},
     rt::{self, System},
     web, Error,
 };

src/dev.rs

@@ -14,9 +14,6 @@ pub use crate::types::form::UrlEncoded;
 pub use crate::types::json::JsonBody;
 pub use crate::types::readlines::Readlines;
 
-#[allow(deprecated)]
-pub use actix_http::body::{BodySize, MessageBody, SizedStream};
-
 pub use actix_http::{Extensions, Payload, PayloadStream, RequestHead, Response, ResponseHead};
 pub use actix_router::{Path, ResourceDef, ResourcePath, Url};
 pub use actix_server::{Server, ServerHandle};
@@ -105,3 +102,40 @@ impl<B> BodyEncoding for crate::HttpResponse<B> {
         self
     }
 }
+
+// pin_project_lite::pin_project! {
+#[derive(Debug)]
+pub enum AnyBody {
+    None,
+    Full { body: crate::web::Bytes },
+    Boxed { body: actix_http::body::BoxBody },
+}
+// }
+
+impl crate::body::MessageBody for AnyBody {
+    type Error = crate::BoxError;
+
+    /// Body size hint.
+    fn size(&self) -> crate::body::BodySize {
+        match self {
+            AnyBody::None => crate::body::BodySize::None,
+            AnyBody::Full { body } => body.size(),
+            AnyBody::Boxed { body } => body.size(),
+        }
+    }
+
+    /// Attempt to pull out the next chunk of body bytes.
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Result<crate::web::Bytes, Self::Error>>> {
+        match self.get_mut() {
+            AnyBody::None => std::task::Poll::Ready(None),
+            AnyBody::Full { body } => {
+                let bytes = std::mem::take(body);
+                std::task::Poll::Ready(Some(Ok(bytes)))
+            }
+            AnyBody::Boxed { body } => body.as_pin_mut().poll_next(cx),
+        }
+    }
+}

src/handler.rs

@@ -9,11 +9,13 @@ use crate::{
 };
 
 /// A request handler is an async function that accepts zero or more parameters that can be
-/// extracted from a request (i.e., [`impl FromRequest`](crate::FromRequest)) and returns a type
+/// extracted from a request (i.e., [`impl FromRequest`]) and returns a type that can be converted
-/// that can be converted into an [`HttpResponse`] (that is, it impls the [`Responder`] trait).
+/// into an [`HttpResponse`] (that is, it impls the [`Responder`] trait).
 ///
 /// If you got the error `the trait Handler<_, _, _> is not implemented`, then your function is not
-/// a valid handler. See [Request Handlers](https://actix.rs/docs/handlers/) for more information.
+/// a valid handler. See <https://actix.rs/docs/handlers> for more information.
+///
+/// [`impl FromRequest`]: crate::FromRequest
 pub trait Handler<T, R>: Clone + 'static
 where
     R: Future,
@@ -22,7 +24,7 @@ where
     fn call(&self, param: T) -> R;
 }
 
-pub fn handler_service<F, T, R>(handler: F) -> BoxedHttpServiceFactory
+pub(crate) fn handler_service<F, T, R>(handler: F) -> BoxedHttpServiceFactory
 where
     F: Handler<T, R>,
     T: FromRequest,
@@ -36,8 +38,9 @@ where
 
         async move {
             let (req, mut payload) = req.into_parts();
+
             let res = match T::from_request(&req, &mut payload).await {
-                Err(err) => HttpResponse::from_error(err).map_into_boxed_body(),
+                Err(err) => HttpResponse::from_error(err),
 
                 Ok(data) => handler
                     .call(data)
@@ -51,7 +54,14 @@ where
     }))
 }
 
-/// FromRequest trait impl for tuples
+/// Generates a [`Handler`] trait impl for N-ary functions where N is specified with a sequence of
+/// space separated type parameters.
+///
+/// # Examples
+/// ```ignore
+/// factory_tuple! {}         // implements Handler for types: fn() -> Res
+/// factory_tuple! { A B C }  // implements Handler for types: fn(A, B, C) -> Res
+/// ```
 macro_rules! factory_tuple ({ $($param:ident)* } => {
     impl<Func, $($param,)* Res> Handler<($($param,)*), Res> for Func
     where Func: Fn($($param),*) -> Res + Clone + 'static,

src/http/header/accept.rs

@@ -208,7 +208,7 @@ impl Accept {
     /// If no q-factors are provided, the first mime type is chosen. Note that items without
     /// q-factors are given the maximum preference value.
     ///
-    /// As per the spec, will return [`Mime::STAR_STAR`] (indicating no preference) if the contained
+    /// As per the spec, will return [`mime::STAR_STAR`] (indicating no preference) if the contained
     /// list is empty.
     ///
     /// [q-factor weighting]: https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2

src/middleware/logger.rs

@@ -22,7 +22,7 @@ use regex::{Regex, RegexSet};
 use time::{format_description::well_known::Rfc3339, OffsetDateTime};
 
 use crate::{
-    dev::{BodySize, MessageBody},
+    body::{BodySize, MessageBody},
     http::HeaderName,
     service::{ServiceRequest, ServiceResponse},
     Error, HttpResponse, Result,

src/response/builder.rs

@@ -1,7 +1,6 @@
 use std::{
     cell::{Ref, RefMut},
     convert::TryInto,
-    error::Error as StdError,
     future::Future,
     pin::Pin,
     task::{Context, Poll},

src/response/response.rs

@@ -241,6 +241,7 @@ impl<B> HttpResponse<B> {
     where
         B: MessageBody + 'static,
     {
+        // TODO: avoid double boxing with down-casting, if it improves perf
         self.map_body(|_, body| BoxBody::new(body))
     }
 

src/route.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::rc_buffer)] // inner value is mutated before being shared (`Rc::get_mut`)
-
 use std::{future::Future, mem, rc::Rc};
 
 use actix_http::http::Method;

src/types/path.rs

@@ -90,7 +90,7 @@ impl<T: fmt::Display> fmt::Display for Path<T> {
     }
 }
 
-/// See [here](#usage) for example of usage as an extractor.
+/// See [here](#Examples) for example of usage as an extractor.
 impl<T> FromRequest for Path<T>
 where
     T: de::DeserializeOwned,

src/types/payload.rs

@@ -43,12 +43,12 @@ use crate::{
 ///     Ok(format!("Request Body Bytes:\n{:?}", bytes))
 /// }
 /// ```
-pub struct Payload(crate::dev::Payload);
+pub struct Payload(dev::Payload);
 
 impl Payload {
     /// Unwrap to inner Payload type.
     #[inline]
-    pub fn into_inner(self) -> crate::dev::Payload {
+    pub fn into_inner(self) -> dev::Payload {
         self.0
     }
 }
@@ -62,7 +62,7 @@ impl Stream for Payload {
     }
 }
 
-/// See [here](#usage) for example of usage as an extractor.
+/// See [here](#Examples) for example of usage as an extractor.
 impl FromRequest for Payload {
     type Error = Error;
     type Future = Ready<Result<Payload, Error>>;

src/types/query.rs

@@ -105,7 +105,7 @@ impl<T: fmt::Display> fmt::Display for Query<T> {
     }
 }
 
-/// See [here](#usage) for example of usage as an extractor.
+/// See [here](#Examples) for example of usage as an extractor.
 impl<T: DeserializeOwned> FromRequest for Query<T> {
     type Error = Error;
     type Future = Ready<Result<Self, Error>>;