drop with2 and with3

src/header/common/mod.rs

@@ -74,8 +74,6 @@ macro_rules! test_header {
     ($id:ident, $raw:expr) => {
         #[test]
         fn $id() {
-            #[allow(unused, deprecated)]
-            use std::ascii::AsciiExt;
             use test;
             let raw = $raw;
             let a: Vec<Vec<u8>> = raw.iter().map(|x| x.to_vec()).collect();

src/header/shared/charset.rs

@@ -1,5 +1,3 @@
-#![allow(unused, deprecated)]
-use std::ascii::AsciiExt;
 use std::fmt::{self, Display};
 use std::str::FromStr;
 

src/header/shared/quality_item.rs

@@ -1,5 +1,3 @@
-#![allow(unused, deprecated)]
-use std::ascii::AsciiExt;
 use std::cmp;
 use std::default::Default;
 use std::fmt;

src/route.rs

@@ -17,7 +17,7 @@ use middleware::{
     Started as MiddlewareStarted,
 };
 use pred::Predicate;
-use with::{ExtractorConfig, With, With2, With3, WithAsync};
+use with::{ExtractorConfig, With, WithAsync};
 
 /// Resource route definition
 ///
@@ -216,85 +216,6 @@ impl<S: 'static> Route<S> {
         self.h(WithAsync::new(handler, Clone::clone(&cfg)));
         cfg
     }
-
-    #[doc(hidden)]
-    /// Set handler function, use request extractor for both parameters.
-    ///
-    /// ```rust
-    /// # extern crate bytes;
-    /// # extern crate actix_web;
-    /// # extern crate futures;
-    /// #[macro_use] extern crate serde_derive;
-    /// use actix_web::{http, App, Path, Query, Result};
-    ///
-    /// #[derive(Deserialize)]
-    /// struct PParam {
-    ///     username: String,
-    /// }
-    ///
-    /// #[derive(Deserialize)]
-    /// struct QParam {
-    ///     count: u32,
-    /// }
-    ///
-    /// /// extract path and query information using serde
-    /// fn index(p: Path<PParam>, q: Query<QParam>) -> Result<String> {
-    ///     Ok(format!("Welcome {}!", p.username))
-    /// }
-    ///
-    /// fn main() {
-    ///     let app = App::new().resource(
-    ///         "/{username}/index.html", // <- define path parameters
-    ///         |r| r.method(http::Method::GET).with2(index),
-    ///     ); // <- use `with` extractor
-    /// }
-    /// ```
-    pub fn with2<T1, T2, F, R>(
-        &mut self, handler: F,
-    ) -> (ExtractorConfig<S, T1>, ExtractorConfig<S, T2>)
-    where
-        F: Fn(T1, T2) -> R + 'static,
-        R: Responder + 'static,
-        T1: FromRequest<S> + 'static,
-        T2: FromRequest<S> + 'static,
-    {
-        let cfg1 = ExtractorConfig::default();
-        let cfg2 = ExtractorConfig::default();
-        self.h(With2::new(
-            handler,
-            Clone::clone(&cfg1),
-            Clone::clone(&cfg2),
-        ));
-        (cfg1, cfg2)
-    }
-
-    #[doc(hidden)]
-    /// Set handler function, use request extractor for all parameters.
-    pub fn with3<T1, T2, T3, F, R>(
-        &mut self, handler: F,
-    ) -> (
-        ExtractorConfig<S, T1>,
-        ExtractorConfig<S, T2>,
-        ExtractorConfig<S, T3>,
-    )
-    where
-        F: Fn(T1, T2, T3) -> R + 'static,
-        R: Responder + 'static,
-        T1: FromRequest<S> + 'static,
-        T2: FromRequest<S> + 'static,
-        T3: FromRequest<S> + 'static,
-    {
-        let cfg1 = ExtractorConfig::default();
-        let cfg2 = ExtractorConfig::default();
-        let cfg3 = ExtractorConfig::default();
-        self.h(With3::new(
-            handler,
-            Clone::clone(&cfg1),
-            Clone::clone(&cfg2),
-            Clone::clone(&cfg3),
-        ));
-        (cfg1, cfg2, cfg3)
-    }
 }
 
 /// `RouteHandler` wrapper. This struct is required because it needs to be

src/with.rs

@@ -361,453 +361,3 @@ where
         self.poll()
     }
 }
