move multipart support to separate crate

actix-multipart/src/error.rs

@@ -0,0 +1,46 @@
+//! Error and Result module
+use actix_web::error::{ParseError, PayloadError};
+use actix_web::http::StatusCode;
+use actix_web::{HttpResponse, ResponseError};
+use derive_more::{Display, From};
+
+/// A set of errors that can occur during parsing multipart streams
+#[derive(Debug, Display, From)]
+pub enum MultipartError {
+    /// Content-Type header is not found
+    #[display(fmt = "No Content-type header found")]
+    NoContentType,
+    /// Can not parse Content-Type header
+    #[display(fmt = "Can not parse Content-Type header")]
+    ParseContentType,
+    /// Multipart boundary is not found
+    #[display(fmt = "Multipart boundary is not found")]
+    Boundary,
+    /// Multipart stream is incomplete
+    #[display(fmt = "Multipart stream is incomplete")]
+    Incomplete,
+    /// Error during field parsing
+    #[display(fmt = "{}", _0)]
+    Parse(ParseError),
+    /// Payload error
+    #[display(fmt = "{}", _0)]
+    Payload(PayloadError),
+}
+
+/// Return `BadRequest` for `MultipartError`
+impl ResponseError for MultipartError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_multipart_error() {
+        let resp: HttpResponse = MultipartError::Boundary.error_response();
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+}

actix-multipart/src/extractor.rs

@@ -0,0 +1,57 @@
+//! Multipart payload support
+use bytes::Bytes;
+use futures::Stream;
+
+use actix_web::dev::ServiceFromRequest;
+use actix_web::error::{Error, PayloadError};
+use actix_web::FromRequest;
+use actix_web::HttpMessage;
+
+use crate::server::Multipart;
+
+/// Get request's payload as multipart stream
+///
+/// Content-type: multipart/form-data;
+///
+/// ## Server example
+///
+/// ```rust
+/// # use futures::{Future, Stream};
+/// # use futures::future::{ok, result, Either};
+/// use actix_web::{web, HttpResponse, Error};
+/// use actix_multipart as mp;
+///
+/// fn index(payload: mp::Multipart) -> impl Future<Item = HttpResponse, Error = Error> {
+///     payload.from_err()               // <- get multipart stream for current request
+///        .and_then(|item| match item { // <- iterate over multipart items
+///            mp::Item::Field(field) => {
+///                // Field in turn is stream of *Bytes* object
+///                Either::A(field.from_err()
+///                          .fold((), |_, chunk| {
+///                              println!("-- CHUNK: \n{:?}", std::str::from_utf8(&chunk));
+///                              Ok::<_, Error>(())
+///                          }))
+///             },
+///             mp::Item::Nested(mp) => {
+///                 // Or item could be nested Multipart stream
+///                 Either::B(ok(()))
+///             }
+///         })
+///         .fold((), |_, _| Ok::<_, Error>(()))
+///         .map(|_| HttpResponse::Ok().into())
+/// }
+/// # fn main() {}
+/// ```
+impl<P> FromRequest<P> for Multipart
+where
+    P: Stream<Item = Bytes, Error = PayloadError> + 'static,
+{
+    type Error = Error;
+    type Future = Result<Multipart, Error>;
+
+    #[inline]
+    fn from_request(req: &mut ServiceFromRequest<P>) -> Self::Future {
+        let pl = req.take_payload();
+        Ok(Multipart::new(req.headers(), pl))
+    }
+}

actix-multipart/src/lib.rs

@@ -0,0 +1,6 @@
+mod error;
+mod extractor;
+mod server;
+
+pub use self::error::MultipartError;
+pub use self::server::{Field, Item, Multipart};