-
-pub struct With2<T1, T2, S, F, R>
-where
-    F: Fn(T1, T2) -> R,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    S: 'static,
-{
-    hnd: Rc<UnsafeCell<F>>,
-    cfg1: ExtractorConfig<S, T1>,
-    cfg2: ExtractorConfig<S, T2>,
-    _s: PhantomData<S>,
-}
-
-impl<T1, T2, S, F, R> With2<T1, T2, S, F, R>
-where
-    F: Fn(T1, T2) -> R,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    S: 'static,
-{
-    pub fn new(
-        f: F, cfg1: ExtractorConfig<S, T1>, cfg2: ExtractorConfig<S, T2>,
-    ) -> Self {
-        With2 {
-            hnd: Rc::new(UnsafeCell::new(f)),
-            cfg1,
-            cfg2,
-            _s: PhantomData,
-        }
-    }
-}
-
-impl<T1, T2, S, F, R> Handler<S> for With2<T1, T2, S, F, R>
-where
-    F: Fn(T1, T2) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    S: 'static,
-{
-    type Result = AsyncResult<HttpResponse>;
-
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        let mut fut = WithHandlerFut2 {
-            req,
-            started: false,
-            hnd: Rc::clone(&self.hnd),
-            cfg1: self.cfg1.clone(),
-            cfg2: self.cfg2.clone(),
-            item: None,
-            fut1: None,
-            fut2: None,
-            fut3: None,
-        };
-        match fut.poll() {
-            Ok(Async::Ready(resp)) => AsyncResult::ok(resp),
-            Ok(Async::NotReady) => AsyncResult::async(Box::new(fut)),
-            Err(e) => AsyncResult::ok(e),
-        }
-    }
-}
-
-struct WithHandlerFut2<T1, T2, S, F, R>
-where
-    F: Fn(T1, T2) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    S: 'static,
-{
-    started: bool,
-    hnd: Rc<UnsafeCell<F>>,
-    cfg1: ExtractorConfig<S, T1>,
-    cfg2: ExtractorConfig<S, T2>,
-    req: HttpRequest<S>,
-    item: Option<T1>,
-    fut1: Option<Box<Future<Item = T1, Error = Error>>>,
-    fut2: Option<Box<Future<Item = T2, Error = Error>>>,
-    fut3: Option<Box<Future<Item = HttpResponse, Error = Error>>>,
-}
-
-impl<T1, T2, S, F, R> Future for WithHandlerFut2<T1, T2, S, F, R>
-where
-    F: Fn(T1, T2) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    S: 'static,
-{
-    type Item = HttpResponse;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut3 {
-            return fut.poll();
-        }
-
-        if !self.started {
-            self.started = true;
-            let reply = T1::from_request(&self.req, self.cfg1.as_ref()).into();
-            let item1 = match reply.into() {
-                AsyncResultItem::Err(err) => return Err(err),
-                AsyncResultItem::Ok(msg) => msg,
-                AsyncResultItem::Future(fut) => {
-                    self.fut1 = Some(fut);
-                    return self.poll();
-                }
-            };
-
-            let reply = T2::from_request(&self.req, self.cfg2.as_ref()).into();
-            let item2 = match reply.into() {
-                AsyncResultItem::Err(err) => return Err(err),
-                AsyncResultItem::Ok(msg) => msg,
-                AsyncResultItem::Future(fut) => {
-                    self.item = Some(item1);
-                    self.fut2 = Some(fut);
-                    return self.poll();
-                }
-            };
-
-            let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-            match (*hnd)(item1, item2).respond_to(&self.req) {
-                Ok(item) => match item.into().into() {
-                    AsyncResultItem::Err(err) => return Err(err),
-                    AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-                    AsyncResultItem::Future(fut) => {
-                        self.fut3 = Some(fut);
-                        return self.poll();
-                    }
-                },
-                Err(e) => return Err(e.into()),
-            }
-        }
-
-        if self.fut1.is_some() {
-            match self.fut1.as_mut().unwrap().poll()? {
-                Async::Ready(item) => {
-                    let reply = T2::from_request(&self.req, self.cfg2.as_ref()).into();
-                    let item2 = match reply.into() {
-                        AsyncResultItem::Err(err) => return Err(err),
-                        AsyncResultItem::Ok(msg) => msg,
-                        AsyncResultItem::Future(fut) => {
-                            self.item = Some(item);
-                            self.fut2 = Some(fut);
-                            return self.poll();
-                        }
-                    };
-
-                    let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-                    match (*hnd)(item, item2).respond_to(&self.req) {
-                        Ok(item) => match item.into().into() {
-                            AsyncResultItem::Err(err) => return Err(err),
-                            AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-                            AsyncResultItem::Future(fut) => {
-                                self.fut3 = Some(fut);
-                                return self.poll();
-                            }
-                        },
-                        Err(e) => return Err(e.into()),
-                    }
-                }
-                Async::NotReady => return Ok(Async::NotReady),
-            }
-        }
-
-        let item = match self.fut2.as_mut().unwrap().poll()? {
-            Async::Ready(item) => item,
-            Async::NotReady => return Ok(Async::NotReady),
-        };
-
-        let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-        let item = match (*hnd)(self.item.take().unwrap(), item).respond_to(&self.req) {
-            Ok(item) => item.into(),
-            Err(err) => return Err(err.into()),
-        };
-
-        match item.into() {
-            AsyncResultItem::Err(err) => return Err(err),
-            AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-            AsyncResultItem::Future(fut) => self.fut3 = Some(fut),
-        }
-
-        self.poll()
-    }
-}
-
-pub struct With3<T1, T2, T3, S, F, R>
-where
-    F: Fn(T1, T2, T3) -> R,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    T3: FromRequest<S> + 'static,
-    S: 'static,
-{
-    hnd: Rc<UnsafeCell<F>>,
-    cfg1: ExtractorConfig<S, T1>,
-    cfg2: ExtractorConfig<S, T2>,
-    cfg3: ExtractorConfig<S, T3>,
-    _s: PhantomData<S>,
-}
-
-impl<T1, T2, T3, S, F, R> With3<T1, T2, T3, S, F, R>
-where
-    F: Fn(T1, T2, T3) -> R,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    T3: FromRequest<S> + 'static,
-    S: 'static,
-{
-    pub fn new(
-        f: F, cfg1: ExtractorConfig<S, T1>, cfg2: ExtractorConfig<S, T2>,
-        cfg3: ExtractorConfig<S, T3>,
-    ) -> Self {
-        With3 {
-            hnd: Rc::new(UnsafeCell::new(f)),
-            cfg1,
-            cfg2,
-            cfg3,
-            _s: PhantomData,
-        }
-    }
-}
-
-impl<T1, T2, T3, S, F, R> Handler<S> for With3<T1, T2, T3, S, F, R>
-where
-    F: Fn(T1, T2, T3) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S>,
-    T2: FromRequest<S>,
-    T3: FromRequest<S>,
-    T1: 'static,
-    T2: 'static,
-    T3: 'static,
-    S: 'static,
-{
-    type Result = AsyncResult<HttpResponse>;
-
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        let mut fut = WithHandlerFut3 {
-            req,
-            hnd: Rc::clone(&self.hnd),
-            cfg1: self.cfg1.clone(),
-            cfg2: self.cfg2.clone(),
-            cfg3: self.cfg3.clone(),
-            started: false,
-            item1: None,
-            item2: None,
-            fut1: None,
-            fut2: None,
-            fut3: None,
-            fut4: None,
-        };
-        match fut.poll() {
-            Ok(Async::Ready(resp)) => AsyncResult::ok(resp),
-            Ok(Async::NotReady) => AsyncResult::async(Box::new(fut)),
-            Err(e) => AsyncResult::err(e),
-        }
-    }
-}
-
-struct WithHandlerFut3<T1, T2, T3, S, F, R>
-where
-    F: Fn(T1, T2, T3) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    T3: FromRequest<S> + 'static,
-    S: 'static,
-{
-    hnd: Rc<UnsafeCell<F>>,
-    req: HttpRequest<S>,
-    cfg1: ExtractorConfig<S, T1>,
-    cfg2: ExtractorConfig<S, T2>,
-    cfg3: ExtractorConfig<S, T3>,
-    started: bool,
-    item1: Option<T1>,
-    item2: Option<T2>,
-    fut1: Option<Box<Future<Item = T1, Error = Error>>>,
-    fut2: Option<Box<Future<Item = T2, Error = Error>>>,
-    fut3: Option<Box<Future<Item = T3, Error = Error>>>,
-    fut4: Option<Box<Future<Item = HttpResponse, Error = Error>>>,
-}
-
-impl<T1, T2, T3, S, F, R> Future for WithHandlerFut3<T1, T2, T3, S, F, R>
-where
-    F: Fn(T1, T2, T3) -> R + 'static,
-    R: Responder + 'static,
-    T1: FromRequest<S> + 'static,
-    T2: FromRequest<S> + 'static,
-    T3: FromRequest<S> + 'static,
-    S: 'static,
-{
-    type Item = HttpResponse;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut4 {
-            return fut.poll();
-        }
-
-        if !self.started {
-            self.started = true;
-            let reply = T1::from_request(&self.req, self.cfg1.as_ref()).into();
-            let item1 = match reply.into() {
-                AsyncResultItem::Err(err) => return Err(err),
-                AsyncResultItem::Ok(msg) => msg,
-                AsyncResultItem::Future(fut) => {
-                    self.fut1 = Some(fut);
-                    return self.poll();
-                }
-            };
-
-            let reply = T2::from_request(&self.req, self.cfg2.as_ref()).into();
-            let item2 = match reply.into() {
-                AsyncResultItem::Err(err) => return Err(err),
-                AsyncResultItem::Ok(msg) => msg,
-                AsyncResultItem::Future(fut) => {
-                    self.item1 = Some(item1);
-                    self.fut2 = Some(fut);
-                    return self.poll();
-                }
-            };
-
-            let reply = T3::from_request(&self.req, self.cfg3.as_ref()).into();
-            let item3 = match reply.into() {
-                AsyncResultItem::Err(err) => return Err(err),
-                AsyncResultItem::Ok(msg) => msg,
-                AsyncResultItem::Future(fut) => {
-                    self.item1 = Some(item1);
-                    self.item2 = Some(item2);
-                    self.fut3 = Some(fut);
-                    return self.poll();
-                }
-            };
-
-            let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-            match (*hnd)(item1, item2, item3).respond_to(&self.req) {
-                Ok(item) => match item.into().into() {
-                    AsyncResultItem::Err(err) => return Err(err),
-                    AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-                    AsyncResultItem::Future(fut) => {
-                        self.fut4 = Some(fut);
-                        return self.poll();
-                    }
-                },
-                Err(e) => return Err(e.into()),
-            }
-        }
-
-        if self.fut1.is_some() {
-            match self.fut1.as_mut().unwrap().poll()? {
-                Async::Ready(item) => {
-                    self.item1 = Some(item);
-                    self.fut1.take();
-                    let reply = T2::from_request(&self.req, self.cfg2.as_ref()).into();
-                    let item2 = match reply.into() {
-                        AsyncResultItem::Err(err) => return Err(err),
-                        AsyncResultItem::Ok(msg) => msg,
-                        AsyncResultItem::Future(fut) => {
-                            self.fut2 = Some(fut);
-                            return self.poll();
-                        }
-                    };
-
-                    let reply = T3::from_request(&self.req, self.cfg3.as_ref()).into();
-                    let item3 = match reply.into() {
-                        AsyncResultItem::Err(err) => return Err(err),
-                        AsyncResultItem::Ok(msg) => msg,
-                        AsyncResultItem::Future(fut) => {
-                            self.item2 = Some(item2);
-                            self.fut3 = Some(fut);
-                            return self.poll();
-                        }
-                    };
-                    let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-                    match (*hnd)(self.item1.take().unwrap(), item2, item3)
-                        .respond_to(&self.req)
-                    {
-                        Ok(item) => match item.into().into() {
-                            AsyncResultItem::Err(err) => return Err(err),
-                            AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-                            AsyncResultItem::Future(fut) => {
-                                self.fut4 = Some(fut);
-                                return self.poll();
-                            }
-                        },
-                        Err(e) => return Err(e.into()),
-                    }
-                }
-                Async::NotReady => return Ok(Async::NotReady),
-            }
-        }
-
-        if self.fut2.is_some() {
-            match self.fut2.as_mut().unwrap().poll()? {
-                Async::Ready(item) => {
-                    self.fut2.take();
-                    let reply = T3::from_request(&self.req, self.cfg3.as_ref()).into();
-                    let item3 = match reply.into() {
-                        AsyncResultItem::Err(err) => return Err(err),
-                        AsyncResultItem::Ok(msg) => msg,
-                        AsyncResultItem::Future(fut) => {
-                            self.item2 = Some(item);
-                            self.fut3 = Some(fut);
-                            return self.poll();
-                        }
-                    };
-                    let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-                    match (*hnd)(self.item1.take().unwrap(), item, item3)
-                        .respond_to(&self.req)
-                    {
-                        Ok(item) => match item.into().into() {
-                            AsyncResultItem::Err(err) => return Err(err),
-                            AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-                            AsyncResultItem::Future(fut) => {
-                                self.fut4 = Some(fut);
-                                return self.poll();
-                            }
-                        },
-                        Err(e) => return Err(e.into()),
-                    }
-                }
-                Async::NotReady => return Ok(Async::NotReady),
-            }
-        }
-
-        let item = match self.fut3.as_mut().unwrap().poll()? {
-            Async::Ready(item) => item,
-            Async::NotReady => return Ok(Async::NotReady),
-        };
-
-        let hnd: &mut F = unsafe { &mut *self.hnd.get() };
-        let item =
-            match (*hnd)(self.item1.take().unwrap(), self.item2.take().unwrap(), item)
-                .respond_to(&self.req)
-            {
-                Ok(item) => item.into(),
-                Err(err) => return Err(err.into()),
-            };
-
-        match item.into() {
-            AsyncResultItem::Err(err) => return Err(err),
-            AsyncResultItem::Ok(resp) => return Ok(Async::Ready(resp)),
-            AsyncResultItem::Future(fut) => self.fut4 = Some(fut),
-        }
-
-        self.poll()
-    }
-}

tests/test_handlers.rs

@@ -100,7 +100,7 @@ fn test_async_extractor_async() {
 fn test_path_and_query_extractor() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route().with2(|p: Path<PParam>, q: Query<PParam>| {
+            r.route().with(|(p, q): (Path<PParam>, Query<PParam>)| {
                 format!("Welcome {} - {}!", p.username, q.username)
             })
         });
@@ -134,7 +134,7 @@ fn test_path_and_query_extractor2() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
             r.route()
-                .with3(|_: HttpRequest, p: Path<PParam>, q: Query<PParam>| {
+                .with(|(_r, p, q): (HttpRequest, Path<PParam>, Query<PParam>)| {
                     format!("Welcome {} - {}!", p.username, q.username)
                 })
         });
@@ -167,14 +167,15 @@ fn test_path_and_query_extractor2() {
 fn test_path_and_query_extractor2_async() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route()
+            r.route().with(
-                .with3(|p: Path<PParam>, _: Query<PParam>, data: Json<Value>| {
+                |(p, _q, data): (Path<PParam>, Query<PParam>, Json<Value>)| {
                     Delay::new(Instant::now() + Duration::from_millis(10))
                         .and_then(move |_| {
                             Ok(format!("Welcome {} - {}!", p.username, data.0))
                         })
                         .responder()
-                })
+                },
+            )
         });
     });
 
@@ -197,7 +198,7 @@ fn test_path_and_query_extractor2_async() {
 fn test_path_and_query_extractor3_async() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route().with2(|p: Path<PParam>, data: Json<Value>| {
+            r.route().with(|(p, data): (Path<PParam>, Json<Value>)| {
                 Delay::new(Instant::now() + Duration::from_millis(10))
                     .and_then(move |_| {
                         Ok(format!("Welcome {} - {}!", p.username, data.0))
@@ -222,7 +223,7 @@ fn test_path_and_query_extractor3_async() {
 fn test_path_and_query_extractor4_async() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route().with2(|data: Json<Value>, p: Path<PParam>| {
+            r.route().with(|(data, p): (Json<Value>, Path<PParam>)| {
                 Delay::new(Instant::now() + Duration::from_millis(10))
                     .and_then(move |_| {
                         Ok(format!("Welcome {} - {}!", p.username, data.0))
@@ -247,14 +248,15 @@ fn test_path_and_query_extractor4_async() {
 fn test_path_and_query_extractor2_async2() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route()
+            r.route().with(
-                .with3(|p: Path<PParam>, data: Json<Value>, _: Query<PParam>| {
+                |(p, data, _q): (Path<PParam>, Json<Value>, Query<PParam>)| {
                     Delay::new(Instant::now() + Duration::from_millis(10))
                         .and_then(move |_| {
                             Ok(format!("Welcome {} - {}!", p.username, data.0))
                         })
                         .responder()
-                })
+                },
+            )
         });
     });
 
@@ -286,14 +288,15 @@ fn test_path_and_query_extractor2_async2() {
 fn test_path_and_query_extractor2_async3() {
     let mut srv = test::TestServer::new(|app| {
         app.resource("/{username}/index.html", |r| {
-            r.route()
+            r.route().with(
-                .with3(|data: Json<Value>, p: Path<PParam>, _: Query<PParam>| {
+                |(data, p, _q): (Json<Value>, Path<PParam>, Query<PParam>)| {
                     Delay::new(Instant::now() + Duration::from_millis(10))
                         .and_then(move |_| {
                             Ok(format!("Welcome {} - {}!", p.username, data.0))
                         })
                         .responder()
-                })
+                },
+            )
         });
     });