openssl features

Public, signed and private cookies

.travis.yml

@@ -14,7 +14,6 @@ matrix:
     - rust: nightly
   allow_failures:
     - rust: nightly
-    - rust: beta
 
 #rust:
 #  - 1.21.0
@@ -47,7 +46,7 @@ script:
        USE_SKEPTIC=1 cargo test --features=alpn
     else
        cargo clean
-       cargo test
+       cargo test -- --nocapture
        # --features=alpn
     fi
 
@@ -55,9 +54,11 @@ script:
     if [[ "$TRAVIS_RUST_VERSION" == "stable" ]]; then
       cd examples/basics && cargo check && cd ../..
       cd examples/hello-world && cargo check && cd ../..
+      cd examples/http-proxy && cargo check && cd ../..
       cd examples/multipart && cargo check && cd ../..
       cd examples/json && cargo check && cd ../..
       cd examples/juniper && cargo check && cd ../..
+      cd examples/protobuf && cargo check && cd ../..
       cd examples/state && cargo check && cd ../..
       cd examples/template_tera && cargo check && cd ../..
       cd examples/diesel && cargo check && cd ../..
@@ -65,6 +66,7 @@ script:
       cd examples/tls && cargo check && cd ../..
       cd examples/websocket-chat && cargo check && cd ../..
       cd examples/websocket && cargo check && cd ../..
+      cd examples/unix-socket && cargo check && cd ../..
     fi
   - |
     if [[ "$TRAVIS_RUST_VERSION" == "nightly" && $CLIPPY ]]; then
@@ -74,10 +76,10 @@ script:
 # Upload docs
 after_success:
   - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-      cargo doc --features "alpn, tls" --no-deps &&
+    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then
+      cargo doc --features "alpn, tls, session" --no-deps &&
       echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
-      cargo install mdbook &&
+      curl -sL https://github.com/rust-lang-nursery/mdBook/releases/download/v0.1.5/mdbook-v0.1.5-x86_64-unknown-linux-gnu.tar.gz | tar xvz -C $HOME/.cargo/bin &&
       cd guide && mdbook build -d ../target/doc/guide && cd .. &&
       git clone https://github.com/davisp/ghp-import.git &&
       ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
@@ -85,7 +87,7 @@ after_success:
     fi
 
   - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_RUST_VERSION" == "1.21.0" ]]; then
+    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
       bash <(curl https://raw.githubusercontent.com/xd009642/tarpaulin/master/travis-install.sh)
       USE_SKEPTIC=1 cargo tarpaulin --out Xml
       bash <(curl -s https://codecov.io/bash)

CHANGES.md

@@ -1,5 +1,143 @@
 # Changes
 
+## 0.5.0
+
+* Type-safe path/query/form parameter handling, using serde #70
+
+* HttpResponse builder's methods  `.body()`, `.finish()`, `.json()`
+  return `HttpResponse` instead of `Result`
+
+* Use more ergonomic `actix_web::Error` instead of `http::Error` for `ClientRequestBuilder::body()`
+
+* Added `HttpRequest::resource()`, returns current matched resource
+
+* Added `ErrorHandlers` middleware
+
+* Fix router cannot parse Non-ASCII characters in URL #137
+
+* Fix client connection pooling
+
+* Fix long client urls #129
+
+* Fix panic on invalid URL characters #130
+
+* Fix logger request duration calculation #152
+
+* Fix prefix and static file serving #168
+
+* Add `signed` and `private` `CookieSessionBackend`s
+
+
+## 0.4.10 (2018-03-20)
+
+* Use `Error` instead of `InternalError` for `error::ErrorXXXX` methods
+
+* Allow to set client request timeout
+
+* Allow to set client websocket handshake timeout
+
+* Refactor `TestServer` configuration
+
+* Fix server websockets big payloads support
+
+* Fix http/2 date header generation
+
+
+## 0.4.9 (2018-03-16)
+
+* Allow to disable http/2 support
+
+* Wake payload reading task when data is available
+
+* Fix server keep-alive handling
+
+* Send Query Parameters in client requests #120
+
+* Move brotli encoding to a feature
+
+* Add option of default handler for `StaticFiles` handler #57
+
+* Add basic client connection pooling
+
+
+## 0.4.8 (2018-03-12)
+
+* Allow to set read buffer capacity for server request
+
+* Handle WouldBlock error for socket accept call
+
+
+## 0.4.7 (2018-03-11)
+
+* Fix panic on unknown content encoding
+
+* Fix connection get closed too early
+
+* Fix streaming response handling for http/2
+
+* Better sleep on error support
+
+
+## 0.4.6 (2018-03-10)
+
+* Fix client cookie handling
+
+* Fix json content type detection
+
+* Fix CORS middleware #117
+
+* Optimize websockets stream support
+
+
+## 0.4.5 (2018-03-07)
+
+* Fix compression #103 and #104
+
+* Fix client cookie handling #111
+
+* Non-blocking processing of a `NamedFile`
+
+* Enable compression support for `NamedFile`
+
+* Better support for `NamedFile` type
+
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
+
+* Add native-tls support for client
+
+* Allow client connection timeout to be set #108
+
+* Allow to use std::net::TcpListener for HttpServer
+
+* Handle panics in worker threads
+
+
+## 0.4.4 (2018-03-04)
+
+* Allow to use Arc<Vec<u8>> as response/request body
+
+* Fix handling of requests with an encoded body with a length > 8192 #93
+
+## 0.4.3 (2018-03-03)
+
+* Fix request body read bug
+
+* Fix segmentation fault #79
+
+* Set reuse address before bind #90
+
+
+## 0.4.2 (2018-03-02)
+
+* Better naming for websockets implementation
+
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
+
+* Add csrf middleware for filter for cross-site request forgery #89
+
+* Fix disconnect on idle connections
+
+
 ## 0.4.1 (2018-03-01)
 
 * Rename `Route::p()` to `Route::filter()`

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-web"
-version = "0.4.1"
+version = "0.5.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix web is a small, pragmatic, extremely fast, web framework for Rust."
+description = "Actix web is a simple, pragmatic, extremely fast, web framework for Rust."
 readme = "README.md"
 keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://github.com/actix/actix-web"
@@ -27,18 +27,25 @@ name = "actix_web"
 path = "src/lib.rs"
 
 [features]
-default = []
+default = ["session", "brotli"]
 
 # tls
 tls = ["native-tls", "tokio-tls"]
 
 # openssl
-alpn = ["openssl", "openssl/v102", "openssl/v110", "tokio-openssl"]
+alpn = ["openssl", "tokio-openssl"]
+
+# sessions
+session = ["cookie/secure"]
+
+# brotli encoding
+brotli = ["brotli2"]
 
 [dependencies]
+actix = "^0.5.5"
+
 base64 = "0.9"
 bitflags = "1.0"
-brotli2 = "^0.3.2"
 failure = "0.1.1"
 flate2 = "1.0"
 h2 = "0.1"
@@ -48,19 +55,23 @@ http-range = "0.1"
 libc = "0.2"
 log = "0.4"
 mime = "0.3"
-mime_guess = "1.8"
+mime_guess = "2.0.0-alpha"
 num_cpus = "1.0"
 percent-encoding = "1.0"
 rand = "0.4"
 regex = "0.2"
 serde = "1.0"
 serde_json = "1.0"
+serde_urlencoded = "0.5"
 sha1 = "0.6"
 smallvec = "0.6"
 time = "0.1"
 encoding = "0.2"
+language-tags = "0.2"
+lazy_static = "1.0"
 url = { version="1.7", features=["query_encoding"] }
-cookie = { version="0.10", features=["percent-encode", "secure"] }
+cookie = { version="0.10", features=["percent-encode"] }
+brotli2 = { version="^0.3.2", optional = true }
 
 # io
 mio = "^0.6.13"
@@ -68,6 +79,7 @@ net2 = "0.2"
 bytes = "0.4"
 byteorder = "1"
 futures = "0.1"
+futures-cpupool = "0.1"
 tokio-io = "0.1"
 tokio-core = "0.1"
 trust-dns-resolver = "0.8"
@@ -80,9 +92,6 @@ tokio-tls = { version="0.1", optional = true }
 openssl = { version="0.10", optional = true }
 tokio-openssl = { version="0.2", optional = true }
 
-[dependencies.actix]
-version = "0.5"
-
 [dev-dependencies]
 env_logger = "0.5"
 skeptic = "0.13"
@@ -105,7 +114,9 @@ members = [
   "examples/diesel",
   "examples/r2d2",
   "examples/json",
+  "examples/protobuf",
   "examples/hello-world",
+  "examples/http-proxy",
   "examples/multipart",
   "examples/state",
   "examples/redis-session",
@@ -114,5 +125,6 @@ members = [
   "examples/websocket",
   "examples/websocket-chat",
   "examples/web-cors/backend",
+  "examples/unix-socket",
   "tools/wsload/",
 ]

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Nikilay Kim
+Copyright (c) 2017 Nikolay Kim
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -1,6 +1,6 @@
-# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](http://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Actix web is a small, pragmatic, extremely fast, web framework for Rust.
+Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 
 * Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.github.io/actix-web/guide/qs_13.html) protocols
 * Streaming and pipelining
@@ -10,15 +10,17 @@ Actix web is a small, pragmatic, extremely fast, web framework for Rust.
 * Configurable [request routing](https://actix.github.io/actix-web/guide/qs_5.html)
 * Graceful server shutdown
 * Multipart streams
-* SSL support with openssl or native-tls
+* Static assets
+* SSL support with OpenSSL or `native-tls`
 * Middlewares ([Logger](https://actix.github.io/actix-web/guide/qs_10.html#logging),
   [Session](https://actix.github.io/actix-web/guide/qs_10.html#user-sessions),
   [Redis sessions](https://github.com/actix/actix-redis),
   [DefaultHeaders](https://actix.github.io/actix-web/guide/qs_10.html#default-headers),
-  [CORS](https://actix.github.io/actix-web/actix_web/middleware/cors/index.html))
-* Built on top of [Actix actor framework](https://github.com/actix/actix).
+  [CORS](https://actix.github.io/actix-web/actix_web/middleware/cors/index.html),
+  [CSRF](https://actix.github.io/actix-web/actix_web/middleware/csrf/index.html))
+* Built on top of [Actix actor framework](https://github.com/actix/actix)
 
-## Documentation
+## Documentation & community resources
 
 * [User Guide](http://actix.github.io/actix-web/guide/)
 * [API Documentation (Development)](http://actix.github.io/actix-web/actix_web/)
@@ -29,18 +31,18 @@ Actix web is a small, pragmatic, extremely fast, web framework for Rust.
 
 ## Example
 
-```rust,ignore
+```rust
 extern crate actix_web;
-use actix_web::*;
+use actix_web::{http, server, App, Path};
 
-fn index(req: HttpRequest) -> String {
-    format!("Hello {}!", &req.match_info()["name"])
+fn index(info: Path<(u32, String)>) -> String {
+    format!("Hello {}! id:{}", info.0, info.1)
 }
 
 fn main() {
-    HttpServer::new(
-        || Application::new()
-            .resource("/{name}", |r| r.f(index)))
+    server::new(
+        || App::new()
+            .route("/{id}/{name}/index.html", http::Method::GET, index))
         .bind("127.0.0.1:8080").unwrap()
         .run();
 }
@@ -50,13 +52,13 @@ fn main() {
 
 * [Basics](https://github.com/actix/actix-web/tree/master/examples/basics/)
 * [Stateful](https://github.com/actix/actix-web/tree/master/examples/state/)
+* [Protobuf support](https://github.com/actix/actix-web/tree/master/examples/protobuf/)
 * [Multipart streams](https://github.com/actix/actix-web/tree/master/examples/multipart/)
 * [Simple websocket session](https://github.com/actix/actix-web/tree/master/examples/websocket/)
 * [Tera templates](https://github.com/actix/actix-web/tree/master/examples/template_tera/)
 * [Diesel integration](https://github.com/actix/actix-web/tree/master/examples/diesel/)
 * [SSL / HTTP/2.0](https://github.com/actix/actix-web/tree/master/examples/tls/)
 * [Tcp/Websocket chat](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)
-* [SockJS Server](https://github.com/actix/actix-sockjs)
 * [Json](https://github.com/actix/actix-web/tree/master/examples/json/)
 
 You may consider checking out

build.rs

@@ -6,12 +6,13 @@ use std::{env, fs};
 
 #[cfg(unix)]
 fn main() {
+    println!("cargo:rerun-if-env-changed=USE_SKEPTIC");
     let f = env::var("OUT_DIR").unwrap() + "/skeptic-tests.rs";
     if env::var("USE_SKEPTIC").is_ok() {
         let _ = fs::remove_file(f);
         // generates doc tests for `README.md`.
         skeptic::generate_doc_tests(
-            &["README.md",
+            &[// "README.md",
               "guide/src/qs_1.md",
               "guide/src/qs_2.md",
               "guide/src/qs_3.md",

examples/basics/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 workspace = "../.."
 
 [dependencies]
-futures = "*"
+futures = "0.1"
 env_logger = "0.5"
 actix = "0.5"
 actix-web = { path="../.." }

examples/basics/src/main.rs

@@ -8,8 +8,10 @@ extern crate futures;
 use futures::Stream;
 
 use std::{io, env};
-use actix_web::*;
-use actix_web::middleware::RequestSession;
+use actix_web::{error, fs, pred, server,
+                App, HttpRequest, HttpResponse, Result, Error};
+use actix_web::http::{Method, StatusCode};
+use actix_web::middleware::{self, RequestSession};
 use futures::future::{FutureResult, result};
 
 /// favicon handler
@@ -49,7 +51,7 @@ fn index(mut req: HttpRequest) -> Result<HttpResponse> {
     // response
     Ok(HttpResponse::build(StatusCode::OK)
         .content_type("text/html; charset=utf-8")
-        .body(&html).unwrap())
+        .body(&html))
 
 }
 
@@ -67,7 +69,7 @@ fn p404(req: HttpRequest) -> Result<HttpResponse> {
     // response
     Ok(HttpResponse::build(StatusCode::NOT_FOUND)
         .content_type("text/html; charset=utf-8")
-        .body(html).unwrap())
+        .body(html))
 }
 
 
@@ -76,20 +78,19 @@ fn index_async(req: HttpRequest) -> FutureResult<HttpResponse, Error>
 {
     println!("{:?}", req);
 
-    result(HttpResponse::Ok()
-           .content_type("text/html")
-           .body(format!("Hello {}!", req.match_info().get("name").unwrap()))
-           .map_err(|e| e.into()))
+    result(Ok(HttpResponse::Ok()
+              .content_type("text/html")
+              .body(format!("Hello {}!", req.match_info().get("name").unwrap()))))
 }
 
 /// handler with path parameters like `/user/{name}/`
-fn with_param(req: HttpRequest) -> Result<HttpResponse>
+fn with_param(req: HttpRequest) -> HttpResponse
 {
     println!("{:?}", req);
 
-    Ok(HttpResponse::Ok()
-       .content_type("test/plain")
-       .body(format!("Hello {}!", req.match_info().get("name").unwrap()))?)
+    HttpResponse::Ok()
+        .content_type("test/plain")
+        .body(format!("Hello {}!", req.match_info().get("name").unwrap()))
 }
 
 fn main() {
@@ -98,15 +99,13 @@ fn main() {
     env_logger::init();
     let sys = actix::System::new("basic-example");
 
-    let addr = HttpServer::new(
-        || Application::new()
+    let addr = server::new(
+        || App::new()
             // enable logger
             .middleware(middleware::Logger::default())
             // cookie session middleware
             .middleware(middleware::SessionStorage::new(
-                middleware::CookieSessionBackend::build(&[0; 32])
-                    .secure(false)
-                    .finish()
+                middleware::CookieSessionBackend::signed(&[0; 32]).secure(false)
             ))
             // register favicon
             .resource("/favicon.ico", |r| r.f(favicon))
@@ -118,16 +117,17 @@ fn main() {
             .resource("/async/{name}", |r| r.method(Method::GET).a(index_async))
             .resource("/test", |r| r.f(|req| {
                 match *req.method() {
-                    Method::GET => httpcodes::HTTPOk,
-                    Method::POST => httpcodes::HTTPMethodNotAllowed,
-                    _ => httpcodes::HTTPNotFound,
+                    Method::GET => HttpResponse::Ok(),
+                    Method::POST => HttpResponse::MethodNotAllowed(),
+                    _ => HttpResponse::NotFound(),
                 }
             }))
             .resource("/error.html", |r| r.f(|req| {
-                error::ErrorBadRequest(io::Error::new(io::ErrorKind::Other, "test"))
+                error::InternalError::new(
+                    io::Error::new(io::ErrorKind::Other, "test"), StatusCode::OK)
             }))
             // static files
-            .handler("/static/", fs::StaticFiles::new("../static/", true))
+            .handler("/static/", fs::StaticFiles::new("../static/"))
             // redirect
             .resource("/", |r| r.method(Method::GET).f(|req| {
                 println!("{:?}", req);
@@ -139,7 +139,8 @@ fn main() {
             // default
             .default_resource(|r| {
                 r.method(Method::GET).f(p404);
-                r.route().p(pred::Not(pred::Get())).f(|req| httpcodes::HTTPMethodNotAllowed);
+                r.route().filter(pred::Not(pred::Get())).f(
+                    |req| HttpResponse::MethodNotAllowed());
             }))
 
         .bind("127.0.0.1:8080").expect("Can not bind to 127.0.0.1:8080")

examples/diesel/Cargo.toml

@@ -15,5 +15,6 @@ serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
 
-diesel = { version = "1.0.0-beta1", features = ["sqlite"] }
+diesel = { version = "^1.1.0", features = ["sqlite", "r2d2"] }
+r2d2 = "0.8"
 dotenv = "0.10"

examples/diesel/src/db.rs

@@ -4,12 +4,13 @@ use diesel;
 use actix_web::*;
 use actix::prelude::*;
 use diesel::prelude::*;
+use diesel::r2d2::{Pool, ConnectionManager};
 
 use models;
 use schema;
 
 /// This is db executor actor. We are going to run 3 of them in parallel.
-pub struct DbExecutor(pub SqliteConnection);
+pub struct DbExecutor(pub Pool<ConnectionManager<SqliteConnection>>);
 
 /// This is only message that this actor can handle, but it is easy to extend number of
 /// messages.
@@ -37,14 +38,16 @@ impl Handler<CreateUser> for DbExecutor {
             name: &msg.name,
         };
 
+        let conn: &SqliteConnection = &self.0.get().unwrap();
+
         diesel::insert_into(users)
             .values(&new_user)
-            .execute(&self.0)
+            .execute(conn)
             .expect("Error inserting person");
 
         let mut items = users
             .filter(id.eq(&uuid))
-            .load::<models::User>(&self.0)
+            .load::<models::User>(conn)
             .expect("Error loading person");
 
         Ok(items.pop().unwrap())

examples/diesel/src/main.rs

@@ -1,8 +1,8 @@
 //! Actix web diesel example
 //!
 //! Diesel does not support tokio, so we have to run it in separate threads.
-//! Actix supports sync actors by default, so we going to create sync actor that will
-//! use diesel. Technically sync actors are worker style actors, multiple of them
+//! Actix supports sync actors by default, so we going to create sync actor that use diesel.
+//! Technically sync actors are worker style actors, multiple of them
 //! can run in parallel and process messages from same queue.
 extern crate serde;
 extern crate serde_json;
@@ -10,16 +10,19 @@ extern crate serde_json;
 extern crate serde_derive;
 #[macro_use]
 extern crate diesel;
+extern crate r2d2;
 extern crate uuid;
 extern crate futures;
 extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
 
-use actix::*;
-use actix_web::*;
+use actix::prelude::*;
+use actix_web::{http, server, middleware,
+                App, Path, State, HttpResponse, AsyncResponder, FutureResponse};
 
 use diesel::prelude::*;
+use diesel::r2d2::{ Pool, ConnectionManager };
 use futures::future::Future;
 
 mod db;
@@ -30,20 +33,19 @@ use db::{CreateUser, DbExecutor};
 
 
 /// State with DbExecutor address
-struct State {
+struct AppState {
     db: Addr<Syn, DbExecutor>,
 }
 
 /// Async request handler
-fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    let name = &req.match_info()["name"];
-
-    req.state().db.send(CreateUser{name: name.to_owned()})
+fn index(name: Path<String>, state: State<AppState>) -> FutureResponse<HttpResponse> {
+    // send async `CreateUser` message to a `DbExecutor`
+    state.db.send(CreateUser{name: name.into_inner()})
         .from_err()
         .and_then(|res| {
             match res {
-                Ok(user) => Ok(httpcodes::HTTPOk.build().json(user)?),
-                Err(_) => Ok(httpcodes::HTTPInternalServerError.into())
+                Ok(user) => Ok(HttpResponse::Ok().json(user)),
+                Err(_) => Ok(HttpResponse::InternalServerError().into())
             }
         })
         .responder()
@@ -51,20 +53,23 @@ fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>>
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("diesel-example");
 
-    // Start db executor actors
-    let addr = SyncArbiter::start(3, || {
-        DbExecutor(SqliteConnection::establish("test.db").unwrap())
+    // Start 3 db executor actors
+    let manager = ConnectionManager::<SqliteConnection>::new("test.db");
+    let pool = r2d2::Pool::builder().build(manager).expect("Failed to create pool.");
+
+    let addr = SyncArbiter::start(3, move || {
+        DbExecutor(pool.clone())
     });
 
     // Start http server
-    let _addr = HttpServer::new(move || {
-        Application::with_state(State{db: addr.clone()})
+    server::new(move || {
+        App::with_state(AppState{db: addr.clone()})
             // enable logger
             .middleware(middleware::Logger::default())
-            .resource("/{name}", |r| r.method(Method::GET).a(index))})
+            .resource("/{name}", |r| r.method(http::Method::GET).with2(index))})
         .bind("127.0.0.1:8080").unwrap()
         .start();
 

examples/hello-world/src/main.rs

@@ -2,7 +2,7 @@ extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
 
-use actix_web::*;
+use actix_web::{App, HttpRequest, server, middleware};
 
 
 fn index(_req: HttpRequest) -> &'static str {
@@ -11,11 +11,11 @@ fn index(_req: HttpRequest) -> &'static str {
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
-    let sys = actix::System::new("ws-example");
+    env_logger::init();
+    let sys = actix::System::new("hello-world");
 
-    let _addr = HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             // enable logger
             .middleware(middleware::Logger::default())
             .resource("/index.html", |r| r.f(|_| "Hello world!"))

examples/http-proxy/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "http-proxy"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+workspace = "../.."
+
+[dependencies]
+env_logger = "0.5"
+futures = "0.1"
+actix = "0.5"
+actix-web = { path = "../../", features=["alpn"] }

examples/http-proxy/src/main.rs

@@ -0,0 +1,58 @@
+extern crate actix;
+extern crate actix_web;
+extern crate futures;
+extern crate env_logger;
+
+use futures::{Future, Stream};
+use actix_web::{
+    client, server, middleware,
+    App, AsyncResponder, Body, HttpRequest, HttpResponse, HttpMessage, Error};
+
+
+/// Stream client request response and then send body to a server response
+fn index(_req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    client::ClientRequest::get("https://www.rust-lang.org/en-US/")
+        .finish().unwrap()
+        .send()
+        .map_err(Error::from)   // <- convert SendRequestError to an Error
+        .and_then(
+            |resp| resp.body()         // <- this is MessageBody type, resolves to complete body
+                .from_err()            // <- convert PayloadError to a Error
+                .and_then(|body| {     // <- we got complete body, now send as server response
+                    Ok(HttpResponse::Ok().body(body))
+                }))
+        .responder()
+}
+
+/// streaming client request to a streaming server response
+fn streaming(_req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    // send client request
+    client::ClientRequest::get("https://www.rust-lang.org/en-US/")
+        .finish().unwrap()
+        .send()                         // <- connect to host and send request
+        .map_err(Error::from)    // <- convert SendRequestError to an Error
+        .and_then(|resp| {              // <- we received client response
+            Ok(HttpResponse::Ok()
+               // read one chunk from client response and send this chunk to a server response
+               // .from_err() converts PayloadError to a Error
+               .body(Body::Streaming(Box::new(resp.from_err()))))
+        })
+        .responder()
+}
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    let sys = actix::System::new("http-proxy");
+
+    server::new(
+        || App::new()
+            .middleware(middleware::Logger::default())
+            .resource("/streaming", |r| r.f(streaming))
+            .resource("/", |r| r.f(index)))
+        .bind("127.0.0.1:8080").unwrap()
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

examples/json/src/main.rs

@@ -7,7 +7,9 @@ extern crate serde_json;
 #[macro_use] extern crate serde_derive;
 #[macro_use] extern crate json;
 
-use actix_web::*;
+use actix_web::{
+    middleware, http, error, server,
+    App, AsyncResponder, HttpRequest, HttpResponse, HttpMessage, Error, Json};
 
 use bytes::BytesMut;
 use futures::{Future, Stream};
@@ -19,21 +21,26 @@ struct MyObj {
     number: i32,
 }
 
-/// This handler uses `HttpRequest::json()` for loading serde json object.
+/// This handler uses `HttpRequest::json()` for loading json object.
 fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
     req.json()
         .from_err()  // convert all errors into `Error`
         .and_then(|val: MyObj| {
             println!("model: {:?}", val);
-            Ok(httpcodes::HTTPOk.build().json(val)?)  // <- send response
+            Ok(HttpResponse::Ok().json(val))  // <- send response
         })
         .responder()
 }
 
+/// This handler uses json extractor
+fn extract_item(item: Json<MyObj>) -> HttpResponse {
+    println!("model: {:?}", &item);
+    HttpResponse::Ok().json(item.0)  // <- send response
+}
 
 const MAX_SIZE: usize = 262_144;  // max payload size is 256k
 
-/// This handler manually load request payload and parse serde json
+/// This handler manually load request payload and parse json object
 fn index_manual(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
     // HttpRequest is stream of Bytes objects
     req
@@ -57,7 +64,7 @@ fn index_manual(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>>
         .and_then(|body| {
             // body is loaded, now we can deserialize serde-json
             let obj = serde_json::from_slice::<MyObj>(&body)?;
-            Ok(httpcodes::HTTPOk.build().json(obj)?) // <- send response
+            Ok(HttpResponse::Ok().json(obj)) // <- send response
         })
         .responder()
 }
@@ -70,26 +77,30 @@ fn index_mjsonrust(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Erro
             // body is loaded, now we can deserialize json-rust
             let result = json::parse(std::str::from_utf8(&body).unwrap()); // return Result
             let injson: JsonValue = match result { Ok(v) => v, Err(e) => object!{"err" => e.to_string() } };
-            Ok(HttpResponse::build(StatusCode::OK)
+            Ok(HttpResponse::Ok()
                 .content_type("application/json")
-                .body(injson.dump()).unwrap())
-
+                .body(injson.dump()))
         })
         .responder()
 }
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("json-example");
 
-    let addr = HttpServer::new(|| {
-        Application::new()
+    server::new(|| {
+        App::new()
             // enable logger
             .middleware(middleware::Logger::default())
-            .resource("/manual", |r| r.method(Method::POST).f(index_manual))
-            .resource("/mjsonrust", |r| r.method(Method::POST).f(index_mjsonrust))
-            .resource("/", |r| r.method(Method::POST).f(index))})
+            .resource("/extractor", |r| {
+                r.method(http::Method::POST)
+                    .with(extract_item)
+                    .limit(4096); // <- limit size of the payload
+            })
+            .resource("/manual", |r| r.method(http::Method::POST).f(index_manual))
+            .resource("/mjsonrust", |r| r.method(http::Method::POST).f(index_mjsonrust))
+            .resource("/", |r| r.method(http::Method::POST).f(index))})
         .bind("127.0.0.1:8080").unwrap()
         .shutdown_timeout(1)
         .start();

examples/juniper/src/main.rs

@@ -12,11 +12,12 @@ extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
 
-use actix::*;
-use actix_web::*;
+use actix::prelude::*;
+use actix_web::{
+    middleware, http, server,
+    App, AsyncResponder, HttpRequest, HttpResponse, FutureResponse, Error, State, Json};
 use juniper::http::graphiql::graphiql_source;
 use juniper::http::GraphQLRequest;
-
 use futures::future::Future;
 
 mod schema;
@@ -24,7 +25,7 @@ mod schema;
 use schema::Schema;
 use schema::create_schema;
 
-struct State {
+struct AppState {
     executor: Addr<Syn, GraphQLExecutor>,
 }
 
@@ -61,33 +62,30 @@ impl Handler<GraphQLData> for GraphQLExecutor {
     }
 }
 
-fn graphiql(_req: HttpRequest<State>) -> Result<HttpResponse>  {
+fn graphiql(_req: HttpRequest<AppState>) -> Result<HttpResponse, Error>  {
     let html = graphiql_source("http://127.0.0.1:8080/graphql");
-    Ok(HttpResponse::build(StatusCode::OK)
-        .content_type("text/html; charset=utf-8")
-        .body(html).unwrap())
+    Ok(HttpResponse::Ok()
+       .content_type("text/html; charset=utf-8")
+       .body(html))
 }
 
-fn graphql(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    let executor = req.state().executor.clone();
-    req.json()
+fn graphql(st: State<AppState>, data: Json<GraphQLData>) -> FutureResponse<HttpResponse> {
+    st.executor.send(data.0)
         .from_err()
-        .and_then(move |val: GraphQLData| {
-            executor.send(val)
-                .from_err()
-                .and_then(|res| {
-                    match res {
-                        Ok(user) => Ok(httpcodes::HTTPOk.build().body(user)?),
-                        Err(_) => Ok(httpcodes::HTTPInternalServerError.into())
-                    }
-                })
+        .and_then(|res| {
+            match res {
+                Ok(user) => Ok(HttpResponse::Ok()
+                               .content_type("application/json")
+                               .body(user)),
+                Err(_) => Ok(HttpResponse::InternalServerError().into())
+            }
         })
         .responder()
 }
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("juniper-example");
 
     let schema = std::sync::Arc::new(create_schema());
@@ -96,12 +94,12 @@ fn main() {
     });
 
     // Start http server
-    let _addr = HttpServer::new(move || {
-        Application::with_state(State{executor: addr.clone()})
+    server::new(move || {
+        App::with_state(AppState{executor: addr.clone()})
             // enable logger
             .middleware(middleware::Logger::default())
-            .resource("/graphql", |r| r.method(Method::POST).a(graphql))
-            .resource("/graphiql", |r| r.method(Method::GET).f(graphiql))})
+            .resource("/graphql", |r| r.method(http::Method::POST).with2(graphql))
+            .resource("/graphiql", |r| r.method(http::Method::GET).h(graphiql))})
         .bind("127.0.0.1:8080").unwrap()
         .start();
 

examples/multipart/src/main.rs

@@ -5,7 +5,9 @@ extern crate env_logger;
 extern crate futures;
 
 use actix::*;
-use actix_web::*;
+use actix_web::{
+    http, middleware, multipart, server,
+    App, AsyncResponder, HttpRequest, HttpResponse, HttpMessage, Error};
 
 use futures::{Future, Stream};
 use futures::future::{result, Either};
@@ -38,7 +40,7 @@ fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>>
             }
         })
         .finish()  // <- Stream::finish() combinator from actix
-        .map(|_| httpcodes::HTTPOk.into())
+        .map(|_| HttpResponse::Ok().into())
         .responder()
 }
 
@@ -47,10 +49,10 @@ fn main() {
     let _ = env_logger::init();
     let sys = actix::System::new("multipart-example");
 
-    let addr = HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             .middleware(middleware::Logger::default()) // <- logger
-            .resource("/multipart", |r| r.method(Method::POST).a(index)))
+            .resource("/multipart", |r| r.method(http::Method::POST).a(index)))
         .bind("127.0.0.1:8080").unwrap()
         .start();
 

examples/protobuf/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "protobuf-example"
+version = "0.1.0"
+authors = ["kingxsp <jin_hb_zh@126.com>"]
+
+[dependencies]
+bytes = "0.4"
+futures = "0.1"
+failure = "0.1"
+env_logger = "*"
+
+prost = "0.2.0"
+prost-derive = "0.2.0"
+
+actix = "0.5"
+actix-web = { path="../../" }

examples/protobuf/client.py

@@ -0,0 +1,66 @@
+# just start server and run client.py
+
+# wget https://github.com/google/protobuf/releases/download/v3.5.1/protobuf-python-3.5.1.zip
+# unzip protobuf-python-3.5.1.zip.1
+# cd protobuf-3.5.1/python/
+# python3.6 setup.py install
+
+# pip3.6 install --upgrade pip
+# pip3.6 install aiohttp
+
+#!/usr/bin/env python
+import test_pb2
+import traceback
+import sys
+
+import asyncio
+import aiohttp
+
+def op():
+    try:
+        obj = test_pb2.MyObj()
+        obj.number = 9
+        obj.name = 'USB'
+
+        #Serialize
+        sendDataStr = obj.SerializeToString()
+        #print serialized string value
+        print('serialized string:', sendDataStr)
+        #------------------------#
+        #  message transmission  #
+        #------------------------#
+        receiveDataStr = sendDataStr
+        receiveData = test_pb2.MyObj()
+
+        #Deserialize
+        receiveData.ParseFromString(receiveDataStr)
+        print('pares serialize string, return: devId = ', receiveData.number, ', name = ', receiveData.name)
+    except(Exception, e):
+        print(Exception, ':', e)
+        print(traceback.print_exc())
+        errInfo = sys.exc_info()
+        print(errInfo[0], ':', errInfo[1])
+
+
+async def fetch(session):
+    obj = test_pb2.MyObj()
+    obj.number = 9
+    obj.name = 'USB'
+    async with session.post('http://localhost:8080/', data=obj.SerializeToString(),
+        headers={"content-type": "application/protobuf"}) as resp:
+        print(resp.status)
+        data = await resp.read()
+        receiveObj = test_pb2.MyObj()
+        receiveObj.ParseFromString(data)
+        print(receiveObj)
+
+async def go(loop):
+    obj = test_pb2.MyObj()
+    obj.number = 9
+    obj.name = 'USB'
+    async with aiohttp.ClientSession(loop=loop) as session:
+        await fetch(session)
+
+loop = asyncio.get_event_loop()
+loop.run_until_complete(go(loop))
+loop.close()

examples/protobuf/src/main.rs

@@ -0,0 +1,57 @@
+extern crate actix;
+extern crate actix_web;
+extern crate bytes;
+extern crate futures;
+#[macro_use]
+extern crate failure;
+extern crate env_logger;
+extern crate prost;
+#[macro_use]
+extern crate prost_derive;
+
+use futures::Future;
+use actix_web::{
+    http, middleware, server,
+    App, AsyncResponder, HttpRequest, HttpResponse, Error};
+
+mod protobuf;
+use protobuf::ProtoBufResponseBuilder;
+
+
+#[derive(Clone, Debug, PartialEq, Message)]
+pub struct MyObj {
+    #[prost(int32, tag="1")]
+    pub number: i32,
+    #[prost(string, tag="2")]
+    pub name: String,
+}
+
+
+/// This handler uses `ProtoBufMessage` for loading protobuf object.
+fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    protobuf::ProtoBufMessage::new(req)
+        .from_err()  // convert all errors into `Error`
+        .and_then(|val: MyObj| {
+            println!("model: {:?}", val);
+            Ok(HttpResponse::Ok().protobuf(val)?)  // <- send response
+        })
+        .responder()
+}
+
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    let sys = actix::System::new("protobuf-example");
+
+    server::new(|| {
+        App::new()
+            .middleware(middleware::Logger::default())
+            .resource("/", |r| r.method(http::Method::POST).f(index))})
+        .bind("127.0.0.1:8080").unwrap()
+        .shutdown_timeout(1)
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

examples/protobuf/src/protobuf.rs

@@ -0,0 +1,168 @@
+use bytes::{Bytes, BytesMut};
+use futures::{Poll, Future, Stream};
+
+use bytes::IntoBuf;
+use prost::Message;
+use prost::DecodeError as ProtoBufDecodeError;
+use prost::EncodeError as ProtoBufEncodeError;
+
+use actix_web::http::header::{CONTENT_TYPE, CONTENT_LENGTH};
+use actix_web::{Responder, HttpMessage, HttpRequest, HttpResponse};
+use actix_web::dev::HttpResponseBuilder;
+use actix_web::error::{Error, PayloadError, ResponseError};
+
+
+#[derive(Fail, Debug)]
+pub enum ProtoBufPayloadError {
+    /// Payload size is bigger than 256k
+    #[fail(display="Payload size is bigger than 256k")]
+    Overflow,
+    /// Content type error
+    #[fail(display="Content type error")]
+    ContentType,
+    /// Serialize error
+    #[fail(display="ProtoBud serialize error: {}", _0)]
+    Serialize(#[cause] ProtoBufEncodeError),
+    /// Deserialize error
+    #[fail(display="ProtoBud deserialize error: {}", _0)]
+    Deserialize(#[cause] ProtoBufDecodeError),
+    /// Payload error
+    #[fail(display="Error that occur during reading payload: {}", _0)]
+    Payload(#[cause] PayloadError),
+}
+
+impl ResponseError for ProtoBufPayloadError {
+
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            ProtoBufPayloadError::Overflow => HttpResponse::PayloadTooLarge().into(),
+            _ => HttpResponse::BadRequest().into(),
+        }
+    }
+}
+
+impl From<PayloadError> for ProtoBufPayloadError {
+    fn from(err: PayloadError) -> ProtoBufPayloadError {
+        ProtoBufPayloadError::Payload(err)
+    }
+}
+
+impl From<ProtoBufDecodeError> for ProtoBufPayloadError {
+    fn from(err: ProtoBufDecodeError) -> ProtoBufPayloadError {
+        ProtoBufPayloadError::Deserialize(err)
+    }
+}
+
+#[derive(Debug)]
+pub struct ProtoBuf<T: Message>(pub T);
+
+impl<T: Message> Responder for ProtoBuf<T> {
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        let mut buf = Vec::new();
+        self.0.encode(&mut buf)
+            .map_err(|e| Error::from(ProtoBufPayloadError::Serialize(e)))
+            .and_then(|()| {
+                Ok(HttpResponse::Ok()
+                   .content_type("application/protobuf")
+                    .body(buf)
+                    .into())
+              })
+    }
+}
+
+pub struct ProtoBufMessage<T, U: Message + Default>{
+    limit: usize,
+    ct: &'static str,
+    req: Option<T>,
+    fut: Option<Box<Future<Item=U, Error=ProtoBufPayloadError>>>,
+}
+
+impl<T, U: Message + Default> ProtoBufMessage<T, U> {
+
+    /// Create `ProtoBufMessage` for request.
+    pub fn new(req: T) -> Self {
+        ProtoBufMessage{
+            limit: 262_144,
+            req: Some(req),
+            fut: None,
+            ct: "application/protobuf",
+        }
+    }
+
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(mut self, limit: usize) -> Self {
+        self.limit = limit;
+        self
+    }
+
+    /// Set allowed content type.
+    ///
+    /// By default *application/protobuf* content type is used. Set content type
+    /// to empty string if you want to disable content type check.
+    pub fn content_type(mut self, ct: &'static str) -> Self {
+        self.ct = ct;
+        self
+    }
+}
+
+impl<T, U: Message + Default + 'static> Future for ProtoBufMessage<T, U>
+    where T: HttpMessage + Stream<Item=Bytes, Error=PayloadError> + 'static
+{
+    type Item = U;
+    type Error = ProtoBufPayloadError;
+
+    fn poll(&mut self) -> Poll<U, ProtoBufPayloadError> {
+        if let Some(req) = self.req.take() {
+            if let Some(len) = req.headers().get(CONTENT_LENGTH) {
+                if let Ok(s) = len.to_str() {
+                    if let Ok(len) = s.parse::<usize>() {
+                        if len > self.limit {
+                            return Err(ProtoBufPayloadError::Overflow);
+                        }
+                    } else {
+                        return Err(ProtoBufPayloadError::Overflow);
+                    }
+                }
+            }
+            // check content-type
+            if !self.ct.is_empty() && req.content_type() != self.ct {
+                return Err(ProtoBufPayloadError::ContentType)
+            }
+
+            let limit = self.limit;
+            let fut = req.from_err()
+                .fold(BytesMut::new(), move |mut body, chunk| {
+                    if (body.len() + chunk.len()) > limit {
+                        Err(ProtoBufPayloadError::Overflow)
+                    } else {
+                        body.extend_from_slice(&chunk);
+                        Ok(body)
+                    }
+                })
+                .and_then(|body| Ok(<U>::decode(&mut body.into_buf())?));
+            self.fut = Some(Box::new(fut));
+        }
+
+        self.fut.as_mut().expect("ProtoBufBody could not be used second time").poll()
+    }
+}
+
+
+pub trait ProtoBufResponseBuilder {
+
+    fn protobuf<T: Message>(&mut self, value: T) -> Result<HttpResponse, Error>;
+}
+
+impl ProtoBufResponseBuilder for HttpResponseBuilder {
+
+    fn protobuf<T: Message>(&mut self, value: T) -> Result<HttpResponse, Error> {
+        self.header(CONTENT_TYPE, "application/protobuf");
+
+        let mut body = Vec::new();
+        value.encode(&mut body).map_err(|e| ProtoBufPayloadError::Serialize(e))?;
+        Ok(self.body(body))
+    }
+}

examples/protobuf/test.proto

@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+message MyObj {
+    int32 number = 1;
+    string name = 2;
+}

examples/protobuf/test_pb2.py

@@ -0,0 +1,76 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: test.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='test.proto',
+  package='',
+  syntax='proto3',
+  serialized_pb=_b('\n\ntest.proto\"%\n\x05MyObj\x12\x0e\n\x06number\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\tb\x06proto3')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+
+_MYOBJ = _descriptor.Descriptor(
+  name='MyObj',
+  full_name='MyObj',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='number', full_name='MyObj.number', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='name', full_name='MyObj.name', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=14,
+  serialized_end=51,
+)
+
+DESCRIPTOR.message_types_by_name['MyObj'] = _MYOBJ
+
+MyObj = _reflection.GeneratedProtocolMessageType('MyObj', (_message.Message,), dict(
+  DESCRIPTOR = _MYOBJ,
+  __module__ = 'test_pb2'
+  # @@protoc_insertion_point(class_scope:MyObj)
+  ))
+_sym_db.RegisterMessage(MyObj)
+
+
+# @@protoc_insertion_point(module_scope)

examples/r2d2/src/main.rs

@@ -10,8 +10,9 @@ extern crate r2d2;
 extern crate r2d2_sqlite;
 extern crate rusqlite;
 
-use actix::*;
-use actix_web::*;
+use actix::prelude::*;
+use actix_web::{
+    middleware, http, server, App, AsyncResponder, HttpRequest, HttpResponse, Error};
 use futures::future::Future;
 use r2d2_sqlite::SqliteConnectionManager;
 
@@ -32,8 +33,8 @@ fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>>
         .from_err()
         .and_then(|res| {
             match res {
-                Ok(user) => Ok(httpcodes::HTTPOk.build().json(user)?),
-                Err(_) => Ok(httpcodes::HTTPInternalServerError.into())
+                Ok(user) => Ok(HttpResponse::Ok().json(user)),
+                Err(_) => Ok(HttpResponse::InternalServerError().into())
             }
         })
         .responder()
@@ -41,7 +42,7 @@ fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>>
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=debug");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("r2d2-example");
 
     // r2d2 pool
@@ -52,11 +53,11 @@ fn main() {
     let addr = SyncArbiter::start(3, move || DbExecutor(pool.clone()));
 
     // Start http server
-    let _addr = HttpServer::new(move || {
-        Application::with_state(State{db: addr.clone()})
+    server::new(move || {
+        App::with_state(State{db: addr.clone()})
             // enable logger
             .middleware(middleware::Logger::default())
-            .resource("/{name}", |r| r.method(Method::GET).a(index))})
+            .resource("/{name}", |r| r.method(http::Method::GET).a(index))})
         .bind("127.0.0.1:8080").unwrap()
         .start();
 

examples/state/Cargo.toml

@@ -5,7 +5,7 @@ authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 workspace = "../.."
 
 [dependencies]
-futures = "*"
+futures = "0.1"
 env_logger = "0.5"
 actix = "0.5"
 actix-web = { path = "../../" }

examples/state/src/main.rs

@@ -9,21 +9,21 @@ extern crate env_logger;
 
 use std::cell::Cell;
 
-use actix::*;
-use actix_web::*;
+use actix::prelude::*;
+use actix_web::{
+    http, server, ws, middleware, App, HttpRequest, HttpResponse};
 
 /// Application state
 struct AppState {
     counter: Cell<usize>,
 }
 
-/// somple handle
+/// simple handle
 fn index(req: HttpRequest<AppState>) -> HttpResponse {
     println!("{:?}", req);
     req.state().counter.set(req.state().counter.get() + 1);
 
-    httpcodes::HTTPOk.with_body(
-        format!("Num of requests: {}", req.state().counter.get()))
+    HttpResponse::Ok().body(format!("Num of requests: {}", req.state().counter.get()))
 }
 
 /// `MyWebSocket` counts how many messages it receives from peer,
@@ -36,7 +36,7 @@ impl Actor for MyWebSocket {
     type Context = ws::WebsocketContext<Self, AppState>;
 }
 
-impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
+impl StreamHandler<ws::Message, ws::ProtocolError> for MyWebSocket {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         self.counter += 1;
@@ -55,17 +55,18 @@ impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("ws-example");
 
-    let addr = HttpServer::new(
-        || Application::with_state(AppState{counter: Cell::new(0)})
+    server::new(
+        || App::with_state(AppState{counter: Cell::new(0)})
             // enable logger
             .middleware(middleware::Logger::default())
             // websocket route
             .resource(
                 "/ws/", |r|
-                r.method(Method::GET).f(|req| ws::start(req, MyWebSocket{counter: 0})))
+                r.method(http::Method::GET).f(
+                    |req| ws::start(req, MyWebSocket{counter: 0})))
             // register simple handler, handle all methods
             .resource("/", |r| r.f(index)))
         .bind("127.0.0.1:8080").unwrap()

examples/template_tera/src/main.rs

@@ -4,14 +4,15 @@ extern crate env_logger;
 #[macro_use]
 extern crate tera;
 
-use actix_web::*;
+use actix_web::{
+    http, error, middleware, server, App, HttpRequest, HttpResponse, Error};
 
 
 struct State {
     template: tera::Tera,  // <- store tera template in application state
 }
 
-fn index(req: HttpRequest<State>) -> Result<HttpResponse> {
+fn index(req: HttpRequest<State>) -> Result<HttpResponse, Error> {
     let s = if let Some(name) = req.query().get("name") { // <- submitted form
         let mut ctx = tera::Context::new();
         ctx.add("name", &name.to_owned());
@@ -22,23 +23,23 @@ fn index(req: HttpRequest<State>) -> Result<HttpResponse> {
         req.state().template.render("index.html", &tera::Context::new())
             .map_err(|_| error::ErrorInternalServerError("Template error"))?
     };
-    Ok(httpcodes::HTTPOk.build()
+    Ok(HttpResponse::Ok()
        .content_type("text/html")
-       .body(s)?)
+       .body(s))
 }
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("tera-example");
 
-    let addr = HttpServer::new(|| {
+    server::new(|| {
         let tera = compile_templates!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/**/*"));
 
-        Application::with_state(State{template: tera})
+        App::with_state(State{template: tera})
             // enable logger
             .middleware(middleware::Logger::default())
-            .resource("/", |r| r.method(Method::GET).f(index))})
+            .resource("/", |r| r.method(http::Method::GET).f(index))})
         .bind("127.0.0.1:8080").unwrap()
         .start();
 

examples/tls/src/main.rs

@@ -4,24 +4,24 @@ extern crate actix_web;
 extern crate env_logger;
 extern crate openssl;
 
-use actix_web::*;
 use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
+use actix_web::{
+    http, middleware, server, App, HttpRequest, HttpResponse, Error};
 
 
 /// simple handle
-fn index(req: HttpRequest) -> Result<HttpResponse> {
+fn index(req: HttpRequest) -> Result<HttpResponse, Error> {
     println!("{:?}", req);
-    Ok(httpcodes::HTTPOk
-       .build()
+    Ok(HttpResponse::Ok()
        .content_type("text/plain")
-       .body("Welcome!")?)
+       .body("Welcome!"))
 }
 
 fn main() {
     if ::std::env::var("RUST_LOG").is_err() {
         ::std::env::set_var("RUST_LOG", "actix_web=info");
     }
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("ws-example");
 
     // load ssl keys
@@ -29,18 +29,17 @@ fn main() {
     builder.set_private_key_file("key.pem", SslFiletype::PEM).unwrap();
     builder.set_certificate_chain_file("cert.pem").unwrap();
 
-    let addr = HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             // enable logger
             .middleware(middleware::Logger::default())
             // register simple handler, handle all methods
             .resource("/index.html", |r| r.f(index))
             // with path parameters
-            .resource("/", |r| r.method(Method::GET).f(|req| {
-                httpcodes::HTTPFound
-                    .build()
+            .resource("/", |r| r.method(http::Method::GET).f(|req| {
+                HttpResponse::Found()
                     .header("LOCATION", "/index.html")
-                    .body(Body::Empty)
+                    .finish()
             })))
         .bind("127.0.0.1:8443").unwrap()
         .start_ssl(builder).unwrap();

examples/unix-socket/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "unix-socket"
+version = "0.1.0"
+authors = ["Messense Lv <messense@icloud.com>"]
+
+[dependencies]
+env_logger = "0.5"
+actix = "0.5"
+actix-web = { path = "../../" }
+tokio-uds = "0.1"

examples/unix-socket/README.md

@@ -0,0 +1,14 @@
+## Unix domain socket example
+
+```bash
+$ curl --unix-socket /tmp/actix-uds.socket http://localhost/
+Hello world!
+```
+
+Although this will only one thread for handling incoming connections 
+according to the 
+[documentation](https://actix.github.io/actix-web/actix_web/struct.HttpServer.html#method.start_incoming).
+
+And it does not delete the socket file (`/tmp/actix-uds.socket`) when stopping
+the server so it will fail to start next time you run it unless you delete
+the socket file manually.

examples/unix-socket/src/main.rs

@@ -0,0 +1,32 @@
+extern crate actix;
+extern crate actix_web;
+extern crate env_logger;
+extern crate tokio_uds;
+
+use actix::*;
+use actix_web::{middleware, server, App, HttpRequest};
+use tokio_uds::UnixListener;
+
+
+fn index(_req: HttpRequest) -> &'static str {
+    "Hello world!"
+}
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    let sys = actix::System::new("unix-socket");
+
+    let listener = UnixListener::bind(
+        "/tmp/actix-uds.socket", Arbiter::handle()).expect("bind failed");
+    server::new(
+        || App::new()
+            // enable logger
+            .middleware(middleware::Logger::default())
+            .resource("/index.html", |r| r.f(|_| "Hello world!"))
+            .resource("/", |r| r.f(index)))
+        .start_incoming(listener.incoming(), false);
+
+    println!("Started http server: /tmp/actix-uds.socket");
+    let _ = sys.run();
+}

examples/web-cors/backend/src/main.rs

@@ -5,12 +5,9 @@ extern crate futures;
 extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
-extern crate http;
 
 use std::env;
-use http::header;
-use actix_web::*;
-use actix_web::middleware::cors;
+use actix_web::{http, middleware, server, App};
 
 mod user;
 use user::info;
@@ -22,20 +19,21 @@ fn main() {
 
     let sys = actix::System::new("Actix-web-CORS");
 
-    HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             .middleware(middleware::Logger::default())
             .resource("/user/info", |r| {
-                cors::Cors::build()
-                .allowed_origin("http://localhost:1234")
-                .allowed_methods(vec!["GET", "POST"])
+                middleware::cors::Cors::build()
+                    .allowed_origin("http://localhost:1234")
+                    .allowed_methods(vec!["GET", "POST"])
                     .allowed_headers(
-                        vec![header::AUTHORIZATION,
-                             header::ACCEPT, header::CONTENT_TYPE])
+                        vec![http::header::AUTHORIZATION,
+                             http::header::ACCEPT,
+                             http::header::CONTENT_TYPE])
                     .max_age(3600)
                     .finish().expect("Can not create CORS middleware")
                     .register(r);
-                r.method(Method::POST).a(info);
+                r.method(http::Method::POST).a(info);
             }))
         .bind("127.0.0.1:8000").unwrap()
         .shutdown_timeout(200)

examples/web-cors/backend/src/user.rs

@@ -1,4 +1,4 @@
-use actix_web::*;
+use actix_web::{AsyncResponder, Error, HttpMessage, HttpResponse, HttpRequest};
 use futures::Future;
 
 
@@ -11,9 +11,9 @@ struct Info {
 }
 
 pub fn info(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.json()                   
+    req.json()
         .from_err()
         .and_then(|res: Info| {
-            Ok(httpcodes::HTTPOk.build().json(res)?)
+            Ok(HttpResponse::Ok().json(res))
         }).responder()
 }

examples/websocket-chat/src/main.rs

@@ -17,7 +17,8 @@ extern crate actix_web;
 use std::time::Instant;
 
 use actix::*;
-use actix_web::*;
+use actix_web::server::HttpServer;
+use actix_web::{http, fs, ws, App, HttpRequest, HttpResponse, Error};
 
 mod codec;
 mod server;
@@ -30,7 +31,7 @@ struct WsChatSessionState {
 }
 
 /// Entry point for our route
-fn chat_route(req: HttpRequest<WsChatSessionState>) -> Result<HttpResponse> {
+fn chat_route(req: HttpRequest<WsChatSessionState>) -> Result<HttpResponse, Error> {
     ws::start(
         req,
         WsChatSession {
@@ -92,7 +93,7 @@ impl Handler<session::Message> for WsChatSession {
 }
 
 /// WebSocket message handler
-impl StreamHandler<ws::Message, ws::WsError> for WsChatSession {
+impl StreamHandler<ws::Message, ws::ProtocolError> for WsChatSession {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         println!("WEBSOCKET MESSAGE: {:?}", msg);
@@ -183,23 +184,22 @@ fn main() {
         }));
 
     // Create Http server with websocket support
-    let addr = HttpServer::new(
+    HttpServer::new(
         move || {
             // Websocket sessions state
             let state = WsChatSessionState { addr: server.clone() };
 
-            Application::with_state(state)
+            App::with_state(state)
                 // redirect to websocket.html
-                .resource("/", |r| r.method(Method::GET).f(|_| {
-                    httpcodes::HTTPFound
-                        .build()
+                .resource("/", |r| r.method(http::Method::GET).f(|_| {
+                    HttpResponse::Found()
                         .header("LOCATION", "/static/websocket.html")
                         .finish()
                 }))
                 // websocket
                 .resource("/ws/", |r| r.route().f(chat_route))
                 // static resources
-                .handler("/static/", fs::StaticFiles::new("static/", true))
+                .handler("/static/", fs::StaticFiles::new("static/"))
         })
         .bind("127.0.0.1:8080").unwrap()
         .start();

examples/websocket/README.md

@@ -1,4 +1,4 @@
-# websockect
+# websocket
 
 Simple echo websocket server.
 

examples/websocket/src/client.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 
 use actix::*;
 use futures::Future;
-use actix_web::ws::{Message, WsError, WsClient, WsClientWriter};
+use actix_web::ws::{Message, ProtocolError, Client, ClientWriter};
 
 
 fn main() {
@@ -21,7 +21,7 @@ fn main() {
     let sys = actix::System::new("ws-example");
 
     Arbiter::handle().spawn(
-        WsClient::new("http://127.0.0.1:8080/ws/")
+        Client::new("http://127.0.0.1:8080/ws/")
             .connect()
             .map_err(|e| {
                 println!("Error: {}", e);
@@ -53,7 +53,7 @@ fn main() {
 }
 
 
-struct ChatClient(WsClientWriter);
+struct ChatClient(ClientWriter);
 
 #[derive(Message)]
 struct ClientCommand(String);
@@ -88,12 +88,12 @@ impl Handler<ClientCommand> for ChatClient {
     type Result = ();
 
     fn handle(&mut self, msg: ClientCommand, ctx: &mut Context<Self>) {
-        self.0.text(msg.0.as_str())
+        self.0.text(msg.0)
     }
 }
 
 /// Handle server websocket messages
-impl StreamHandler<Message, WsError> for ChatClient {
+impl StreamHandler<Message, ProtocolError> for ChatClient {
 
     fn handle(&mut self, msg: Message, ctx: &mut Context<Self>) {
         match msg {

examples/websocket/src/main.rs

@@ -8,11 +8,12 @@ extern crate actix;
 extern crate actix_web;
 extern crate env_logger;
 
-use actix::*;
-use actix_web::*;
+use actix::prelude::*;
+use actix_web::{
+    http, middleware, server, fs, ws, App, HttpRequest, HttpResponse, Error};
 
 /// do websocket handshake and start `MyWebSocket` actor
-fn ws_index(r: HttpRequest) -> Result<HttpResponse> {
+fn ws_index(r: HttpRequest) -> Result<HttpResponse, Error> {
     ws::start(r, MyWebSocket)
 }
 
@@ -25,7 +26,7 @@ impl Actor for MyWebSocket {
 }
 
 /// Handler for `ws::Message`
-impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
+impl StreamHandler<ws::Message, ws::ProtocolError> for MyWebSocket {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         // process websocket messages
@@ -44,17 +45,17 @@ impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
 
 fn main() {
     ::std::env::set_var("RUST_LOG", "actix_web=info");
-    let _ = env_logger::init();
+    env_logger::init();
     let sys = actix::System::new("ws-example");
 
-    let _addr = HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             // enable logger
             .middleware(middleware::Logger::default())
             // websocket route
-            .resource("/ws/", |r| r.method(Method::GET).f(ws_index))
+            .resource("/ws/", |r| r.method(http::Method::GET).f(ws_index))
             // static files
-            .handler("/", fs::StaticFiles::new("../static/", true)
+            .handler("/", fs::StaticFiles::new("../static/")
                      .index_file("index.html")))
         // start http server on 127.0.0.1:8080
         .bind("127.0.0.1:8080").unwrap()

guide/src/qs_1.md

@@ -1,11 +1,8 @@
 # Quick start
 
-Before you can start writing a actix web application, you’ll need a version of Rust installed.
-We recommend you use rustup to install or configure such a version.
-
 ## Install Rust
 
-Before we begin, we need to install Rust using the [rustup](https://www.rustup.rs/) installer:
+Before we begin, we need to install Rust using [rustup](https://www.rustup.rs/):
 
 ```bash
 curl https://sh.rustup.rs -sSf | sh
@@ -21,9 +18,10 @@ Actix web framework requires rust version 1.21 and up.
 
 ## Running Examples
 
-The fastest way to start experimenting with actix web is to clone the actix web repository
-and run the included examples in the examples/ directory. The following set of
-commands runs the `basics` example:
+The fastest way to start experimenting with actix web is to clone the
+[repository](https://github.com/actix/actix-web) and run the included examples.
+
+The following set of commands runs the `basics` example:
 
 ```bash
 git clone https://github.com/actix/actix-web

guide/src/qs_10.md

@@ -1,29 +1,31 @@
-# Middlewares
+# Middleware
 
-Actix middlewares system allows to add additional behavior to request/response processing.
-Middleware can hook into incoming request process and modify request or halt request 
-processing and return response early. Also it can hook into response processing.
+Actix's middleware system allows us to add additional behavior to request/response processing.
+Middleware can hook into an incoming request process, enabling us to modify requests
+as well as halt request processing to return a response early.
 
-Typically middlewares involves in following actions:
+Middleware can also hook into response processing.
+
+Typically, middleware is involved in the following actions:
 
 * Pre-process the Request
 * Post-process a Response
 * Modify application state
 * Access external services (redis, logging, sessions)
 
-Middlewares are registered for each application and get executed in same order as
-registration order. In general, *middleware* is a type that implements
+Middleware is registered for each application and executed in same order as
+registration. In general, a *middleware* is a type that implements the
 [*Middleware trait*](../actix_web/middlewares/trait.Middleware.html). Each method
-in this trait has default implementation. Each method can return result immediately
-or *future* object.
+in this trait has a default implementation. Each method can return a result immediately
+or a *future* object.
 
-Here is example of simple middleware that adds request and response headers:
+The following demonstrates using middleware to add request and response headers:
 
 ```rust
 # extern crate http;
 # extern crate actix_web;
 use http::{header, HttpTryFrom};
-use actix_web::*;
+use actix_web::{App, HttpRequest, HttpResponse, Result};
 use actix_web::middleware::{Middleware, Started, Response};
 
 struct Headers;  // <- Our middleware
@@ -51,49 +53,51 @@ impl<S> Middleware<S> for Headers {
 }
 
 fn main() {
-    Application::new()
-       .middleware(Headers)  // <- Register middleware, this method could be called multiple times
-       .resource("/", |r| r.h(httpcodes::HttpOk));
+    App::new()
+       .middleware(Headers)  // <- Register middleware, this method can be called multiple times
+       .resource("/", |r| r.f(|_| HttpResponse::Ok()));
 }
 ```
 
-Active provides several useful middlewares, like *logging*, *user sessions*, etc.
-
+> Actix provides several useful middlewares, such as *logging*, *user sessions*, etc.
 
 ## Logging
 
-Logging is implemented as middleware. 
-It is common to register logging middleware as first middleware for application. 
-Logging middleware has to be registered for each application. *Logger* middleware
-uses standard log crate to log information. You should enable logger for *actix_web*
-package to see access log. ([env_logger](https://docs.rs/env_logger/*/env_logger/) or similar)
+Logging is implemented as a middleware.
+It is common to register a logging middleware as the first middleware for the application.
+Logging middleware must be registered for each application.
+
+The `Logger` middleware uses the standard log crate to log information. You should enable logger
+for *actix_web* package to see access log ([env_logger](https://docs.rs/env_logger/*/env_logger/)
+or similar).
 
 ### Usage
 
 Create `Logger` middleware with the specified `format`.
-Default `Logger` could be created with `default` method, it uses the default format:
+Default `Logger` can be created with `default` method, it uses the default format:
 
 ```ignore
   %a %t "%r" %s %b "%{Referer}i" "%{User-Agent}i" %T
 ```
+
 ```rust
 # extern crate actix_web;
 extern crate env_logger;
-use actix_web::Application;
+use actix_web::App;
 use actix_web::middleware::Logger;
 
 fn main() {
     std::env::set_var("RUST_LOG", "actix_web=info");
     env_logger::init();
 
-    Application::new()
+    App::new()
        .middleware(Logger::default())
        .middleware(Logger::new("%a %{User-Agent}i"))
        .finish();
 }
 ```
 
-Here is example of default logging format:
+The following is an example of the default logging format:
 
 ```
 INFO:actix_web::middleware::logger: 127.0.0.1:59934 [02/Dec/2017:00:21:43 -0800] "GET / HTTP/1.1" 302 0 "-" "curl/7.54.0" 0.000397
@@ -126,26 +130,24 @@ INFO:actix_web::middleware::logger: 127.0.0.1:59947 [02/Dec/2017:00:22:40 -0800]
 
  `%{FOO}e`  os.environ['FOO']
 
-
 ## Default headers
 
-To set default response headers `DefaultHeaders` middleware could be used.
-*DefaultHeaders* middleware does not set header if response headers already contains
-specified header.
+To set default response headers, the `DefaultHeaders` middleware can be used. The
+*DefaultHeaders* middleware does not set the header if response headers already contain
+a specified header.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
+use actix_web::{http, middleware, App, HttpResponse};
 
 fn main() {
-    let app = Application::new()
+    let app = App::new()
         .middleware(
-            middleware::DefaultHeaders::build()
-                .header("X-Version", "0.2")
-                .finish())
+            middleware::DefaultHeaders::new()
+                .header("X-Version", "0.2"))
         .resource("/test", |r| {
-             r.method(Method::GET).f(|req| httpcodes::HttpOk);
-             r.method(Method::HEAD).f(|req| httpcodes::HttpMethodNotAllowed);
+             r.method(http::Method::GET).f(|req| HttpResponse::Ok());
+             r.method(http::Method::HEAD).f(|req| HttpResponse::MethodNotAllowed());
         })
        .finish();
 }
@@ -153,34 +155,38 @@ fn main() {
 
 ## User sessions
 
-Actix provides general solution for session management. 
-[*Session storage*](../actix_web/middleware/struct.SessionStorage.html) middleware can be 
-use with different backend types to store session data in different backends. 
-By default only cookie session backend is implemented. Other backend implementations 
-could be added later.
+Actix provides a general solution for session management. The
+[**SessionStorage**](../actix_web/middleware/struct.SessionStorage.html) middleware can be
+used with different backend types to store session data in different backends.
 
-[*Cookie session backend*](../actix_web/middleware/struct.CookieSessionBackend.html)
-uses signed cookies as session storage. *Cookie session backend* creates sessions which
-are limited to storing fewer than 4000 bytes of data (as the payload must fit into a
-single cookie). Internal server error get generated if session contains more than 4000 bytes.
+> By default, only cookie session backend is implemented. Other backend implementations
+> can be added.
 
-You need to pass a random value to the constructor of *CookieSessionBackend*.
-This is private key for cookie session. When this value is changed, all session data is lost.
-Note that whatever you write into your session is visible by the user (but not modifiable).
+[**CookieSessionBackend**](../actix_web/middleware/struct.CookieSessionBackend.html)
+uses cookies as session storage. `CookieSessionBackend` creates sessions which
+are limited to storing fewer than 4000 bytes of data, as the payload must fit into a
+single cookie. An internal server error is generated if a session contains more than 4000 bytes.
 
-In general case, you create
-[*Session storage*](../actix_web/middleware/struct.SessionStorage.html) middleware
-and initializes it with specific backend implementation, like *CookieSessionBackend*.
-To access session data
+A cookie may have a security policy of *signed* or *private*. Each has a respective `CookieSessionBackend` constructor.
+
+A *signed* cookie may be viewed but not modified by the client. A *private* cookie may neither be viewed nor modified by the client.
+
+The constructors take a key as an argument. This is the private key for cookie session - when this value is changed, all session data is lost.
+
+
+
+In general, you create a
+`SessionStorage` middleware and initialize it with specific backend implementation,
+such as a `CookieSessionBackend`. To access session data,
 [*HttpRequest::session()*](../actix_web/middleware/trait.RequestSession.html#tymethod.session)
-method has to be used. This method returns
-[*Session*](../actix_web/middleware/struct.Session.html) object, which allows to get or set
+ must be used. This method returns a
+[*Session*](../actix_web/middleware/struct.Session.html) object, which allows us to get or set
 session data.
 
 ```rust
 # extern crate actix;
 # extern crate actix_web;
-use actix_web::*;
+use actix_web::{server, App, HttpRequest, Result};
 use actix_web::middleware::{RequestSession, SessionStorage, CookieSessionBackend};
 
 fn index(mut req: HttpRequest) -> Result<&'static str> {
@@ -197,12 +203,11 @@ fn index(mut req: HttpRequest) -> Result<&'static str> {
 
 fn main() {
 #   let sys = actix::System::new("basic-example");
-    HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             .middleware(SessionStorage::new(          // <- create session middleware
-                CookieSessionBackend::build(&[0; 32]) // <- create cookie session backend
+                CookieSessionBackend::signed(&[0; 32]) // <- create signed cookie session backend
                     .secure(false)
-                    .finish()
             )))
         .bind("127.0.0.1:59880").unwrap()
         .start();
@@ -210,3 +215,37 @@ fn main() {
 #     let _ = sys.run();
 }
 ```
+
+## Error handlers
+
+`ErrorHandlers` middleware allows us to provide custom handlers for responses.
+
+You can use the `ErrorHandlers::handler()` method to register a custom error handler
+for a specific status code. You can modify an existing response or create a completly new
+one. The error handler can return a response immediately or return a future that resolves
+into a response.
+
+```rust
+# extern crate actix_web;
+use actix_web::{
+    App, HttpRequest, HttpResponse, Result,
+    http, middleware::Response, middleware::ErrorHandlers};
+
+fn render_500<S>(_: &mut HttpRequest<S>, resp: HttpResponse) -> Result<Response> {
+   let mut builder = resp.into_builder();
+   builder.header(http::header::CONTENT_TYPE, "application/json");
+   Ok(Response::Done(builder.into()))
+}
+
+fn main() {
+    let app = App::new()
+        .middleware(
+            ErrorHandlers::new()
+                .handler(http::StatusCode::INTERNAL_SERVER_ERROR, render_500))
+        .resource("/test", |r| {
+             r.method(http::Method::GET).f(|_| HttpResponse::Ok());
+             r.method(http::Method::HEAD).f(|_| HttpResponse::MethodNotAllowed());
+        })
+        .finish();
+}
+```

guide/src/qs_12.md

@@ -2,21 +2,21 @@
 
 ## Individual file
 
-It is possible to serve static files with custom path pattern and `NamedFile`. To
-match path tail we can use `[.*]` regex.
+It is possible to serve static files with a custom path pattern and `NamedFile`. To
+match a path tail, we can use a `[.*]` regex.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
 use std::path::PathBuf;
+use actix_web::{App, HttpRequest, Result, http::Method, fs::NamedFile};
 
-fn index(req: HttpRequest) -> Result<fs::NamedFile> {
+fn index(req: HttpRequest) -> Result<NamedFile> {
     let path: PathBuf = req.match_info().query("tail")?;
-    Ok(fs::NamedFile::open(path)?)
+    Ok(NamedFile::open(path)?)
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource(r"/a/{tail:.*}", |r| r.method(Method::GET).f(index))
         .finish();
 }
@@ -24,26 +24,31 @@ fn main() {
 
 ## Directory
 
-To serve files from specific directory and sub-directories `StaticFiles` could be used. 
-`StaticFiles` must be registered with `Application::handler()` method otherwise
-it won't be able to server sub-paths.
+To serve files from specific directories and sub-directories, `StaticFiles` can be used.
+`StaticFiles` must be registered with an `App::handler()` method, otherwise
+it will be unable to serve sub-paths.
 
 ```rust
 # extern crate actix_web;
 use actix_web::*;
 
 fn main() {
-    Application::new()
-        .handler("/static", fs::StaticFiles::new(".", true))
+    App::new()
+        .handler(
+            "/static",
+            fs::StaticFiles::new(".")
+                .show_files_listing())
         .finish();
 }
 ```
 
-First parameter is a base directory. Second parameter is *show_index*, if it is set to *true*
-directory listing would be returned for directories, if it is set to *false*
-then *404 Not Found* would be returned instead of directory listing.
+The parameter is the base directory. By default files listing for sub-directories
+is disabled. Attempt to load directory listing will return *404 Not Found* response.
+To enable files listing, use 
+[*StaticFiles::show_files_listing()*](../actix_web/s/struct.StaticFiles.html#method.show_files_listing)
+method.
 
-Instead of showing files listing for directory, it is possible to redirect to specific
-index file. Use 
+Instead of showing files listing for directory, it is possible to redirect
+to a specific index file. Use the
 [*StaticFiles::index_file()*](../actix_web/s/struct.StaticFiles.html#method.index_file)
 method to configure this redirect.

guide/src/qs_13.md

@@ -1,13 +1,15 @@
 # HTTP/2.0
 
-Actix web automatically upgrades connection to *HTTP/2.0* if possible.
+Actix web automatically upgrades connections to *HTTP/2.0* if possible.
 
 ## Negotiation
 
 *HTTP/2.0* protocol over tls without prior knowledge requires
-[tls alpn](https://tools.ietf.org/html/rfc7301). At the moment only
-`rust-openssl` has support. Turn on `alpn` feature to enable `alpn` negotiation.
-With enable `alpn` feature `HttpServer` provides
+[tls alpn](https://tools.ietf.org/html/rfc7301).
+
+> Currently, only `rust-openssl` has support.
+
+`alpn` negotiation requires enabling the feature. When enabled, `HttpServer` provides the
 [serve_tls](../actix_web/struct.HttpServer.html#method.serve_tls) method.
 
 ```toml
@@ -28,17 +30,17 @@ fn main() {
     builder.set_certificate_chain_file("cert.pem").unwrap();
 
     HttpServer::new(
-        || Application::new()
+        || App::new()
             .resource("/index.html", |r| r.f(index)))
         .bind("127.0.0.1:8080").unwrap();
         .serve_ssl(builder).unwrap();
 }
 ```
 
-Upgrade to *HTTP/2.0* schema described in
+Upgrades to *HTTP/2.0* schema described in
 [rfc section 3.2](https://http2.github.io/http2-spec/#rfc.section.3.2) is not supported.
 Starting *HTTP/2* with prior knowledge is supported for both clear text connection
 and tls connection. [rfc section 3.4](https://http2.github.io/http2-spec/#rfc.section.3.4)
 
-Please check [example](https://github.com/actix/actix-web/tree/master/examples/tls) 
-for concrete example.
+> Check out [examples/tls](https://github.com/actix/actix-web/tree/master/examples/tls)
+> for a concrete example.

guide/src/qs_14.md

@@ -2,17 +2,18 @@
 
 ## Diesel
 
-At the moment of 1.0 release Diesel does not support asynchronous operations.
-But it possible to use `actix` synchronous actor system as a db interface api.
-Technically sync actors are worker style actors, multiple of them
-can be run in parallel and process messages from same queue (sync actors work in mpmc mode).
+At the moment, Diesel 1.0 does not support asynchronous operations,
+but it possible to use the `actix` synchronous actor system as a database interface api.
 
-Let's create simple db api that can insert new user row into sqlite table.
-We have to define sync actor and connection that this actor will use. Same approach
-could be used for other databases.
+Technically, sync actors are worker style actors. Multiple sync actors
+can be run in parallel and process messages from same queue. Sync actors work in mpsc mode.
+
+Let's create a simple database api that can insert a new user row into a SQLite table.
+We must define a sync actor and a connection that this actor will use. The same approach
+can be used for other databases.
 
 ```rust,ignore
-use actix::prelude::*;*
+use actix::prelude::*;
 
 struct DbExecutor(SqliteConnection);
 
@@ -21,22 +22,24 @@ impl Actor for DbExecutor {
 }
 ```
 
-This is definition of our actor. Now we need to define *create user* message and response.
+This is the definition of our actor. Now, we must define the *create user* message and response.
 
 ```rust,ignore
-#[derive(Message)]
-#[rtype(User, Error)]
 struct CreateUser {
     name: String,
 }
+
+impl Message for CreateUser {
+    type Result = Result<User, Error>;
+}
 ```
 
-We can send `CreateUser` message to `DbExecutor` actor, and as result we get
-`User` model. Now we need to define actual handler implementation for this message.
+We can send a `CreateUser` message to the `DbExecutor` actor, and as a result, we will receive a
+`User` model instance. Next, we must define the handler implementation for this message.
 
 ```rust,ignore
 impl Handler<CreateUser> for DbExecutor {
-    type Result = Result<User, Error>
+    type Result = Result<User, Error>;
 
     fn handle(&mut self, msg: CreateUser, _: &mut Self::Context) -> Self::Result
     {
@@ -49,7 +52,7 @@ impl Handler<CreateUser> for DbExecutor {
             name: &msg.name,
         };
 
-        // normal diesl operations
+        // normal diesel operations
         diesel::insert_into(users)
             .values(&new_user)
             .execute(&self.0)
@@ -65,8 +68,8 @@ impl Handler<CreateUser> for DbExecutor {
 }
 ```
 
-That is it. Now we can use *DbExecutor* actor from any http handler or middleware.
-All we need is to start *DbExecutor* actors and store address in a state where http handler 
+That's it! Now, we can use the *DbExecutor* actor from any http handler or middleware.
+All we need is to start *DbExecutor* actors and store the address in a state where http handler
 can access it.
 
 ```rust,ignore
@@ -85,7 +88,7 @@ fn main() {
 
     // Start http server
     HttpServer::new(move || {
-        Application::with_state(State{db: addr.clone()})
+        App::with_state(State{db: addr.clone()})
             .resource("/{name}", |r| r.method(Method::GET).a(index))})
         .bind("127.0.0.1:8080").unwrap()
         .start().unwrap();
@@ -95,9 +98,9 @@ fn main() {
 }
 ```
 
-And finally we can use address in a request handler. We get message response
-asynchronously, so handler needs to return future object, also `Route::a()` needs to be 
-used for async handler registration.
+We will use the address in a request handler. The handle returns a future object;
+thus, we receive the message response asynchronously.
+`Route::a()` must be used for async handler registration.
 
 
 ```rust,ignore
@@ -110,16 +113,16 @@ fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>>
         .from_err()
         .and_then(|res| {
             match res {
-                Ok(user) => Ok(httpcodes::HttpOk.build().json(user)?),
-                Err(_) => Ok(httpcodes::HttpInternalServerError.into())
+                Ok(user) => Ok(HttpResponse::Ok().json(user)),
+                Err(_) => Ok(HttpResponse::InternalServerError().into())
             }
         })
         .responder()
 }
 ```
 
-Full example is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/diesel/).
+> A full example is available in the
+> [examples directory](https://github.com/actix/actix-web/tree/master/examples/diesel/).
 
-More information on sync actors could be found in 
-[actix documentation](https://docs.rs/actix/0.5.0/actix/sync/index.html).
+> More information on sync actors can be found in the
+> [actix documentation](https://docs.rs/actix/0.5.0/actix/sync/index.html).

guide/src/qs_2.md

@@ -1,34 +1,31 @@
 # Getting Started
 
-Let’s create and run our first actix web application. We’ll create a new Cargo project
-that depends on actix web and then run the application.
+Let’s write our first actix web application!
 
-In previous section we already installed required rust version. Now let's create new cargo projects.
+## Hello, world!
 
-## Hello, world! 
-
-Let’s write our first actix web application! Start by creating a new binary-based
-Cargo project and changing into the new directory:
+Start by creating a new binary-based Cargo project and changing into the new directory:
 
 ```bash
 cargo new hello-world --bin
 cd hello-world
 ```
 
-Now, add actix and actix web as dependencies of your project by ensuring your Cargo.toml 
+Now, add actix and actix web as dependencies of your project by ensuring your Cargo.toml
 contains the following:
 
 ```toml
 [dependencies]
 actix = "0.5"
-actix-web = "0.4"
+actix-web = "0.5"
 ```
 
-In order to implement a web server, first we need to create a request handler.
+In order to implement a web server, we first need to create a request handler.
 
-A request handler is a function that accepts a `HttpRequest` instance as its only parameter 
+A request handler is a function that accepts an `HttpRequest` instance as its only parameter
 and returns a type that can be converted into `HttpResponse`:
 
+Filename: src/main.rs
 ```rust
 # extern crate actix_web;
 # use actix_web::*;
@@ -48,31 +45,31 @@ request handler with the application's `resource` on a particular *HTTP method*
 #    "Hello world!"
 # }
 # fn main() {
-   Application::new()
+   App::new()
        .resource("/", |r| r.f(index));
 # }
 ```
 
-After that, application instance can be used with `HttpServer` to listen for incoming
-connections. Server accepts function that should return `HttpHandler` instance:
+After that, the application instance can be used with `HttpServer` to listen for incoming
+connections. The server accepts a function that should return an `HttpHandler` instance:
 
 ```rust,ignore
    HttpServer::new(
-       || Application::new()
+       || App::new()
            .resource("/", |r| r.f(index)))
        .bind("127.0.0.1:8088")?
        .run();
 ```
 
-That's it. Now, compile and run the program with cargo run. 
+That's it! Now, compile and run the program with `cargo run`.
 Head over to ``http://localhost:8088/`` to see the results.
 
-Here is full source of main.rs file:
+The full source of src/main.rs is listed below:
 
 ```rust
 # use std::thread;
 extern crate actix_web;
-use actix_web::*;
+use actix_web::{server, App, HttpRequest, HttpResponse};
 
 fn index(req: HttpRequest) -> &'static str {
     "Hello world!"
@@ -80,11 +77,11 @@ fn index(req: HttpRequest) -> &'static str {
 
 fn main() {
 #  // In the doctest suite we can't run blocking code - deliberately leak a thread
-#  // If copying this example in show-all mode make sure you skip the thread spawn
+#  // If copying this example in show-all mode, make sure you skip the thread spawn
 #  // call.
 #  thread::spawn(|| {
-    HttpServer::new(
-        || Application::new()
+    server::HttpServer::new(
+        || App::new()
             .resource("/", |r| r.f(index)))
         .bind("127.0.0.1:8088").expect("Can not bind to 127.0.0.1:8088")
         .run();
@@ -92,7 +89,11 @@ fn main() {
 }
 ```
 
-Note on `actix` crate. Actix web framework is built on top of actix actor library. 
-`actix::System` initializes actor system, `HttpServer` is an actor and must run within
-properly configured actix system. For more information please check
-[actix documentation](https://actix.github.io/actix/actix/)
+> **Note**: actix web is built upon [actix](https://github.com/actix/actix),
+> an [actor model](https://en.wikipedia.org/wiki/Actor_model) framework in Rust.
+
+`actix::System` initializes actor system, `HttpServer` is an actor and must run within a
+properly configured actix system.
+
+> For more information, check out the [actix documentation](https://actix.github.io/actix/actix/)
+> and [actix guide](https://actix.github.io/actix/guide/).

guide/src/qs_3.md

@@ -1,87 +1,88 @@
 # Application
 
-Actix web provides some primitives to build web servers and applications with Rust.
-It provides routing, middlewares, pre-processing of requests, and post-processing of responses,
+Actix web provides various primitives to build web servers and applications with Rust.
+It provides routing, middlewares, pre-processing of requests, post-processing of responses,
 websocket protocol handling, multipart streams, etc.
 
-All actix web server is built around `Application` instance.
-It is used for registering routes for resources, middlewares.
-Also it stores application specific state that is shared across all handlers
-within same application.
+All actix web servers are built around the `App` instance.
+It is used for registering routes for resources and middlewares.
+It also stores application state shared across all handlers within same application.
 
-Application acts as namespace for all routes, i.e all routes for specific application
-has same url path prefix. Application prefix always contains leading "/" slash. 
-If supplied prefix does not contain leading slash, it get inserted. 
-Prefix should consists of value path segments. i.e for application with prefix `/app` 
-any request with following paths `/app`, `/app/` or `/app/test` would match,
-but path `/application` would not match.
+Applications act as a namespace for all routes, i.e all routes for a specific application
+have the same url path prefix. The application prefix always contains a leading "/" slash.
+If a supplied prefix does not contain leading slash, it is automatically inserted.
+The prefix should consist of value path segments.
+
+> For an application with prefix `/app`,
+> any request with the paths `/app`, `/app/`, or `/app/test` would match;
+> however, the path `/application` would not match.
 
 ```rust,ignore
 # extern crate actix_web;
 # extern crate tokio_core;
-# use actix_web::*;
+# use actix_web::{*, http::Method};
 # fn index(req: HttpRequest) -> &'static str {
 #    "Hello world!"
 # }
 # fn main() {
-   let app = Application::new()
+   let app = App::new()
        .prefix("/app")
        .resource("/index.html", |r| r.method(Method::GET).f(index))
        .finish()
 # }
 ```
 
-In this example application with `/app` prefix and `index.html` resource
-get created. This resource is available as on `/app/index.html` url.
-For more information check 
-[*URL Matching*](./qs_5.html#using-a-application-prefix-to-compose-applications) section.
+In this example, an application with the `/app` prefix and a `index.html` resource
+are created. This resource is available through the `/app/index.html` url.
 
-Multiple applications could be served with one server:
+> For more information, check the
+> [URL Dispatch](./qs_5.html#using-a-application-prefix-to-compose-applications) section.
+
+Multiple applications can be served with one server:
 
 ```rust
 # extern crate actix_web;
 # extern crate tokio_core;
 # use tokio_core::net::TcpStream;
 # use std::net::SocketAddr;
-use actix_web::*;
+use actix_web::{server, App, HttpResponse};
 
 fn main() {
-    HttpServer::new(|| vec![
-        Application::new()
+    server::new(|| vec![
+        App::new()
             .prefix("/app1")
-            .resource("/", |r| r.f(|r| httpcodes::HttpOk)),
-        Application::new()
+            .resource("/", |r| r.f(|r| HttpResponse::Ok())),
+        App::new()
             .prefix("/app2")
-            .resource("/", |r| r.f(|r| httpcodes::HttpOk)),
-        Application::new()
-            .resource("/", |r| r.f(|r| httpcodes::HttpOk)),
+            .resource("/", |r| r.f(|r| HttpResponse::Ok())),
+        App::new()
+            .resource("/", |r| r.f(|r| HttpResponse::Ok())),
     ]);
 }
 ```
 
-All `/app1` requests route to first application, `/app2` to second and then all other to third.
-Applications get matched based on registration order, if application with more general
-prefix is registered before less generic, that would effectively block less generic
-application to get matched. For example if *application* with prefix "/" get registered
-as first application, it would match all incoming requests.
+All `/app1` requests route to the first application, `/app2` to the second, and all other to the third.
+**Applications get matched based on registration order**. If an application with a more generic
+prefix is registered before a less generic one, it would effectively block the less generic
+application matching. For example, if an `App` with the prefix `"/"` was registered
+as the first application, it would match all incoming requests.
 
 ## State
 
-Application state is shared with all routes and resources within same application.
-State could be accessed with `HttpRequest::state()` method as a read-only item
-but interior mutability pattern with `RefCell` could be used to archive state mutability.
-State could be accessed with `HttpContext::state()` in case of http actor.
-State also available to route matching predicates and middlewares.
+Application state is shared with all routes and resources within the same application.
+When using an http actor,state can be accessed with the `HttpRequest::state()` as read-only,
+but interior mutability with `RefCell` can be used to achieve state mutability.
+State is also available for route matching predicates and middlewares.
 
-Let's write simple application that uses shared state. We are going to store requests count
+Let's write a simple application that uses shared state. We are going to store request count
 in the state:
 
 ```rust
 # extern crate actix;
 # extern crate actix_web;
 #
-use actix_web::*;
 use std::cell::Cell;
+use actix_web::{App, HttpRequest, http};
 
 // This struct represents state
 struct AppState {
@@ -96,14 +97,14 @@ fn index(req: HttpRequest<AppState>) -> String {
 }
 
 fn main() {
-    Application::with_state(AppState{counter: Cell::new(0)})
-        .resource("/", |r| r.method(Method::GET).f(index))
+    App::with_state(AppState{counter: Cell::new(0)})
+        .resource("/", |r| r.method(http::Method::GET).f(index))
         .finish();
 }
 ```
 
-Note on application state, http server accepts application factory rather than application
-instance. Http server construct application instance for each thread, so application state
-must be constructed multiple times. If you want to share state between different thread
-shared object should be used, like `Arc`. Application state does not need to be `Send` and `Sync`
-but application factory must be `Send` + `Sync`.
+> **Note**: http server accepts an application factory rather than an application
+> instance. Http server constructs an application instance for each thread, thus application state
+> must be constructed multiple times. If you want to share state between different threads, a
+> shared object should be used, e.g. `Arc`. Application state does not need to be `Send` and `Sync`,
+> but the application factory must be `Send` + `Sync`.

guide/src/qs_3_5.md

@@ -1,26 +1,31 @@
 # Server
 
-[*HttpServer*](../actix_web/struct.HttpServer.html) type is responsible for
-serving http requests. *HttpServer* accept application factory as a parameter,
-Application factory must have `Send` + `Sync` boundaries. More about that in
-*multi-threading* section. To bind to specific socket address `bind()` must be used.
-This method could be called multiple times. To start http server one of the *start*
-methods could be used. `start()` method start simple server, `start_tls()` or `start_ssl()`
-starts ssl server. *HttpServer* is an actix actor, it has to be initialized
-within properly configured actix system:
+The [**HttpServer**](../actix_web/server/struct.HttpServer.html) type is responsible for
+serving http requests.
+
+`HttpServer` accepts an application factory as a parameter, and the
+application factory must have `Send` + `Sync` boundaries. More about that in the
+*multi-threading* section.
+
+To bind to a specific socket address, `bind()` must be used, and it may be called multiple times.
+To start the http server, one of the start methods.
+
+- use `start()` for a simple server
+- use `start_tls()` or `start_ssl()` for a ssl server
+
+`HttpServer` is an actix actor. It must be initialized within a properly configured actix system:
 
 ```rust
 # extern crate actix;
 # extern crate actix_web;
-use actix::*;
-use actix_web::*;
+use actix_web::{server::HttpServer, App, HttpResponse};
 
 fn main() {
     let sys = actix::System::new("guide");
 
     HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.h(httpcodes::HttpOk)))
+        || App::new()
+            .resource("/", |r| r.f(|_| HttpResponse::Ok())))
         .bind("127.0.0.1:59080").unwrap()
         .start();
 
@@ -29,35 +34,35 @@ fn main() {
 }
 ```
 
-It is possible to start server in separate thread with *spawn()* method. In that
-case server spawns new thread and create new actix system in it. To stop
-this server send `StopServer` message.
+> It is possible to start a server in a separate thread with the `spawn()` method. In that
+> case the server spawns a new thread and creates a new actix system in it. To stop
+> this server, send a `StopServer` message.
 
-Http server is implemented as an actix actor. It is possible to communicate with server
-via messaging system. All start methods like `start()`, `start_ssl()`, etc returns
-address of the started http server. Actix http server accept several messages:
+`HttpServer` is implemented as an actix actor. It is possible to communicate with the server
+via a messaging system. All start methods, e.g. `start()` and `start_ssl()`, return the
+address of the started http server. It accepts several messages:
 
-* `PauseServer` - Pause accepting incoming connections
-* `ResumeServer` - Resume accepting incoming connections
-* `StopServer` - Stop incoming connection processing, stop all workers and exit
+- `PauseServer` - Pause accepting incoming connections
+- `ResumeServer` - Resume accepting incoming connections
+- `StopServer` - Stop incoming connection processing, stop all workers and exit
 
 ```rust
 # extern crate futures;
 # extern crate actix;
 # extern crate actix_web;
 # use futures::Future;
-use actix_web::*;
 use std::thread;
 use std::sync::mpsc;
+use actix_web::{server, App, HttpResponse};
 
 fn main() {
     let (tx, rx) = mpsc::channel();
 
     thread::spawn(move || {
         let sys = actix::System::new("http-server");
-        let addr = HttpServer::new(
-            || Application::new()
-                .resource("/", |r| r.h(httpcodes::HttpOk)))
+        let addr = server::new(
+            || App::new()
+                .resource("/", |r| r.f(|_| HttpResponse::Ok())))
             .bind("127.0.0.1:0").expect("Can not bind to 127.0.0.1:0")
             .shutdown_timeout(60)    // <- Set shutdown timeout to 60 seconds
             .start();
@@ -73,30 +78,32 @@ fn main() {
 
 ## Multi-threading
 
-Http server automatically starts number of http workers, by default
-this number is equal to number of logical cpu in the system. This number
-could be overridden with `HttpServer::threads()` method.
+`HttpServer` automatically starts an number of http workers, by default
+this number is equal to number of logical CPUs in the system. This number
+can be overridden with the `HttpServer::threads()` method.
 
 ```rust
 # extern crate actix_web;
 # extern crate tokio_core;
-use actix_web::*;
+use actix_web::{App, HttpResponse, server::HttpServer};
 
 fn main() {
     HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.h(httpcodes::HttpOk)))
+        || App::new()
+            .resource("/", |r| r.f(|_| HttpResponse::Ok())))
         .threads(4); // <- Start 4 workers
 }
 ```
 
-Server create separate application instance for each created worker. Application state
-is not shared between threads, to share state `Arc` could be used. Application state
-does not need to be `Send` and `Sync` but application factory must be `Send` + `Sync`.
+The server creates a separate application instance for each created worker. Application state
+is not shared between threads. To share state, `Arc` could be used.
+
+> Application state does not need to be `Send` and `Sync`,
+> but factories must be `Send` + `Sync`.
 
 ## SSL
 
-There are two `tls` and `alpn` features for ssl server. `tls` feature is for `native-tls`
+There are two features for ssl server: `tls` and `alpn`. The `tls` feature is for `native-tls`
 integration and `alpn` is for `openssl`.
 
 ```toml
@@ -109,85 +116,95 @@ use std::fs::File;
 use actix_web::*;
 
 fn main() {
-    let mut file = File::open("identity.pfx").unwrap();
-    let mut pkcs12 = vec![];
-    file.read_to_end(&mut pkcs12).unwrap();
-    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();
+    // load ssl keys
+    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
+    builder.set_private_key_file("key.pem", SslFiletype::PEM).unwrap();
+    builder.set_certificate_chain_file("cert.pem").unwrap();
 
-    HttpServer::new(
-        || Application::new()
+    server::new(
+        || App::new()
             .resource("/index.html", |r| r.f(index)))
         .bind("127.0.0.1:8080").unwrap()
-        .serve_ssl(pkcs12).unwrap();
+        .serve_ssl(builder).unwrap();
 }
 ```
 
-Note on *HTTP/2.0* protocol over tls without prior knowledge, it requires
-[tls alpn](https://tools.ietf.org/html/rfc7301). At the moment only
-`openssl` has `alpn ` support.
-
-Please check [example](https://github.com/actix/actix-web/tree/master/examples/tls)
-for full example.
+> **Note**: the *HTTP/2.0* protocol requires
+> [tls alpn](https://tools.ietf.org/html/rfc7301).
+> At the moment, only `openssl` has `alpn` support.
+> For a full example, check out
+> [examples/tls](https://github.com/actix/actix-web/tree/master/examples/tls).
 
 ## Keep-Alive
 
-Actix can wait for requests on a keep-alive connection. *Keep alive*
-connection behavior is defined by server settings.
+Actix can wait for requests on a keep-alive connection.
 
- * `Some(75)` - enable 75 sec *keep alive* timer according request and response settings.
- * `Some(0)` - disable *keep alive*.
- * `None` - Use `SO_KEEPALIVE` socket option.
+> *keep alive* connection behavior is defined by server settings.
+
+- `75`, `Some(75)`, `KeepAlive::Timeout(75)` - enable 75 second *keep alive* timer.
+- `None` or `KeepAlive::Disabled` - disable *keep alive*.
+- `KeepAlive::Tcp(75)` - use `SO_KEEPALIVE` socket option.
 
 ```rust
 # extern crate actix_web;
 # extern crate tokio_core;
-use actix_web::*;
+use actix_web::{server, App, HttpResponse};
 
 fn main() {
-    HttpServer::new(||
-        Application::new()
-            .resource("/", |r| r.h(httpcodes::HttpOk)))
-        .keep_alive(None); // <- Use `SO_KEEPALIVE` socket option.
+    server::new(||
+        App::new()
+            .resource("/", |r| r.f(|_| HttpResponse::Ok())))
+        .keep_alive(75); // <- Set keep-alive to 75 seconds
+
+    server::new(||
+        App::new()
+            .resource("/", |r| r.f(|_| HttpResponse::Ok())))
+        .keep_alive(server::KeepAlive::Tcp(75)); // <- Use `SO_KEEPALIVE` socket option.
+
+    server::new(||
+        App::new()
+            .resource("/", |r| r.f(|_| HttpResponse::Ok())))
+        .keep_alive(None); // <- Disable keep-alive
 }
 ```
 
-If first option is selected then *keep alive* state
-calculated based on response's *connection-type*. By default
-`HttpResponse::connection_type` is not defined in that case *keep alive*
-defined by request's http version. Keep alive is off for *HTTP/1.0*
-and is on for *HTTP/1.1* and *HTTP/2.0*.
+If the first option is selected, then *keep alive* state is
+calculated based on the response's *connection-type*. By default
+`HttpResponse::connection_type` is not defined. In that case *keep alive* is
+defined by the request's http version.
 
-*Connection type* could be change with `HttpResponseBuilder::connection_type()` method.
+> *keep alive* is **off** for *HTTP/1.0* and is **on** for *HTTP/1.1* and *HTTP/2.0*.
+
+*Connection type* can be change with `HttpResponseBuilder::connection_type()` method.
 
 ```rust
 # extern crate actix_web;
-# use actix_web::httpcodes::*;
-use actix_web::*;
+use actix_web::{HttpRequest, HttpResponse, http};
 
 fn index(req: HttpRequest) -> HttpResponse {
-    HttpOk.build()
-        .connection_type(headers::ConnectionType::Close) // <- Close connection
-        .force_close()                                   // <- Alternative method
-        .finish().unwrap()
+    HttpResponse::Ok()
+        .connection_type(http::ConnectionType::Close) // <- Close connection
+        .force_close()                                // <- Alternative method
+        .finish()
 }
 # fn main() {}
 ```
 
 ## Graceful shutdown
 
-Actix http server support graceful shutdown. After receiving a stop signal, workers
-have specific amount of time to finish serving requests. Workers still alive after the
-timeout are force dropped. By default shutdown timeout sets to 30 seconds.
-You can change this parameter with `HttpServer::shutdown_timeout()` method.
+`HttpServer` supports graceful shutdown. After receiving a stop signal, workers
+have a specific amount of time to finish serving requests. Any workers still alive after the
+timeout are force-dropped. By default the shutdown timeout is set to 30 seconds.
+You can change this parameter with the `HttpServer::shutdown_timeout()` method.
 
-You can send stop message to server with server address and specify if you what
-graceful shutdown or not. `start()` methods return address of the server.
+You can send a stop message to the server with the server address and specify if you want
+graceful shutdown or not. The `start()` methods returns address of the server.
 
-Http server handles several OS signals. *CTRL-C* is available on all OSs,
+`HttpServer` handles several OS signals. *CTRL-C* is available on all OSs,
 other signals are available on unix systems.
 
-* *SIGINT* - Force shutdown workers
-* *SIGTERM* - Graceful shutdown workers
-* *SIGQUIT* - Force shutdown workers
+- *SIGINT* - Force shutdown workers
+- *SIGTERM* - Graceful shutdown workers
+- *SIGQUIT* - Force shutdown workers
 
-It is possible to disable signals handling with `HttpServer::disable_signals()` method.
+> It is possible to disable signal handling with `HttpServer::disable_signals()` method.

guide/src/qs_4.md

@@ -1,17 +1,18 @@
 # Handler
 
-A request handler can by any object that implements 
-[*Handler trait*](../actix_web/dev/trait.Handler.html).
-Request handling happen in two stages. First handler object get called. 
-Handle can return any object that implements 
-[*Responder trait*](../actix_web/trait.Responder.html#foreign-impls).
-Then `respond_to()` get called on returned object. And finally
-result of the `respond_to()` call get converted to `Reply` object.
+A request handler can be any object that implements
+[`Handler` trait](../actix_web/dev/trait.Handler.html).
 
-By default actix provides `Responder` implementations for some standard types, 
-like `&'static str`, `String`, etc.
-For complete list of implementations check 
-[*Responder documentation*](../actix_web/trait.Responder.html#foreign-impls).
+Request handling happens in two stages. First the handler object is called,
+returning any object that implements the
+[`Responder` trait](../actix_web/trait.Responder.html#foreign-impls).
+Then, `respond_to()` is called on the returned object, converting itself to a `Reply` or `Error`.
+
+By default actix provides `Responder` implementations for some standard types,
+such as `&'static str`, `String`, etc.
+
+> For a complete list of implementations, check
+> [*Responder documentation*](../actix_web/trait.Responder.html#foreign-impls).
 
 Examples of valid handlers:
 
@@ -39,23 +40,22 @@ fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
 }
 ```
 
-Some notes on shared application state and handler state. If you noticed
-*Handler* trait is generic over *S*, which defines application state type. So
-application state is accessible from handler with `HttpRequest::state()` method. 
-But state is accessible as a read-only reference, if you need mutable access to state
-you have to implement it yourself. On other hand handler can mutable access it's own state
-as `handle` method takes mutable reference to *self*. Beware, actix creates multiple copies
-of application state and handlers, unique for each thread, so if you run your
-application in several threads actix will create same amount as number of threads 
-of application state objects and handler objects.
+*Handler* trait is generic over *S*, which defines the application state's type.
+Application state is accessible from the handler with the `HttpRequest::state()` method;
+however, state is accessible as a read-only reference. If you need mutable access to state,
+it must be implemented.
 
-Here is example of handler that stores number of processed requests:
+> **Note**: Alternatively, the handler can mutably access its own state because the `handle` method takes
+> mutable reference to *self*. **Beware**, actix creates multiple copies
+> of the application state and the handlers, unique for each thread. If you run your
+> application in several threads, actix will create the same amount as number of threads
+> of application state objects and handler objects.
+
+Here is an example of a handler that stores the number of processed requests:
 
 ```rust
-# extern crate actix;
 # extern crate actix_web;
-use actix_web::*;
-use actix_web::dev::Handler;
+use actix_web::{App, HttpRequest, HttpResponse, dev::Handler};
 
 struct MyHandler(usize);
 
@@ -65,20 +65,19 @@ impl<S> Handler<S> for MyHandler {
     /// Handle request
     fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
         self.0 += 1;
-        httpcodes::HttpOk.into()
+        HttpResponse::Ok().into()
     }
 }
 # fn main() {}
 ```
 
-This handler will work, but `self.0` value will be different depends on number of threads and
-number of requests processed per thread. Proper implementation would use `Arc` and `AtomicUsize`
+Although this handler will work, `self.0` will be different depending on the number of threads and
+number of requests processed per thread. A proper implementation would use `Arc` and `AtomicUsize`.
 
 ```rust
 # extern crate actix;
 # extern crate actix_web;
-use actix_web::*;
-use actix_web::dev::Handler;
+use actix_web::{server, App, HttpRequest, HttpResponse, dev::Handler};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
@@ -90,7 +89,7 @@ impl<S> Handler<S> for MyHandler {
     /// Handle request
     fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
         self.0.fetch_add(1, Ordering::Relaxed);
-        httpcodes::HttpOk.into()
+        HttpResponse::Ok().into()
     }
 }
 
@@ -99,10 +98,10 @@ fn main() {
 
     let inc = Arc::new(AtomicUsize::new(0));
 
-    HttpServer::new(
-        move || { 
+    server::new(
+        move || {
             let cloned = inc.clone();
-            Application::new()
+            App::new()
                 .resource("/", move |r| r.h(MyHandler(cloned)))
         })
         .bind("127.0.0.1:8088").unwrap()
@@ -114,15 +113,16 @@ fn main() {
 }
 ```
 
-Be careful with synchronization primitives like *Mutex* or *RwLock*. Actix web framework
-handles request asynchronously, by blocking thread execution all concurrent
-request handling processes would block. If you need to share or update some state 
-from multiple threads consider using [actix](https://actix.github.io/actix/actix/)  actor system.
+> Be careful with synchronization primitives like `Mutex` or `RwLock`. Actix web framework
+> handles requests asynchronously. By blocking thread execution, all concurrent
+> request handling processes would block. If you need to share or update some state
+> from multiple threads, consider using the [actix](https://actix.github.io/actix/actix/) actor system.
 
 ## Response with custom type
 
-To return custom type directly from handler function, type needs to implement `Responder` trait.
-Let's create response for custom type that serializes to `application/json` response:
+To return a custom type directly from a handler function, the type needs to implement the `Responder` trait.
+
+Let's create a response for a custom type that serializes to an `application/json` response:
 
 ```rust
 # extern crate actix;
@@ -130,7 +130,7 @@ Let's create response for custom type that serializes to `application/json` resp
 extern crate serde;
 extern crate serde_json;
 #[macro_use] extern crate serde_derive;
-use actix_web::*;
+use actix_web::{server, App, HttpRequest, HttpResponse, Error, Responder, http};
 
 #[derive(Serialize)]
 struct MyObj {
@@ -142,13 +142,13 @@ impl Responder for MyObj {
     type Item = HttpResponse;
     type Error = Error;
 
-    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse> {
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
         let body = serde_json::to_string(&self)?;
 
         // Create response and set content type
         Ok(HttpResponse::Ok()
             .content_type("application/json")
-            .body(body)?)
+            .body(body))
     }
 }
 
@@ -160,9 +160,9 @@ fn index(req: HttpRequest) -> MyObj {
 fn main() {
     let sys = actix::System::new("example");
 
-    HttpServer::new(
-        || Application::new()
-            .resource("/", |r| r.method(Method::GET).f(index)))
+    server::new(
+        || App::new()
+            .resource("/", |r| r.method(http::Method::GET).f(index)))
         .bind("127.0.0.1:8088").unwrap()
         .start();
 
@@ -174,11 +174,10 @@ fn main() {
 
 ## Async handlers
 
-There are two different types of async handlers. 
+There are two different types of async handlers. Response objects can be generated asynchronously
+or more precisely, any type that implements the [*Responder*](../actix_web/trait.Responder.html) trait.
 
-Response object could be generated asynchronously or more precisely, any type
-that implements [*Responder*](../actix_web/trait.Responder.html) trait. In this case handle must
-return `Future` object that resolves to *Responder* type, i.e:
+In this case, the handler must return a `Future` object that resolves to the *Responder* type, i.e:
 
 ```rust
 # extern crate actix_web;
@@ -187,29 +186,30 @@ return `Future` object that resolves to *Responder* type, i.e:
 # use actix_web::*;
 # use bytes::Bytes;
 # use futures::stream::once;
-# use futures::future::{FutureResult, result};
-fn index(req: HttpRequest) -> FutureResult<HttpResponse, Error> {
+# use futures::future::{Future, result};
+fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
 
-    result(HttpResponse::Ok()
-           .content_type("text/html")
-           .body(format!("Hello!"))
-           .map_err(|e| e.into()))
+    result(Ok(HttpResponse::Ok()
+              .content_type("text/html")
+              .body(format!("Hello!"))))
+           .responder()
 }
 
-fn index2(req: HttpRequest) -> FutureResult<&'static str, Error> {
+fn index2(req: HttpRequest) -> Box<Future<Item=&'static str, Error=Error>> {
     result(Ok("Welcome!"))
+        .responder()
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource("/async", |r| r.route().a(index))
         .resource("/", |r| r.route().a(index2))
         .finish();
 }
 ```
 
-Or response body can be generated asynchronously. In this case body
-must implement stream trait `Stream<Item=Bytes, Error=Error>`, i.e:
+Or the response body can be generated asynchronously. In this case, body
+must implement the stream trait `Stream<Item=Bytes, Error=Error>`, i.e:
 
 ```rust
 # extern crate actix_web;
@@ -223,23 +223,91 @@ fn index(req: HttpRequest) -> HttpResponse {
 
     HttpResponse::Ok()
        .content_type("application/json")
-       .body(Body::Streaming(Box::new(body))).unwrap()
+       .body(Body::Streaming(Box::new(body)))
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource("/async", |r| r.f(index))
         .finish();
 }
 ```
 
-Both methods could be combined. (i.e Async response with streaming body)
+Both methods can be combined. (i.e Async response with streaming body)
+
+It is possible to return a `Result` where the `Result::Item` type can be `Future`.
+In this example, the `index` handler can return an error immediately or return a
+future that resolves to a `HttpResponse`.
+
+```rust
+# extern crate actix_web;
+# extern crate futures;
+# extern crate bytes;
+# use actix_web::*;
+# use bytes::Bytes;
+# use futures::stream::once;
+# use futures::future::{Future, result};
+fn index(req: HttpRequest) -> Result<Box<Future<Item=HttpResponse, Error=Error>>, Error> {
+    if is_error() {
+       Err(error::ErrorBadRequest("bad request"))
+    } else {
+       Ok(Box::new(
+           result(Ok(HttpResponse::Ok()
+                  .content_type("text/html")
+                  .body(format!("Hello!"))))))
+    }
+}
+#
+# fn is_error() -> bool { true }
+# fn main() {
+#     App::new()
+#        .resource("/async", |r| r.route().f(index))
+#        .finish();
+# }
+```
+
+## Different return types (Either)
+
+Sometimes, you need to return different types of responses. For example,
+you can error check and return errors, return async responses, or any result that requires two different types.
+
+For this case, the [`Either`](../actix_web/enum.Either.html) type can be used.
+`Either` allows combining two different responder types into a single type.
+
+```rust
+# extern crate actix_web;
+# extern crate futures;
+# use actix_web::*;
+# use futures::future::Future;
+use futures::future::result;
+use actix_web::{Either, Error, HttpResponse};
+
+type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
+
+fn index(req: HttpRequest) -> RegisterResult {
+    if is_a_variant() { // <- choose variant A
+        Either::A(
+            HttpResponse::BadRequest().body("Bad data"))
+    } else {
+        Either::B(      // <- variant B
+            result(Ok(HttpResponse::Ok()
+                   .content_type("text/html")
+                   .body(format!("Hello!")))).responder())
+    }
+}
+# fn is_a_variant() -> bool { true }
+# fn main() {
+#    App::new()
+#        .resource("/register", |r| r.f(index))
+#        .finish();
+# }
+```
 
 ## Tokio core handle
 
-Any actix web handler runs within properly configured
+Any actix web handler runs within a properly configured
 [actix system](https://actix.github.io/actix/actix/struct.System.html)
 and [arbiter](https://actix.github.io/actix/actix/struct.Arbiter.html).
-You can always get access to tokio handle via
+You can always get access to the tokio handle via the
 [Arbiter::handle()](https://actix.github.io/actix/actix/struct.Arbiter.html#method.handle)
 method.

guide/src/qs_4_5.md

@@ -1,20 +1,22 @@
 # Errors
 
-Actix uses [`Error` type](../actix_web/error/struct.Error.html) 
-and [`ResponseError` trait](../actix_web/error/trait.ResponseError.html) 
+Actix uses the [`Error` type](../actix_web/error/struct.Error.html)
+and [`ResponseError` trait](../actix_web/error/trait.ResponseError.html)
 for handling handler's errors.
-Any error that implements `ResponseError` trait can be returned as error value.
-*Handler* can return *Result* object, actix by default provides 
-`Responder` implementation for compatible result object. Here is implementation
+
+Any error that implements the `ResponseError` trait can be returned as an error value.
+`Handler` can return an `Result` object. By default, actix provides a
+`Responder` implementation for compatible result types. Here is the implementation
 definition:
 
 ```rust,ignore
 impl<T: Responder, E: Into<Error>> Responder for Result<T, E>
 ```
 
-And any error that implements `ResponseError` can be converted into `Error` object.
-For example if *handler* function returns `io::Error`, it would be converted
-into `HttpInternalServerError` response. Implementation for `io::Error` is provided 
+Any error that implements `ResponseError` can be converted into an `Error` object.
+
+For example, if the *handler* function returns `io::Error`, it would be converted
+into an `HttpInternalServerError` response. Implementation for `io::Error` is provided
 by default.
 
 ```rust
@@ -27,7 +29,7 @@ fn index(req: HttpRequest) -> io::Result<fs::NamedFile> {
 }
 #
 # fn main() {
-#     Application::new()
+#     App::new()
 #         .resource(r"/a/index.html", |r| r.f(index))
 #         .finish();
 # }
@@ -35,9 +37,9 @@ fn index(req: HttpRequest) -> io::Result<fs::NamedFile> {
 
 ## Custom error response
 
-To add support for custom errors, all we need to do is just implement `ResponseError` trait
-for custom error. `ResponseError` trait has default implementation
-for `error_response()` method, it generates *500* response.
+To add support for custom errors, all we need to do is implement the `ResponseError` trait
+for the custom error type. The `ResponseError` trait has a default implementation
+for the `error_response()` method: it generates a *500* response.
 
 ```rust
 # extern crate actix_web;
@@ -58,19 +60,19 @@ fn index(req: HttpRequest) -> Result<&'static str, MyError> {
 }
 #
 # fn main() {
-#     Application::new()
+#     App::new()
 #         .resource(r"/a/index.html", |r| r.f(index))
 #         .finish();
 # }
 ```
 
-In this example *index* handler will always return *500* response. But it is easy
-to return different responses for different type of errors.
+In this example the *index* handler always returns a *500* response. But it is easy
+to return different responses for different types of errors.
 
 ```rust
 # extern crate actix_web;
 #[macro_use] extern crate failure;
-use actix_web::*;
+use actix_web::{App, HttpRequest, HttpResponse, http, error};
 
 #[derive(Fail, Debug)]
 enum MyError {
@@ -86,11 +88,11 @@ impl error::ResponseError for MyError {
     fn error_response(&self) -> HttpResponse {
        match *self {
           MyError::InternalError => HttpResponse::new(
-              StatusCode::INTERNAL_SERVER_ERROR, Body::Empty),
+              http::StatusCode::INTERNAL_SERVER_ERROR),
           MyError::BadClientData => HttpResponse::new(
-              StatusCode::BAD_REQUEST, Body::Empty),
+              http::StatusCode::BAD_REQUEST),
           MyError::Timeout => HttpResponse::new(
-              StatusCode::GATEWAY_TIMEOUT, Body::Empty),
+              http::StatusCode::GATEWAY_TIMEOUT),
        }
     }
 }
@@ -100,7 +102,7 @@ fn index(req: HttpRequest) -> Result<&'static str, MyError> {
 }
 #
 # fn main() {
-#     Application::new()
+#     App::new()
 #         .resource(r"/a/index.html", |r| r.f(index))
 #         .finish();
 # }
@@ -108,8 +110,8 @@ fn index(req: HttpRequest) -> Result<&'static str, MyError> {
 
 ## Error helpers
 
-Actix provides set of error helper types. It is possible to use them to generate
-specific error response. We can use helper types for first example with custom error.
+Actix provides a set of error helper types. It is possible to use them for generating
+specific error responses. We can use the helper types for the first example with a custom error.
 
 ```rust
 # extern crate actix_web;
@@ -123,28 +125,28 @@ struct MyError {
 
 fn index(req: HttpRequest) -> Result<&'static str> {
     let result: Result<&'static str, MyError> = Err(MyError{name: "test"});
-    
-    Ok(result.map_err(error::ErrorBadRequest)?)
+
+    Ok(result.map_err(|e| error::ErrorBadRequest(e))?)
 }
 # fn main() {
-#     Application::new()
+#     App::new()
 #         .resource(r"/a/index.html", |r| r.f(index))
 #         .finish();
 # }
 ```
 
-In this example *BAD REQUEST* response get generated for `MyError` error.
+In this example, a *BAD REQUEST* response is generated for the `MyError` error.
 
 ## Error logging
 
-Actix logs all errors with `WARN` log level. If log level set to `DEBUG`
-and `RUST_BACKTRACE` is enabled, backtrace get logged. The Error type uses
-cause's error backtrace if available, if the underlying failure does not provide
+Actix logs all errors with the log level `WARN`. If log level set to `DEBUG`
+and `RUST_BACKTRACE` is enabled, the backtrace gets logged. The Error type uses
+the cause's error backtrace if available. If the underlying failure does not provide
 a backtrace, a new backtrace is constructed pointing to that conversion point
 (rather than the origin of the error). This construction only happens if there
-is no underlying backtrace; if it does have a backtrace no new backtrace is constructed.
+is no underlying backtrace; if it does have a backtrace, no new backtrace is constructed.
 
-You can enable backtrace and debug logging with following command: 
+You can enable backtrace and debug logging with following command:
 
 ```
 >> RUST_BACKTRACE=1 RUST_LOG=actix_web=debug cargo run

guide/src/qs_5.md

@@ -1,105 +1,131 @@
 # URL Dispatch
 
-URL dispatch provides a simple way to map URLs to `Handler` code using a simple pattern matching
-language. If one of the patterns matches the path information associated with a request,
-a particular handler object is invoked. A handler is a specific object that implements
-`Handler` trait, defined in your application, that receives the request and returns
-a response object. More information is available in [handler section](../qs_4.html).
+URL dispatch provides a simple way for mapping URLs to `Handler` code using a simple pattern
+matching language. If one of the patterns matches the path information associated with a request,
+a particular handler object is invoked.
+
+> A handler is a specific object that implements the
+> `Handler` trait, defined in your application, that receives the request and returns
+> a response object. More information is available in the [handler section](../qs_4.html).
 
 ## Resource configuration
 
-Resource configuration is the act of adding a new resource to an application.
+Resource configuration is the act of adding a new resources to an application.
 A resource has a name, which acts as an identifier to be used for URL generation.
 The name also allows developers to add routes to existing resources.
-A resource also has a pattern, meant to match against the *PATH* portion of a *URL*,
-it does not match against *QUERY* portion (the portion following the scheme and
+A resource also has a pattern, meant to match against the *PATH* portion of a *URL*.
+It does not match against the *QUERY* portion (the portion following the scheme and
 port, e.g., */foo/bar* in the *URL* *http://localhost:8080/foo/bar?q=value*).
 
-The [Application::resource](../actix_web/struct.Application.html#method.resource) methods
-add a single resource to application routing table. This method accepts *path pattern*
-and resource configuration function.
+The [App::route](../actix_web/struct.App.html#method.route) method provides
+simple way of registering routes. This method adds a single route to application
+routing table. This method accepts a *path pattern*,
+*http method* and a handler function. `route()` method could be called multiple times
+for the same path, in that case, multiple routes register for the same resource path.
 
 ```rust
 # extern crate actix_web;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
-#
-# fn index(req: HttpRequest) -> HttpResponse {
-#   unimplemented!()
-# }
-#
+use actix_web::{App, HttpRequest, HttpResponse, http::Method};
+
+fn index(req: HttpRequest) -> HttpResponse {
+   unimplemented!()
+}
+
 fn main() {
-    Application::new()
-        .resource("/prefix", |r| r.f(index))
-        .resource("/user/{name}",
-             |r| r.method(Method::GET).f(|req| HttpOk))
+    App::new()
+        .route("/user/{name}", Method::GET, index)
+        .route("/user/{name}", Method::POST, index)
         .finish();
 }
 ```
 
-*Configuration function* has following type:
+While *App::route()* provides simple way of registering routes, to access
+complete resource configuration, different method has to be used.
+The [App::resource](../actix_web/struct.App.html#method.resource) method
+adds a single resource to application routing table. This method accepts a *path pattern*
+and a resource configuration function.
+
+```rust
+# extern crate actix_web;
+use actix_web::{App, HttpRequest, HttpResponse, http::Method};
+
+fn index(req: HttpRequest) -> HttpResponse {
+   unimplemented!()
+}
+
+fn main() {
+    App::new()
+        .resource("/prefix", |r| r.f(index))
+        .resource("/user/{name}",
+             |r| r.method(Method::GET).f(|req| HttpResponse::Ok()))
+        .finish();
+}
+```
+
+The *Configuration function* has the following type:
 
 ```rust,ignore
    FnOnce(&mut Resource<_>) -> ()
 ```
 
-*Configuration function* can set name and register specific routes.
-If resource does not contain any route or does not have any matching routes it
-returns *NOT FOUND* http resources.
+The *Configuration function* can set a name and register specific routes.
+If a resource does not contain any route or does not have any matching routes, it
+returns *NOT FOUND* http response.
 
 ## Configuring a Route
 
-Resource contains set of routes. Each route in turn has set of predicates and handler.
-New route could be created with `Resource::route()` method which returns reference
-to new *Route* instance. By default *route* does not contain any predicates, so matches
-all requests and default handler is `HttpNotFound`.
+Resource contains a set of routes. Each route in turn has a set of predicates and a handler.
+New routes can be created with `Resource::route()` method which returns a reference
+to new *Route* instance. By default the *route* does not contain any predicates, so matches
+all requests and the default handler is `HttpNotFound`.
 
-Application routes incoming requests based on route criteria which is defined during
+The application routes incoming requests based on route criteria which are defined during
 resource registration and route registration. Resource matches all routes it contains in
-the order that the routes were registered via `Resource::route()`. *Route* can contain
-any number of *predicates* but only one handler.
+the order the routes were registered via `Resource::route()`.
+
+> A *Route* can contain any number of *predicates* but only one handler.
 
 ```rust
 # extern crate actix_web;
 # use actix_web::*;
-# use actix_web::httpcodes::*;
 
 fn main() {
-    Application::new()
+    App::new()
         .resource("/path", |resource|
             resource.route()
               .filter(pred::Get())
               .filter(pred::Header("content-type", "text/plain"))
-              .f(|req| HttpOk)
+              .f(|req| HttpResponse::Ok())
         )
         .finish();
 }
 ```
 
-In this example `index` get called for *GET* request,
-if request contains `Content-Type` header and value of this header is *text/plain*
-and path equals to `/test`. Resource calls handle of the first matches route.
-If resource can not match any route "NOT FOUND" response get returned.
+In this example, `HttpResponse::Ok()` is returned for *GET* requests.
+If a request contains `Content-Type` header, the value of this header is *text/plain*,
+and path equals to `/path`, Resource calls handle of the first matching route.
 
-[*Resource::route()*](../actix_web/struct.Resource.html#method.route) method returns
-[*Route*](../actix_web/struct.Route.html) object. Route can be configured with
+If a resource can not match any route, a "NOT FOUND" response is returned.
+
+[*Resource::route()*](../actix_web/struct.Resource.html#method.route) returns a
+[*Route*](../actix_web/struct.Route.html) object. Route can be configured with a
 builder-like pattern. Following configuration methods are available:
 
-* [*Route::filter()*](../actix_web/struct.Route.html#method.filter) method registers new predicate,
-  any number of predicates could be registered for each route.
+* [*Route::filter()*](../actix_web/struct.Route.html#method.filter) registers a new predicate.
+  Any number of predicates can be registered for each route.
 
-* [*Route::f()*](../actix_web/struct.Route.html#method.f) method registers handler function
-  for this route. Only one handler could be registered. Usually handler registration
-  is the last config operation. Handler function could be function or closure and has type
+* [*Route::f()*](../actix_web/struct.Route.html#method.f) registers handler function
+  for this route. Only one handler can be registered. Usually handler registration
+  is the last config operation. Handler function can be a function or closure and has the type
   `Fn(HttpRequest<S>) -> R + 'static`
 
-* [*Route::h()*](../actix_web/struct.Route.html#method.h) method registers handler object
-  that implements `Handler` trait. This is similar to `f()` method, only one handler could
+* [*Route::h()*](../actix_web/struct.Route.html#method.h) registers a handler object
+  that implements the `Handler` trait. This is similar to `f()` method - only one handler can
   be registered. Handler registration is the last config operation.
 
-* [*Route::a()*](../actix_web/struct.Route.html#method.a) method registers async handler
-  function for this route. Only one handler could be registered. Handler registration
-  is the last config operation. Handler function could be function or closure and has type
+* [*Route::a()*](../actix_web/struct.Route.html#method.a) registers an async handler
+  function for this route. Only one handler can be registered. Handler registration
+  is the last config operation. Handler function can be a function or closure and has the type
   `Fn(HttpRequest<S>) -> Future<Item = HttpResponse, Error = Error> + 'static`
 
 ## Route matching
@@ -110,8 +136,8 @@ against a URL path pattern. `path` represents the path portion of the URL that w
 The way that *actix* does this is very simple. When a request enters the system,
 for each resource configuration declaration present in the system, actix checks
 the request's path against the pattern declared. This checking happens in the order that
-the routes were declared via `Application::resource()` method. If resource could not be found,
-*default resource* get used as matched resource.
+the routes were declared via `App::resource()` method. If resource can not be found,
+the *default resource* is used as the matched resource.
 
 When a route configuration is declared, it may contain route predicate arguments. All route
 predicates associated with a route declaration must be `true` for the route configuration to
@@ -120,13 +146,11 @@ arguments provided to a route configuration returns `false` during a check, that
 skipped and route matching continues through the ordered set of routes.
 
 If any route matches, the route matching process stops and the handler associated with
-route get invoked.
-
-If no route matches after all route patterns are exhausted, *NOT FOUND* response get returned.
+the route is invoked. If no route matches after all route patterns are exhausted, a *NOT FOUND* response get returned.
 
 ## Resource pattern syntax
 
-The syntax of the pattern matching language used by the actix in the pattern
+The syntax of the pattern matching language used by actix in the pattern
 argument is straightforward.
 
 The pattern used in route configuration may start with a slash character. If the pattern
@@ -210,8 +234,9 @@ For example, for the URL */abc/*:
 * */abc/{foo}* will not match.
 * */{foo}/* will match.
 
-Note that path will be URL-unquoted and decoded into valid unicode string before
-matching pattern and values representing matched path segments will be URL-unquoted too.
+> **Note**: path will be URL-unquoted and decoded into valid unicode string before
+> matching pattern and values representing matched path segments will be URL-unquoted too.
+
 So for instance, the following pattern:
 
 ```
@@ -261,12 +286,12 @@ foo/abc/def/a/b/c  -> Params{'bar':u'abc', 'tail': 'def/a/b/c'}
 
 All values representing matched path segments are available in
 [`HttpRequest::match_info`](../actix_web/struct.HttpRequest.html#method.match_info).
-Specific value can be received with
-[`Params::get()`](../actix_web/dev/struct.Params.html#method.get) method.
+Specific values can be retrieved with
+[`Params::get()`](../actix_web/dev/struct.Params.html#method.get).
 
-Any matched parameter can be deserialized into specific type if this type
-implements `FromParam` trait. For example most of standard integer types
-implements `FromParam` trait. i.e.:
+Any matched parameter can be deserialized into a specific type if the type
+implements the `FromParam` trait. For example most standard integer types
+the trait, i.e.:
 
 ```rust
 # extern crate actix_web;
@@ -279,7 +304,7 @@ fn index(req: HttpRequest) -> Result<String> {
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource(r"/a/{v1}/{v2}/", |r| r.f(index))
         .finish();
 }
@@ -294,19 +319,19 @@ any) is skipped.
 For security purposes, if a segment meets any of the following conditions,
 an `Err` is returned indicating the condition met:
 
-  * Decoded segment starts with any of: `.` (except `..`), `*`
-  * Decoded segment ends with any of: `:`, `>`, `<`
-  * Decoded segment contains any of: `/`
-  * On Windows, decoded segment contains any of: '\'
-  * Percent-encoding results in invalid UTF8.
+* Decoded segment starts with any of: `.` (except `..`), `*`
+* Decoded segment ends with any of: `:`, `>`, `<`
+* Decoded segment contains any of: `/`
+* On Windows, decoded segment contains any of: '\'
+* Percent-encoding results in invalid UTF8.
 
 As a result of these conditions, a `PathBuf` parsed from request path parameter is
 safe to interpolate within, or use as a suffix of, a path without additional checks.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
 use std::path::PathBuf;
+use actix_web::{App, HttpRequest, Result, http::Method};
 
 fn index(req: HttpRequest) -> Result<String> {
     let path: PathBuf = req.match_info().query("tail")?;
@@ -314,64 +339,122 @@ fn index(req: HttpRequest) -> Result<String> {
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource(r"/a/{tail:.*}", |r| r.method(Method::GET).f(index))
         .finish();
 }
 ```
 
-List of `FromParam` implementation could be found in
+List of `FromParam` implementations can be found in
 [api docs](../actix_web/dev/trait.FromParam.html#foreign-impls)
 
+## Path information extractor
+
+Actix provides functionality for type safe path information extraction.
+[Path](../actix_web/struct.Path.html) extracts information, destination type
+could be defined in several different forms. Simplest approach is to use
+`tuple` type. Each element in tuple must correpond to one element from
+path pattern. i.e. you can match path pattern `/{id}/{username}/` against
+`Pyth<(u32, String)>` type, but `Path<(String, String, String)>` type will
+always fail.
+
+```rust
+# extern crate actix_web;
+use actix_web::{App, Path, Result, http::Method};
+
+// extract path info using serde
+fn index(info: Path<(String, u32)>) -> Result<String> {
+    Ok(format!("Welcome {}! id: {}", info.0, info.1))
+}
+
+fn main() {
+    let app = App::new()
+        .resource("/{username}/{id}/index.html",    // <- define path parameters
+                  |r| r.method(Method::GET).with(index));
+}
+```
+
+
+It also possible to extract path pattern information to a struct. In this case,
+this struct must implement *serde's *`Deserialize` trait.
+
+```rust
+# extern crate actix_web;
+#[macro_use] extern crate serde_derive;
+use actix_web::{App, Path, Result, http::Method};
+
+#[derive(Deserialize)]
+struct Info {
+    username: String,
+}
+
+// extract path info using serde
+fn index(info: Path<Info>) -> Result<String> {
+    Ok(format!("Welcome {}!", info.username))
+}
+
+fn main() {
+    let app = App::new()
+        .resource("/{username}/index.html",    // <- define path parameters
+                  |r| r.method(Method::GET).with(index));
+}
+```
+
+[Query](../actix_web/struct.Query.html) provides similar functionality for
+request query parameters.
+
+
 ## Generating resource URLs
 
 Use the [HttpRequest.url_for()](../actix_web/struct.HttpRequest.html#method.url_for)
 method to generate URLs based on resource patterns. For example, if you've configured a
-resource with the name "foo" and the pattern "{a}/{b}/{c}", you might do this.
+resource with the name "foo" and the pattern "{a}/{b}/{c}", you might do this:
 
 ```rust
 # extern crate actix_web;
-# use actix_web::*;
-# use actix_web::httpcodes::*;
+# use actix_web::{App, Result, HttpRequest, HttpResponse, http::Method, http::header};
 #
-fn index(req: HttpRequest) -> HttpResponse {
-    let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
-    HttpOk.into()
+fn index(req: HttpRequest) -> Result<HttpResponse> {
+    let url = req.url_for("foo", &["1", "2", "3"])?; // <- generate url for "foo" resource
+    Ok(HttpResponse::Found()
+       .header(header::LOCATION, url.as_str())
+       .finish())
 }
 
 fn main() {
-    let app = Application::new()
+    let app = App::new()
         .resource("/test/{a}/{b}/{c}", |r| {
              r.name("foo");  // <- set resource name, then it could be used in `url_for`
-             r.method(Method::GET).f(|_| httpcodes::HttpOk);
+             r.method(Method::GET).f(|_| HttpResponse::Ok());
         })
+        .route("/test/", Method::GET, index)
         .finish();
 }
 ```
 
 This would return something like the string *http://example.com/test/1/2/3* (at least if
 the current protocol and hostname implied http://example.com).
-`url_for()` method return [*Url object*](https://docs.rs/url/1.6.0/url/struct.Url.html) so you
+`url_for()` method returns [*Url object*](https://docs.rs/url/1.6.0/url/struct.Url.html) so you
 can modify this url (add query parameters, anchor, etc).
 `url_for()` could be called only for *named* resources otherwise error get returned.
 
 ## External resources
 
-Resources that are valid URLs, could be registered as external resources. They are useful
+Resources that are valid URLs, can be registered as external resources. They are useful
 for URL generation purposes only and are never considered for matching at request time.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
+use actix_web::{App, HttpRequest, HttpResponse, Error};
 
-fn index(mut req: HttpRequest) -> Result<HttpResponse> {
+fn index(mut req: HttpRequest) -> Result<HttpResponse, Error> {
     let url = req.url_for("youtube", &["oHg5SJYRHA0"])?;
     assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0");
-    Ok(httpcodes::HttpOk.into())
+    Ok(HttpResponse::Ok().into())
 }
 
 fn main() {
-    let app = Application::new()
+    let app = App::new()
         .resource("/index.html", |r| r.f(index))
         .external_resource("youtube", "https://youtube.com/watch/{video_id}")
         .finish();
@@ -382,66 +465,67 @@ fn main() {
 
 By normalizing it means:
 
- - Add a trailing slash to the path.
- - Double slashes are replaced by one.
+* Add a trailing slash to the path.
+* Double slashes are replaced by one.
 
 The handler returns as soon as it finds a path that resolves
 correctly. The order if all enable is 1) merge, 3) both merge and append
 and 3) append. If the path resolves with
 at least one of those conditions, it will redirect to the new path.
 
-If *append* is *true* append slash when needed. If a resource is
-defined with trailing slash and the request comes without it, it will
-append it automatically.
+If *append* is *true*, append slash when needed. If a resource is
+defined with trailing slash and the request doesn't have one, it will
+be appended automatically.
 
 If *merge* is *true*, merge multiple consecutive slashes in the path into one.
 
-This handler designed to be use as a handler for application's *default resource*.
+This handler designed to be used as a handler for application's *default resource*.
 
 ```rust
 # extern crate actix_web;
 # #[macro_use] extern crate serde_derive;
 # use actix_web::*;
+use actix_web::http::NormalizePath;
 #
-# fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-#    httpcodes::HttpOk
+# fn index(req: HttpRequest) -> HttpResponse {
+#    HttpResponse::Ok().into()
 # }
 fn main() {
-    let app = Application::new()
+    let app = App::new()
         .resource("/resource/", |r| r.f(index))
         .default_resource(|r| r.h(NormalizePath::default()))
         .finish();
 }
 ```
 
-In this example `/resource`, `//resource///` will be redirected to `/resource/` url.
+In this example `/resource`, `//resource///` will be redirected to `/resource/`.
 
-In this example path normalization handler get registered for all method,
+In this example, the path normalization handler is registered for all methods,
 but you should not rely on this mechanism to redirect *POST* requests. The redirect of the
 slash-appending *Not Found* will turn a *POST* request into a GET, losing any
 *POST* data in the original request.
 
-It is possible to register path normalization only for *GET* requests only
+It is possible to register path normalization only for *GET* requests only:
 
 ```rust
 # extern crate actix_web;
 # #[macro_use] extern crate serde_derive;
-# use actix_web::*;
+use actix_web::{App, HttpRequest, http::Method, http::NormalizePath};
 #
-# fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-#    httpcodes::HttpOk
+# fn index(req: HttpRequest) -> &'static str {
+#    "test"
 # }
 fn main() {
-    let app = Application::new()
+    let app = App::new()
         .resource("/resource/", |r| r.f(index))
         .default_resource(|r| r.method(Method::GET).h(NormalizePath::default()))
         .finish();
 }
 ```
 
-## Using a Application Prefix to Compose Applications
+## Using an Application Prefix to Compose Applications
 
-The `Application::prefix()`" method allows to set specific application prefix.
+The `App::prefix()` method allows to set a specific application prefix.
 This prefix represents a resource prefix that will be prepended to all resource patterns added
 by the resource configuration. This can be used to help mount a set of routes at a different
 location than the included callable's author intended while still maintaining the same
@@ -458,7 +542,7 @@ fn show_users(req: HttpRequest) -> HttpResponse {
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .prefix("/users")
         .resource("/show", |r| r.f(show_users))
         .finish();
@@ -473,77 +557,73 @@ it will generate a URL with that same path.
 
 ## Custom route predicates
 
-You can think of predicate as simple function that accept *request* object reference
-and returns *true* or *false*. Formally predicate is any object that implements
+You can think of a predicate as a simple function that accepts a *request* object reference
+and returns *true* or *false*. Formally, a predicate is any object that implements the
 [`Predicate`](../actix_web/pred/trait.Predicate.html) trait. Actix provides
 several predicates, you can check [functions section](../actix_web/pred/index.html#functions)
 of api docs.
 
-Here is simple predicates that check that request contains specific *header*:
+Here is a simple predicate that check that a request contains a specific *header*:
 
 ```rust
 # extern crate actix_web;
-# extern crate http;
 # use actix_web::*;
-# use actix_web::httpcodes::*;
-use http::header::CONTENT_TYPE;
-use actix_web::pred::Predicate;
+use actix_web::{http, pred::Predicate, App, HttpRequest};
 
 struct ContentTypeHeader;
 
 impl<S: 'static> Predicate<S> for ContentTypeHeader {
 
     fn check(&self, req: &mut HttpRequest<S>) -> bool {
-       req.headers().contains_key(CONTENT_TYPE)
+       req.headers().contains_key(http::header::CONTENT_TYPE)
     }
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource("/index.html", |r|
            r.route()
               .filter(ContentTypeHeader)
-              .h(HttpOk));
+              .f(|_| HttpResponse::Ok()));
 }
 ```
 
-In this example *index* handler will be called only if request contains *CONTENT-TYPE* header.
+In this example, *index* handler will be called only if request contains *CONTENT-TYPE* header.
 
-Predicates can have access to application's state via `HttpRequest::state()` method.
+Predicates have access to the application's state via `HttpRequest::state()`.
 Also predicates can store extra information in
-[requests`s extensions](../actix_web/struct.HttpRequest.html#method.extensions).
+[request extensions](../actix_web/struct.HttpRequest.html#method.extensions).
 
 ### Modifying predicate values
 
 You can invert the meaning of any predicate value by wrapping it in a `Not` predicate.
-For example if you want to return "METHOD NOT ALLOWED" response for all methods
+For example, if you want to return "METHOD NOT ALLOWED" response for all methods
 except "GET":
 
 ```rust
 # extern crate actix_web;
 # extern crate http;
 # use actix_web::*;
-# use actix_web::httpcodes::*;
-use actix_web::pred;
+use actix_web::{pred, App, HttpResponse};
 
 fn main() {
-    Application::new()
+    App::new()
         .resource("/index.html", |r|
            r.route()
               .filter(pred::Not(pred::Get()))
-              .f(|req| HttpMethodNotAllowed))
+              .f(|req| HttpResponse::MethodNotAllowed()))
         .finish();
 }
 ```
 
-`Any` predicate accept list of predicates and matches if any of the supplied
+The `Any` predicate accepts a list of predicates and matches if any of the supplied
 predicates match. i.e:
 
 ```rust,ignore
     pred::Any(pred::Get()).or(pred::Post())
 ```
 
-`All` predicate accept list of predicates and matches if all of the supplied
+The `All` predicate accepts a list of predicates and matches if all of the supplied
 predicates match. i.e:
 
 ```rust,ignore
@@ -552,23 +632,22 @@ predicates match. i.e:
 
 ## Changing the default Not Found response
 
-If path pattern can not be found in routing table or resource can not find matching
-route, default resource is used. Default response is *NOT FOUND* response.
-It is possible to override *NOT FOUND* response with `Application::default_resource()` method.
-This method accepts *configuration function* same as normal resource configuration
-with `Application::resource()` method.
+If the path pattern can not be found in the routing table or a resource can not find matching
+route, the default resource is used. The default response is *NOT FOUND*.
+It is possible to override the *NOT FOUND* response with `App::default_resource()`.
+This method accepts a *configuration function* same as normal resource configuration
+with `App::resource()` method.
 
 ```rust
 # extern crate actix_web;
-# extern crate http;
-use actix_web::*;
-use actix_web::httpcodes::*;
+use actix_web::{App, HttpResponse, http::Method, pred};
 
 fn main() {
-    Application::new()
+    App::new()
         .default_resource(|r| {
-              r.method(Method::GET).f(|req| HttpNotFound);
-              r.route().filter(pred::Not(pred::Get())).f(|req| HttpMethodNotAllowed);
+              r.method(Method::GET).f(|req| HttpResponse::NotFound());
+              r.route().filter(pred::Not(pred::Get()))
+                  .f(|req| HttpResponse::MethodNotAllowed());
          })
 #        .finish();
 }

guide/src/qs_7.md

@@ -2,69 +2,98 @@
 
 ## Response
 
-Builder-like patter is used to construct an instance of `HttpResponse`.
-`HttpResponse` provides several method that returns `HttpResponseBuilder` instance,
-which is implements various convenience methods that helps build response.
-Check [documentation](../actix_web/dev/struct.HttpResponseBuilder.html)
-for type description. Methods `.body`, `.finish`, `.json` finalizes response creation and
-returns constructed *HttpResponse* instance. if this methods get called for the same
-builder instance multiple times, builder will panic.
+A builder-like pattern is used to construct an instance of `HttpResponse`.
+`HttpResponse` provides several methods that return a `HttpResponseBuilder` instance,
+which implements various convenience methods for building responses.
+
+> Check the [documentation](../actix_web/dev/struct.HttpResponseBuilder.html)
+> for type descriptions.
+
+The methods `.body`, `.finish`, and `.json` finalize response creation and
+return a constructed *HttpResponse* instance. If this methods is called on the same
+builder instance multiple times, the builder will panic.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
-use actix_web::headers::ContentEncoding;
+use actix_web::{HttpRequest, HttpResponse, http::ContentEncoding};
 
 fn index(req: HttpRequest) -> HttpResponse {
     HttpResponse::Ok()
         .content_encoding(ContentEncoding::Br)
         .content_type("plain/text")
         .header("X-Hdr", "sample")
-        .body("data").unwrap()
+        .body("data")
 }
 # fn main() {}
 ```
 
 ## Content encoding
 
-Actix automatically *compress*/*decompress* payload. Following codecs are supported: 
+Actix automatically *compresses*/*decompresses* payloads. The following codecs are supported:
 
- * Brotli
- * Gzip
- * Deflate
- * Identity
- 
- If request headers contains `Content-Encoding` header, request payload get decompressed
- according to header value. Multiple codecs are not supported, i.e: `Content-Encoding: br, gzip`.
- 
-Response payload get compressed based on *content_encoding* parameter. 
-By default `ContentEncoding::Auto` is used. If `ContentEncoding::Auto` is selected
-then compression depends on request's `Accept-Encoding` header. 
-`ContentEncoding::Identity` could be used to disable compression.
-If other content encoding is selected the compression is enforced for this codec. For example,
-to enable `brotli` response's body compression use `ContentEncoding::Br`:
+* Brotli
+* Gzip
+* Deflate
+* Identity
+
+If request headers contain a `Content-Encoding` header, the request payload is decompressed
+according to the header value. Multiple codecs are not supported, i.e: `Content-Encoding: br, gzip`.
+
+Response payload is compressed based on the *content_encoding* parameter.
+By default, `ContentEncoding::Auto` is used. If `ContentEncoding::Auto` is selected,
+then the compression depends on the request's `Accept-Encoding` header.
+
+> `ContentEncoding::Identity` can be used to disable compression.
+> If another content encoding is selected, the compression is enforced for that codec.
+
+For example, to enable `brotli` use `ContentEncoding::Br`:
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
-use actix_web::headers::ContentEncoding;
+use actix_web::{HttpRequest, HttpResponse, http::ContentEncoding};
 
 fn index(req: HttpRequest) -> HttpResponse {
     HttpResponse::Ok()
         .content_encoding(ContentEncoding::Br)
-        .body("data").unwrap()
+        .body("data")
 }
 # fn main() {}
 ```
 
-
 ## JSON Request
 
-There are two options of json body deserialization. 
+There are several options for json body deserialization.
 
-First option is to use *HttpResponse::json()* method. This method returns
-[*JsonBody*](../actix_web/dev/struct.JsonBody.html) object which resolves into 
-deserialized value.
+The first option is to use *Json* extractor. First, you define a handler function
+that accepts `Json<T>` as a parameter, then, you use the `.with()` method for registering
+this handler. It is also possible to accept arbitrary valid json object by
+using `serde_json::Value` as a type `T`.
+
+```rust
+# extern crate actix_web;
+#[macro_use] extern crate serde_derive;
+use actix_web::{App, Json, Result, http};
+
+#[derive(Deserialize)]
+struct Info {
+    username: String,
+}
+
+/// extract `Info` using serde
+fn index(info: Json<Info>) -> Result<String> {
+    Ok(format!("Welcome {}!", info.username))
+}
+
+fn main() {
+    let app = App::new().resource(
+       "/index.html",
+       |r| r.method(http::Method::POST).with(index));  // <- use `with` extractor
+}
+```
+
+Another option is to use *HttpResponse::json()*. This method returns a
+[*JsonBody*](../actix_web/dev/struct.JsonBody.html) object which resolves into
+the deserialized value.
 
 ```rust
 # extern crate actix;
@@ -84,16 +113,17 @@ fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
     req.json().from_err()
         .and_then(|val: MyObj| {
             println!("model: {:?}", val);
-            Ok(httpcodes::HttpOk.build().json(val)?)  // <- send response
+            Ok(HttpResponse::Ok().json(val))  // <- send response
         })
         .responder()
 }
 # fn main() {}
 ```
 
-Or you can manually load payload into memory and then deserialize it.
-Here is simple example. We will deserialize *MyObj* struct. We need to load request
-body first and then deserialize json into object.
+You may also manually load the payload into memory and then deserialize it.
+
+In the following example, we will deserialize a *MyObj* struct. We need to load the request
+body first and then deserialize the json into an object.
 
 ```rust
 # extern crate actix_web;
@@ -117,27 +147,26 @@ fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
       // synchronous workflow
       .and_then(|body| {                           // <- body is loaded, now we can deserialize json
           let obj = serde_json::from_slice::<MyObj>(&body)?;
-          Ok(httpcodes::HttpOk.build().json(obj)?) // <- send response
+          Ok(HttpResponse::Ok().json(obj))        // <- send response
       })
       .responder()
 }
 # fn main() {}
 ```
 
-Complete example for both options is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/json/).
-
+> A complete example for both options is available in
+> [examples directory](https://github.com/actix/actix-web/tree/master/examples/json/).
 
 ## JSON Response
 
-The `Json` type allows you to respond with well-formed JSON data: simply return a value of 
-type Json<T> where T is the type of a structure to serialize into *JSON*. The 
-type `T` must implement the `Serialize` trait from *serde*.
+The `Json` type allows to respond with well-formed JSON data: simply return a value of
+type Json<T> where `T` is the type of a structure to serialize into *JSON*.
+The type `T` must implement the `Serialize` trait from *serde*.
 
 ```rust
 # extern crate actix_web;
 #[macro_use] extern crate serde_derive;
-use actix_web::*;
+use actix_web::{App, HttpRequest, Json, Result, http::Method};
 
 #[derive(Serialize)]
 struct MyObj {
@@ -149,7 +178,7 @@ fn index(req: HttpRequest) -> Result<Json<MyObj>> {
 }
 
 fn main() {
-    Application::new()
+    App::new()
         .resource(r"/a/{name}", |r| r.method(Method::GET).f(index))
         .finish();
 }
@@ -157,16 +186,16 @@ fn main() {
 
 ## Chunked transfer encoding
 
-Actix automatically decode *chunked* encoding. `HttpRequest::payload()` already contains
-decoded bytes stream. If request payload compressed with one of supported
-compression codecs (br, gzip, deflate) bytes stream get decompressed.
+Actix automatically decodes *chunked* encoding. `HttpRequest::payload()` already contains
+the decoded byte stream. If the request payload is compressed with one of the supported
+compression codecs (br, gzip, deflate), then the byte stream is decompressed.
 
-Chunked encoding on response could be enabled with `HttpResponseBuilder::chunked()` method.
-But this takes effect only for `Body::Streaming(BodyStream)` or `Body::StreamingContext` bodies.
-Also if response payload compression is enabled and streaming body is used, chunked encoding
-get enabled automatically.
+Chunked encoding on a response can be enabled with `HttpResponseBuilder::chunked()`.
+This takes effect only for `Body::Streaming(BodyStream)` or `Body::StreamingContext` bodies.
+If the response payload compression is enabled and a streaming body is used, chunked encoding
+is enabled automatically.
 
-Enabling chunked encoding for *HTTP/2.0* responses is forbidden.
+> Enabling chunked encoding for *HTTP/2.0* responses is forbidden.
 
 ```rust
 # extern crate bytes;
@@ -180,20 +209,20 @@ use futures::stream::once;
 fn index(req: HttpRequest) -> HttpResponse {
     HttpResponse::Ok()
         .chunked()
-        .body(Body::Streaming(Box::new(once(Ok(Bytes::from_static(b"data")))))).unwrap()
+        .body(Body::Streaming(Box::new(once(Ok(Bytes::from_static(b"data"))))))
 }
 # fn main() {}
 ```
 
 ## Multipart body
 
-Actix provides multipart stream support. 
-[*Multipart*](../actix_web/multipart/struct.Multipart.html) is implemented as 
-a stream of multipart items, each item could be
-[*Field*](../actix_web/multipart/struct.Field.html) or nested *Multipart* stream.
-`HttpResponse::multipart()` method returns *Multipart* stream for current request.
+Actix provides multipart stream support.
+[*Multipart*](../actix_web/multipart/struct.Multipart.html) is implemented as
+a stream of multipart items. Each item can be a
+[*Field*](../actix_web/multipart/struct.Field.html) or a nested *Multipart* stream.
+`HttpResponse::multipart()` returns the *Multipart* stream for the current request.
 
-In simple form multipart stream handling could be implemented similar to this example
+The following demonstrates multipart stream handling for a simple form:
 
 ```rust,ignore
 # extern crate actix_web;
@@ -206,7 +235,7 @@ fn index(req: HttpRequest) -> Box<Future<...>> {
                            // Handle multipart Field
               multipart::MultipartItem::Field(field) => {
                  println!("==== FIELD ==== {:?} {:?}", field.headers(), field.content_type());
-                 
+
                  Either::A(
                            // Field in turn is a stream of *Bytes* objects
                    field.map(|chunk| {
@@ -215,7 +244,7 @@ fn index(req: HttpRequest) -> Box<Future<...>> {
                       .fold((), |_, _| result(Ok(()))))
                 },
               multipart::MultipartItem::Nested(mp) => {
-                         // Or item could be nested Multipart stream 
+                         // Or item could be nested Multipart stream
                  Either::B(result(Ok(())))
               }
          }
@@ -223,48 +252,54 @@ fn index(req: HttpRequest) -> Box<Future<...>> {
 }
 ```
 
-Full example is available in 
-[examples directory](https://github.com/actix/actix-web/tree/master/examples/multipart/).
+> A full example is available in the
+> [examples directory](https://github.com/actix/actix-web/tree/master/examples/multipart/).
 
 ## Urlencoded body
 
-Actix provides support for *application/x-www-form-urlencoded* encoded body.
-`HttpResponse::urlencoded()` method returns
-[*UrlEncoded*](../actix_web/dev/struct.UrlEncoded.html) future, it resolves 
-into `HashMap<String, String>` which contains decoded parameters.
-*UrlEncoded* future can resolve into a error in several cases:
+Actix provides support for *application/x-www-form-urlencoded* encoded bodies.
+`HttpResponse::urlencoded()` returns a
+[*UrlEncoded*](../actix_web/dev/struct.UrlEncoded.html) future, which resolves
+to the deserialized instance. The type of the instance must implement the
+`Deserialize` trait from *serde*.
+
+The *UrlEncoded* future can resolve into an error in several cases:
 
 * content type is not `application/x-www-form-urlencoded`
 * transfer encoding is `chunked`.
 * content-length is greater than 256k
 * payload terminates with error.
 
-
 ```rust
 # extern crate actix_web;
 # extern crate futures;
+#[macro_use] extern crate serde_derive;
 use actix_web::*;
 use futures::future::{Future, ok};
 
+#[derive(Deserialize)]
+struct FormData {
+    username: String,
+}
+
 fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req.urlencoded()         // <- get UrlEncoded future
+    req.urlencoded::<FormData>() // <- get UrlEncoded future
        .from_err()
-       .and_then(|params| {  // <- url encoded parameters
-             println!("==== BODY ==== {:?}", params);
-             ok(httpcodes::HttpOk.into())
+       .and_then(|data| {        // <- deserialized instance
+             println!("USERNAME: {:?}", data.username);
+             ok(HttpResponse::Ok().into())
        })
        .responder()
 }
 # fn main() {}
 ```
 
-
 ## Streaming request
 
-*HttpRequest* is a stream of `Bytes` objects. It could be used to read request
+*HttpRequest* is a stream of `Bytes` objects. It can be used to read the request
 body payload.
 
-In this example handle reads request payload chunk by chunk and prints every chunk.
+In the following example, we read and print the request payload chunk by chunk:
 
 ```rust
 # extern crate actix_web;
@@ -280,7 +315,7 @@ fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
             println!("Chunk: {:?}", chunk);
             result::<_, error::PayloadError>(Ok(()))
         })
-       .map(|_| HttpResponse::Ok().finish().unwrap())
+       .map(|_| HttpResponse::Ok().finish())
        .responder()
 }
 # fn main() {}

guide/src/qs_8.md

@@ -1,65 +1,63 @@
 # Testing
 
-Every application should be well tested and. Actix provides the tools to perform unit and
+Every application should be well tested. Actix provides tools to perform unit and
 integration tests.
 
 ## Unit tests
 
-For unit testing actix provides request builder type and simple handler runner.
-[*TestRequest*](../actix_web/test/struct.TestRequest.html) implements builder-like pattern.
-You can generate `HttpRequest` instance with `finish()` method or you can
-run your handler with `run()` or `run_async()` methods.
+For unit testing, actix provides a request builder type and a simple handler runner.
+[*TestRequest*](../actix_web/test/struct.TestRequest.html) implements a builder-like pattern.
+You can generate a `HttpRequest` instance with `finish()`, or you can
+run your handler with `run()` or `run_async()`.
 
 ```rust
-# extern crate http;
 # extern crate actix_web;
-use http::{header, StatusCode};
-use actix_web::*;
-use actix_web::test::TestRequest;
+use actix_web::{http, test, HttpRequest, HttpResponse, HttpMessage};
 
 fn index(req: HttpRequest) -> HttpResponse {
-     if let Some(hdr) = req.headers().get(header::CONTENT_TYPE) {
+     if let Some(hdr) = req.headers().get(http::header::CONTENT_TYPE) {
         if let Ok(s) = hdr.to_str() {
-            return httpcodes::HttpOk.into()
+            return HttpResponse::Ok().into()
         }
      }
-     httpcodes::HttpBadRequest.into()
+     HttpResponse::BadRequest().into()
 }
 
 fn main() {
-    let resp = TestRequest::with_header("content-type", "text/plain")
+    let resp = test::TestRequest::with_header("content-type", "text/plain")
         .run(index)
         .unwrap();
-    assert_eq!(resp.status(), StatusCode::OK);
+    assert_eq!(resp.status(), http::StatusCode::OK);
 
-    let resp = TestRequest::default()
+    let resp = test::TestRequest::default()
         .run(index)
         .unwrap();
-    assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    assert_eq!(resp.status(), http::StatusCode::BAD_REQUEST);
 }
 ```
 
-
 ## Integration tests
 
-There are several methods how you can test your application. Actix provides 
-[*TestServer*](../actix_web/test/struct.TestServer.html)
-server that could be used to run whole application of just specific handlers
-in real http server. *TrstServer::get()*, *TrstServer::post()* or *TrstServer::client()*
-methods could be used to send request to test server.
+There are several methods for testing your application. Actix provides
+[*TestServer*](../actix_web/test/struct.TestServer.html), which can be used
+to run the application with specific handlers in a real http server.
 
-In simple form *TestServer* could be configured to use handler. *TestServer::new* method
-accepts configuration function, only argument for this function is *test application*
-instance. You can check [api documentation](../actix_web/test/struct.TestApp.html)
-for more information.
+`TestServer::get()`, `TestServer::post()`, and `TestServer::client()`
+methods can be used to send requests to the test server.
+
+A simple form `TestServer` can be configured to use a handler.
+`TestServer::new` method accepts a configuration function, and the only argument 
+for this function is a *test application* instance.
+
+> Check the [api documentation](../actix_web/test/struct.TestApp.html) for more information.
 
 ```rust
 # extern crate actix_web;
-use actix_web::*;
+use actix_web::{HttpRequest, HttpResponse, HttpMessage};
 use actix_web::test::TestServer;
 
 fn index(req: HttpRequest) -> HttpResponse {
-     httpcodes::HttpOk.into()
+     HttpResponse::Ok().into()
 }
 
 fn main() {
@@ -73,45 +71,69 @@ fn main() {
 }
 ```
 
-Other option is to use application factory. In this case you need to pass factory function
-same as you use for real http server configuration.
+The other option is to use an application factory. In this case, you need to pass the factory
+function the same way as you would for real http server configuration.
 
 ```rust
-# extern crate http;
 # extern crate actix_web;
-use http::Method;
-use actix_web::*;
-use actix_web::test::TestServer;
+use actix_web::{http, test, App, HttpRequest, HttpResponse};
 
 fn index(req: HttpRequest) -> HttpResponse {
-     httpcodes::HttpOk.into()
+     HttpResponse::Ok().into()
 }
 
 /// This function get called by http server.
-fn create_app() -> Application {
-    Application::new()
+fn create_app() -> App {
+    App::new()
         .resource("/test", |r| r.h(index))
 }
 
 fn main() {
-    let mut srv = TestServer::with_factory(create_app);         // <- Start new test server
+    let mut srv = test::TestServer::with_factory(create_app); // <- Start new test server
 
-    let request = srv.client(Method::GET, "/test").finish().unwrap(); // <- create client request
-    let response = srv.execute(request.send()).unwrap();        // <- send request to the server
+    let request = srv.client(
+         http::Method::GET, "/test").finish().unwrap();       // <- create client request
+    let response = srv.execute(request.send()).unwrap();      // <- send request to the server
 
-    assert!(response.status().is_success());                    // <- check response
+    assert!(response.status().is_success());                  // <- check response
 }
 ```
 
+If you need more complex application configuration, use the `TestServer::build_with_state()`
+method. For example, you may need to initialize application state or start `SyncActor`'s for diesel
+interation. This method accepts a closure that constructs the application state,
+and it runs when the actix system is configured. Thus, you can initialize any additional actors.
+
+```rust,ignore
+#[test]
+fn test() {
+    let srv = TestServer::build_with_state(|| { // <- construct builder with config closure
+        // we can start diesel actors
+        let addr = SyncArbiter::start(3, || {
+            DbExecutor(SqliteConnection::establish("test.db").unwrap())
+        });
+        // then we can construct custom state, or it could be `()`
+        MyState{addr: addr}
+   })
+   .start(|app| {      // <- register server handlers and start test server
+        app.resource(
+            "/{username}/index.html", |r| r.with(
+                |p: Path<PParam>| format!("Welcome {}!", p.username)));
+    });
+    
+    // now we can run our test code
+);
+```
+
 ## WebSocket server tests
 
-It is possible to register *handler* with `TestApp::handler()` method that
-initiate web socket connection. *TestServer* provides `ws()` which connects to
-websocket server and returns ws reader and writer objects. *TestServer* also 
-provides `execute()` method which runs future object to completion and returns
+It is possible to register a *handler* with `TestApp::handler()`, which
+initiates a web socket connection. *TestServer* provides the method `ws()`, which connects to
+the websocket server and returns ws reader and writer objects. *TestServer* also
+provides an `execute()` method, which runs future objects to completion and returns
 result of the future computation.
 
-Here is simple example, that shows how to test server websocket handler.
+The following example demonstrates how to test a websocket handler:
 
 ```rust
 # extern crate actix;
@@ -130,7 +152,7 @@ impl Actor for Ws {
     type Context = ws::WebsocketContext<Self>;
 }
 
-impl StreamHandler<ws::Message, ws::WsError> for Ws {
+impl StreamHandler<ws::Message, ws::ProtocolError> for Ws {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         match msg {
@@ -147,7 +169,7 @@ fn main() {
     let (reader, mut writer) = srv.ws().unwrap();    // <- connect to ws server
 
     writer.text("text");                             // <- send message to server
-    
+
     let (item, reader) = srv.execute(reader.into_future()).unwrap();  // <- wait for one message
     assert_eq!(item, Some(ws::Message::Text("text".to_owned())));
 }

guide/src/qs_9.md

@@ -1,12 +1,12 @@
 # WebSockets
 
-Actix supports WebSockets out-of-the-box. It is possible to convert request's `Payload`
-to a stream of [*ws::Message*](../actix_web/ws/enum.Message.html) with 
+Actix supports WebSockets out-of-the-box. It is possible to convert a request's `Payload`
+to a stream of [*ws::Message*](../actix_web/ws/enum.Message.html) with
 a [*ws::WsStream*](../actix_web/ws/struct.WsStream.html) and then use stream
-combinators to handle actual messages. But it is simpler to handle websocket communications
-with http actor.
+combinators to handle actual messages, but it is simpler to handle websocket communications
+with an http actor.
 
-This is example of simple websocket echo server:
+The following is an example of a simple websocket echo server:
 
 ```rust
 # extern crate actix;
@@ -22,7 +22,7 @@ impl Actor for Ws {
 }
 
 /// Handler for ws::Message message
-impl StreamHandler<ws::Message, ws::WsError> for Ws {
+impl StreamHandler<ws::Message, ws::ProtocolError> for Ws {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         match msg {
@@ -35,14 +35,14 @@ impl StreamHandler<ws::Message, ws::WsError> for Ws {
 }
 
 fn main() {
-    Application::new()
+    App::new()
       .resource("/ws/", |r| r.f(|req| ws::start(req, Ws)))  // <- register websocket route
       .finish();
 }
 ```
 
-Simple websocket echo server example is available in 
-[examples directory](https://github.com/actix/actix-web/blob/master/examples/websocket).
+> A simple websocket echo server example is available in the
+> [examples directory](https://github.com/actix/actix-web/blob/master/examples/websocket).
 
-Example chat server with ability to chat over websocket connection or tcp connection
-is available in [websocket-chat directory](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)
+> An example chat server with the ability to chat over a websocket or tcp connection
+> is available in [websocket-chat directory](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)

src/application.rs

@@ -1,33 +1,37 @@
 use std::mem;
 use std::rc::Rc;
-use std::cell::RefCell;
+use std::cell::UnsafeCell;
 use std::collections::HashMap;
 
+use http::Method;
 use handler::Reply;
-use router::{Router, Pattern};
-use resource::Resource;
-use headers::ContentEncoding;
-use handler::{Handler, RouteHandler, WrapHandler};
+use router::{Router, Resource};
+use resource::{ResourceHandler};
+use header::ContentEncoding;
+use handler::{Handler, RouteHandler, WrapHandler, FromRequest, Responder};
 use httprequest::HttpRequest;
-use pipeline::{Pipeline, PipelineHandler};
+use pipeline::{Pipeline, PipelineHandler, HandlerType};
 use middleware::Middleware;
 use server::{HttpHandler, IntoHttpHandler, HttpHandlerTask, ServerSettings};
 
+#[deprecated(since="0.5.0", note="please use `actix_web::App` instead")]
+pub type Application<S> = App<S>;
+
 /// Application
 pub struct HttpApplication<S=()> {
     state: Rc<S>,
     prefix: String,
+    prefix_len: usize,
     router: Router,
-    inner: Rc<RefCell<Inner<S>>>,
+    inner: Rc<UnsafeCell<Inner<S>>>,
     middlewares: Rc<Vec<Box<Middleware<S>>>>,
 }
 
 pub(crate) struct Inner<S> {
     prefix: usize,
-    default: Resource<S>,
+    default: ResourceHandler<S>,
     encoding: ContentEncoding,
-    router: Router,
-    resources: Vec<Resource<S>>,
+    resources: Vec<ResourceHandler<S>>,
     handlers: Vec<(String, Box<RouteHandler<S>>)>,
 }
 
@@ -37,38 +41,61 @@ impl<S: 'static> PipelineHandler<S> for Inner<S> {
         self.encoding
     }
 
-    fn handle(&mut self, mut req: HttpRequest<S>) -> Reply {
-        if let Some(idx) = self.router.recognize(&mut req) {
-            self.resources[idx].handle(req.clone(), Some(&mut self.default))
+    fn handle(&mut self, req: HttpRequest<S>, htype: HandlerType) -> Reply {
+        match htype {
+            HandlerType::Normal(idx) =>
+                self.resources[idx].handle(req, Some(&mut self.default)),
+            HandlerType::Handler(idx) =>
+                self.handlers[idx].1.handle(req),
+            HandlerType::Default =>
+                self.default.handle(req, None)
+        }
+    }
+}
+
+impl<S: 'static> HttpApplication<S> {
+
+    #[inline]
+    fn as_ref(&self) -> &Inner<S> {
+        unsafe{&*self.inner.get()}
+    }
+
+    #[inline]
+    fn get_handler(&self, req: &mut HttpRequest<S>) -> HandlerType {
+        if let Some(idx) = self.router.recognize(req) {
+            HandlerType::Normal(idx)
         } else {
-            for &mut (ref prefix, ref mut handler) in &mut self.handlers {
+            let inner = self.as_ref();
+            for idx in 0..inner.handlers.len() {
+                let &(ref prefix, _) = &inner.handlers[idx];
                 let m = {
-                    let path = &req.path()[self.prefix..];
-                    path.starts_with(prefix) && (path.len() == prefix.len() ||
-                                                 path.split_at(prefix.len()).1.starts_with('/'))
+                    let path = &req.path()[inner.prefix..];
+                    path.starts_with(prefix) && (
+                        path.len() == prefix.len() ||
+                            path.split_at(prefix.len()).1.starts_with('/'))
                 };
+
                 if m {
                     let path: &'static str = unsafe {
-                        mem::transmute(&req.path()[self.prefix+prefix.len()..]) };
+                        mem::transmute(&req.path()[inner.prefix+prefix.len()..]) };
                     if path.is_empty() {
                         req.match_info_mut().add("tail", "");
                     } else {
                         req.match_info_mut().add("tail", path.split_at(1).1);
                     }
-                    return handler.handle(req)
+                    return HandlerType::Handler(idx)
                 }
             }
-            self.default.handle(req, None)
+            HandlerType::Default
         }
     }
-}
 
-#[cfg(test)]
-impl<S: 'static> HttpApplication<S> {
     #[cfg(test)]
-    pub(crate) fn run(&mut self, req: HttpRequest<S>) -> Reply {
-        self.inner.borrow_mut().handle(req)
+    pub(crate) fn run(&mut self, mut req: HttpRequest<S>) -> Reply {
+        let tp = self.get_handler(&mut req);
+        unsafe{&mut *self.inner.get()}.handle(req, tp)
     }
+
     #[cfg(test)]
     pub(crate) fn prepare_request(&self, req: HttpRequest) -> HttpRequest<S> {
         req.with_state(Rc::clone(&self.state), self.router.clone())
@@ -81,14 +108,14 @@ impl<S: 'static> HttpHandler for HttpApplication<S> {
         let m = {
             let path = req.path();
             path.starts_with(&self.prefix) && (
-                path.len() == self.prefix.len() ||
-                    path.split_at(self.prefix.len()).1.starts_with('/'))
+                path.len() == self.prefix_len ||
+                    path.split_at(self.prefix_len).1.starts_with('/'))
         };
         if m {
+            let mut req = req.with_state(Rc::clone(&self.state), self.router.clone());
+            let tp = self.get_handler(&mut req);
             let inner = Rc::clone(&self.inner);
-            let req = req.with_state(Rc::clone(&self.state), self.router.clone());
-
-            Ok(Box::new(Pipeline::new(req, Rc::clone(&self.middlewares), inner)))
+            Ok(Box::new(Pipeline::new(req, Rc::clone(&self.middlewares), inner, tp)))
         } else {
             Err(req)
         }
@@ -99,30 +126,30 @@ struct ApplicationParts<S> {
     state: S,
     prefix: String,
     settings: ServerSettings,
-    default: Resource<S>,
-    resources: Vec<(Pattern, Option<Resource<S>>)>,
+    default: ResourceHandler<S>,
+    resources: Vec<(Resource, Option<ResourceHandler<S>>)>,
     handlers: Vec<(String, Box<RouteHandler<S>>)>,
-    external: HashMap<String, Pattern>,
+    external: HashMap<String, Resource>,
     encoding: ContentEncoding,
     middlewares: Vec<Box<Middleware<S>>>,
 }
 
-/// Structure that follows the builder pattern for building `Application` structs.
-pub struct Application<S=()> {
+/// Structure that follows the builder pattern for building application instances.
+pub struct App<S=()> {
     parts: Option<ApplicationParts<S>>,
 }
 
-impl Application<()> {
+impl App<()> {
 
-    /// Create application with empty state. Application can
-    /// be configured with builder-like pattern.
-    pub fn new() -> Application<()> {
-        Application {
+   /// Create application with empty state. Application can
+    /// be configured with a builder-like pattern.
+    pub fn new() -> App<()> {
+        App {
             parts: Some(ApplicationParts {
                 state: (),
                 prefix: "/".to_owned(),
                 settings: ServerSettings::default(),
-                default: Resource::default_not_found(),
+                default: ResourceHandler::default_not_found(),
                 resources: Vec::new(),
                 handlers: Vec::new(),
                 external: HashMap::new(),
@@ -133,26 +160,26 @@ impl Application<()> {
     }
 }
 
-impl Default for Application<()> {
+impl Default for App<()> {
     fn default() -> Self {
-        Application::new()
+        App::new()
     }
 }
 
-impl<S> Application<S> where S: 'static {
+impl<S> App<S> where S: 'static {
 
-    /// Create application with specific state. Application can be
-    /// configured with builder-like pattern.
+    /// Create application with specified state. Application can be
+    /// configured with a builder-like pattern.
     ///
-    /// State is shared with all resources within same application and could be
-    /// accessed with `HttpRequest::state()` method.
-    pub fn with_state(state: S) -> Application<S> {
-        Application {
+    /// State is shared with all resources within same application and
+    /// could be accessed with `HttpRequest::state()` method.
+    pub fn with_state(state: S) -> App<S> {
+        App {
             parts: Some(ApplicationParts {
                 state,
                 prefix: "/".to_owned(),
                 settings: ServerSettings::default(),
-                default: Resource::default_not_found(),
+                default: ResourceHandler::default_not_found(),
                 resources: Vec::new(),
                 handlers: Vec::new(),
                 external: HashMap::new(),
@@ -162,34 +189,40 @@ impl<S> Application<S> where S: 'static {
         }
     }
 
-    /// Set application prefix
+    /// Set application prefix.
     ///
-    /// Only requests that matches application's prefix get processed by this application.
-    /// Application prefix always contains leading "/" slash. If supplied prefix
-    /// does not contain leading slash, it get inserted. Prefix should
-    /// consists valid path segments. i.e for application with
-    /// prefix `/app` any request with following paths `/app`, `/app/` or `/app/test`
-    /// would match, but path `/application` would not match.
+    /// Only requests that match the application's prefix get
+    /// processed by this application.
     ///
-    /// In the following example only requests with "/app/" path prefix
-    /// get handled. Request with path "/app/test/" would be handled,
-    /// but request with path "/application" or "/other/..." would return *NOT FOUND*
+    /// The application prefix always contains a leading slash (`/`).
+    /// If the supplied prefix does not contain leading slash, it is
+    /// inserted.
+    ///
+    /// Prefix should consist of valid path segments. i.e for an
+    /// application with the prefix `/app` any request with the paths
+    /// `/app`, `/app/` or `/app/test` would match, but the path
+    /// `/application` would not.
+    ///
+    /// In the following example only requests with an `/app/` path
+    /// prefix get handled. Requests with path `/app/test/` would be
+    /// handled, while requests with the paths `/application` or
+    /// `/other/...` would return `NOT FOUND`.
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// use actix_web::*;
+    /// use actix_web::{http, App, HttpResponse};
     ///
     /// fn main() {
-    ///     let app = Application::new()
+    ///     let app = App::new()
     ///         .prefix("/app")
     ///         .resource("/test", |r| {
-    ///              r.method(Method::GET).f(|_| httpcodes::HttpOk);
-    ///              r.method(Method::HEAD).f(|_| httpcodes::HttpMethodNotAllowed);
+    ///              r.get().f(|_| HttpResponse::Ok());
+    ///              r.head().f(|_| HttpResponse::MethodNotAllowed());
     ///         })
     ///         .finish();
     /// }
     /// ```
-    pub fn prefix<P: Into<String>>(mut self, prefix: P) -> Application<S> {
+    pub fn prefix<P: Into<String>>(mut self, prefix: P) -> App<S> {
         {
             let parts = self.parts.as_mut().expect("Use after finish");
             let mut prefix = prefix.into();
@@ -201,55 +234,113 @@ impl<S> Application<S> where S: 'static {
         self
     }
 
-    /// Configure resource for specific path.
+    /// Configure route for a specific path.
     ///
-    /// Resource may have variable path also. For instance, a resource with
-    /// the path */a/{name}/c* would match all incoming requests with paths
-    /// such as */a/b/c*, */a/1/c*, and */a/etc/c*.
+    /// This is a simplified version of the `App::resource()` method.
+    /// Handler functions need to accept one request extractor
+    /// argument.
     ///
-    /// A variable part is specified in the form `{identifier}`, where
-    /// the identifier can be used later in a request handler to access the matched
-    /// value for that part. This is done by looking up the identifier
-    /// in the `Params` object returned by `HttpRequest.match_info()` method.
-    ///
-    /// By default, each part matches the regular expression `[^{}/]+`.
-    ///
-    /// You can also specify a custom regex in the form `{identifier:regex}`:
-    ///
-    /// For instance, to route Get requests on any route matching `/users/{userid}/{friend}` and
-    /// store userid and friend in the exposed Params object:
+    /// This method could be called multiple times, in that case
+    /// multiple routes would be registered for same resource path.
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// use actix_web::*;
+    /// use actix_web::{http, App, HttpRequest, HttpResponse};
     ///
     /// fn main() {
-    ///     let app = Application::new()
-    ///         .resource("/test", |r| {
-    ///              r.method(Method::GET).f(|_| httpcodes::HttpOk);
-    ///              r.method(Method::HEAD).f(|_| httpcodes::HttpMethodNotAllowed);
-    ///         });
+    ///     let app = App::new()
+    ///         .route("/test", http::Method::GET,
+    ///                |_: HttpRequest| HttpResponse::Ok())
+    ///         .route("/test", http::Method::POST,
+    ///                |_: HttpRequest| HttpResponse::MethodNotAllowed());
     /// }
     /// ```
-    pub fn resource<F>(mut self, path: &str, f: F) -> Application<S>
-        where F: FnOnce(&mut Resource<S>) + 'static
+    pub fn route<T, F, R>(mut self, path: &str, method: Method, f: F) -> App<S>
+        where F: Fn(T) -> R + 'static,
+              R: Responder + 'static,
+              T: FromRequest<S> + 'static,
     {
         {
-            let parts = self.parts.as_mut().expect("Use after finish");
+            let parts: &mut ApplicationParts<S> = unsafe{
+                mem::transmute(self.parts.as_mut().expect("Use after finish"))};
 
-            // add resource
-            let mut resource = Resource::default();
-            f(&mut resource);
+            // get resource handler
+            for &mut (ref pattern, ref mut handler) in &mut parts.resources {
+                if let Some(ref mut handler) = *handler {
+                    if pattern.pattern() == path {
+                        handler.method(method).with(f);
+                        return self
+                    }
+                }
+            }
 
-            let pattern = Pattern::new(resource.get_name(), path);
-            parts.resources.push((pattern, Some(resource)));
+            let mut handler = ResourceHandler::default();
+            handler.method(method).with(f);
+            let pattern = Resource::new(handler.get_name(), path);
+            parts.resources.push((pattern, Some(handler)));
         }
         self
     }
 
-    /// Default resource is used if no matched route could be found.
-    pub fn default_resource<F>(mut self, f: F) -> Application<S>
-        where F: FnOnce(&mut Resource<S>) + 'static
+    /// Configure resource for a specific path.
+    ///
+    /// Resources may have variable path segments. For example, a
+    /// resource with the path `/a/{name}/c` would match all incoming
+    /// requests with paths such as `/a/b/c`, `/a/1/c`, or `/a/etc/c`.
+    ///
+    /// A variable segment is specified in the form `{identifier}`,
+    /// where the identifier can be used later in a request handler to
+    /// access the matched value for that segment. This is done by
+    /// looking up the identifier in the `Params` object returned by
+    /// `HttpRequest.match_info()` method.
+    ///
+    /// By default, each segment matches the regular expression `[^{}/]+`.
+    ///
+    /// You can also specify a custom regex in the form `{identifier:regex}`:
+    ///
+    /// For instance, to route `GET`-requests on any route matching
+    /// `/users/{userid}/{friend}` and store `userid` and `friend` in
+    /// the exposed `Params` object:
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::{http, App, HttpResponse};
+    ///
+    /// fn main() {
+    ///     let app = App::new()
+    ///         .resource("/test", |r| {
+    ///              r.get().f(|_| HttpResponse::Ok());
+    ///              r.head().f(|_| HttpResponse::MethodNotAllowed());
+    ///         });
+    /// }
+    /// ```
+    pub fn resource<F, R>(mut self, path: &str, f: F) -> App<S>
+        where F: FnOnce(&mut ResourceHandler<S>) -> R + 'static
+    {
+        {
+            let parts = self.parts.as_mut().expect("Use after finish");
+
+            // add resource handler
+            let mut handler = ResourceHandler::default();
+            f(&mut handler);
+
+            let pattern = Resource::new(handler.get_name(), path);
+            parts.resources.push((pattern, Some(handler)));
+        }
+        self
+    }
+
+    /// Configure resource for a specific path.
+    #[doc(hidden)]
+    pub fn register_resource(&mut self, path: &str, resource: ResourceHandler<S>) {
+        let pattern = Resource::new(resource.get_name(), path);
+        self.parts.as_mut().expect("Use after finish")
+            .resources.push((pattern, Some(resource)));
+    }
+
+    /// Default resource to be used if no matching route could be found.
+    pub fn default_resource<F, R>(mut self, f: F) -> App<S>
+        where F: FnOnce(&mut ResourceHandler<S>) -> R + 'static
     {
         {
             let parts = self.parts.as_mut().expect("Use after finish");
@@ -259,7 +350,7 @@ impl<S> Application<S> where S: 'static {
     }
 
     /// Set default content encoding. `ContentEncoding::Auto` is set by default.
-    pub fn default_encoding<F>(mut self, encoding: ContentEncoding) -> Application<S>
+    pub fn default_encoding<F>(mut self, encoding: ContentEncoding) -> App<S>
     {
         {
             let parts = self.parts.as_mut().expect("Use after finish");
@@ -268,30 +359,30 @@ impl<S> Application<S> where S: 'static {
         self
     }
 
-    /// Register external resource.
+    /// Register an external resource.
     ///
-    /// External resources are useful for URL generation purposes only and
-    /// are never considered for matching at request time.
-    /// Call to `HttpRequest::url_for()` will work as expected.
+    /// External resources are useful for URL generation purposes only
+    /// and are never considered for matching at request time. Calls to
+    /// `HttpRequest::url_for()` will work as expected.
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// use actix_web::*;
+    /// use actix_web::{App, HttpRequest, HttpResponse, Result};
     ///
     /// fn index(mut req: HttpRequest) -> Result<HttpResponse> {
     ///    let url = req.url_for("youtube", &["oHg5SJYRHA0"])?;
     ///    assert_eq!(url.as_str(), "https://youtube.com/watch/oHg5SJYRHA0");
-    ///    Ok(httpcodes::HttpOk.into())
+    ///    Ok(HttpResponse::Ok().into())
     /// }
     ///
     /// fn main() {
-    ///     let app = Application::new()
-    ///         .resource("/index.html", |r| r.f(index))
+    ///     let app = App::new()
+    ///         .resource("/index.html", |r| r.get().f(index))
     ///         .external_resource("youtube", "https://youtube.com/watch/{video_id}")
     ///         .finish();
     /// }
     /// ```
-    pub fn external_resource<T, U>(mut self, name: T, url: U) -> Application<S>
+    pub fn external_resource<T, U>(mut self, name: T, url: U) -> App<S>
         where T: AsRef<str>, U: AsRef<str>
     {
         {
@@ -301,66 +392,109 @@ impl<S> Application<S> where S: 'static {
                 panic!("External resource {:?} is registered.", name.as_ref());
             }
             parts.external.insert(
-                String::from(name.as_ref()), Pattern::new(name.as_ref(), url.as_ref()));
+                String::from(name.as_ref()),
+                Resource::external(name.as_ref(), url.as_ref()));
         }
         self
     }
 
     /// Configure handler for specific path prefix.
     ///
-    /// Path prefix consists valid path segments. i.e for prefix `/app`
-    /// any request with following paths `/app`, `/app/` or `/app/test`
-    /// would match, but path `/application` would not match.
+    /// A path prefix consists of valid path segments, i.e for the
+    /// prefix `/app` any request with the paths `/app`, `/app/` or
+    /// `/app/test` would match, but the path `/application` would
+    /// not.
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// use actix_web::*;
+    /// use actix_web::{http, App, HttpRequest, HttpResponse};
     ///
     /// fn main() {
-    ///     let app = Application::new()
+    ///     let app = App::new()
     ///         .handler("/app", |req: HttpRequest| {
     ///             match *req.method() {
-    ///                 Method::GET => httpcodes::HttpOk,
-    ///                 Method::POST => httpcodes::HttpMethodNotAllowed,
-    ///                 _ => httpcodes::HttpNotFound,
+    ///                 http::Method::GET => HttpResponse::Ok(),
+    ///                 http::Method::POST => HttpResponse::MethodNotAllowed(),
+    ///                 _ => HttpResponse::NotFound(),
     ///         }});
     /// }
     /// ```
-    pub fn handler<H: Handler<S>>(mut self, path: &str, handler: H) -> Application<S>
+    pub fn handler<H: Handler<S>>(mut self, path: &str, handler: H) -> App<S>
     {
         {
-            let path = path.trim().trim_right_matches('/').to_owned();
+            let mut path = path.trim().trim_right_matches('/').to_owned();
+            if !path.is_empty() && !path.starts_with('/') {
+                path.insert(0, '/')
+            }
             let parts = self.parts.as_mut().expect("Use after finish");
+
             parts.handlers.push((path, Box::new(WrapHandler::new(handler))));
         }
         self
     }
 
-    /// Register a middleware
-    pub fn middleware<M: Middleware<S>>(mut self, mw: M) -> Application<S> {
+    /// Register a middleware.
+    pub fn middleware<M: Middleware<S>>(mut self, mw: M) -> App<S> {
         self.parts.as_mut().expect("Use after finish")
             .middlewares.push(Box::new(mw));
         self
     }
 
-    /// Finish application configuration and create HttpHandler object
+    /// Run external configuration as part of the application building
+    /// process
+    ///
+    /// This function is useful for moving parts of configuration to a
+    /// different module or event library. For example we can move
+    /// some of the resources' configuration to different module.
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::{App, HttpResponse, fs, middleware};
+    ///
+    /// // this function could be located in different module
+    /// fn config(app: App) -> App {
+    ///     app
+    ///         .resource("/test", |r| {
+    ///              r.get().f(|_| HttpResponse::Ok());
+    ///              r.head().f(|_| HttpResponse::MethodNotAllowed());
+    ///         })
+    /// }
+    ///
+    /// fn main() {
+    ///     let app = App::new()
+    ///         .middleware(middleware::Logger::default())
+    ///         .configure(config)  // <- register resources
+    ///         .handler("/static", fs::StaticFiles::new("."));
+    /// }
+    /// ```
+    pub fn configure<F>(self, cfg: F) -> App<S>
+        where F: Fn(App<S>) -> App<S>
+    {
+        cfg(self)
+    }
+
+    /// Finish application configuration and create `HttpHandler` object.
     pub fn finish(&mut self) -> HttpApplication<S> {
         let parts = self.parts.take().expect("Use after finish");
         let prefix = parts.prefix.trim().trim_right_matches('/');
+        let (prefix, prefix_len) = if prefix.is_empty() {
+            ("/".to_owned(), 0)
+        } else {
+            (prefix.to_owned(), prefix.len())
+        };
 
         let mut resources = parts.resources;
         for (_, pattern) in parts.external {
             resources.push((pattern, None));
         }
 
-        let (router, resources) = Router::new(prefix, parts.settings, resources);
+        let (router, resources) = Router::new(&prefix, parts.settings, resources);
 
-        let inner = Rc::new(RefCell::new(
+        let inner = Rc::new(UnsafeCell::new(
             Inner {
-                prefix: prefix.len(),
+                prefix: prefix_len,
                 default: parts.default,
                 encoding: parts.encoding,
-                router: router.clone(),
                 handlers: parts.handlers,
                 resources,
             }
@@ -368,22 +502,23 @@ impl<S> Application<S> where S: 'static {
 
         HttpApplication {
             state: Rc::new(parts.state),
-            prefix: prefix.to_owned(),
             router: router.clone(),
             middlewares: Rc::new(parts.middlewares),
+            prefix,
+            prefix_len,
             inner,
         }
     }
 
-    /// Convenience method for creating `Box<HttpHandler>` instance.
+    /// Convenience method for creating `Box<HttpHandler>` instances.
     ///
-    /// This method is useful if you need to register several application instances
-    /// with different state.
+    /// This method is useful if you need to register multiple
+    /// application instances with different state.
     ///
     /// ```rust
     /// # use std::thread;
     /// # extern crate actix_web;
-    /// use actix_web::*;
+    /// use actix_web::{server, App, HttpResponse};
     ///
     /// struct State1;
     ///
@@ -391,14 +526,14 @@ impl<S> Application<S> where S: 'static {
     ///
     /// fn main() {
     /// # thread::spawn(|| {
-    ///     HttpServer::new(|| { vec![
-    ///         Application::with_state(State1)
+    ///     server::new(|| { vec![
+    ///         App::with_state(State1)
     ///              .prefix("/app1")
-    ///              .resource("/", |r| r.h(httpcodes::HttpOk))
+    ///              .resource("/", |r| r.f(|r| HttpResponse::Ok()))
     ///              .boxed(),
-    ///         Application::with_state(State2)
+    ///         App::with_state(State2)
     ///              .prefix("/app2")
-    ///              .resource("/", |r| r.h(httpcodes::HttpOk))
+    ///              .resource("/", |r| r.f(|r| HttpResponse::Ok()))
     ///              .boxed() ]})
     ///         .bind("127.0.0.1:8080").unwrap()
     ///         .run()
@@ -410,7 +545,7 @@ impl<S> Application<S> where S: 'static {
     }
 }
 
-impl<S: 'static> IntoHttpHandler for Application<S> {
+impl<S: 'static> IntoHttpHandler for App<S> {
     type Handler = HttpApplication<S>;
 
     fn into_handler(mut self, settings: ServerSettings) -> HttpApplication<S> {
@@ -422,7 +557,7 @@ impl<S: 'static> IntoHttpHandler for Application<S> {
     }
 }
 
-impl<'a, S: 'static> IntoHttpHandler for &'a mut Application<S> {
+impl<'a, S: 'static> IntoHttpHandler for &'a mut App<S> {
     type Handler = HttpApplication<S>;
 
     fn into_handler(self, settings: ServerSettings) -> HttpApplication<S> {
@@ -435,7 +570,7 @@ impl<'a, S: 'static> IntoHttpHandler for &'a mut Application<S> {
 }
 
 #[doc(hidden)]
-impl<S: 'static> Iterator for Application<S> {
+impl<S: 'static> Iterator for App<S> {
     type Item = HttpApplication<S>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -454,12 +589,12 @@ mod tests {
     use super::*;
     use test::TestRequest;
     use httprequest::HttpRequest;
-    use httpcodes;
+    use httpresponse::HttpResponse;
 
     #[test]
     fn test_default_resource() {
-        let mut app = Application::new()
-            .resource("/test", |r| r.h(httpcodes::HttpOk))
+        let mut app = App::new()
+            .resource("/test", |r| r.f(|_| HttpResponse::Ok()))
             .finish();
 
         let req = TestRequest::with_uri("/test").finish();
@@ -470,8 +605,8 @@ mod tests {
         let resp = app.run(req);
         assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
 
-        let mut app = Application::new()
-            .default_resource(|r| r.h(httpcodes::HttpMethodNotAllowed))
+        let mut app = App::new()
+            .default_resource(|r| r.f(|_| HttpResponse::MethodNotAllowed()))
             .finish();
         let req = TestRequest::with_uri("/blah").finish();
         let resp = app.run(req);
@@ -480,17 +615,17 @@ mod tests {
 
     #[test]
     fn test_unhandled_prefix() {
-        let mut app = Application::new()
+        let mut app = App::new()
             .prefix("/test")
-            .resource("/test", |r| r.h(httpcodes::HttpOk))
+            .resource("/test", |r| r.f(|_| HttpResponse::Ok()))
             .finish();
         assert!(app.handle(HttpRequest::default()).is_err());
     }
 
     #[test]
     fn test_state() {
-        let mut app = Application::with_state(10)
-            .resource("/", |r| r.h(httpcodes::HttpOk))
+        let mut app = App::with_state(10)
+            .resource("/", |r| r.f(|_| HttpResponse::Ok()))
             .finish();
         let req = HttpRequest::default().with_state(Rc::clone(&app.state), app.router.clone());
         let resp = app.run(req);
@@ -499,9 +634,9 @@ mod tests {
 
     #[test]
     fn test_prefix() {
-        let mut app = Application::new()
+        let mut app = App::new()
             .prefix("/test")
-            .resource("/blah", |r| r.h(httpcodes::HttpOk))
+            .resource("/blah", |r| r.f(|_| HttpResponse::Ok()))
             .finish();
         let req = TestRequest::with_uri("/test").finish();
         let resp = app.handle(req);
@@ -522,8 +657,8 @@ mod tests {
 
     #[test]
     fn test_handler() {
-        let mut app = Application::new()
-            .handler("/test", httpcodes::HttpOk)
+        let mut app = App::new()
+            .handler("/test", |_| HttpResponse::Ok())
             .finish();
 
         let req = TestRequest::with_uri("/test").finish();
@@ -547,11 +682,86 @@ mod tests {
         assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
     }
 
+    #[test]
+    fn test_handler2() {
+        let mut app = App::new()
+            .handler("test", |_| HttpResponse::Ok())
+            .finish();
+
+        let req = TestRequest::with_uri("/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test/").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test/app").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/testapp").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let req = TestRequest::with_uri("/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+    }
+
+    #[test]
+    fn test_handler_with_prefix() {
+        let mut app = App::new()
+            .prefix("prefix")
+            .handler("/test", |_| HttpResponse::Ok())
+            .finish();
+
+        let req = TestRequest::with_uri("/prefix/test").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/prefix/test/").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/prefix/test/app").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/prefix/testapp").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+
+        let req = TestRequest::with_uri("/prefix/blah").finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+    }
+
+    #[test]
+    fn test_route() {
+        let mut app = App::new()
+            .route("/test", Method::GET, |_: HttpRequest| HttpResponse::Ok())
+            .route("/test", Method::POST, |_: HttpRequest| HttpResponse::Created())
+            .finish();
+
+        let req = TestRequest::with_uri("/test").method(Method::GET).finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::OK);
+
+        let req = TestRequest::with_uri("/test").method(Method::POST).finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::CREATED);
+
+        let req = TestRequest::with_uri("/test").method(Method::HEAD).finish();
+        let resp = app.run(req);
+        assert_eq!(resp.as_response().unwrap().status(), StatusCode::NOT_FOUND);
+    }
+
     #[test]
     fn test_handler_prefix() {
-        let mut app = Application::new()
+        let mut app = App::new()
             .prefix("/app")
-            .handler("/test", httpcodes::HttpOk)
+            .handler("/test", |_| HttpResponse::Ok())
             .finish();
 
         let req = TestRequest::with_uri("/test").finish();

src/body.rs

@@ -6,6 +6,10 @@ use futures::Stream;
 
 use error::Error;
 use context::ActorHttpContext;
+use handler::Responder;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+
 
 /// Type represent streaming body
 pub type BodyStream = Box<Stream<Item=Bytes, Error=Error>>;
@@ -36,6 +40,8 @@ pub enum Binary {
     /// Shared string body
     #[doc(hidden)]
     ArcSharedString(Arc<String>),
+    /// Shared vec body
+    SharedVec(Arc<Vec<u8>>),
 }
 
 impl Body {
@@ -115,6 +121,7 @@ impl Binary {
             Binary::Slice(slice) => slice.len(),
             Binary::SharedString(ref s) => s.len(),
             Binary::ArcSharedString(ref s) => s.len(),
+            Binary::SharedVec(ref s) => s.len(),
         }
     }
 
@@ -134,8 +141,9 @@ impl Clone for Binary {
         match *self {
             Binary::Bytes(ref bytes) => Binary::Bytes(bytes.clone()),
             Binary::Slice(slice) => Binary::Bytes(Bytes::from(slice)),
-            Binary::SharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
-            Binary::ArcSharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
+            Binary::SharedString(ref s) => Binary::SharedString(s.clone()),
+            Binary::ArcSharedString(ref s) => Binary::ArcSharedString(s.clone()),
+            Binary::SharedVec(ref s) => Binary::SharedVec(s.clone()),
         }
     }
 }
@@ -147,6 +155,7 @@ impl Into<Bytes> for Binary {
             Binary::Slice(slice) => Bytes::from(slice),
             Binary::SharedString(s) => Bytes::from(s.as_str()),
             Binary::ArcSharedString(s) => Bytes::from(s.as_str()),
+            Binary::SharedVec(s) => Bytes::from(AsRef::<[u8]>::as_ref(s.as_ref())),
         }
     }
 }
@@ -217,17 +226,42 @@ impl<'a> From<&'a Arc<String>> for Binary {
     }
 }
 
+impl From<Arc<Vec<u8>>> for Binary {
+    fn from(body: Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(body)
+    }
+}
+
+impl<'a> From<&'a Arc<Vec<u8>>> for Binary {
+    fn from(body: &'a Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(Arc::clone(body))
+    }
+}
+
 impl AsRef<[u8]> for Binary {
+    #[inline]
     fn as_ref(&self) -> &[u8] {
         match *self {
             Binary::Bytes(ref bytes) => bytes.as_ref(),
             Binary::Slice(slice) => slice,
             Binary::SharedString(ref s) => s.as_bytes(),
             Binary::ArcSharedString(ref s) => s.as_bytes(),
+            Binary::SharedVec(ref s) => s.as_ref().as_ref(),
         }
     }
 }
 
+impl Responder for Binary {
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(HttpResponse::Ok()
+           .content_type("application/octet-stream")
+           .body(self))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -247,68 +281,77 @@ mod tests {
     #[test]
     fn test_static_str() {
         assert_eq!(Binary::from("test").len(), 4);
-        assert_eq!(Binary::from("test").as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from("test").as_ref(), b"test");
     }
 
     #[test]
     fn test_static_bytes() {
         assert_eq!(Binary::from(b"test".as_ref()).len(), 4);
-        assert_eq!(Binary::from(b"test".as_ref()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b"test".as_ref()).as_ref(), b"test");
         assert_eq!(Binary::from_slice(b"test".as_ref()).len(), 4);
-        assert_eq!(Binary::from_slice(b"test".as_ref()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from_slice(b"test".as_ref()).as_ref(), b"test");
     }
 
     #[test]
     fn test_vec() {
         assert_eq!(Binary::from(Vec::from("test")).len(), 4);
-        assert_eq!(Binary::from(Vec::from("test")).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Vec::from("test")).as_ref(), b"test");
     }
 
     #[test]
     fn test_bytes() {
         assert_eq!(Binary::from(Bytes::from("test")).len(), 4);
-        assert_eq!(Binary::from(Bytes::from("test")).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(Bytes::from("test")).as_ref(), b"test");
     }
 
     #[test]
     fn test_ref_string() {
         let b = Rc::new("test".to_owned());
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_rc_string() {
         let b = Rc::new("test".to_owned());
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_arc_string() {
         let b = Arc::new("test".to_owned());
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
     }
 
     #[test]
     fn test_string() {
         let b = "test".to_owned();
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b.clone()).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b.clone()).as_ref(), b"test");
         assert_eq!(Binary::from(&b).len(), 4);
-        assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(&b).as_ref(), b"test");
+    }
+
+    #[test]
+    fn test_shared_vec() {
+        let b = Arc::new(Vec::from(&b"test"[..]));
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b.clone()).as_ref(), &b"test"[..]);
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), &b"test"[..]);
     }
 
     #[test]
     fn test_bytes_mut() {
         let b =  BytesMut::from("test");
         assert_eq!(Binary::from(b.clone()).len(), 4);
-        assert_eq!(Binary::from(b).as_ref(), "test".as_bytes());
+        assert_eq!(Binary::from(b).as_ref(), b"test");
     }
 
     #[test]

src/client/mod.rs

@@ -1,4 +1,31 @@
-//! Http client
+//! Http client api
+//!
+//! ```rust
+//! # extern crate actix;
+//! # extern crate actix_web;
+//! # extern crate futures;
+//! # use futures::Future;
+//! use actix_web::client;
+//!
+//! fn main() {
+//!     let sys = actix::System::new("test");
+//!
+//!     actix::Arbiter::handle().spawn({
+//!         client::get("http://www.rust-lang.org")   // <- Create request builder
+//!             .header("User-Agent", "Actix-web")
+//!             .finish().unwrap()
+//!             .send()                               // <- Send http request
+//!             .map_err(|_| ())
+//!             .and_then(|response| {                // <- server http response
+//!                 println!("Response: {:?}", response);
+//! #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+//!                 Ok(())
+//!             })
+//!     });
+//!
+//!     sys.run();
+//! }
+//! ```
 mod connector;
 mod parser;
 mod request;
@@ -9,6 +36,86 @@ mod writer;
 pub use self::pipeline::{SendRequest, SendRequestError};
 pub use self::request::{ClientRequest, ClientRequestBuilder};
 pub use self::response::ClientResponse;
-pub use self::connector::{Connect, Connection, ClientConnector, ClientConnectorError};
+pub use self::connector::{
+    Connect, Pause, Resume,
+    Connection, ClientConnector, ClientConnectorError};
 pub(crate) use self::writer::HttpClientWriter;
 pub(crate) use self::parser::{HttpResponseParser, HttpResponseParserError};
+
+use error::ResponseError;
+use http::Method;
+use httpresponse::HttpResponse;
+
+
+/// Convert `SendRequestError` to a `HttpResponse`
+impl ResponseError for SendRequestError {
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            SendRequestError::Connector(_) => HttpResponse::BadGateway(),
+            _ => HttpResponse::InternalServerError(),
+        }
+        .into()
+    }
+}
+
+/// Create request builder for `GET` requests
+///
+/// ```rust
+/// # extern crate actix;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::Future;
+/// use actix_web::client;
+///
+/// fn main() {
+///     let sys = actix::System::new("test");
+///
+///     actix::Arbiter::handle().spawn({
+///         client::get("http://www.rust-lang.org")   // <- Create request builder
+///             .header("User-Agent", "Actix-web")
+///             .finish().unwrap()
+///             .send()                               // <- Send http request
+///             .map_err(|_| ())
+///             .and_then(|response| {  // <- server http response
+///                 println!("Response: {:?}", response);
+/// #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+///                 Ok(())
+///             })
+///     });
+///
+///     sys.run();
+/// }
+/// ```
+pub fn get<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::GET).uri(uri);
+    builder
+}
+
+/// Create request builder for `HEAD` requests
+pub fn head<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::HEAD).uri(uri);
+    builder
+}
+
+/// Create request builder for `POST` requests
+pub fn post<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::POST).uri(uri);
+    builder
+}
+
+/// Create request builder for `PUT` requests
+pub fn put<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::PUT).uri(uri);
+    builder
+}
+
+/// Create request builder for `DELETE` requests
+pub fn delete<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
+    let mut builder = ClientRequest::build();
+    builder.method(Method::DELETE).uri(uri);
+    builder
+}

src/client/parser.rs

@@ -2,7 +2,7 @@ use std::mem;
 use httparse;
 use http::{Version, HttpTryFrom, HeaderMap, StatusCode};
 use http::header::{self, HeaderName, HeaderValue};
-use bytes::{Bytes, BytesMut, BufMut};
+use bytes::{Bytes, BytesMut};
 use futures::{Poll, Async};
 
 use error::{ParseError, PayloadError};
@@ -37,25 +37,22 @@ impl HttpResponseParser {
         where T: IoStream
     {
         // if buf is empty parse_message will always return NotReady, let's avoid that
-        let read = if buf.is_empty() {
+        if buf.is_empty() {
             match utils::read_from_io(io, buf) {
-                Ok(Async::Ready(0)) => {
-                    // debug!("Ignored premature client disconnection");
-                    return Err(HttpResponseParserError::Disconnect);
-                },
+                Ok(Async::Ready(0)) =>
+                    return Err(HttpResponseParserError::Disconnect),
                 Ok(Async::Ready(_)) => (),
                 Ok(Async::NotReady) =>
                     return Ok(Async::NotReady),
                 Err(err) =>
                     return Err(HttpResponseParserError::Error(err.into()))
             }
-            false
-        } else {
-            true
-        };
+        }
 
         loop {
-            match HttpResponseParser::parse_message(buf).map_err(HttpResponseParserError::Error)? {
+            match HttpResponseParser::parse_message(buf)
+                .map_err(HttpResponseParserError::Error)?
+            {
                 Async::Ready((msg, decoder)) => {
                     self.decoder = decoder;
                     return Ok(Async::Ready(msg));
@@ -64,15 +61,13 @@ impl HttpResponseParser {
                     if buf.capacity() >= MAX_BUFFER_SIZE {
                         return Err(HttpResponseParserError::Error(ParseError::TooLarge));
                     }
-                    if read || buf.remaining_mut() == 0 {
-                        match utils::read_from_io(io, buf) {
-                            Ok(Async::Ready(0)) => return Err(HttpResponseParserError::Disconnect),
-                            Ok(Async::Ready(_)) => (),
-                            Ok(Async::NotReady) => return Ok(Async::NotReady),
-                            Err(err) => return Err(HttpResponseParserError::Error(err.into())),
-                        }
-                    } else {
-                        return Ok(Async::NotReady)
+                    match utils::read_from_io(io, buf) {
+                        Ok(Async::Ready(0)) =>
+                            return Err(HttpResponseParserError::Disconnect),
+                        Ok(Async::Ready(_)) => (),
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Err(err) =>
+                            return Err(HttpResponseParserError::Error(err.into())),
                     }
                 },
             }
@@ -84,32 +79,42 @@ impl HttpResponseParser {
         where T: IoStream
     {
         if self.decoder.is_some() {
-            // read payload
-            match utils::read_from_io(io, buf) {
-                Ok(Async::Ready(0)) => {
-                    if buf.is_empty() {
-                        return Err(PayloadError::Incomplete)
+            loop {
+                // read payload
+                let not_ready = match utils::read_from_io(io, buf) {
+                    Ok(Async::Ready(0)) => {
+                        if buf.is_empty() {
+                            return Err(PayloadError::Incomplete)
+                        }
+                        true
                     }
-                }
-                Err(err) => return Err(err.into()),
-                _ => (),
-            }
+                    Err(err) => return Err(err.into()),
+                    Ok(Async::NotReady) => true,
+                    _ => false,
+                };
 
-            match self.decoder.as_mut().unwrap().decode(buf) {
-                Ok(Async::Ready(Some(b))) => Ok(Async::Ready(Some(b))),
-                Ok(Async::Ready(None)) => {
-                    self.decoder.take();
-                    Ok(Async::Ready(None))
+                match self.decoder.as_mut().unwrap().decode(buf) {
+                    Ok(Async::Ready(Some(b))) =>
+                        return Ok(Async::Ready(Some(b))),
+                    Ok(Async::Ready(None)) => {
+                        self.decoder.take();
+                        return Ok(Async::Ready(None))
+                    }
+                    Ok(Async::NotReady) => {
+                        if not_ready {
+                            return Ok(Async::NotReady)
+                        }
+                    }
+                    Err(err) => return Err(err.into()),
                 }
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Err(err) => Err(err.into()),
             }
         } else {
             Ok(Async::Ready(None))
         }
     }
 
-    fn parse_message(buf: &mut BytesMut) -> Poll<(ClientResponse, Option<Decoder>), ParseError>
+    fn parse_message(buf: &mut BytesMut)
+                     -> Poll<(ClientResponse, Option<Decoder>), ParseError>
     {
         // Parse http message
         let bytes_ptr = buf.as_ref().as_ptr() as usize;
@@ -121,7 +126,7 @@ impl HttpResponseParser {
             let mut resp = httparse::Response::new(&mut headers);
             match resp.parse(b)? {
                 httparse::Status::Complete(len) => {
-                    let version = if resp.version.unwrap() == 1 {
+                    let version = if resp.version.unwrap_or(1) == 1 {
                         Version::HTTP_11
                     } else {
                         Version::HTTP_10

src/client/pipeline.rs

@@ -1,15 +1,17 @@
 use std::{io, mem};
+use std::time::Duration;
 use bytes::{Bytes, BytesMut};
 use http::header::CONTENT_ENCODING;
 use futures::{Async, Future, Poll};
 use futures::unsync::oneshot;
+use tokio_core::reactor::Timeout;
 
 use actix::prelude::*;
 
 use error::Error;
 use body::{Body, BodyStream};
 use context::{Frame, ActorHttpContext};
-use headers::ContentEncoding;
+use header::ContentEncoding;
 use httpmessage::HttpMessage;
 use error::PayloadError;
 use server::WriterState;
@@ -20,9 +22,12 @@ use super::{Connect, Connection, ClientConnector, ClientConnectorError};
 use super::HttpClientWriter;
 use super::{HttpResponseParser, HttpResponseParserError};
 
-/// A set of errors that can occur during sending request and reading response
+/// A set of errors that can occur during request sending and response reading
 #[derive(Fail, Debug)]
 pub enum SendRequestError {
+    /// Response took too long
+    #[fail(display = "Timeout while waiting for response")]
+    Timeout,
     /// Failed to connect to host
     #[fail(display="Failed to connect to host: {}", _0)]
     Connector(#[cause] ClientConnectorError),
@@ -40,6 +45,15 @@ impl From<io::Error> for SendRequestError {
     }
 }
 
+impl From<ClientConnectorError> for SendRequestError {
+    fn from(err: ClientConnectorError) -> SendRequestError {
+        match err {
+            ClientConnectorError::Timeout => SendRequestError::Timeout,
+            _ => SendRequestError::Connector(err),
+        }
+    }
+}
+
 enum State {
     New,
     Connect(actix::dev::Request<Unsync, ClientConnector, Connect>),
@@ -48,12 +62,16 @@ enum State {
     None,
 }
 
-/// `SendRequest` is a `Future` which represents asynchronous request sending process.
+/// `SendRequest` is a `Future` which represents an asynchronous
+/// request sending process.
 #[must_use = "SendRequest does nothing unless polled"]
 pub struct SendRequest {
     req: ClientRequest,
     state: State,
     conn: Addr<Unsync, ClientConnector>,
+    conn_timeout: Duration,
+    wait_timeout: Duration,
+    timeout: Option<Timeout>,
 }
 
 impl SendRequest {
@@ -64,15 +82,51 @@ impl SendRequest {
     pub(crate) fn with_connector(req: ClientRequest, conn: Addr<Unsync, ClientConnector>)
                                  -> SendRequest
     {
-        SendRequest{req, conn, state: State::New}
+        SendRequest{req, conn,
+                    state: State::New,
+                    timeout: None,
+                    wait_timeout: Duration::from_secs(5),
+                    conn_timeout: Duration::from_secs(1),
+        }
     }
 
     pub(crate) fn with_connection(req: ClientRequest, conn: Connection) -> SendRequest
     {
-        SendRequest{
-            req,
-            state: State::Connection(conn),
-            conn: ClientConnector::from_registry()}
+        SendRequest{req,
+                    state: State::Connection(conn),
+                    conn: ClientConnector::from_registry(),
+                    timeout: None,
+                    wait_timeout: Duration::from_secs(5),
+                    conn_timeout: Duration::from_secs(1),
+        }
+    }
+
+    /// Set request timeout
+    ///
+    /// Request timeout is the total time before a response must be received.
+    /// Default value is 5 seconds.
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(Timeout::new(timeout, Arbiter::handle()).unwrap());
+        self
+    }
+
+    /// Set connection timeout
+    ///
+    /// Connection timeout includes resolving hostname and actual connection to
+    /// the host.
+    /// Default value is 1 second.
+    pub fn conn_timeout(mut self, timeout: Duration) -> Self {
+        self.conn_timeout = timeout;
+        self
+    }
+
+    /// Set wait timeout
+    ///
+    /// If connections pool limits are enabled, wait time indicates max time
+    /// to wait for available connection. Default value is 5 seconds.
+    pub fn wait_timeout(mut self, timeout: Duration) -> Self {
+        self.wait_timeout = timeout;
+        self
     }
 }
 
@@ -86,7 +140,11 @@ impl Future for SendRequest {
 
             match state {
                 State::New =>
-                    self.state = State::Connect(self.conn.send(Connect(self.req.uri().clone()))),
+                    self.state = State::Connect(self.conn.send(Connect {
+                        uri: self.req.uri().clone(),
+                        wait_timeout: self.wait_timeout,
+                        conn_timeout: self.conn_timeout,
+                    })),
                 State::Connect(mut conn) => match conn.poll() {
                     Ok(Async::NotReady) => {
                         self.state = State::Connect(conn);
@@ -96,7 +154,7 @@ impl Future for SendRequest {
                         Ok(stream) => {
                             self.state = State::Connection(stream)
                         },
-                        Err(err) => return Err(SendRequestError::Connector(err)),
+                        Err(err) => return Err(err.into()),
                     },
                     Err(_) => return Err(SendRequestError::Connector(
                         ClientConnectorError::Disconnected))
@@ -111,8 +169,13 @@ impl Future for SendRequest {
                         _ => IoBody::Done,
                     };
 
-                    let mut pl = Box::new(Pipeline {
-                        body, conn, writer,
+                    let timeout = self.timeout.take().unwrap_or_else(||
+                        Timeout::new(
+                            Duration::from_secs(5), Arbiter::handle()).unwrap());
+
+                    let pl = Box::new(Pipeline {
+                        body, writer,
+                        conn: Some(conn),
                         parser: Some(HttpResponseParser::default()),
                         parser_buf: BytesMut::new(),
                         disconnected: false,
@@ -120,6 +183,7 @@ impl Future for SendRequest {
                         decompress: None,
                         should_decompress: self.req.response_decompress(),
                         write_state: RunningState::Running,
+                        timeout: Some(timeout),
                     });
                     self.state = State::Send(pl);
                 },
@@ -149,7 +213,7 @@ impl Future for SendRequest {
 
 pub(crate) struct Pipeline {
     body: IoBody,
-    conn: Connection,
+    conn: Option<Connection>,
     writer: HttpClientWriter,
     parser: Option<HttpResponseParser>,
     parser_buf: BytesMut,
@@ -158,6 +222,7 @@ pub(crate) struct Pipeline {
     decompress: Option<PayloadStream>,
     should_decompress: bool,
     write_state: RunningState,
+    timeout: Option<Timeout>,
 }
 
 enum IoBody {
@@ -190,44 +255,63 @@ impl RunningState {
 
 impl Pipeline {
 
+    fn release_conn(&mut self) {
+        if let Some(conn) = self.conn.take() {
+            conn.release()
+        }
+    }
+
     #[inline]
-    pub fn parse(&mut self) -> Poll<ClientResponse, HttpResponseParserError> {
-        match self.parser.as_mut().unwrap().parse(&mut self.conn, &mut self.parser_buf) {
-            Ok(Async::Ready(resp)) => {
-                // check content-encoding
-                if self.should_decompress {
-                    if let Some(enc) = resp.headers().get(CONTENT_ENCODING) {
-                        if let Ok(enc) = enc.to_str() {
-                            match ContentEncoding::from(enc) {
-                                ContentEncoding::Auto | ContentEncoding::Identity => (),
-                                enc => self.decompress = Some(PayloadStream::new(enc)),
+    fn parse(&mut self) -> Poll<ClientResponse, HttpResponseParserError> {
+        if let Some(ref mut conn) = self.conn {
+            match self.parser.as_mut().unwrap().parse(conn, &mut self.parser_buf) {
+                Ok(Async::Ready(resp)) => {
+                    // check content-encoding
+                    if self.should_decompress {
+                        if let Some(enc) = resp.headers().get(CONTENT_ENCODING) {
+                            if let Ok(enc) = enc.to_str() {
+                                match ContentEncoding::from(enc) {
+                                    ContentEncoding::Auto | ContentEncoding::Identity => (),
+                                    enc => self.decompress = Some(PayloadStream::new(enc)),
+                                }
                             }
                         }
                     }
-                }
 
-                Ok(Async::Ready(resp))
+                    Ok(Async::Ready(resp))
+                }
+                val => val,
             }
-            val => val,
+        } else {
+            Ok(Async::NotReady)
         }
     }
 
     #[inline]
     pub fn poll(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        if self.conn.is_none() {
+            return Ok(Async::Ready(None))
+        }
+        let conn: &mut Connection = unsafe{ mem::transmute(self.conn.as_mut().unwrap())};
+
         let mut need_run = false;
 
         // need write?
-        if let Async::NotReady = self.poll_write()
+        match self.poll_write()
             .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?
         {
-            need_run = true;
+            Async::NotReady => need_run = true,
+            Async::Ready(_) => {
+                let _ = self.poll_timeout()
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?;
+            }
         }
 
         // need read?
         if self.parser.is_some() {
             loop {
                 match self.parser.as_mut().unwrap()
-                    .parse_payload(&mut self.conn, &mut self.parser_buf)?
+                    .parse_payload(conn, &mut self.parser_buf)?
                 {
                     Async::Ready(Some(b)) => {
                         if let Some(ref mut decompress) = self.decompress {
@@ -255,6 +339,7 @@ impl Pipeline {
         if let Some(mut decompress) = self.decompress.take() {
             let res = decompress.feed_eof();
             if let Some(b) = res? {
+                self.release_conn();
                 return Ok(Async::Ready(Some(b)))
             }
         }
@@ -262,18 +347,30 @@ impl Pipeline {
         if need_run {
             Ok(Async::NotReady)
         } else {
+            self.release_conn();
             Ok(Async::Ready(None))
         }
     }
 
+    fn poll_timeout(&mut self) -> Poll<(), SendRequestError> {
+        if self.timeout.is_some() {
+            match self.timeout.as_mut().unwrap().poll() {
+                Ok(Async::Ready(())) => Err(SendRequestError::Timeout),
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(_) => unreachable!()
+            }
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
     #[inline]
-    pub fn poll_write(&mut self) -> Poll<(), Error> {
-        if self.write_state == RunningState::Done {
+    fn poll_write(&mut self) -> Poll<(), Error> {
+        if self.write_state == RunningState::Done || self.conn.is_none() {
             return Ok(Async::Ready(()))
         }
 
         let mut done = false;
-
         if self.drain.is_none() && self.write_state != RunningState::Paused {
             'outter: loop {
                 let result = match mem::replace(&mut self.body, IoBody::Done) {
@@ -357,7 +454,7 @@ impl Pipeline {
         }
 
         // flush io but only if we need to
-        match self.writer.poll_completed(&mut self.conn, false) {
+        match self.writer.poll_completed(self.conn.as_mut().unwrap(), false) {
             Ok(Async::Ready(_)) => {
                 if self.disconnected {
                     self.write_state = RunningState::Done;
@@ -381,3 +478,11 @@ impl Pipeline {
         }
     }
 }
+
+impl Drop for Pipeline {
+    fn drop(&mut self) {
+        if let Some(conn) = self.conn.take() {
+            conn.close()
+        }
+    }
+}

src/client/request.rs

@@ -1,21 +1,55 @@
 use std::{fmt, mem};
+use std::fmt::Write as FmtWrite;
 use std::io::Write;
+use std::time::Duration;
 
 use actix::{Addr, Unsync};
 use cookie::{Cookie, CookieJar};
-use bytes::{BytesMut, BufMut};
-use http::{uri, HeaderMap, Method, Version, Uri, HttpTryFrom, Error as HttpError};
-use http::header::{self, HeaderName, HeaderValue};
+use bytes::{Bytes, BytesMut, BufMut};
+use futures::Stream;
 use serde_json;
 use serde::Serialize;
+use url::Url;
+use percent_encoding::{USERINFO_ENCODE_SET, percent_encode};
 
 use body::Body;
 use error::Error;
-use headers::ContentEncoding;
+use header::{ContentEncoding, Header, IntoHeaderValue};
+use httpmessage::HttpMessage;
+use httprequest::HttpRequest;
+use http::{uri, HeaderMap, Method, Version, Uri, HttpTryFrom, Error as HttpError};
+use http::header::{self, HeaderName, HeaderValue};
 use super::pipeline::SendRequest;
 use super::connector::{Connection, ClientConnector};
 
 /// An HTTP Client Request
+///
+/// ```rust
+/// # extern crate actix;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::Future;
+/// use actix_web::client::ClientRequest;
+///
+/// fn main() {
+///     let sys = actix::System::new("test");
+///
+///     actix::Arbiter::handle().spawn({
+///         ClientRequest::get("http://www.rust-lang.org") // <- Create request builder
+///             .header("User-Agent", "Actix-web")
+///             .finish().unwrap()
+///             .send()                                    // <- Send http request
+///             .map_err(|_| ())
+///             .and_then(|response| {  // <- server http response
+///                 println!("Response: {:?}", response);
+/// #               actix::Arbiter::system().do_send(actix::msgs::SystemExit(0));
+///                 Ok(())
+///             })
+///     });
+///
+///     sys.run();
+/// }
+/// ```
 pub struct ClientRequest {
     uri: Uri,
     method: Method,
@@ -24,11 +58,11 @@ pub struct ClientRequest {
     body: Body,
     chunked: bool,
     upgrade: bool,
+    timeout: Option<Duration>,
     encoding: ContentEncoding,
     response_decompress: bool,
-    buffer_capacity: Option<(usize, usize)>,
+    buffer_capacity: usize,
     conn: ConnectionType,
-
 }
 
 enum ConnectionType {
@@ -48,9 +82,10 @@ impl Default for ClientRequest {
             body: Body::Empty,
             chunked: false,
             upgrade: false,
+            timeout: None,
             encoding: ContentEncoding::Auto,
             response_decompress: true,
-            buffer_capacity: None,
+            buffer_capacity: 32_768,
             conn: ConnectionType::Default,
         }
     }
@@ -59,35 +94,35 @@ impl Default for ClientRequest {
 impl ClientRequest {
 
     /// Create request builder for `GET` request
-    pub fn get<U>(uri: U) -> ClientRequestBuilder where Uri: HttpTryFrom<U> {
+    pub fn get<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
         let mut builder = ClientRequest::build();
         builder.method(Method::GET).uri(uri);
         builder
     }
 
     /// Create request builder for `HEAD` request
-    pub fn head<U>(uri: U) -> ClientRequestBuilder where Uri: HttpTryFrom<U> {
+    pub fn head<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
         let mut builder = ClientRequest::build();
         builder.method(Method::HEAD).uri(uri);
         builder
     }
 
     /// Create request builder for `POST` request
-    pub fn post<U>(uri: U) -> ClientRequestBuilder where Uri: HttpTryFrom<U> {
+    pub fn post<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
         let mut builder = ClientRequest::build();
         builder.method(Method::POST).uri(uri);
         builder
     }
 
     /// Create request builder for `PUT` request
-    pub fn put<U>(uri: U) -> ClientRequestBuilder where Uri: HttpTryFrom<U> {
+    pub fn put<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
         let mut builder = ClientRequest::build();
         builder.method(Method::PUT).uri(uri);
         builder
     }
 
     /// Create request builder for `DELETE` request
-    pub fn delete<U>(uri: U) -> ClientRequestBuilder where Uri: HttpTryFrom<U> {
+    pub fn delete<U: AsRef<str>>(uri: U) -> ClientRequestBuilder {
         let mut builder = ClientRequest::build();
         builder.method(Method::DELETE).uri(uri);
         builder
@@ -102,17 +137,22 @@ impl ClientRequest {
             request: Some(ClientRequest::default()),
             err: None,
             cookies: None,
-            default_headers: true,
+            default_headers: true
         }
     }
 
-    /// Get the request uri
+    /// Create client request builder
+    pub fn build_from<T: Into<ClientRequestBuilder>>(source: T) -> ClientRequestBuilder {
+        source.into()
+    }
+
+    /// Get the request URI
     #[inline]
     pub fn uri(&self) -> &Uri {
         &self.uri
     }
 
-    /// Set client request uri
+    /// Set client request URI
     #[inline]
     pub fn set_uri(&mut self, uri: Uri) {
         self.uri = uri
@@ -124,13 +164,13 @@ impl ClientRequest {
         &self.method
     }
 
-    /// Set http `Method` for the request
+    /// Set HTTP `Method` for the request
     #[inline]
     pub fn set_method(&mut self, method: Method) {
         self.method = method
     }
 
-    /// Get http version for the request
+    /// Get HTTP version for the request
     #[inline]
     pub fn version(&self) -> Version {
         self.version
@@ -178,11 +218,12 @@ impl ClientRequest {
         self.response_decompress
     }
 
-    pub fn buffer_capacity(&self) -> Option<(usize, usize)> {
+    /// Requested write buffer capacity
+    pub fn write_buffer_capacity(&self) -> usize {
         self.buffer_capacity
     }
-    
-    /// Get body os this response
+
+    /// Get body of this response
     #[inline]
     pub fn body(&self) -> &Body {
         &self.body
@@ -193,41 +234,41 @@ impl ClientRequest {
         self.body = body.into();
     }
 
-    /// Extract body, replace it with Empty
+    /// Extract body, replace it with `Empty`
     pub(crate) fn replace_body(&mut self, body: Body) -> Body {
         mem::replace(&mut self.body, body)
     }
 
     /// Send request
     ///
-    /// This method returns future that resolves to a ClientResponse
+    /// This method returns a future that resolves to a ClientResponse
     pub fn send(mut self) -> SendRequest {
-        match mem::replace(&mut self.conn, ConnectionType::Default) {
+        let timeout = self.timeout.take();
+        let send = match mem::replace(&mut self.conn, ConnectionType::Default) {
             ConnectionType::Default => SendRequest::new(self),
             ConnectionType::Connector(conn) => SendRequest::with_connector(self, conn),
             ConnectionType::Connection(conn) => SendRequest::with_connection(self, conn),
+        };
+        if let Some(timeout) = timeout {
+            send.timeout(timeout)
+        } else {
+            send
         }
     }
 }
 
 impl fmt::Debug for ClientRequest {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let res = write!(f, "\nClientRequest {:?} {}:{}\n",
+        let res = writeln!(f, "\nClientRequest {:?} {}:{}",
                          self.version, self.method, self.uri);
-        let _ = write!(f, "  headers:\n");
-        for key in self.headers.keys() {
-            let vals: Vec<_> = self.headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
         }
         res
     }
 }
 
-
 /// An HTTP Client request builder
 ///
 /// This type can be used to construct an instance of `ClientRequest` through a
@@ -236,14 +277,21 @@ pub struct ClientRequestBuilder {
     request: Option<ClientRequest>,
     err: Option<HttpError>,
     cookies: Option<CookieJar>,
-    default_headers: bool,
+    default_headers: bool
 }
 
 impl ClientRequestBuilder {
-    /// Set HTTP uri of request.
+    /// Set HTTP URI of request.
     #[inline]
-    pub fn uri<U>(&mut self, uri: U) -> &mut Self where Uri: HttpTryFrom<U> {
-        match Uri::try_from(uri) {
+    pub fn uri<U: AsRef<str>>(&mut self, uri: U) -> &mut Self {
+        match Url::parse(uri.as_ref()) {
+            Ok(url) => self._uri(url.as_str()),
+            Err(_) => self._uri(uri.as_ref()),
+        }
+    }
+
+    fn _uri(&mut self, url: &str) -> &mut Self {
+        match Uri::try_from(url) {
             Ok(uri) => {
                 // set request host header
                 if let Some(host) = uri.host() {
@@ -267,9 +315,17 @@ impl ClientRequestBuilder {
         self
     }
 
+    /// Set HTTP method of this request.
+    #[inline]
+    pub fn get_method(&mut self) -> &Method {
+        let parts = parts(&mut self.request, &self.err)
+            .expect("cannot reuse request builder");
+        &parts.method
+    }
+
     /// Set HTTP version of this request.
     ///
-    /// By default requests's http version depends on network stream
+    /// By default requests's HTTP version depends on network stream
     #[inline]
     pub fn version(&mut self, version: Version) -> &mut Self {
         if let Some(parts) = parts(&mut self.request, &self.err) {
@@ -278,9 +334,37 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Add a header.
+    /// Set a header.
     ///
-    /// Header get appended to existing header.
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_web;
+    /// # use actix_web::client::*;
+    /// #
+    /// use actix_web::{client, http};
+    ///
+    /// fn main() {
+    ///     let req = client::ClientRequest::build()
+    ///         .set(http::header::Date::now())
+    ///         .set(http::header::ContentType(mime::TEXT_HTML))
+    ///         .finish().unwrap();
+    /// }
+    /// ```
+    #[doc(hidden)]
+    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self
+    {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match hdr.try_into() {
+                Ok(value) => { parts.headers.insert(H::name(), value); }
+                Err(e) => self.err = Some(e.into()),
+            }
+        }
+        self
+    }
+
+    /// Append a header.
+    ///
+    /// Header gets appended to existing header.
     /// To override header use `set_header()` method.
     ///
     /// ```rust
@@ -298,12 +382,12 @@ impl ClientRequestBuilder {
     /// }
     /// ```
     pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
-        where HeaderName: HttpTryFrom<K>, HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         if let Some(parts) = parts(&mut self.request, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.append(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -314,14 +398,14 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Replace a header.
+    /// Set a header.
     pub fn set_header<K, V>(&mut self, key: K, value: V) -> &mut Self
-        where HeaderName: HttpTryFrom<K>, HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         if let Some(parts) = parts(&mut self.request, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.insert(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -387,16 +471,12 @@ impl ClientRequestBuilder {
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// # use actix_web::*;
-    /// # use actix_web::httpcodes::*;
-    /// #
-    /// use actix_web::headers::Cookie;
-    /// use actix_web::client::ClientRequest;
+    /// use actix_web::{client, http};
     ///
     /// fn main() {
-    ///     let req = ClientRequest::build()
+    ///     let req = client::ClientRequest::build()
     ///         .cookie(
-    ///             Cookie::build("name", "value")
+    ///             http::Cookie::build("name", "value")
     ///                 .domain("www.rust-lang.org")
     ///                 .path("/")
     ///                 .secure(true)
@@ -416,20 +496,6 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Remove cookie, cookie has to be cookie from `HttpRequest::cookies()` method.
-    pub fn del_cookie<'a>(&mut self, cookie: &Cookie<'a>) -> &mut Self {
-        {
-            if self.cookies.is_none() {
-                self.cookies = Some(CookieJar::new())
-            }
-            let jar = self.cookies.as_mut().unwrap();
-            let cookie = cookie.clone().into_owned();
-            jar.add_original(cookie.clone());
-            jar.remove(cookie);
-        }
-        self
-    }
-
     /// Do not add default request headers.
     /// By default `Accept-Encoding` header is set.
     pub fn no_default_headers(&mut self) -> &mut Self {
@@ -446,12 +512,22 @@ impl ClientRequestBuilder {
     }
 
     /// Set write buffer capacity
-    pub fn buffer_capacity(&mut self,
-                           low_watermark: usize,
-                           high_watermark: usize) -> &mut Self
-    {
+    ///
+    /// Default buffer capacity is 32kb
+    pub fn write_buffer_capacity(&mut self, cap: usize) -> &mut Self {
         if let Some(parts) = parts(&mut self.request, &self.err) {
-            parts.buffer_capacity = Some((low_watermark, high_watermark));
+            parts.buffer_capacity = cap;
+        }
+        self
+    }
+
+    /// Set request timeout
+    ///
+    /// Request timeout is a total time before response should be received.
+    /// Default value is 5 seconds.
+    pub fn timeout(&mut self, timeout: Duration) -> &mut Self {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            parts.timeout = Some(timeout);
         }
         self
     }
@@ -464,7 +540,7 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Send request using existing Connection
+    /// Send request using existing `Connection`
     pub fn with_connection(&mut self, conn: Connection) -> &mut Self {
         if let Some(parts) = parts(&mut self.request, &self.err) {
             parts.conn = ConnectionType::Connection(conn);
@@ -472,7 +548,8 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// This method calls provided closure with builder reference if value is true.
+    /// This method calls provided closure with builder reference if
+    /// value is `true`.
     pub fn if_true<F>(&mut self, value: bool, f: F) -> &mut Self
         where F: FnOnce(&mut ClientRequestBuilder)
     {
@@ -482,7 +559,8 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// This method calls provided closure with builder reference if value is Some.
+    /// This method calls provided closure with builder reference if
+    /// value is `Some`.
     pub fn if_some<T, F>(&mut self, value: Option<T>, f: F) -> &mut Self
         where F: FnOnce(T, &mut ClientRequestBuilder)
     {
@@ -495,9 +573,9 @@ impl ClientRequestBuilder {
     /// Set a body and generate `ClientRequest`.
     ///
     /// `ClientRequestBuilder` can not be used after this call.
-    pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<ClientRequest, HttpError> {
+    pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<ClientRequest, Error> {
         if let Some(e) = self.err.take() {
-            return Err(e)
+            return Err(e.into())
         }
 
         if self.default_headers {
@@ -520,18 +598,21 @@ impl ClientRequestBuilder {
         let mut request = self.request.take().expect("cannot reuse request builder");
 
         // set cookies
-        if let Some(ref jar) = self.cookies {
-            for cookie in jar.delta() {
-                request.headers.append(
-                    header::SET_COOKIE,
-                    HeaderValue::from_str(&cookie.to_string())?);
+        if let Some(ref mut jar) = self.cookies {
+            let mut cookie = String::new();
+            for c in jar.delta() {
+                let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
+                let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+                let _ = write!(&mut cookie, "; {}={}", name, value);
             }
+            request.headers.insert(
+                header::COOKIE, HeaderValue::from_str(&cookie.as_str()[2..]).unwrap());
         }
         request.body = body.into();
         Ok(request)
     }
 
-    /// Set a json body and generate `ClientRequest`
+    /// Set a JSON body and generate `ClientRequest`
     ///
     /// `ClientRequestBuilder` can not be used after this call.
     pub fn json<T: Serialize>(&mut self, value: T) -> Result<ClientRequest, Error> {
@@ -546,13 +627,23 @@ impl ClientRequestBuilder {
             self.header(header::CONTENT_TYPE, "application/json");
         }
 
-        Ok(self.body(body)?)
+        self.body(body)
+    }
+
+    /// Set a streaming body and generate `ClientRequest`.
+    ///
+    /// `ClientRequestBuilder` can not be used after this call.
+    pub fn streaming<S, E>(&mut self, stream: S) -> Result<ClientRequest, Error>
+        where S: Stream<Item=Bytes, Error=E> + 'static,
+              E: Into<Error>,
+    {
+        self.body(Body::Streaming(Box::new(stream.map_err(|e| e.into()))))
     }
 
     /// Set an empty body and generate `ClientRequest`
     ///
     /// `ClientRequestBuilder` can not be used after this call.
-    pub fn finish(&mut self) -> Result<ClientRequest, HttpError> {
+    pub fn finish(&mut self) -> Result<ClientRequest, Error> {
         self.body(Body::Empty)
     }
 
@@ -562,7 +653,7 @@ impl ClientRequestBuilder {
             request: self.request.take(),
             err: self.err.take(),
             cookies: self.cookies.take(),
-            default_headers: self.default_headers,
+            default_headers: self.default_headers
         }
     }
 }
@@ -576,3 +667,34 @@ fn parts<'a>(parts: &'a mut Option<ClientRequest>, err: &Option<HttpError>)
     }
     parts.as_mut()
 }
+
+impl fmt::Debug for ClientRequestBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref parts) = self.request {
+            let res = writeln!(f, "\nClientRequestBuilder {:?} {}:{}",
+                               parts.version, parts.method, parts.uri);
+            let _ = writeln!(f, "  headers:");
+            for (key, val) in parts.headers.iter() {
+                let _ = writeln!(f, "    {:?}: {:?}", key, val);
+            }
+            res
+        } else {
+            write!(f, "ClientRequestBuilder(Consumed)")
+        }
+    }
+}
+
+/// Create `ClientRequestBuilder` from `HttpRequest`
+///
+/// It is useful for proxy requests. This implementation
+/// copies all request headers and the method.
+impl<'a, S: 'static> From<&'a HttpRequest<S>> for ClientRequestBuilder {
+    fn from(req: &'a HttpRequest<S>) -> ClientRequestBuilder {
+        let mut builder = ClientRequest::build();
+        for (key, value) in req.headers() {
+            builder.header(key.clone(), value.clone());
+        }
+        builder.method(req.method().clone());
+        builder
+    }
+}

src/client/response.rs

@@ -77,17 +77,14 @@ impl ClientResponse {
         self.as_ref().status
     }
 
-    /// Load request cookies.
+    /// Load response cookies.
     pub fn cookies(&self) -> Result<&Vec<Cookie<'static>>, CookieParseError> {
         if self.as_ref().cookies.is_none() {
             let msg = self.as_mut();
             let mut cookies = Vec::new();
-            if let Some(val) = msg.headers.get(header::COOKIE) {
-                let s = str::from_utf8(val.as_bytes())
-                    .map_err(CookieParseError::from)?;
-                for cookie in s.split("; ") {
-                    cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
-                }
+            for val in msg.headers.get_all(header::SET_COOKIE).iter() {
+                let s = str::from_utf8(val.as_bytes()).map_err(CookieParseError::from)?;
+                cookies.push(Cookie::parse_encoded(s)?.into_owned());
             }
             msg.cookies = Some(cookies)
         }
@@ -109,16 +106,11 @@ impl ClientResponse {
 
 impl fmt::Debug for ClientResponse {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let res = write!(
-            f, "\nClientResponse {:?} {}\n", self.version(), self.status());
-        let _ = write!(f, "  headers:\n");
-        for key in self.headers().keys() {
-            let vals: Vec<_> = self.headers().get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        let res = writeln!(
+            f, "\nClientResponse {:?} {}", self.version(), self.status());
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.headers().iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
         }
         res
     }
@@ -137,3 +129,20 @@ impl Stream for ClientResponse {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug() {
+        let resp = ClientResponse::new(ClientMessage::default());
+        resp.as_mut().headers.insert(
+            header::COOKIE, HeaderValue::from_static("cookie1=value1"));
+        resp.as_mut().headers.insert(
+            header::COOKIE, HeaderValue::from_static("cookie2=value2"));
+
+        let dbg = format!("{:?}", resp);
+        assert!(dbg.contains("ClientResponse"));
+    }
+}

src/client/writer.rs

@@ -13,10 +13,11 @@ use http::header::{HeaderValue, DATE,
                    CONNECTION, CONTENT_ENCODING, CONTENT_LENGTH, TRANSFER_ENCODING};
 use flate2::Compression;
 use flate2::write::{GzEncoder, DeflateEncoder};
+#[cfg(feature="brotli")]
 use brotli2::write::BrotliEncoder;
 
 use body::{Body, Binary};
-use headers::ContentEncoding;
+use header::ContentEncoding;
 use server::WriterState;
 use server::shared::SharedBytes;
 use server::encoding::{ContentEncoder, TransferEncoding};
@@ -24,8 +25,6 @@ use server::encoding::{ContentEncoder, TransferEncoding};
 use client::ClientRequest;
 
 
-const LOW_WATERMARK: usize = 1024;
-const HIGH_WATERMARK: usize = 8 * LOW_WATERMARK;
 const AVERAGE_HEADER_SIZE: usize = 30;
 
 bitflags! {
@@ -42,9 +41,8 @@ pub(crate) struct HttpClientWriter {
     written: u64,
     headers_size: u32,
     buffer: SharedBytes,
+    buffer_capacity: usize,
     encoder: ContentEncoder,
-    low: usize,
-    high: usize,
 }
 
 impl HttpClientWriter {
@@ -55,10 +53,9 @@ impl HttpClientWriter {
             flags: Flags::empty(),
             written: 0,
             headers_size: 0,
+            buffer_capacity: 0,
             buffer,
             encoder,
-            low: LOW_WATERMARK,
-            high: HIGH_WATERMARK,
         }
     }
 
@@ -70,12 +67,6 @@ impl HttpClientWriter {
     //    self.flags.contains(Flags::KEEPALIVE) && !self.flags.contains(Flags::UPGRADE)
     // }
 
-    /// Set write buffer capacity
-    pub fn set_buffer_capacity(&mut self, low_watermark: usize, high_watermark: usize) {
-        self.low = low_watermark;
-        self.high = high_watermark;
-    }
-
     fn write_to_stream<T: AsyncWrite>(&mut self, stream: &mut T) -> io::Result<WriterState> {
         while !self.buffer.is_empty() {
             match stream.write(self.buffer.as_ref()) {
@@ -87,7 +78,7 @@ impl HttpClientWriter {
                     let _ = self.buffer.split_to(n);
                 },
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    if self.buffer.len() > self.high {
+                    if self.buffer.len() > self.buffer_capacity {
                         return Ok(WriterState::Pause)
                     } else {
                         return Ok(WriterState::Done)
@@ -106,28 +97,27 @@ impl HttpClientWriter {
         // prepare task
         self.flags.insert(Flags::STARTED);
         self.encoder = content_encoder(self.buffer.clone(), msg);
-        if let Some(capacity) = msg.buffer_capacity() {
-            self.set_buffer_capacity(capacity.0, capacity.1);
+
+        if msg.upgrade() {
+            self.flags.insert(Flags::UPGRADE);
         }
 
         // render message
         {
-            let mut buffer = self.buffer.get_mut();
-            if let Body::Binary(ref bytes) = *msg.body() {
-                buffer.reserve(256 + msg.headers().len() * AVERAGE_HEADER_SIZE + bytes.len());
-            } else {
-                buffer.reserve(256 + msg.headers().len() * AVERAGE_HEADER_SIZE);
-            }
-
-            if msg.upgrade() {
-                self.flags.insert(Flags::UPGRADE);
-            }
-
             // status line
-            let _ = write!(buffer, "{} {} {:?}\r\n",
-                           msg.method(), msg.uri().path(), msg.version());
+            writeln!(self.buffer, "{} {} {:?}\r",
+                     msg.method(),
+                     msg.uri().path_and_query().map(|u| u.as_str()).unwrap_or("/"),
+                     msg.version())?;
 
             // write headers
+            let mut buffer = self.buffer.get_mut();
+            if let Body::Binary(ref bytes) = *msg.body() {
+                buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE + bytes.len());
+            } else {
+                buffer.reserve(msg.headers().len() * AVERAGE_HEADER_SIZE);
+            }
+
             for (key, value) in msg.headers() {
                 let v = value.as_ref();
                 let k = key.as_str().as_bytes();
@@ -153,6 +143,8 @@ impl HttpClientWriter {
                     self.written += bytes.len() as u64;
                     self.encoder.write(bytes)?;
                 }
+            } else {
+                self.buffer_capacity = msg.write_buffer_capacity();
             }
         }
         Ok(())
@@ -168,7 +160,7 @@ impl HttpClientWriter {
             }
         }
 
-        if self.buffer.len() > self.high {
+        if self.buffer.len() > self.buffer_capacity {
             Ok(WriterState::Pause)
         } else {
             Ok(WriterState::Done)
@@ -224,6 +216,7 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
                         DeflateEncoder::new(transfer, Compression::default())),
                     ContentEncoding::Gzip => ContentEncoder::Gzip(
                         GzEncoder::new(transfer, Compression::default())),
+                    #[cfg(feature="brotli")]
                     ContentEncoding::Br => ContentEncoder::Br(
                         BrotliEncoder::new(transfer, 5)),
                     ContentEncoding::Identity => ContentEncoder::Identity(transfer),
@@ -273,6 +266,7 @@ fn content_encoder(buf: SharedBytes, req: &mut ClientRequest) -> ContentEncoder
             DeflateEncoder::new(transfer, Compression::default())),
         ContentEncoding::Gzip => ContentEncoder::Gzip(
             GzEncoder::new(transfer, Compression::default())),
+        #[cfg(feature="brotli")]
         ContentEncoding::Br => ContentEncoder::Br(
             BrotliEncoder::new(transfer, 5)),
         ContentEncoding::Identity | ContentEncoding::Auto => ContentEncoder::Identity(transfer),

src/context.rs

@@ -35,7 +35,7 @@ impl Frame {
     }
 }
 
-/// Http actor execution context
+/// Execution context for http actors
 pub struct HttpContext<A, S=()> where A: Actor<Context=HttpContext<A, S>>,
 {
     inner: ContextImpl<A>,
@@ -191,7 +191,7 @@ impl<A, S> ActorHttpContext for HttpContext<A, S> where A: Actor<Context=Self>,
         if self.inner.alive() {
             match self.inner.poll(ctx) {
                 Ok(Async::NotReady) | Ok(Async::Ready(())) => (),
-                Err(_) => return Err(ErrorInternalServerError("error").into()),
+                Err(_) => return Err(ErrorInternalServerError("error")),
             }
         }
 

src/de.rs

@@ -0,0 +1,390 @@
+use std::slice::Iter;
+use std::borrow::Cow;
+use std::convert::AsRef;
+use serde::de::{self, Deserializer, Visitor, Error as DeError};
+
+use httprequest::HttpRequest;
+
+
+macro_rules! unsupported_type {
+    ($trait_fn:ident, $name:expr) => {
+        fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            Err(de::value::Error::custom(concat!("unsupported type: ", $name)))
+        }
+    };
+}
+
+macro_rules! parse_single_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            if self.req.match_info().len() != 1 {
+                Err(de::value::Error::custom(
+                    format!("wrong number of parameters: {} expected 1",
+                            self.req.match_info().len()).as_str()))
+            } else {
+                let v = self.req.match_info()[0].parse().map_err(
+                    |_| de::value::Error::custom(
+                        format!("can not parse {:?} to a {}",
+                                &self.req.match_info()[0], $tp)))?;
+                visitor.$visit_fn(v)
+            }
+        }
+    }
+}
+
+pub struct PathDeserializer<'de, S: 'de> {
+    req: &'de HttpRequest<S>
+}
+
+impl<'de, S: 'de> PathDeserializer<'de, S> {
+    pub fn new(req: &'de HttpRequest<S>) -> Self {
+        PathDeserializer{req}
+    }
+}
+
+impl<'de, S: 'de> Deserializer<'de> for PathDeserializer<'de, S>
+{
+    type Error = de::value::Error;
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_map(ParamsDeserializer{
+            params: self.req.match_info().iter(),
+            current: None,
+        })
+    }
+
+    fn deserialize_struct<V>(self, _: &'static str, _: &'static [&'static str], visitor: V)
+                             -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(self, _: &'static str, visitor: V)
+                                  -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(self, _: &'static str, visitor: V)
+                                     -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        if self.req.match_info().len() < len {
+            Err(de::value::Error::custom(
+                format!("wrong number of parameters: {} expected {}",
+                        self.req.match_info().len(), len).as_str()))
+        } else {
+            visitor.visit_seq(ParamsSeq{params: self.req.match_info().iter()})
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(self, _: &'static str, len: usize, visitor: V)
+                                   -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        if self.req.match_info().len() < len {
+            Err(de::value::Error::custom(
+                format!("wrong number of parameters: {} expected {}",
+                        self.req.match_info().len(), len).as_str()))
+        } else {
+            visitor.visit_seq(ParamsSeq{params: self.req.match_info().iter()})
+        }
+    }
+
+    fn deserialize_enum<V>(self, _: &'static str, _: &'static [&'static str], _: V)
+                           -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        Err(de::value::Error::custom("unsupported type: enum"))
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        if self.req.match_info().len() != 1 {
+            Err(de::value::Error::custom(
+                format!("wrong number of parameters: {} expected 1",
+                        self.req.match_info().len()).as_str()))
+        } else {
+            visitor.visit_str(&self.req.match_info()[0])
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        visitor.visit_seq(ParamsSeq{params: self.req.match_info().iter()})
+    }
+
+    unsupported_type!(deserialize_any, "'any'");
+    unsupported_type!(deserialize_bytes, "bytes");
+    unsupported_type!(deserialize_option, "Option<T>");
+    unsupported_type!(deserialize_identifier, "identifier");
+    unsupported_type!(deserialize_ignored_any, "ignored_any");
+
+    parse_single_value!(deserialize_bool, visit_bool, "bool");
+    parse_single_value!(deserialize_i8, visit_i8, "i8");
+    parse_single_value!(deserialize_i16, visit_i16, "i16");
+    parse_single_value!(deserialize_i32, visit_i32, "i16");
+    parse_single_value!(deserialize_i64, visit_i64, "i64");
+    parse_single_value!(deserialize_u8, visit_u8, "u8");
+    parse_single_value!(deserialize_u16, visit_u16, "u16");
+    parse_single_value!(deserialize_u32, visit_u32, "u32");
+    parse_single_value!(deserialize_u64, visit_u64, "u64");
+    parse_single_value!(deserialize_f32, visit_f32, "f32");
+    parse_single_value!(deserialize_f64, visit_f64, "f64");
+    parse_single_value!(deserialize_string, visit_string, "String");
+    parse_single_value!(deserialize_byte_buf, visit_string, "String");
+    parse_single_value!(deserialize_char, visit_char, "char");
+}
+
+struct ParamsDeserializer<'de> {
+    params: Iter<'de, (Cow<'de, str>, Cow<'de, str>)>,
+    current: Option<(&'de str, &'de str)>,
+}
+
+impl<'de> de::MapAccess<'de> for ParamsDeserializer<'de>
+{
+    type Error = de::value::Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+        where K: de::DeserializeSeed<'de>,
+    {
+        self.current = self.params.next().map(|&(ref k, ref v)| (k.as_ref(), v.as_ref()));
+        match self.current {
+            Some((key, _)) => Ok(Some(seed.deserialize(Key{key})?)),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+        where V: de::DeserializeSeed<'de>,
+    {
+        if let Some((_, value)) = self.current.take() {
+            seed.deserialize(Value { value })
+        } else {
+            Err(de::value::Error::custom("unexpected item"))
+        }
+    }
+}
+
+struct Key<'de> {
+    key: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Key<'de> {
+    type Error = de::value::Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_str(self.key)
+    }
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("Unexpected"))
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+            byte_buf option unit unit_struct newtype_struct seq tuple
+            tuple_struct map struct enum ignored_any
+    }
+}
+
+macro_rules! parse_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            let v = self.value.parse().map_err(
+                |_| de::value::Error::custom(
+                    format!("can not parse {:?} to a {}", self.value, $tp)))?;
+            visitor.$visit_fn(v)
+        }
+    }
+}
+
+struct Value<'de> {
+    value: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Value<'de>
+{
+    type Error = de::value::Error;
+
+    parse_value!(deserialize_bool, visit_bool, "bool");
+    parse_value!(deserialize_i8, visit_i8, "i8");
+    parse_value!(deserialize_i16, visit_i16, "i16");
+    parse_value!(deserialize_i32, visit_i32, "i16");
+    parse_value!(deserialize_i64, visit_i64, "i64");
+    parse_value!(deserialize_u8, visit_u8, "u8");
+    parse_value!(deserialize_u16, visit_u16, "u16");
+    parse_value!(deserialize_u32, visit_u32, "u32");
+    parse_value!(deserialize_u64, visit_u64, "u64");
+    parse_value!(deserialize_f32, visit_f32, "f32");
+    parse_value!(deserialize_f64, visit_f64, "f64");
+    parse_value!(deserialize_string, visit_string, "String");
+    parse_value!(deserialize_byte_buf, visit_string, "String");
+    parse_value!(deserialize_char, visit_char, "char");
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self, _: &'static str, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value.as_bytes())
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    fn deserialize_enum<V>(self, _: &'static str, _: &'static [&'static str], visitor: V)
+                           -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_enum(ValueEnum {value: self.value})
+    }
+
+    fn deserialize_newtype_struct<V>(self, _: &'static str, visitor: V)
+                                     -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        Err(de::value::Error::custom("unsupported type: tuple"))
+    }
+
+    fn deserialize_struct<V>(self, _: &'static str, _: &'static [&'static str], _: V)
+                             -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        Err(de::value::Error::custom("unsupported type: struct"))
+    }
+
+    fn deserialize_tuple_struct<V>(self, _: &'static str, _: usize, _: V)
+                                   -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>
+    {
+        Err(de::value::Error::custom("unsupported type: tuple struct"))
+    }
+
+    unsupported_type!(deserialize_any, "any");
+    unsupported_type!(deserialize_seq, "seq");
+    unsupported_type!(deserialize_map, "map");
+    unsupported_type!(deserialize_identifier, "identifier");
+}
+
+struct ParamsSeq<'de> {
+    params: Iter<'de, (Cow<'de, str>, Cow<'de, str>)>,
+}
+
+impl<'de> de::SeqAccess<'de> for ParamsSeq<'de>
+{
+    type Error = de::value::Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed<'de>,
+    {
+        match self.params.next() {
+            Some(item) => Ok(Some(seed.deserialize(Value { value: item.1.as_ref() })?)),
+            None => Ok(None),
+        }
+    }
+}
+
+struct ValueEnum<'de> {
+    value: &'de str,
+}
+
+impl<'de> de::EnumAccess<'de> for ValueEnum<'de> {
+    type Error = de::value::Error;
+    type Variant = UnitVariant;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+        where V: de::DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(Key { key: self.value })?, UnitVariant))
+    }
+}
+
+struct UnitVariant;
+
+impl<'de> de::VariantAccess<'de> for UnitVariant {
+    type Error = de::value::Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+        where T: de::DeserializeSeed<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn struct_variant<V>(self, _: &'static [&'static str], _: V)
+                         -> Result<V::Value, Self::Error>
+        where V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+}

src/error.rs

@@ -8,23 +8,21 @@ use cookie;
 use httparse;
 use actix::MailboxError;
 use futures::Canceled;
-use failure;
-use failure::{Fail, Backtrace};
+use failure::{self, Fail, Backtrace};
 use http2::Error as Http2Error;
 use http::{header, StatusCode, Error as HttpError};
-use http::uri::InvalidUriBytes;
+use http::uri::InvalidUri;
 use http_range::HttpRangeParseError;
+use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
 pub use url::ParseError as UrlParseError;
 
 // re-exports
 pub use cookie::{ParseError as CookieParseError};
 
-use body::Body;
 use handler::Responder;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
-use httpcodes::{self, HttpExpectationFailed};
 
 /// A specialized [`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)
 /// for actix web operations
@@ -55,7 +53,7 @@ pub trait ResponseError: Fail {
     ///
     /// Internal server error is generated by default.
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR, Body::Empty)
+        HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR)
     }
 }
 
@@ -110,6 +108,20 @@ impl ResponseError for JsonError {}
 /// `InternalServerError` for `UrlParseError`
 impl ResponseError for UrlParseError {}
 
+/// Return `BAD_REQUEST` for `de::value::Error`
+impl ResponseError for DeError {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
+/// Return `BAD_REQUEST` for `Utf8Error`
+impl ResponseError for Utf8Error {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
+
 /// Return `InternalServerError` for `HttpError`,
 /// Response generation can return `HttpError`, so it is internal error
 impl ResponseError for HttpError {}
@@ -120,17 +132,28 @@ impl ResponseError for io::Error {
     fn error_response(&self) -> HttpResponse {
         match self.kind() {
             io::ErrorKind::NotFound =>
-                HttpResponse::new(StatusCode::NOT_FOUND, Body::Empty),
+                HttpResponse::new(StatusCode::NOT_FOUND),
             io::ErrorKind::PermissionDenied =>
-                HttpResponse::new(StatusCode::FORBIDDEN, Body::Empty),
+                HttpResponse::new(StatusCode::FORBIDDEN),
             _ =>
-                HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR, Body::Empty)
+                HttpResponse::new(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
 
-/// `InternalServerError` for `InvalidHeaderValue`
-impl ResponseError for header::InvalidHeaderValue {}
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValue {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+ }
+}
+
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValueBytes {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST)
+    }
+}
 
 /// `InternalServerError` for `futures::Canceled`
 impl ResponseError for Canceled {}
@@ -146,7 +169,7 @@ pub enum ParseError {
     Method,
     /// An invalid `Uri`, such as `exam ple.domain`.
     #[fail(display="Uri error: {}", _0)]
-    Uri(InvalidUriBytes),
+    Uri(InvalidUri),
     /// An invalid `HttpVersion`, such as `HTP/1.1`
     #[fail(display="Invalid HTTP version specified")]
     Version,
@@ -177,7 +200,7 @@ pub enum ParseError {
 /// Return `BadRequest` for `ParseError`
 impl ResponseError for ParseError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -187,6 +210,12 @@ impl From<IoError> for ParseError {
     }
 }
 
+impl From<InvalidUri> for ParseError {
+    fn from(err: InvalidUri) -> ParseError {
+        ParseError::Uri(err)
+    }
+}
+
 impl From<Utf8Error> for ParseError {
     fn from(err: Utf8Error) -> ParseError {
         ParseError::Utf8(err)
@@ -246,7 +275,7 @@ impl ResponseError for PayloadError {}
 /// Return `BadRequest` for `cookie::ParseError`
 impl ResponseError for cookie::ParseError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -266,8 +295,8 @@ pub enum HttpRangeError {
 /// Return `BadRequest` for `HttpRangeError`
 impl ResponseError for HttpRangeError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(
-            StatusCode::BAD_REQUEST, Body::from("Invalid Range header provided"))
+        HttpResponse::with_body(
+            StatusCode::BAD_REQUEST, "Invalid Range header provided")
     }
 }
 
@@ -319,7 +348,7 @@ impl From<PayloadError> for MultipartError {
 impl ResponseError for MultipartError {
 
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -336,7 +365,7 @@ pub enum ExpectError {
 
 impl ResponseError for ExpectError {
     fn error_response(&self) -> HttpResponse {
-        HttpExpectationFailed.with_body("Unknown Expect")
+        HttpResponse::with_body(StatusCode::EXPECTATION_FAILED, "Unknown Expect")
     }
 }
 
@@ -354,7 +383,7 @@ pub enum ContentTypeError {
 /// Return `BadRequest` for `ContentTypeError`
 impl ResponseError for ContentTypeError {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -386,9 +415,12 @@ impl ResponseError for UrlencodedError {
 
     fn error_response(&self) -> HttpResponse {
         match *self {
-            UrlencodedError::Overflow => httpcodes::HttpPayloadTooLarge.into(),
-            UrlencodedError::UnknownLength => httpcodes::HttpLengthRequired.into(),
-            _ => httpcodes::HttpBadRequest.into(),
+            UrlencodedError::Overflow =>
+                HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE),
+            UrlencodedError::UnknownLength =>
+                HttpResponse::new(StatusCode::LENGTH_REQUIRED),
+            _ =>
+                HttpResponse::new(StatusCode::BAD_REQUEST),
         }
     }
 }
@@ -421,8 +453,10 @@ impl ResponseError for JsonPayloadError {
 
     fn error_response(&self) -> HttpResponse {
         match *self {
-            JsonPayloadError::Overflow => httpcodes::HttpPayloadTooLarge.into(),
-            _ => httpcodes::HttpBadRequest.into(),
+            JsonPayloadError::Overflow =>
+                HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE),
+            _ =>
+                HttpResponse::new(StatusCode::BAD_REQUEST),
         }
     }
 }
@@ -458,7 +492,7 @@ pub enum UriSegmentError {
 impl ResponseError for UriSegmentError {
 
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+        HttpResponse::new(StatusCode::BAD_REQUEST)
     }
 }
 
@@ -547,7 +581,7 @@ impl<T> ResponseError for InternalError<T>
     where T: Send + Sync + fmt::Debug + 'static
 {
     fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(self.status, Body::Empty)
+        HttpResponse::new(self.status)
     }
 }
 
@@ -564,68 +598,91 @@ impl<T> Responder for InternalError<T>
 
 /// Helper function that creates wrapper of any error and generate *BAD REQUEST* response.
 #[allow(non_snake_case)]
-pub fn ErrorBadRequest<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::BAD_REQUEST)
+pub fn ErrorBadRequest<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::BAD_REQUEST).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *UNAUTHORIZED* response.
 #[allow(non_snake_case)]
-pub fn ErrorUnauthorized<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::UNAUTHORIZED)
+pub fn ErrorUnauthorized<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::UNAUTHORIZED).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *FORBIDDEN* response.
 #[allow(non_snake_case)]
-pub fn ErrorForbidden<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::FORBIDDEN)
+pub fn ErrorForbidden<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::FORBIDDEN).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *NOT FOUND* response.
 #[allow(non_snake_case)]
-pub fn ErrorNotFound<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::NOT_FOUND)
+pub fn ErrorNotFound<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::NOT_FOUND).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *METHOD NOT ALLOWED* response.
 #[allow(non_snake_case)]
-pub fn ErrorMethodNotAllowed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::METHOD_NOT_ALLOWED)
+pub fn ErrorMethodNotAllowed<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::METHOD_NOT_ALLOWED).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *REQUEST TIMEOUT* response.
 #[allow(non_snake_case)]
-pub fn ErrorRequestTimeout<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::REQUEST_TIMEOUT)
+pub fn ErrorRequestTimeout<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::REQUEST_TIMEOUT).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *CONFLICT* response.
 #[allow(non_snake_case)]
-pub fn ErrorConflict<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::CONFLICT)
+pub fn ErrorConflict<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::CONFLICT).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *GONE* response.
 #[allow(non_snake_case)]
-pub fn ErrorGone<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::GONE)
+pub fn ErrorGone<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::GONE).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *PRECONDITION FAILED* response.
 #[allow(non_snake_case)]
-pub fn ErrorPreconditionFailed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::PRECONDITION_FAILED)
+pub fn ErrorPreconditionFailed<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::PRECONDITION_FAILED).into()
 }
 
 ///  Helper function that creates wrapper of any error and generate *EXPECTATION FAILED* response.
 #[allow(non_snake_case)]
-pub fn ErrorExpectationFailed<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::EXPECTATION_FAILED)
+pub fn ErrorExpectationFailed<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::EXPECTATION_FAILED).into()
 }
 
-///  Helper function that creates wrapper of any error and generate *INTERNAL SERVER ERROR* response.
+/// Helper function that creates wrapper of any error and
+/// generate *INTERNAL SERVER ERROR* response.
 #[allow(non_snake_case)]
-pub fn ErrorInternalServerError<T>(err: T) -> InternalError<T> {
-    InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR)
+pub fn ErrorInternalServerError<T>(err: T) -> Error
+    where T: Send + Sync + fmt::Debug + 'static
+{
+    InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR).into()
 }
 
 #[cfg(test)]
@@ -719,7 +776,7 @@ mod tests {
                 e @ $error => {
                     assert!(format!("{}", e).len() >= 5);
                 } ,
-                e => panic!("{:?}", e)
+                e => unreachable!("{:?}", e)
             }
         }
     }
@@ -731,7 +788,7 @@ mod tests {
                     let desc = format!("{}", e.cause().unwrap());
                     assert_eq!(desc, $from.description().to_owned());
                 },
-                _ => panic!("{:?}", $from)
+                _ => unreachable!("{:?}", $from)
             }
         }
     }

src/extractor.rs

@@ -0,0 +1,606 @@
+use std::str;
+use std::ops::{Deref, DerefMut};
+
+use mime::Mime;
+use bytes::Bytes;
+use serde_urlencoded;
+use serde::de::{self, DeserializeOwned};
+use futures::future::{Future, FutureResult, result};
+use encoding::all::UTF_8;
+use encoding::types::{Encoding, DecoderTrap};
+
+use error::{Error, ErrorBadRequest};
+use handler::{Either, FromRequest};
+use httprequest::HttpRequest;
+use httpmessage::{HttpMessage, MessageBody, UrlEncoded};
+use de::PathDeserializer;
+
+/// Extract typed information from the request's path.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// use actix_web::{App, Path, Result, http};
+///
+/// /// extract path info from "/{username}/{count}/?index.html" url
+/// /// {username} - deserializes to a String
+/// /// {count} -  - deserializes to a u32
+/// fn index(info: Path<(String, u32)>) -> Result<String> {
+///     Ok(format!("Welcome {}! {}", info.0, info.1))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/{username}/{count}/?index.html",       // <- define path parameters
+///        |r| r.method(http::Method::GET).with(index));  // <- use `with` extractor
+/// }
+/// ```
+///
+/// It is possible to extract path information to a specific type that implements
+/// `Deserialize` trait from *serde*.
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Path, Result, http};
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// /// extract path info using serde
+/// fn index(info: Path<Info>) -> Result<String> {
+///     Ok(format!("Welcome {}!", info.username))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/{username}/index.html",                // <- define path parameters
+///        |r| r.method(http::Method::GET).with(index));  // <- use `with` extractor
+/// }
+/// ```
+pub struct Path<T>{
+    inner: T
+}
+
+impl<T> AsRef<T> for Path<T> {
+
+    fn as_ref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T> Deref for Path<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for Path<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+impl<T> Path<T> {
+    /// Deconstruct to an inner value
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T, S> FromRequest<S> for Path<T>
+    where T: DeserializeOwned, S: 'static
+{
+    type Config = ();
+    type Result = FutureResult<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        let req = req.clone();
+        result(de::Deserialize::deserialize(PathDeserializer::new(&req))
+               .map_err(|e| e.into())
+               .map(|inner| Path{inner}))
+    }
+}
+
+/// Extract typed information from from the request's query.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate bytes;
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Query, http};
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// // use `with` extractor for query info
+/// // this handler get called only if request's query contains `username` field
+/// fn index(info: Query<Info>) -> String {
+///     format!("Welcome {}!", info.username)
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html",
+///        |r| r.method(http::Method::GET).with(index)); // <- use `with` extractor
+/// }
+/// ```
+pub struct Query<T>(T);
+
+impl<T> Deref for Query<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Query<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
+impl<T> Query<T> {
+    /// Deconstruct to a inner value
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T, S> FromRequest<S> for Query<T>
+    where T: de::DeserializeOwned, S: 'static
+{
+    type Config = ();
+    type Result = FutureResult<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        let req = req.clone();
+        result(serde_urlencoded::from_str::<T>(req.query_string())
+               .map_err(|e| e.into())
+               .map(Query))
+    }
+}
+
+/// Extract typed information from the request's body.
+///
+/// To extract typed information from request's body, the type `T` must implement the
+/// `Deserialize` trait from *serde*.
+///
+/// [**FormConfig**](dev/struct.FormConfig.html) allows to configure extraction
+/// process.
+///
+/// ## Example
+///
+/// It is possible to extract path information to a specific type that implements
+/// `Deserialize` trait from *serde*.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Form, Result};
+///
+/// #[derive(Deserialize)]
+/// struct FormData {
+///     username: String,
+/// }
+///
+/// /// extract form data using serde
+/// /// this handler get called only if content type is *x-www-form-urlencoded*
+/// /// and content of the request could be deserialized to a `FormData` struct
+/// fn index(form: Form<FormData>) -> Result<String> {
+///     Ok(format!("Welcome {}!", form.username))
+/// }
+/// # fn main() {}
+/// ```
+pub struct Form<T>(pub T);
+
+impl<T> Deref for Form<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Form<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
+impl<T, S> FromRequest<S> for Form<T>
+    where T: DeserializeOwned + 'static, S: 'static
+{
+    type Config = FormConfig;
+    type Result = Box<Future<Item=Self, Error=Error>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        Box::new(UrlEncoded::new(req.clone())
+                 .limit(cfg.limit)
+                 .from_err()
+                 .map(Form))
+    }
+}
+
+/// Form extractor configuration
+///
+/// ```rust
+/// # extern crate actix_web;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Form, Result, http};
+///
+/// #[derive(Deserialize)]
+/// struct FormData {
+///     username: String,
+/// }
+///
+/// /// extract form data using serde.
+/// /// custom configuration is used for this handler, max payload size is 4k
+/// fn index(form: Form<FormData>) -> Result<String> {
+///     Ok(format!("Welcome {}!", form.username))
+/// }
+///
+/// fn main() {
+///     let app = App::new().resource(
+///        "/index.html", |r| {
+///            r.method(http::Method::GET)
+///              .with(index)
+///              .limit(4096);} // <- change form extractor configuration
+///     );
+/// }
+/// ```
+pub struct FormConfig {
+    limit: usize,
+}
+
+impl FormConfig {
+
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(&mut self, limit: usize) -> &mut Self {
+        self.limit = limit;
+        self
+    }
+}
+
+impl Default for FormConfig {
+    fn default() -> Self {
+        FormConfig{limit: 262_144}
+    }
+}
+
+/// Request payload extractor.
+///
+/// Loads request's payload and construct Bytes instance.
+///
+/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure extraction
+/// process.
+///
+/// ## Example
+///
+/// ```rust
+/// extern crate bytes;
+/// # extern crate actix_web;
+/// use actix_web::{App, Result};
+///
+/// /// extract text data from request
+/// fn index(body: bytes::Bytes) -> Result<String> {
+///     Ok(format!("Body {:?}!", body))
+/// }
+/// # fn main() {}
+/// ```
+impl<S: 'static> FromRequest<S> for Bytes
+{
+    type Config = PayloadConfig;
+    type Result = Either<FutureResult<Self, Error>,
+                         Box<Future<Item=Self, Error=Error>>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        // check content-type
+        if let Err(e) = cfg.check_mimetype(req) {
+            return Either::A(result(Err(e)));
+        }
+
+        Either::B(Box::new(MessageBody::new(req.clone())
+                           .limit(cfg.limit)
+                           .from_err()))
+    }
+}
+
+/// Extract text information from the request's body.
+///
+/// Text extractor automatically decode body according to the request's charset.
+///
+/// [**PayloadConfig**](dev/struct.PayloadConfig.html) allows to configure
+/// extraction process.
+///
+/// ## Example
+///
+/// ```rust
+/// # extern crate actix_web;
+/// use actix_web::{App, Result};
+///
+/// /// extract text data from request
+/// fn index(body: String) -> Result<String> {
+///     Ok(format!("Body {}!", body))
+/// }
+/// # fn main() {}
+/// ```
+impl<S: 'static> FromRequest<S> for String
+{
+    type Config = PayloadConfig;
+    type Result = Either<FutureResult<String, Error>,
+                         Box<Future<Item=String, Error=Error>>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result {
+        // check content-type
+        if let Err(e) = cfg.check_mimetype(req) {
+            return Either::A(result(Err(e)));
+        }
+
+        // check charset
+        let encoding = match req.encoding() {
+            Err(_) => return Either::A(
+                result(Err(ErrorBadRequest("Unknown request charset")))),
+            Ok(encoding) => encoding,
+        };
+
+        Either::B(Box::new(
+            MessageBody::new(req.clone())
+                .limit(cfg.limit)
+                .from_err()
+                .and_then(move |body| {
+                    let enc: *const Encoding = encoding as *const Encoding;
+                    if enc == UTF_8 {
+                        Ok(str::from_utf8(body.as_ref())
+                           .map_err(|_| ErrorBadRequest("Can not decode body"))?
+                           .to_owned())
+                    } else {
+                        Ok(encoding.decode(&body, DecoderTrap::Strict)
+                           .map_err(|_| ErrorBadRequest("Can not decode body"))?)
+                    }
+                })))
+    }
+}
+
+/// Payload configuration for request's payload.
+pub struct PayloadConfig {
+    limit: usize,
+    mimetype: Option<Mime>,
+}
+
+impl PayloadConfig {
+
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(&mut self, limit: usize) -> &mut Self {
+        self.limit = limit;
+        self
+    }
+
+    /// Set required mime-type of the request. By default mime type is not enforced.
+    pub fn mimetype(&mut self, mt: Mime) -> &mut Self {
+        self.mimetype = Some(mt);
+        self
+    }
+
+    fn check_mimetype<S>(&self, req: &HttpRequest<S>) -> Result<(), Error> {
+        // check content-type
+        if let Some(ref mt) = self.mimetype {
+            match req.mime_type() {
+                Ok(Some(ref req_mt)) => {
+                    if mt != req_mt {
+                        return Err(ErrorBadRequest("Unexpected Content-Type"));
+                    }
+                },
+                Ok(None) => {
+                    return Err(ErrorBadRequest("Content-Type is expected"));
+                },
+                Err(err) => {
+                    return Err(err.into());
+                },
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Default for PayloadConfig {
+    fn default() -> Self {
+        PayloadConfig{limit: 262_144, mimetype: None}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mime;
+    use bytes::Bytes;
+    use futures::{Async, Future};
+    use http::header;
+    use router::{Router, Resource};
+    use resource::ResourceHandler;
+    use test::TestRequest;
+    use server::ServerSettings;
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    struct Info {
+        hello: String,
+    }
+
+    #[test]
+    fn test_bytes() {
+        let cfg = PayloadConfig::default();
+        let mut req = TestRequest::with_header(header::CONTENT_LENGTH, "11").finish();
+        req.payload_mut().unread_data(Bytes::from_static(b"hello=world"));
+
+        match Bytes::from_request(&req, &cfg).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s, Bytes::from_static(b"hello=world"));
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_string() {
+        let cfg = PayloadConfig::default();
+        let mut req = TestRequest::with_header(header::CONTENT_LENGTH, "11").finish();
+        req.payload_mut().unread_data(Bytes::from_static(b"hello=world"));
+
+        match String::from_request(&req, &cfg).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s, "hello=world");
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_form() {
+        let mut req = TestRequest::with_header(
+            header::CONTENT_TYPE, "application/x-www-form-urlencoded")
+            .header(header::CONTENT_LENGTH, "11")
+            .finish();
+        req.payload_mut().unread_data(Bytes::from_static(b"hello=world"));
+
+        let mut cfg = FormConfig::default();
+        cfg.limit(4096);
+        match Form::<Info>::from_request(&req, &cfg).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.hello, "world");
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_payload_config() {
+        let req = HttpRequest::default();
+        let mut cfg = PayloadConfig::default();
+        cfg.mimetype(mime::APPLICATION_JSON);
+        assert!(cfg.check_mimetype(&req).is_err());
+
+        let req = TestRequest::with_header(
+            header::CONTENT_TYPE, "application/x-www-form-urlencoded").finish();
+        assert!(cfg.check_mimetype(&req).is_err());
+
+        let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json").finish();
+        assert!(cfg.check_mimetype(&req).is_ok());
+    }
+
+    #[derive(Deserialize)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Id {
+        id: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").finish();
+
+        let mut resource = ResourceHandler::<()>::default();
+        resource.name("index");
+        let mut routes = Vec::new();
+        routes.push((Resource::new("index", "/{key}/{value}/"), Some(resource)));
+        let (router, _) = Router::new("", ServerSettings::default(), routes);
+        assert!(router.recognize(&mut req).is_some());
+
+        match Path::<MyStruct>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.key, "name");
+                assert_eq!(s.value, "user1");
+            },
+            _ => unreachable!(),
+        }
+
+        match Path::<(String, String)>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.0, "name");
+                assert_eq!(s.1, "user1");
+            },
+            _ => unreachable!(),
+        }
+
+        match Query::<Id>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.id, "test");
+            },
+            _ => unreachable!(),
+        }
+
+        let mut req = TestRequest::with_uri("/name/32/").finish();
+        assert!(router.recognize(&mut req).is_some());
+
+        match Path::<Test2>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.as_ref().key, "name");
+                assert_eq!(s.value, 32);
+            },
+            _ => unreachable!(),
+        }
+
+        match Path::<(String, u8)>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.0, "name");
+                assert_eq!(s.1, 32);
+            },
+            _ => unreachable!(),
+        }
+
+        match Path::<Vec<String>>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.into_inner(), vec!["name".to_owned(), "32".to_owned()]);
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_extract_path_signle() {
+        let mut resource = ResourceHandler::<()>::default();
+        resource.name("index");
+        let mut routes = Vec::new();
+        routes.push((Resource::new("index", "/{value}/"), Some(resource)));
+        let (router, _) = Router::new("", ServerSettings::default(), routes);
+
+        let mut req = TestRequest::with_uri("/32/").finish();
+        assert!(router.recognize(&mut req).is_some());
+
+        match Path::<i8>::from_request(&req, &()).poll().unwrap() {
+            Async::Ready(s) => {
+                assert_eq!(s.into_inner(), 32);
+            },
+            _ => unreachable!(),
+        }
+    }
+}

src/fs.rs

@@ -1,26 +1,41 @@
-//! Static files support.
-
-// //! TODO: needs to re-implement actual files handling, current impl blocks
-use std::io;
-use std::io::Read;
+//! Static files support
+use std::{io, cmp};
+use std::io::{Read, Seek};
 use std::fmt::Write;
-use std::fs::{File, DirEntry};
+use std::fs::{File, DirEntry, Metadata};
 use std::path::{Path, PathBuf};
 use std::ops::{Deref, DerefMut};
+use std::time::{SystemTime, UNIX_EPOCH};
 
+#[cfg(unix)]
+use std::os::unix::fs::MetadataExt;
+
+use bytes::{Bytes, BytesMut, BufMut};
+use futures::{Async, Poll, Future, Stream};
+use futures_cpupool::{CpuPool, CpuFuture};
 use mime_guess::get_mime_type;
 
+use header;
+use error::Error;
 use param::FromParam;
-use handler::{Handler, Responder};
-use headers::ContentEncoding;
+use handler::{Handler, RouteHandler, WrapHandler, Responder, Reply};
+use http::{Method, StatusCode};
+use httpmessage::HttpMessage;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
-use httpcodes::{HttpOk, HttpFound};
 
 /// A file with an associated name; responds with the Content-Type based on the
 /// file extension.
 #[derive(Debug)]
-pub struct NamedFile(PathBuf, File);
+pub struct NamedFile {
+    path: PathBuf,
+    file: File,
+    md: Metadata,
+    modified: Option<SystemTime>,
+    cpu_pool: Option<CpuPool>,
+    only_get: bool,
+    status_code: StatusCode,
+}
 
 impl NamedFile {
     /// Attempts to open a file in read-only mode.
@@ -30,18 +45,30 @@ impl NamedFile {
     /// ```rust
     /// use actix_web::fs::NamedFile;
     ///
-    /// # #[allow(unused_variables)]
     /// let file = NamedFile::open("foo.txt");
     /// ```
     pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
         let file = File::open(path.as_ref())?;
-        Ok(NamedFile(path.as_ref().to_path_buf(), file))
+        let md = file.metadata()?;
+        let path = path.as_ref().to_path_buf();
+        let modified = md.modified().ok();
+        let cpu_pool = None;
+        Ok(NamedFile{path, file, md, modified, cpu_pool,
+                     only_get: false,
+                     status_code: StatusCode::OK})
+    }
+
+    /// Allow only GET and HEAD methods
+    #[inline]
+    pub fn only_get(mut self) -> Self {
+        self.only_get = true;
+        self
     }
 
     /// Returns reference to the underlying `File` object.
     #[inline]
     pub fn file(&self) -> &File {
-        &self.1
+        &self.file
     }
 
     /// Retrieve the path of this file.
@@ -52,7 +79,6 @@ impl NamedFile {
     /// # use std::io;
     /// use actix_web::fs::NamedFile;
     ///
-    /// # #[allow(dead_code)]
     /// # fn path() -> io::Result<()> {
     /// let file = NamedFile::open("test.txt")?;
     /// assert_eq!(file.path().as_os_str(), "foo.txt");
@@ -61,7 +87,43 @@ impl NamedFile {
     /// ```
     #[inline]
     pub fn path(&self) -> &Path {
-        self.0.as_path()
+        self.path.as_path()
+    }
+
+    /// Set `CpuPool` to use
+    #[inline]
+    pub fn set_cpu_pool(mut self, cpu_pool: CpuPool) -> Self {
+        self.cpu_pool = Some(cpu_pool);
+        self
+    }
+
+    /// Set response **Status Code**
+    pub fn set_status_code(mut self, status: StatusCode) -> Self {
+        self.status_code = status;
+        self
+    }
+
+    fn etag(&self) -> Option<header::EntityTag> {
+        // This etag format is similar to Apache's.
+        self.modified.as_ref().map(|mtime| {
+            let ino = {
+                #[cfg(unix)]
+                { self.md.ino() }
+                #[cfg(not(unix))]
+                { 0 }
+            };
+
+            let dur = mtime.duration_since(UNIX_EPOCH)
+                .expect("modification time must be after epoch");
+            header::EntityTag::strong(
+                format!("{:x}:{:x}:{:x}:{:x}",
+                        ino, self.md.len(), dur.as_secs(),
+                        dur.subsec_nanos()))
+        })
+    }
+
+    fn last_modified(&self) -> Option<header::HttpDate> {
+        self.modified.map(|mtime| mtime.into())
     }
 }
 
@@ -69,30 +131,181 @@ impl Deref for NamedFile {
     type Target = File;
 
     fn deref(&self) -> &File {
-        &self.1
+        &self.file
     }
 }
 
 impl DerefMut for NamedFile {
     fn deref_mut(&mut self) -> &mut File {
-        &mut self.1
+        &mut self.file
     }
 }
 
+/// Returns true if `req` has no `If-Match` header or one which matches `etag`.
+fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
+    match req.get_header::<header::IfMatch>() {
+        None | Some(header::IfMatch::Any) => true,
+        Some(header::IfMatch::Items(ref items)) => {
+            if let Some(some_etag) = etag {
+                for item in items {
+                    if item.strong_eq(some_etag) {
+                        return true;
+                    }
+                }
+            }
+            false
+        }
+    }
+}
+
+/// Returns true if `req` doesn't have an `If-None-Match` header matching `req`.
+fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
+    match req.get_header::<header::IfNoneMatch>() {
+        Some(header::IfNoneMatch::Any) => false,
+        Some(header::IfNoneMatch::Items(ref items)) => {
+            if let Some(some_etag) = etag {
+                for item in items {
+                    if item.weak_eq(some_etag) {
+                        return false;
+                    }
+                }
+            }
+            true
+        }
+        None => true,
+    }
+}
+
+
 impl Responder for NamedFile {
     type Item = HttpResponse;
     type Error = io::Error;
 
-    fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, io::Error> {
-        let mut resp = HttpOk.build();
-        resp.content_encoding(ContentEncoding::Identity);
-        if let Some(ext) = self.path().extension() {
-            let mime = get_mime_type(&ext.to_string_lossy());
-            resp.content_type(format!("{}", mime).as_str());
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
+        if self.status_code != StatusCode::OK {
+            let mut resp = HttpResponse::build(self.status_code);
+            resp.if_some(self.path().extension(), |ext, resp| {
+                resp.set(header::ContentType(get_mime_type(&ext.to_string_lossy())));
+            });
+            let reader = ChunkedReadFile {
+                size: self.md.len(),
+                offset: 0,
+                cpu_pool: self.cpu_pool.unwrap_or_else(|| req.cpu_pool().clone()),
+                file: Some(self.file),
+                fut: None,
+            };
+            return Ok(resp.streaming(reader))
+        }
+
+        if self.only_get && *req.method() != Method::GET && *req.method() != Method::HEAD {
+            return Ok(HttpResponse::MethodNotAllowed()
+                      .header(header::CONTENT_TYPE, "text/plain")
+                      .header(header::ALLOW, "GET, HEAD")
+                      .body("This resource only supports GET and HEAD."))
+        }
+
+        let etag = self.etag();
+        let last_modified = self.last_modified();
+
+        // check preconditions
+        let precondition_failed = if !any_match(etag.as_ref(), &req) {
+            true
+        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
+            (last_modified, req.get_header())
+        {
+            m > since
+        } else {
+            false
+        };
+
+        // check last modified
+        let not_modified = if !none_match(etag.as_ref(), &req) {
+            true
+        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
+            (last_modified, req.get_header())
+        {
+            m <= since
+        } else {
+            false
+        };
+
+        let mut resp = HttpResponse::build(self.status_code);
+
+        resp
+            .if_some(self.path().extension(), |ext, resp| {
+                resp.set(header::ContentType(get_mime_type(&ext.to_string_lossy())));
+            })
+            .if_some(last_modified, |lm, resp| {resp.set(header::LastModified(lm));})
+            .if_some(etag, |etag, resp| {resp.set(header::ETag(etag));});
+
+        if precondition_failed {
+            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish())
+        } else if not_modified {
+            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish())
+        }
+
+        if *req.method() == Method::HEAD {
+            Ok(resp.finish())
+        } else {
+            let reader = ChunkedReadFile {
+                size: self.md.len(),
+                offset: 0,
+                cpu_pool: self.cpu_pool.unwrap_or_else(|| req.cpu_pool().clone()),
+                file: Some(self.file),
+                fut: None,
+            };
+            Ok(resp.streaming(reader))
+        }
+    }
+}
+
+/// A helper created from a `std::fs::File` which reads the file
+/// chunk-by-chunk on a `CpuPool`.
+pub struct ChunkedReadFile {
+    size: u64,
+    offset: u64,
+    cpu_pool: CpuPool,
+    file: Option<File>,
+    fut: Option<CpuFuture<(File, Bytes), io::Error>>,
+}
+
+impl Stream for ChunkedReadFile {
+    type Item = Bytes;
+    type Error= Error;
+
+    fn poll(&mut self) -> Poll<Option<Bytes>, Error> {
+        if self.fut.is_some() {
+            return match self.fut.as_mut().unwrap().poll()? {
+                Async::Ready((file, bytes)) => {
+                    self.fut.take();
+                    self.file = Some(file);
+                    self.offset += bytes.len() as u64;
+                    Ok(Async::Ready(Some(bytes)))
+                },
+                Async::NotReady => Ok(Async::NotReady),
+            };
+        }
+
+        let size = self.size;
+        let offset = self.offset;
+
+        if size == offset {
+            Ok(Async::Ready(None))
+        } else {
+            let mut file = self.file.take().expect("Use after completion");
+            self.fut = Some(self.cpu_pool.spawn_fn(move || {
+                let max_bytes = cmp::min(size.saturating_sub(offset), 65_536) as usize;
+                let mut buf = BytesMut::with_capacity(max_bytes);
+                file.seek(io::SeekFrom::Start(offset))?;
+                let nbytes = file.read(unsafe{buf.bytes_mut()})?;
+                if nbytes == 0 {
+                    return Err(io::ErrorKind::UnexpectedEof.into())
+                }
+                unsafe{buf.advance_mut(nbytes)};
+                Ok((file, buf.freeze()))
+            }));
+            self.poll()
         }
-        let mut data = Vec::new();
-        let _ = self.1.read_to_end(&mut data);
-        Ok(resp.body(data).unwrap())
     }
 }
 
@@ -164,64 +377,42 @@ impl Responder for Directory {
                             <ul>\
                             {}\
                             </ul></body>\n</html>", index_of, index_of, body);
-        Ok(HttpOk.build()
+        Ok(HttpResponse::Ok()
            .content_type("text/html; charset=utf-8")
-           .body(html).unwrap())
+           .body(html))
     }
 }
 
-/// This enum represents all filesystem elements.
-pub enum FilesystemElement {
-    File(NamedFile),
-    Directory(Directory),
-    Redirect(HttpResponse),
-}
-
-impl Responder for FilesystemElement {
-    type Item = HttpResponse;
-    type Error = io::Error;
-
-    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
-        match self {
-            FilesystemElement::File(file) => file.respond_to(req),
-            FilesystemElement::Directory(dir) => dir.respond_to(req),
-            FilesystemElement::Redirect(resp) => Ok(resp),
-        }
-    }
-}
-
-
 /// Static files handling
 ///
-/// `StaticFile` handler must be registered with `Application::handler()` method,
+/// `StaticFile` handler must be registered with `App::handler()` method,
 /// because `StaticFile` handler requires access sub-path information.
 ///
 /// ```rust
 /// # extern crate actix_web;
-/// use actix_web::{fs, Application};
+/// use actix_web::{fs, App};
 ///
 /// fn main() {
-///     let app = Application::new()
-///         .handler("/static", fs::StaticFiles::new(".", true))
+///     let app = App::new()
+///         .handler("/static", fs::StaticFiles::new("."))
 ///         .finish();
 /// }
 /// ```
-pub struct StaticFiles {
+pub struct StaticFiles<S> {
     directory: PathBuf,
     accessible: bool,
     index: Option<String>,
     show_index: bool,
+    cpu_pool: CpuPool,
+    default: Box<RouteHandler<S>>,
     _chunk_size: usize,
     _follow_symlinks: bool,
 }
 
-impl StaticFiles {
-    /// Create new `StaticFiles` instance
-    ///
-    /// `dir` - base directory
-    ///
-    /// `index` - show index for directory
-    pub fn new<T: Into<PathBuf>>(dir: T, index: bool) -> StaticFiles {
+impl<S: 'static> StaticFiles<S> {
+
+    /// Create new `StaticFiles` instance for specified base directory.
+    pub fn new<T: Into<PathBuf>>(dir: T) -> StaticFiles<S> {
         let dir = dir.into();
 
         let (dir, access) = match dir.canonicalize() {
@@ -243,38 +434,51 @@ impl StaticFiles {
             directory: dir,
             accessible: access,
             index: None,
-            show_index: index,
+            show_index: false,
+            cpu_pool: CpuPool::new(40),
+            default: Box::new(WrapHandler::new(
+                |_| HttpResponse::new(StatusCode::NOT_FOUND))),
             _chunk_size: 0,
             _follow_symlinks: false,
         }
     }
 
+    /// Show files listing for directories.
+    ///
+    /// By default show files listing is disabled.
+    pub fn show_files_listing(mut self) -> Self {
+        self.show_index = true;
+        self
+    }
+
     /// Set index file
     ///
     /// Redirects to specific index file for directory "/" instead of
     /// showing files listing.
-    pub fn index_file<T: Into<String>>(mut self, index: T) -> StaticFiles {
+    pub fn index_file<T: Into<String>>(mut self, index: T) -> StaticFiles<S> {
         self.index = Some(index.into());
         self
     }
+
+    /// Sets default handler which is used when no matched file could be found.
+    pub fn default_handler<H: Handler<S>>(mut self, handler: H) -> StaticFiles<S> {
+        self.default = Box::new(WrapHandler::new(handler));
+        self
+    }
 }
 
-impl<S> Handler<S> for StaticFiles {
-    type Result = Result<FilesystemElement, io::Error>;
+impl<S: 'static> Handler<S> for StaticFiles<S> {
+    type Result = Result<Reply, Error>;
 
     fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
         if !self.accessible {
-            Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+            Ok(self.default.handle(req))
         } else {
-            let path = if let Some(path) = req.match_info().get("tail") {
-                path
-            } else {
-                return Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+            let relpath = match req.match_info().get("tail").map(PathBuf::from_param) {
+                Some(Ok(path)) => path,
+                _ => return Ok(self.default.handle(req))
             };
 
-            let relpath = PathBuf::from_param(path)
-                .map_err(|_| io::Error::new(io::ErrorKind::NotFound, "not found"))?;
-
             // full filepath
             let path = self.directory.join(&relpath).canonicalize()?;
 
@@ -287,19 +491,25 @@ impl<S> Handler<S> for StaticFiles {
                         new_path.push_str(&el.to_string_lossy());
                         new_path.push('/');
                     }
+                    if !new_path.ends_with('/') {
+                        new_path.push('/');
+                    }
                     new_path.push_str(redir_index);
-                    Ok(FilesystemElement::Redirect(
-                        HttpFound
-                            .build()
-                            .header::<_, &str>("LOCATION", &new_path)
-                            .finish().unwrap()))
+                    HttpResponse::Found()
+                        .header(header::LOCATION, new_path.as_str())
+                        .finish()
+                        .respond_to(req.without_state())
                 } else if self.show_index {
-                    Ok(FilesystemElement::Directory(Directory::new(self.directory.clone(), path)))
+                    Directory::new(self.directory.clone(), path)
+                        .respond_to(req.without_state())?
+                    .respond_to(req.without_state())
                 } else {
-                    Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
+                    Ok(self.default.handle(req))
                 }
             } else {
-                Ok(FilesystemElement::File(NamedFile::open(path)?))
+                NamedFile::open(path)?.set_cpu_pool(self.cpu_pool.clone())
+                    .respond_to(req.without_state())?
+                .respond_to(req.without_state())
             }
         }
     }
@@ -308,12 +518,15 @@ impl<S> Handler<S> for StaticFiles {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use http::{header, StatusCode};
+    use application::App;
+    use test::{self, TestRequest};
+    use http::{header, Method, StatusCode};
 
     #[test]
     fn test_named_file() {
         assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
+        let mut file = NamedFile::open("Cargo.toml").unwrap()
+            .set_cpu_pool(CpuPool::new(1));
         { file.file();
           let _f: &File = &file; }
         { let _f: &mut File = &mut file; }
@@ -322,21 +535,57 @@ mod tests {
         assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/x-toml")
     }
 
+    #[test]
+    fn test_named_file_status_code() {
+        let mut file = NamedFile::open("Cargo.toml").unwrap()
+            .set_status_code(StatusCode::NOT_FOUND)
+            .set_cpu_pool(CpuPool::new(1));
+        { file.file();
+          let _f: &File = &file; }
+        { let _f: &mut File = &mut file; }
+
+        let resp = file.respond_to(HttpRequest::default()).unwrap();
+        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/x-toml");
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[test]
+    fn test_named_file_not_allowed() {
+        let req = TestRequest::default().method(Method::POST).finish();
+        let file = NamedFile::open("Cargo.toml").unwrap();
+
+        let resp = file.only_get().respond_to(req).unwrap();
+        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+    }
+
+    #[test]
+    fn test_named_file_any_method() {
+        let req = TestRequest::default().method(Method::POST).finish();
+        let file = NamedFile::open("Cargo.toml").unwrap();
+        let resp = file.respond_to(req).unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
     #[test]
     fn test_static_files() {
-        let mut st = StaticFiles::new(".", true);
+        let mut st = StaticFiles::new(".").show_files_listing();
         st.accessible = false;
-        assert!(st.handle(HttpRequest::default()).is_err());
+        let resp = st.handle(HttpRequest::default()).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
         st.accessible = true;
         st.show_index = false;
-        assert!(st.handle(HttpRequest::default()).is_err());
+        let resp = st.handle(HttpRequest::default()).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
 
         let mut req = HttpRequest::default();
         req.match_info_mut().add("tail", "");
 
         st.show_index = true;
         let resp = st.handle(req).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
         assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/html; charset=utf-8");
         assert!(resp.body().is_binary());
         assert!(format!("{:?}", resp.body()).contains("README.md"));
@@ -344,11 +593,12 @@ mod tests {
 
     #[test]
     fn test_redirect_to_index() {
-        let mut st = StaticFiles::new(".", false).index_file("index.html");
+        let mut st = StaticFiles::new(".").index_file("index.html");
         let mut req = HttpRequest::default();
         req.match_info_mut().add("tail", "guide");
 
         let resp = st.handle(req).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
         assert_eq!(resp.status(), StatusCode::FOUND);
         assert_eq!(resp.headers().get(header::LOCATION).unwrap(), "/guide/index.html");
 
@@ -356,18 +606,59 @@ mod tests {
         req.match_info_mut().add("tail", "guide/");
 
         let resp = st.handle(req).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
         assert_eq!(resp.status(), StatusCode::FOUND);
         assert_eq!(resp.headers().get(header::LOCATION).unwrap(), "/guide/index.html");
     }
 
     #[test]
     fn test_redirect_to_index_nested() {
-        let mut st = StaticFiles::new(".", false).index_file("Cargo.toml");
+        let mut st = StaticFiles::new(".").index_file("Cargo.toml");
         let mut req = HttpRequest::default();
         req.match_info_mut().add("tail", "examples/basics");
 
         let resp = st.handle(req).respond_to(HttpRequest::default()).unwrap();
+        let resp = resp.as_response().expect("HTTP Response");
         assert_eq!(resp.status(), StatusCode::FOUND);
         assert_eq!(resp.headers().get(header::LOCATION).unwrap(), "/examples/basics/Cargo.toml");
     }
+
+    #[test]
+    fn integration_redirect_to_index_with_prefix() {
+        let mut srv = test::TestServer::with_factory(
+            || App::new()
+                .prefix("public")
+                .handler("/", StaticFiles::new(".").index_file("Cargo.toml")));
+
+        let request = srv.get().uri(srv.url("/public")).finish().unwrap();
+        let response = srv.execute(request.send()).unwrap();
+        assert_eq!(response.status(), StatusCode::FOUND);
+        let loc = response.headers().get(header::LOCATION).unwrap().to_str().unwrap();
+        assert_eq!(loc, "/public/Cargo.toml");
+
+        let request = srv.get().uri(srv.url("/public/")).finish().unwrap();
+        let response = srv.execute(request.send()).unwrap();
+        assert_eq!(response.status(), StatusCode::FOUND);
+        let loc = response.headers().get(header::LOCATION).unwrap().to_str().unwrap();
+        assert_eq!(loc, "/public/Cargo.toml");
+    }
+
+    #[test]
+    fn integration_redirect_to_index() {
+        let mut srv = test::TestServer::with_factory(
+            || App::new()
+                .handler("test", StaticFiles::new(".").index_file("Cargo.toml")));
+
+        let request = srv.get().uri(srv.url("/test")).finish().unwrap();
+        let response = srv.execute(request.send()).unwrap();
+        assert_eq!(response.status(), StatusCode::FOUND);
+        let loc = response.headers().get(header::LOCATION).unwrap().to_str().unwrap();
+        assert_eq!(loc, "/test/Cargo.toml");
+
+        let request = srv.get().uri(srv.url("/test/")).finish().unwrap();
+        let response = srv.execute(request.send()).unwrap();
+        assert_eq!(response.status(), StatusCode::FOUND);
+        let loc = response.headers().get(header::LOCATION).unwrap().to_str().unwrap();
+        assert_eq!(loc, "/test/Cargo.toml");
+    }
 }

src/handler.rs

@@ -1,10 +1,8 @@
+use std::ops::Deref;
 use std::marker::PhantomData;
+use futures::Poll;
+use futures::future::{Future, FutureResult, ok, err};
 
-use regex::Regex;
-use futures::future::{Future, ok, err};
-use http::{header, StatusCode, Error as HttpError};
-
-use body::Body;
 use error::Error;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
@@ -34,8 +32,119 @@ pub trait Responder {
     fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error>;
 }
 
-#[doc(hidden)]
-/// Convenience trait that convert `Future` object into `Boxed` future
+/// Trait implemented by types that can be extracted from request.
+///
+/// Types that implement this trait can be used with `Route::with()` method.
+pub trait FromRequest<S>: Sized where S: 'static
+{
+    /// Configuration for conversion process
+    type Config: Default;
+
+    /// Future that resolves to a Self
+    type Result: Future<Item=Self, Error=Error>;
+
+    /// Convert request to a Self
+    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result;
+}
+
+/// Combines two different responder types into a single type
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::future::Future;
+/// use futures::future::result;
+/// use actix_web::{Either, Error, HttpRequest, HttpResponse, AsyncResponder};
+///
+/// type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
+///
+///
+/// fn index(req: HttpRequest) -> RegisterResult {
+///     if is_a_variant() { // <- choose variant A
+///         Either::A(
+///             HttpResponse::BadRequest().body("Bad data"))
+///     } else {
+///         Either::B(      // <- variant B
+///             result(Ok(HttpResponse::Ok()
+///                    .content_type("text/html")
+///                    .body("Hello!")))
+///                    .responder())
+///     }
+/// }
+/// # fn is_a_variant() -> bool { true }
+/// # fn main() {}
+/// ```
+#[derive(Debug)]
+pub enum Either<A, B> {
+    /// First branch of the type
+    A(A),
+    /// Second branch of the type
+    B(B),
+}
+
+impl<A, B> Responder for Either<A, B>
+    where A: Responder, B: Responder
+{
+    type Item = Reply;
+    type Error = Error;
+
+    fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
+        match self {
+            Either::A(a) => match a.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+            Either::B(b) => match b.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+        }
+    }
+}
+
+impl<A, B, I, E> Future for Either<A, B>
+    where A: Future<Item=I, Error=E>,
+          B: Future<Item=I, Error=E>,
+{
+    type Item = I;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<I, E> {
+        match *self {
+            Either::A(ref mut fut) => fut.poll(),
+            Either::B(ref mut fut) => fut.poll(),
+        }
+    }
+}
+
+/// Convenience trait that converts `Future` object to a `Boxed` future
+///
+/// For example loading json from request's body is async operation.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # #[macro_use] extern crate serde_derive;
+/// use futures::future::Future;
+/// use actix_web::{
+///     App, HttpRequest, HttpResponse, HttpMessage, Error, AsyncResponder};
+///
+/// #[derive(Deserialize, Debug)]
+/// struct MyObj {
+///     name: String,
+/// }
+///
+/// fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+///     req.json()                   // <- get JsonBody future
+///        .from_err()
+///        .and_then(|val: MyObj| {  // <- deserialized value
+///            Ok(HttpResponse::Ok().into())
+///        })
+///     // Construct boxed future by using `AsyncResponder::responder()` method
+///     .responder()
+/// }
+/// # fn main() {}
+/// ```
 pub trait AsyncResponder<I, E>: Sized {
     fn responder(self) -> Box<Future<Item=I, Error=E>>;
 }
@@ -170,6 +279,9 @@ impl From<Box<Future<Item=HttpResponse, Error=Error>>> for Reply {
     }
 }
 
+/// Convenience type alias
+pub type FutureResponse<I, E=Error> = Box<Future<Item=I, Error=E>>;
+
 impl<I, E> Responder for Box<Future<Item=I, Error=E>>
     where I: Responder + 'static,
           E: Into<Error> + 'static
@@ -282,315 +394,55 @@ impl<S, H, F, R, E> RouteHandler<S> for AsyncHandler<S, H, F, R, E>
     }
 }
 
-/// Path normalization helper
+/// Access an application state
 ///
-/// By normalizing it means:
+/// `S` - application state type
 ///
-/// - Add a trailing slash to the path.
-/// - Remove a trailing slash from the path.
-/// - Double slashes are replaced by one.
-///
-/// The handler returns as soon as it finds a path that resolves
-/// correctly. The order if all enable is 1) merge, 3) both merge and append
-/// and 3) append. If the path resolves with
-/// at least one of those conditions, it will redirect to the new path.
-///
-/// If *append* is *true* append slash when needed. If a resource is
-/// defined with trailing slash and the request comes without it, it will
-/// append it automatically.
-///
-/// If *merge* is *true*, merge multiple consecutive slashes in the path into one.
-///
-/// This handler designed to be use as a handler for application's *default resource*.
+/// ## Example
 ///
 /// ```rust
+/// # extern crate bytes;
 /// # extern crate actix_web;
-/// # #[macro_use] extern crate serde_derive;
-/// # use actix_web::*;
-/// #
-/// # fn index(req: HttpRequest) -> httpcodes::StaticResponse {
-/// #     httpcodes::HttpOk
-/// # }
+/// # extern crate futures;
+/// #[macro_use] extern crate serde_derive;
+/// use actix_web::{App, Path, State, http};
+///
+/// /// Application state
+/// struct MyApp {msg: &'static str}
+///
+/// #[derive(Deserialize)]
+/// struct Info {
+///     username: String,
+/// }
+///
+/// /// extract path info using serde
+/// fn index(state: State<MyApp>, info: Path<Info>) -> String {
+///     format!("{} {}!", state.msg, info.username)
+/// }
+///
 /// fn main() {
-///     let app = Application::new()
-///         .resource("/test/", |r| r.f(index))
-///         .default_resource(|r| r.h(NormalizePath::default()))
-///         .finish();
+///     let app = App::with_state(MyApp{msg: "Welcome"}).resource(
+///        "/{username}/index.html",                      // <- define path parameters
+///        |r| r.method(http::Method::GET).with2(index)); // <- use `with` extractor
 /// }
 /// ```
-/// In this example `/test`, `/test///` will be redirected to `/test/` url.
-pub struct NormalizePath {
-    append: bool,
-    merge: bool,
-    re_merge: Regex,
-    redirect: StatusCode,
-    not_found: StatusCode,
-}
+pub struct State<S> (HttpRequest<S>);
 
-impl Default for NormalizePath {
-    /// Create default `NormalizePath` instance, *append* is set to *true*,
-    /// *merge* is set to *true* and *redirect* is set to `StatusCode::MOVED_PERMANENTLY`
-    fn default() -> NormalizePath {
-        NormalizePath {
-            append: true,
-            merge: true,
-            re_merge: Regex::new("//+").unwrap(),
-            redirect: StatusCode::MOVED_PERMANENTLY,
-            not_found: StatusCode::NOT_FOUND,
-        }
+impl<S> Deref for State<S> {
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.0.state()
     }
 }
 
-impl NormalizePath {
-    /// Create new `NormalizePath` instance
-    pub fn new(append: bool, merge: bool, redirect: StatusCode) -> NormalizePath {
-        NormalizePath {
-            append,
-            merge,
-            redirect,
-            re_merge: Regex::new("//+").unwrap(),
-            not_found: StatusCode::NOT_FOUND,
-        }
+impl<S: 'static> FromRequest<S> for State<S>
+{
+    type Config = ();
+    type Result = FutureResult<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        ok(State(req.clone()))
     }
 }
-
-impl<S> Handler<S> for NormalizePath {
-    type Result = Result<HttpResponse, HttpError>;
-
-    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
-        if let Some(router) = req.router() {
-            let query = req.query_string();
-            if self.merge {
-                // merge slashes
-                let p = self.re_merge.replace_all(req.path(), "/");
-                if p.len() != req.path().len() {
-                    if router.has_route(p.as_ref()) {
-                        let p = if !query.is_empty() { p + "?" + query } else { p };
-                        return HttpResponse::build(self.redirect)
-                            .header(header::LOCATION, p.as_ref())
-                            .body(Body::Empty);
-                    }
-                    // merge slashes and append trailing slash
-                    if self.append && !p.ends_with('/') {
-                        let p = p.as_ref().to_owned() + "/";
-                        if router.has_route(&p) {
-                            let p = if !query.is_empty() { p + "?" + query } else { p };
-                            return HttpResponse::build(self.redirect)
-                                .header(header::LOCATION, p.as_str())
-                                .body(Body::Empty);
-                        }
-                    }
-
-                    // try to remove trailing slash
-                    if p.ends_with('/') {
-                        let p = p.as_ref().trim_right_matches('/');
-                        if router.has_route(p) {
-                            let mut req = HttpResponse::build(self.redirect);
-                            return if !query.is_empty() {
-                                req.header(header::LOCATION, (p.to_owned() + "?" + query).as_str())
-                            } else {
-                                req.header(header::LOCATION, p)
-                            }
-                            .body(Body::Empty);
-                        }
-                    }
-                } else if p.ends_with('/') {
-                    // try to remove trailing slash
-                    let p = p.as_ref().trim_right_matches('/');
-                    if router.has_route(p) {
-                        let mut req = HttpResponse::build(self.redirect);
-                        return if !query.is_empty() {
-                            req.header(header::LOCATION, (p.to_owned() + "?" + query).as_str())
-                        } else {
-                            req.header(header::LOCATION, p)
-                        }
-                        .body(Body::Empty);
-                    }
-                }
-            }
-            // append trailing slash
-            if self.append && !req.path().ends_with('/') {
-                let p = req.path().to_owned() + "/";
-                if router.has_route(&p) {
-                    let p = if !query.is_empty() { p + "?" + query } else { p };
-                    return HttpResponse::build(self.redirect)
-                        .header(header::LOCATION, p.as_str())
-                        .body(Body::Empty);
-                }
-            }
-        }
-        Ok(HttpResponse::new(self.not_found, Body::Empty))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use http::{header, Method};
-    use test::TestRequest;
-    use application::Application;
-
-    fn index(_req: HttpRequest) -> HttpResponse {
-        HttpResponse::new(StatusCode::OK, Body::Empty)
-    }
-
-    #[test]
-    fn test_normalize_path_trailing_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params =
-            vec![("/resource1", "", StatusCode::OK),
-                 ("/resource1/", "/resource1", StatusCode::MOVED_PERMANENTLY),
-                 ("/resource2", "/resource2/", StatusCode::MOVED_PERMANENTLY),
-                 ("/resource2/", "", StatusCode::OK),
-                 ("/resource1?p1=1&p2=2", "", StatusCode::OK),
-                 ("/resource1/?p1=1&p2=2", "/resource1?p1=1&p2=2", StatusCode::MOVED_PERMANENTLY),
-                 ("/resource2?p1=1&p2=2", "/resource2/?p1=1&p2=2",
-                  StatusCode::MOVED_PERMANENTLY),
-                 ("/resource2/?p1=1&p2=2", "", StatusCode::OK)
-            ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target,
-                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_trailing_slashes_disabled() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(
-                NormalizePath::new(false, true, StatusCode::MOVED_PERMANENTLY)))
-            .finish();
-
-        // trailing slashes
-        let params = vec![("/resource1", StatusCode::OK),
-                          ("/resource1/", StatusCode::MOVED_PERMANENTLY),
-                          ("/resource2", StatusCode::NOT_FOUND),
-                          ("/resource2/", StatusCode::OK),
-                          ("/resource1?p1=1&p2=2", StatusCode::OK),
-                          ("/resource1/?p1=1&p2=2", StatusCode::MOVED_PERMANENTLY),
-                          ("/resource2?p1=1&p2=2", StatusCode::NOT_FOUND),
-                          ("/resource2/?p1=1&p2=2", StatusCode::OK)
-        ];
-        for (path, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_merge_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params = vec![
-            ("/resource1/a/b", "", StatusCode::OK),
-            ("/resource1/", "/resource1", StatusCode::MOVED_PERMANENTLY),
-            ("/resource1//", "/resource1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b//", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/resource1/a/b?p=1", "", StatusCode::OK),
-            ("//resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a//b//?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-        ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target,
-                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-    #[test]
-    fn test_normalize_path_merge_and_append_slashes() {
-        let mut app = Application::new()
-            .resource("/resource1", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/", |r| r.method(Method::GET).f(index))
-            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
-            .resource("/resource2/a/b/", |r| r.method(Method::GET).f(index))
-            .default_resource(|r| r.h(NormalizePath::default()))
-            .finish();
-
-        // trailing slashes
-        let params = vec![
-            ("/resource1/a/b", "", StatusCode::OK),
-            ("/resource1/a/b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b//", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
-            ("/resource2/a/b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/resource2/a/b/", "", StatusCode::OK),
-            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
-            ("/resource1/a/b?p=1", "", StatusCode::OK),
-            ("/resource1/a/b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource1/a///b//?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/resource2/a/b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("///resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-            ("/////resource2/a///b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
-        ];
-        for (path, target, code) in params {
-            let req = app.prepare_request(TestRequest::with_uri(path).finish());
-            let resp = app.run(req);
-            let r = resp.as_response().unwrap();
-            assert_eq!(r.status(), code);
-            if !target.is_empty() {
-                assert_eq!(
-                    target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
-            }
-        }
-    }
-
-
-}

src/header/common/accept.rs

@@ -0,0 +1,159 @@
+use mime::{self, Mime};
+use header::{QualityItem, qitem};
+use http::header as http;
+
+header! {
+    /// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
+    ///
+    /// The `Accept` header field can be used by user agents to specify
+    /// response media types that are acceptable.  Accept header fields can
+    /// be used to indicate that the request is specifically limited to a
+    /// small set of desired types, as in the case of a request for an
+    /// in-line image
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept = #( media-range [ accept-params ] )
+    ///
+    /// media-range    = ( "*/*"
+    ///                  / ( type "/" "*" )
+    ///                  / ( type "/" subtype )
+    ///                  ) *( OWS ";" OWS parameter )
+    /// accept-params  = weight *( accept-ext )
+    /// accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]
+    /// ```
+    ///
+    /// # Example values
+    /// * `audio/*; q=0.2, audio/basic`
+    /// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::APPLICATION_JSON),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{Accept, QualityItem, q, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///         qitem("application/xhtml+xml".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::TEXT_XML,
+    ///             q(900)
+    ///         ),
+    ///         qitem("image/webp".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::STAR_STAR,
+    ///             q(800)
+    ///         ),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Accept, http::ACCEPT) => (QualityItem<Mime>)+
+
+    test_accept {
+        // Tests from the RFC
+         test_header!(
+            test1,
+            vec![b"audio/*; q=0.2, audio/basic"],
+            Some(HeaderField(vec![
+                QualityItem::new("audio/*".parse().unwrap(), q(200)),
+                qitem("audio/basic".parse().unwrap()),
+                ])));
+        test_header!(
+            test2,
+            vec![b"text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"],
+            Some(HeaderField(vec![
+                QualityItem::new(TEXT_PLAIN, q(500)),
+                qitem(TEXT_HTML),
+                QualityItem::new(
+                    "text/x-dvi".parse().unwrap(),
+                    q(800)),
+                qitem("text/x-c".parse().unwrap()),
+                ])));
+        // Custom tests
+        test_header!(
+            test3,
+            vec![b"text/plain; charset=utf-8"],
+            Some(Accept(vec![
+                qitem(TEXT_PLAIN_UTF_8),
+                ])));
+        test_header!(
+            test4,
+            vec![b"text/plain; charset=utf-8; q=0.5"],
+            Some(Accept(vec![
+                QualityItem::new(TEXT_PLAIN_UTF_8,
+                    q(500)),
+            ])));
+
+        #[test]
+        fn test_fuzzing1() {
+            use test::TestRequest;
+            let req = TestRequest::with_header(super::http::ACCEPT, "chunk#;e").finish();
+            let header = Accept::parse(&req);
+            assert!(header.is_ok());
+        }
+    }
+}
+
+impl Accept {
+    /// A constructor to easily create `Accept: */*`.
+    pub fn star() -> Accept {
+        Accept(vec![qitem(mime::STAR_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: application/json`.
+    pub fn json() -> Accept {
+        Accept(vec![qitem(mime::APPLICATION_JSON)])
+    }
+
+    /// A constructor to easily create `Accept: text/*`.
+    pub fn text() -> Accept {
+        Accept(vec![qitem(mime::TEXT_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: image/*`.
+    pub fn image() -> Accept {
+        Accept(vec![qitem(mime::IMAGE_STAR)])
+    }
+}

src/header/common/accept_charset.rs

@@ -0,0 +1,69 @@
+use header::{ACCEPT_CHARSET, Charset, QualityItem};
+
+header! {
+    /// `Accept-Charset` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.3)
+    ///
+    /// The `Accept-Charset` header field can be sent by a user agent to
+    /// indicate what charsets are acceptable in textual response content.
+    /// This field allows user agents capable of understanding more
+    /// comprehensive or special-purpose charsets to signal that capability
+    /// to an origin server that is capable of representing information in
+    /// those charsets.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Charset = 1#( ( charset / "*" ) [ weight ] )
+    /// ```
+    ///
+    /// # Example values
+    /// * `iso-8859-5, unicode-1-1;q=0.8`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Us_Ascii)])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, q, QualityItem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![
+    ///         QualityItem::new(Charset::Us_Ascii, q(900)),
+    ///         QualityItem::new(Charset::Iso_8859_10, q(200)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Ext("utf-8".to_owned()))])
+    /// );
+    /// # }
+    /// ```
+    (AcceptCharset, ACCEPT_CHARSET) => (QualityItem<Charset>)+
+
+    test_accept_charset {
+        /// Test case from RFC
+        test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
+    }
+}

src/header/common/accept_encoding.rs

@@ -0,0 +1,72 @@
+use header::{Encoding, QualityItem};
+
+header! {
+    /// `Accept-Encoding` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.4)
+    ///
+    /// The `Accept-Encoding` header field can be used by user agents to
+    /// indicate what response content-codings are
+    /// acceptable in the response.  An  `identity` token is used as a synonym
+    /// for "no encoding" in order to communicate when no encoding is
+    /// preferred.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Encoding  = #( codings [ weight ] )
+    /// codings          = content-coding / "identity" / "*"
+    /// ```
+    ///
+    /// # Example values
+    /// * `compress, gzip`
+    /// * ``
+    /// * `*`
+    /// * `compress;q=0.5, gzip;q=1`
+    /// * `gzip;q=1.0, identity; q=0.5, *;q=0`
+    ///
+    /// # Examples
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![qitem(Encoding::Chunked)])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         qitem(Encoding::Gzip),
+    ///         qitem(Encoding::Deflate),
+    ///     ])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, QualityItem, q, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         QualityItem::new(Encoding::Gzip, q(600)),
+    ///         QualityItem::new(Encoding::EncodingExt("*".to_owned()), q(0)),
+    ///     ])
+    /// );
+    /// ```
+    (AcceptEncoding, "Accept-Encoding") => (QualityItem<Encoding>)*
+
+    test_accept_encoding {
+        // From the RFC
+        test_header!(test1, vec![b"compress, gzip"]);
+        test_header!(test2, vec![b""], Some(AcceptEncoding(vec![])));
+        test_header!(test3, vec![b"*"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test4, vec![b"compress;q=0.5, gzip"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test5, vec![b"gzip, identity; q=0.5, *;q=0"]);
+    }
+}

src/header/common/accept_language.rs

@@ -0,0 +1,75 @@
+use language_tags::LanguageTag;
+use header::{ACCEPT_LANGUAGE, QualityItem};
+
+header! {
+    /// `Accept-Language` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.5)
+    ///
+    /// The `Accept-Language` header field can be used by user agents to
+    /// indicate the set of natural languages that are preferred in the
+    /// response.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Language = 1#( language-range [ weight ] )
+    /// language-range  = <language-range, see [RFC4647], Section 2.1>
+    /// ```
+    ///
+    /// # Example values
+    /// * `da, en-gb;q=0.8, en;q=0.7`
+    /// * `en-us;q=1.0, en;q=0.5, fr`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// let mut langtag: LanguageTag = Default::default();
+    /// langtag.language = Some("en".to_owned());
+    /// langtag.region = Some("US".to_owned());
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
+    ///         QualityItem::new(langtag!(en), q(700)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (AcceptLanguage, ACCEPT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_accept_language {
+        // From the RFC
+        test_header!(test1, vec![b"da, en-gb;q=0.8, en;q=0.7"]);
+        // Own test
+        test_header!(
+            test2, vec![b"en-US, en; q=0.5, fr"],
+            Some(AcceptLanguage(vec![
+                qitem("en-US".parse().unwrap()),
+                QualityItem::new("en".parse().unwrap(), q(500)),
+                qitem("fr".parse().unwrap()),
+        ])));
+    }
+}

src/header/common/allow.rs

@@ -0,0 +1,85 @@
+use http::Method;
+use http::header;
+
+header! {
+    /// `Allow` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.4.1)
+    ///
+    /// The `Allow` header field lists the set of methods advertised as
+    /// supported by the target resource.  The purpose of this field is
+    /// strictly to inform the recipient of valid request methods associated
+    /// with the resource.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Allow = #method
+    /// ```
+    ///
+    /// # Example values
+    /// * `GET, HEAD, PUT`
+    /// * `OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH, fOObAr`
+    /// * ``
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     Allow(vec![Method::GET])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     Allow(vec![
+    ///         Method::GET,
+    ///         Method::POST,
+    ///         Method::PATCH,
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Allow, header::ALLOW) => (Method)*
+
+    test_allow {
+        // From the RFC
+        test_header!(
+            test1,
+            vec![b"GET, HEAD, PUT"],
+            Some(HeaderField(vec![Method::GET, Method::HEAD, Method::PUT])));
+        // Own tests
+        test_header!(
+            test2,
+            vec![b"OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH"],
+            Some(HeaderField(vec![
+                Method::OPTIONS,
+                Method::GET,
+                Method::PUT,
+                Method::POST,
+                Method::DELETE,
+                Method::HEAD,
+                Method::TRACE,
+                Method::CONNECT,
+                Method::PATCH])));
+        test_header!(
+            test3,
+            vec![b""],
+            Some(HeaderField(Vec::<Method>::new())));
+    }
+}

src/header/common/cache_control.rs

@@ -0,0 +1,232 @@
+use std::fmt::{self, Write};
+use std::str::FromStr;
+use http::header;
+use header::{Header, IntoHeaderValue, Writer};
+use header::{from_comma_delimited, fmt_comma_delimited};
+
+/// `Cache-Control` header, defined in [RFC7234](https://tools.ietf.org/html/rfc7234#section-5.2)
+///
+/// The `Cache-Control` header field is used to specify directives for
+/// caches along the request/response chain.  Such cache directives are
+/// unidirectional in that the presence of a directive in a request does
+/// not imply that the same directive is to be given in the response.
+///
+/// # ABNF
+///
+/// ```text
+/// Cache-Control   = 1#cache-directive
+/// cache-directive = token [ "=" ( token / quoted-string ) ]
+/// ```
+///
+/// # Example values
+///
+/// * `no-cache`
+/// * `private, community="UCI"`
+/// * `max-age=30`
+///
+/// # Examples
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpResponse::Ok();
+/// builder.set(
+///     CacheControl(vec![CacheDirective::MaxAge(86400u32)])
+/// );
+/// ```
+///
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpResponse::Ok();
+/// builder.set(
+///     CacheControl(vec![
+///         CacheDirective::NoCache,
+///         CacheDirective::Private,
+///         CacheDirective::MaxAge(360u32),
+///         CacheDirective::Extension("foo".to_owned(),
+///                                   Some("bar".to_owned())),
+///     ])
+/// );
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub struct CacheControl(pub Vec<CacheDirective>);
+
+__hyper__deref!(CacheControl => Vec<CacheDirective>);
+
+//TODO: this could just be the header! macro
+impl Header for CacheControl {
+    fn name() -> header::HeaderName {
+        header::CACHE_CONTROL
+    }
+
+    #[inline]
+    fn parse<T>(msg: &T) -> Result<Self, ::error::ParseError>
+        where T: ::HttpMessage
+    {
+        let directives = from_comma_delimited(msg.headers().get_all(Self::name()))?;
+        if !directives.is_empty() {
+            Ok(CacheControl(directives))
+        } else {
+            Err(::error::ParseError::Header)
+        }
+    }
+}
+
+impl fmt::Display for CacheControl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt_comma_delimited(f, &self[..])
+    }
+}
+
+impl IntoHeaderValue for CacheControl {
+    type Error = header::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        header::HeaderValue::from_shared(writer.take())
+    }
+}
+
+/// `CacheControl` contains a list of these directives.
+#[derive(PartialEq, Clone, Debug)]
+pub enum CacheDirective {
+    /// "no-cache"
+    NoCache,
+    /// "no-store"
+    NoStore,
+    /// "no-transform"
+    NoTransform,
+    /// "only-if-cached"
+    OnlyIfCached,
+
+    // request directives
+    /// "max-age=delta"
+    MaxAge(u32),
+    /// "max-stale=delta"
+    MaxStale(u32),
+    /// "min-fresh=delta"
+    MinFresh(u32),
+
+    // response directives
+    /// "must-revalidate"
+    MustRevalidate,
+    /// "public"
+    Public,
+    /// "private"
+    Private,
+    /// "proxy-revalidate"
+    ProxyRevalidate,
+    /// "s-maxage=delta"
+    SMaxAge(u32),
+
+    /// Extension directives. Optionally include an argument.
+    Extension(String, Option<String>)
+}
+
+impl fmt::Display for CacheDirective {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::CacheDirective::*;
+        fmt::Display::fmt(match *self {
+            NoCache => "no-cache",
+            NoStore => "no-store",
+            NoTransform => "no-transform",
+            OnlyIfCached => "only-if-cached",
+
+            MaxAge(secs) => return write!(f, "max-age={}", secs),
+            MaxStale(secs) => return write!(f, "max-stale={}", secs),
+            MinFresh(secs) => return write!(f, "min-fresh={}", secs),
+
+            MustRevalidate => "must-revalidate",
+            Public => "public",
+            Private => "private",
+            ProxyRevalidate => "proxy-revalidate",
+            SMaxAge(secs) => return write!(f, "s-maxage={}", secs),
+
+            Extension(ref name, None) => &name[..],
+            Extension(ref name, Some(ref arg)) => return write!(f, "{}={}", name, arg),
+
+        }, f)
+    }
+}
+
+impl FromStr for CacheDirective {
+    type Err = Option<<u32 as FromStr>::Err>;
+    fn from_str(s: &str) -> Result<CacheDirective, Option<<u32 as FromStr>::Err>> {
+        use self::CacheDirective::*;
+        match s {
+            "no-cache" => Ok(NoCache),
+            "no-store" => Ok(NoStore),
+            "no-transform" => Ok(NoTransform),
+            "only-if-cached" => Ok(OnlyIfCached),
+            "must-revalidate" => Ok(MustRevalidate),
+            "public" => Ok(Public),
+            "private" => Ok(Private),
+            "proxy-revalidate" => Ok(ProxyRevalidate),
+            "" => Err(None),
+            _ => match s.find('=') {
+                Some(idx) if idx+1 < s.len() => match (&s[..idx], (&s[idx+1..]).trim_matches('"')) {
+                    ("max-age" , secs) => secs.parse().map(MaxAge).map_err(Some),
+                    ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
+                    ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
+                    ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(Some),
+                    (left, right) => Ok(Extension(left.to_owned(), Some(right.to_owned())))
+                },
+                Some(_) => Err(None),
+                None => Ok(Extension(s.to_owned(), None))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use header::Header;
+    use test::TestRequest;
+
+    #[test]
+    fn test_parse_multiple_headers() {
+        let req = TestRequest::with_header(
+            header::CACHE_CONTROL, "no-cache, private").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::NoCache,
+                                                      CacheDirective::Private])))
+    }
+
+    #[test]
+    fn test_parse_argument() {
+        let req = TestRequest::with_header(
+            header::CACHE_CONTROL, "max-age=100, private").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::MaxAge(100),
+                                                      CacheDirective::Private])))
+    }
+
+    #[test]
+    fn test_parse_quote_form() {
+        let req = TestRequest::with_header(
+            header::CACHE_CONTROL, "max-age=\"200\"").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::MaxAge(200)])))
+    }
+
+    #[test]
+    fn test_parse_extension() {
+        let req = TestRequest::with_header(
+            header::CACHE_CONTROL, "foo, bar=baz").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![
+            CacheDirective::Extension("foo".to_owned(), None),
+            CacheDirective::Extension("bar".to_owned(), Some("baz".to_owned()))])))
+    }
+
+    #[test]
+    fn test_parse_bad_syntax() {
+        let req = TestRequest::with_header(header::CACHE_CONTROL, "foo=").finish();
+        let cache: Result<CacheControl, _> = Header::parse(&req);
+        assert_eq!(cache.ok(), None)
+    }
+}

src/header/common/content_disposition.rs

@@ -0,0 +1,264 @@
+// # References
+//
+// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
+// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
+// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc2388.txt
+// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
+// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
+
+use language_tags::LanguageTag;
+use std::fmt;
+use unicase;
+
+use header::{Header, Raw, parsing};
+use header::parsing::{parse_extended_value, http_percent_encode};
+use header::shared::Charset;
+
+/// The implied disposition of the content of the HTTP body.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionType {
+    /// Inline implies default processing
+    Inline,
+    /// Attachment implies that the recipient should prompt the user to save the response locally,
+    /// rather than process it normally (as per its media type).
+    Attachment,
+    /// Extension type.  Should be handled by recipients the same way as Attachment
+    Ext(String)
+}
+
+/// A parameter to the disposition type.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionParam {
+    /// A Filename consisting of a Charset, an optional LanguageTag, and finally a sequence of
+    /// bytes representing the filename
+    Filename(Charset, Option<LanguageTag>, Vec<u8>),
+    /// Extension type consisting of token and value.  Recipients should ignore unrecognized
+    /// parameters.
+    Ext(String, String)
+}
+
+/// A `Content-Disposition` header, (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266).
+///
+/// The Content-Disposition response header field is used to convey
+/// additional information about how to process the response payload, and
+/// also can be used to attach additional metadata, such as the filename
+/// to use when saving the response payload locally.
+///
+/// # ABNF
+
+/// ```text
+/// content-disposition = "Content-Disposition" ":"
+///                       disposition-type *( ";" disposition-parm )
+///
+/// disposition-type    = "inline" | "attachment" | disp-ext-type
+///                       ; case-insensitive
+///
+/// disp-ext-type       = token
+///
+/// disposition-parm    = filename-parm | disp-ext-parm
+///
+/// filename-parm       = "filename" "=" value
+///                     | "filename*" "=" ext-value
+///
+/// disp-ext-parm       = token "=" value
+///                     | ext-token "=" ext-value
+///
+/// ext-token           = <the characters in token, followed by "*">
+/// ```
+///
+/// # Example
+///
+/// ```
+/// use hyper::header::{Headers, ContentDisposition, DispositionType, DispositionParam, Charset};
+///
+/// let mut headers = Headers::new();
+/// headers.set(ContentDisposition {
+///     disposition: DispositionType::Attachment,
+///     parameters: vec![DispositionParam::Filename(
+///       Charset::Iso_8859_1, // The character set for the bytes of the filename
+///       None, // The optional language tag (see `language-tag` crate)
+///       b"\xa9 Copyright 1989.txt".to_vec() // the actual bytes of the filename
+///     )]
+/// });
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub struct ContentDisposition {
+    /// The disposition
+    pub disposition: DispositionType,
+    /// Disposition parameters
+    pub parameters: Vec<DispositionParam>,
+}
+
+impl Header for ContentDisposition {
+    fn header_name() -> &'static str {
+        static NAME: &'static str = "Content-Disposition";
+        NAME
+    }
+
+    fn parse_header(raw: &Raw) -> ::Result<ContentDisposition> {
+        parsing::from_one_raw_str(raw).and_then(|s: String| {
+            let mut sections = s.split(';');
+            let disposition = match sections.next() {
+                Some(s) => s.trim(),
+                None => return Err(::Error::Header),
+            };
+
+            let mut cd = ContentDisposition {
+                disposition: if unicase::eq_ascii(&*disposition, "inline") {
+                    DispositionType::Inline
+                } else if unicase::eq_ascii(&*disposition, "attachment") {
+                    DispositionType::Attachment
+                } else {
+                    DispositionType::Ext(disposition.to_owned())
+                },
+                parameters: Vec::new(),
+            };
+
+            for section in sections {
+                let mut parts = section.splitn(2, '=');
+
+                let key = if let Some(key) = parts.next() {
+                    key.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                let val = if let Some(val) = parts.next() {
+                    val.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                cd.parameters.push(
+                    if unicase::eq_ascii(&*key, "filename") {
+                        DispositionParam::Filename(
+                            Charset::Ext("UTF-8".to_owned()), None,
+                            val.trim_matches('"').as_bytes().to_owned())
+                    } else if unicase::eq_ascii(&*key, "filename*") {
+                        let extended_value = try!(parse_extended_value(val));
+                        DispositionParam::Filename(extended_value.charset, extended_value.language_tag, extended_value.value)
+                    } else {
+                        DispositionParam::Ext(key.to_owned(), val.trim_matches('"').to_owned())
+                    }
+                );
+            }
+
+            Ok(cd)
+        })
+    }
+
+    #[inline]
+    fn fmt_header(&self, f: &mut ::header::Formatter) -> fmt::Result {
+        f.fmt_line(self)
+    }
+}
+
+impl fmt::Display for ContentDisposition {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.disposition {
+            DispositionType::Inline => try!(write!(f, "inline")),
+            DispositionType::Attachment => try!(write!(f, "attachment")),
+            DispositionType::Ext(ref s) => try!(write!(f, "{}", s)),
+        }
+        for param in &self.parameters {
+            match *param {
+                DispositionParam::Filename(ref charset, ref opt_lang, ref bytes) => {
+                    let mut use_simple_format: bool = false;
+                    if opt_lang.is_none() {
+                        if let Charset::Ext(ref ext) = *charset {
+                            if unicase::eq_ascii(&**ext, "utf-8") {
+                                use_simple_format = true;
+                            }
+                        }
+                    }
+                    if use_simple_format {
+                        try!(write!(f, "; filename=\"{}\"",
+                                    match String::from_utf8(bytes.clone()) {
+                                        Ok(s) => s,
+                                        Err(_) => return Err(fmt::Error),
+                                    }));
+                    } else {
+                        try!(write!(f, "; filename*={}'", charset));
+                        if let Some(ref lang) = *opt_lang {
+                            try!(write!(f, "{}", lang));
+                        };
+                        try!(write!(f, "'"));
+                        try!(http_percent_encode(f, bytes))
+                    }
+                },
+                DispositionParam::Ext(ref k, ref v) => try!(write!(f, "; {}=\"{}\"", k, v)),
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ContentDisposition,DispositionType,DispositionParam};
+    use ::header::Header;
+    use ::header::shared::Charset;
+
+    #[test]
+    fn test_parse_header() {
+        assert!(ContentDisposition::parse_header(&"".into()).is_err());
+
+        let a = "form-data; dummy=3; name=upload;\r\n filename=\"sample.png\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Ext("form-data".to_owned()),
+            parameters: vec![
+                DispositionParam::Ext("dummy".to_owned(), "3".to_owned()),
+                DispositionParam::Ext("name".to_owned(), "upload".to_owned()),
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "sample.png".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename=\"image.jpg\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "image.jpg".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    vec![0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20,
+                         0xe2, 0x82, 0xac, 0x20, b'r', b'a', b't', b'e', b's']) ]
+        };
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn test_display() {
+        let as_string = "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
+        let a = as_string.into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!(as_string, display_rendered);
+
+        let a = "attachment; filename*=UTF-8''black%20and%20white.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"black and white.csv\"".to_owned(), display_rendered);
+
+        let a = "attachment; filename=colourful.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"colourful.csv\"".to_owned(), display_rendered);
+    }
+}

src/header/common/content_language.rs

@@ -0,0 +1,65 @@
+use language_tags::LanguageTag;
+use header::{CONTENT_LANGUAGE, QualityItem};
+
+header! {
+    /// `Content-Language` header, defined in
+    /// [RFC7231](https://tools.ietf.org/html/rfc7231#section-3.1.3.2)
+    /// 
+    /// The `Content-Language` header field describes the natural language(s)
+    /// of the intended audience for the representation.  Note that this
+    /// might not be equivalent to all the languages used within the
+    /// representation.
+    /// 
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Language = 1#language-tag
+    /// ```
+    /// 
+    /// # Example values
+    ///
+    /// * `da`
+    /// * `mi, en`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// # use actix_web::http::header::{ContentLanguage, qitem};
+    /// # 
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(en)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::HttpResponse;
+    /// # use actix_web::http::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    /// 
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         qitem(langtag!(en;;;GB)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (ContentLanguage, CONTENT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_content_language {
+        test_header!(test1, vec![b"da"]);
+        test_header!(test2, vec![b"mi, en"]);
+    }
+}

src/header/common/content_range.rs

@@ -0,0 +1,205 @@
+use std::fmt::{self, Display, Write};
+use std::str::FromStr;
+use error::ParseError;
+use header::{IntoHeaderValue, Writer,
+             HeaderValue, InvalidHeaderValueBytes, CONTENT_RANGE};
+
+header! {
+    /// `Content-Range` header, defined in
+    /// [RFC7233](http://tools.ietf.org/html/rfc7233#section-4.2)
+    (ContentRange, CONTENT_RANGE) => [ContentRangeSpec]
+
+    test_content_range {
+        test_header!(test_bytes,
+            vec![b"bytes 0-499/500"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: Some((0, 499)),
+                instance_length: Some(500)
+            })));
+
+        test_header!(test_bytes_unknown_len,
+            vec![b"bytes 0-499/*"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: Some((0, 499)),
+                instance_length: None
+            })));
+
+        test_header!(test_bytes_unknown_range,
+            vec![b"bytes */500"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: None,
+                instance_length: Some(500)
+            })));
+
+        test_header!(test_unregistered,
+            vec![b"seconds 1-2"],
+            Some(ContentRange(ContentRangeSpec::Unregistered {
+                unit: "seconds".to_owned(),
+                resp: "1-2".to_owned()
+            })));
+
+        test_header!(test_no_len,
+            vec![b"bytes 0-499"],
+            None::<ContentRange>);
+
+        test_header!(test_only_unit,
+            vec![b"bytes"],
+            None::<ContentRange>);
+
+        test_header!(test_end_less_than_start,
+            vec![b"bytes 499-0/500"],
+            None::<ContentRange>);
+
+        test_header!(test_blank,
+            vec![b""],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_spaces,
+            vec![b"bytes 1-2/500 3"],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_slashes,
+            vec![b"bytes 1-2/500/600"],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_dashes,
+            vec![b"bytes 1-2-3/500"],
+            None::<ContentRange>);
+
+    }
+}
+
+
+/// Content-Range, described in [RFC7233](https://tools.ietf.org/html/rfc7233#section-4.2)
+///
+/// # ABNF
+///
+/// ```text
+/// Content-Range       = byte-content-range
+///                     / other-content-range
+///
+/// byte-content-range  = bytes-unit SP
+///                       ( byte-range-resp / unsatisfied-range )
+///
+/// byte-range-resp     = byte-range "/" ( complete-length / "*" )
+/// byte-range          = first-byte-pos "-" last-byte-pos
+/// unsatisfied-range   = "*/" complete-length
+///
+/// complete-length     = 1*DIGIT
+///
+/// other-content-range = other-range-unit SP other-range-resp
+/// other-range-resp    = *CHAR
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub enum ContentRangeSpec {
+    /// Byte range
+    Bytes {
+        /// First and last bytes of the range, omitted if request could not be
+        /// satisfied
+        range: Option<(u64, u64)>,
+
+        /// Total length of the instance, can be omitted if unknown
+        instance_length: Option<u64>
+    },
+
+    /// Custom range, with unit not registered at IANA
+    Unregistered {
+        /// other-range-unit
+        unit: String,
+
+        /// other-range-resp
+        resp: String
+    }
+}
+
+fn split_in_two(s: &str, separator: char) -> Option<(&str, &str)> {
+    let mut iter = s.splitn(2, separator);
+    match (iter.next(), iter.next()) {
+        (Some(a), Some(b)) => Some((a, b)),
+        _ => None
+    }
+}
+
+impl FromStr for ContentRangeSpec {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, ParseError> {
+        let res = match split_in_two(s, ' ') {
+            Some(("bytes", resp)) => {
+                let (range, instance_length) = split_in_two(
+                    resp, '/').ok_or(ParseError::Header)?;
+
+                let instance_length = if instance_length == "*" {
+                    None
+                } else {
+                    Some(instance_length.parse()
+                         .map_err(|_| ParseError::Header)?)
+                };
+
+                let range = if range == "*" {
+                    None
+                } else {
+                    let (first_byte, last_byte) = split_in_two(
+                        range, '-').ok_or(ParseError::Header)?;
+                    let first_byte = first_byte.parse()
+                        .map_err(|_| ParseError::Header)?;
+                    let last_byte = last_byte.parse()
+                        .map_err(|_| ParseError::Header)?;
+                    if last_byte < first_byte {
+                        return Err(ParseError::Header);
+                    }
+                    Some((first_byte, last_byte))
+                };
+
+                ContentRangeSpec::Bytes {range, instance_length}
+            }
+            Some((unit, resp)) => {
+                ContentRangeSpec::Unregistered {
+                    unit: unit.to_owned(),
+                    resp: resp.to_owned()
+                }
+            }
+            _ => return Err(ParseError::Header)
+        };
+        Ok(res)
+    }
+}
+
+impl Display for ContentRangeSpec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ContentRangeSpec::Bytes { range, instance_length } => {
+                try!(f.write_str("bytes "));
+                match range {
+                    Some((first_byte, last_byte)) => {
+                        try!(write!(f, "{}-{}", first_byte, last_byte));
+                    },
+                    None => {
+                        try!(f.write_str("*"));
+                    }
+                };
+                try!(f.write_str("/"));
+                if let Some(v) = instance_length {
+                    write!(f, "{}", v)
+                } else {
+                    f.write_str("*")
+                }
+            }
+            ContentRangeSpec::Unregistered { ref unit, ref resp } => {
+                try!(f.write_str(unit));
+                try!(f.write_str(" "));
+                f.write_str(resp)
+            }
+        }
+    }
+}
+
+impl IntoHeaderValue for ContentRangeSpec {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        HeaderValue::from_shared(writer.take())
+    }
+}

src/header/common/content_type.rs

@@ -0,0 +1,119 @@
+use mime::{self, Mime};
+use header::CONTENT_TYPE;
+
+
+header! {
+    /// `Content-Type` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)
+    ///
+    /// The `Content-Type` header field indicates the media type of the
+    /// associated representation: either the representation enclosed in the
+    /// message payload or the selected representation, as determined by the
+    /// message semantics.  The indicated media type defines both the data
+    /// format and how that data is intended to be processed by a recipient,
+    /// within the scope of the received message semantics, after any content
+    /// codings indicated by Content-Encoding are decoded.
+    ///
+    /// Although the `mime` crate allows the mime options to be any slice, this crate
+    /// forces the use of Vec. This is to make sure the same header can't have more than 1 type. If
+    /// this is an issue, it's possible to implement `Header` on a custom struct.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Type = media-type
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `text/html; charset=utf-8`
+    /// * `application/json`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::ContentType;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentType::json()
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_web;
+    /// use mime::TEXT_HTML;
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::ContentType;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     ContentType(TEXT_HTML)
+    /// );
+    /// # }
+    /// ```
+    (ContentType, CONTENT_TYPE) => [Mime]
+
+    test_content_type {
+        test_header!(
+            test1,
+            vec![b"text/html"],
+            Some(HeaderField(TEXT_HTML)));
+    }
+}
+
+impl ContentType {
+    /// A constructor  to easily create a `Content-Type: application/json` header.
+    #[inline]
+    pub fn json() -> ContentType {
+        ContentType(mime::APPLICATION_JSON)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/plain; charset=utf-8` header.
+    #[inline]
+    pub fn plaintext() -> ContentType {
+        ContentType(mime::TEXT_PLAIN_UTF_8)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/html` header.
+    #[inline]
+    pub fn html() -> ContentType {
+        ContentType(mime::TEXT_HTML)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/xml` header.
+    #[inline]
+    pub fn xml() -> ContentType {
+        ContentType(mime::TEXT_XML)
+    }
+
+    /// A constructor  to easily create a `Content-Type: application/www-form-url-encoded` header.
+    #[inline]
+    pub fn form_url_encoded() -> ContentType {
+        ContentType(mime::APPLICATION_WWW_FORM_URLENCODED)
+    }
+    /// A constructor  to easily create a `Content-Type: image/jpeg` header.
+    #[inline]
+    pub fn jpeg() -> ContentType {
+        ContentType(mime::IMAGE_JPEG)
+    }
+
+    /// A constructor  to easily create a `Content-Type: image/png` header.
+    #[inline]
+    pub fn png() -> ContentType {
+        ContentType(mime::IMAGE_PNG)
+    }
+
+    /// A constructor  to easily create a `Content-Type: application/octet-stream` header.
+    #[inline]
+    pub fn octet_stream() -> ContentType {
+        ContentType(mime::APPLICATION_OCTET_STREAM)
+    }
+}
+
+impl Eq for ContentType {}

src/header/common/date.rs

@@ -0,0 +1,42 @@
+use std::time::SystemTime;
+use header::{DATE, HttpDate};
+
+
+header! {
+    /// `Date` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.1.2)
+    ///
+    /// The `Date` header field represents the date and time at which the
+    /// message was originated.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Date = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Tue, 15 Nov 1994 08:12:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Date;
+    /// use std::time::SystemTime;
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(Date(SystemTime::now().into()));
+    /// ```
+    (Date, DATE) => [HttpDate]
+
+    test_date {
+        test_header!(test1, vec![b"Tue, 15 Nov 1994 08:12:31 GMT"]);
+    }
+}
+
+impl Date {
+    pub fn now() -> Date {
+        Date(SystemTime::now().into())
+    }
+}

src/header/common/etag.rs

@@ -0,0 +1,96 @@
+use header::{ETAG, EntityTag};
+
+header! {
+    /// `ETag` header, defined in [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.3)
+    ///
+    /// The `ETag` header field in a response provides the current entity-tag
+    /// for the selected representation, as determined at the conclusion of
+    /// handling the request.  An entity-tag is an opaque validator for
+    /// differentiating between multiple representations of the same
+    /// resource, regardless of whether those multiple representations are
+    /// due to resource state changes over time, content negotiation
+    /// resulting in multiple representations being valid at the same time,
+    /// or both.  An entity-tag consists of an opaque quoted string, possibly
+    /// prefixed by a weakness indicator.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// ETag       = entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * `W/"xyzzy"`
+    /// * `""`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{ETag, EntityTag};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(ETag(EntityTag::new(false, "xyzzy".to_owned())));
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{ETag, EntityTag};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(ETag(EntityTag::new(true, "xyzzy".to_owned())));
+    /// ```
+    (ETag, ETAG) => [EntityTag]
+
+    test_etag {
+        // From the RFC
+        test_header!(test1,
+            vec![b"\"xyzzy\""],
+            Some(ETag(EntityTag::new(false, "xyzzy".to_owned()))));
+        test_header!(test2,
+            vec![b"W/\"xyzzy\""],
+            Some(ETag(EntityTag::new(true, "xyzzy".to_owned()))));
+        test_header!(test3,
+            vec![b"\"\""],
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
+        // Own tests
+        test_header!(test4,
+            vec![b"\"foobar\""],
+            Some(ETag(EntityTag::new(false, "foobar".to_owned()))));
+        test_header!(test5,
+            vec![b"\"\""],
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
+        test_header!(test6,
+            vec![b"W/\"weak-etag\""],
+            Some(ETag(EntityTag::new(true, "weak-etag".to_owned()))));
+        test_header!(test7,
+            vec![b"W/\"\x65\x62\""],
+            Some(ETag(EntityTag::new(true, "\u{0065}\u{0062}".to_owned()))));
+        test_header!(test8,
+            vec![b"W/\"\""],
+            Some(ETag(EntityTag::new(true, "".to_owned()))));
+        test_header!(test9,
+            vec![b"no-dquotes"],
+            None::<ETag>);
+        test_header!(test10,
+            vec![b"w/\"the-first-w-is-case-sensitive\""],
+            None::<ETag>);
+        test_header!(test11,
+            vec![b""],
+            None::<ETag>);
+        test_header!(test12,
+            vec![b"\"unmatched-dquotes1"],
+            None::<ETag>);
+        test_header!(test13,
+            vec![b"unmatched-dquotes2\""],
+            None::<ETag>);
+        test_header!(test14,
+            vec![b"matched-\"dquotes\""],
+            None::<ETag>);
+        test_header!(test15,
+            vec![b"\""],
+            None::<ETag>);
+    }
+}

src/header/common/expires.rs

@@ -0,0 +1,39 @@
+use header::{EXPIRES, HttpDate};
+
+header! {
+    /// `Expires` header, defined in [RFC7234](http://tools.ietf.org/html/rfc7234#section-5.3)
+    ///
+    /// The `Expires` header field gives the date/time after which the
+    /// response is considered stale.
+    ///
+    /// The presence of an Expires field does not imply that the original
+    /// resource will change or cease to exist at, before, or after that
+    /// time.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Expires = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    /// * `Thu, 01 Dec 1994 16:00:00 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::Expires;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// let expiration = SystemTime::now() + Duration::from_secs(60 * 60 * 24);
+    /// builder.set(Expires(expiration.into()));
+    /// ```
+    (Expires, EXPIRES) => [HttpDate]
+
+    test_expires {
+        // Test case from RFC
+        test_header!(test1, vec![b"Thu, 01 Dec 1994 16:00:00 GMT"]);
+    }
+}

src/header/common/if_match.rs

@@ -0,0 +1,70 @@
+use header::{IF_MATCH, EntityTag};
+
+header! {
+    /// `If-Match` header, defined in
+    /// [RFC7232](https://tools.ietf.org/html/rfc7232#section-3.1)
+    ///
+    /// The `If-Match` header field makes the request method conditional on
+    /// the recipient origin server either having at least one current
+    /// representation of the target resource, when the field-value is "*",
+    /// or having a current representation of the target resource that has an
+    /// entity-tag matching a member of the list of entity-tags provided in
+    /// the field-value.
+    ///
+    /// An origin server MUST use the strong comparison function when
+    /// comparing entity-tags for `If-Match`, since the client
+    /// intends this precondition to prevent the method from being applied if
+    /// there have been any changes to the representation data.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Match = "*" / 1#entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * "xyzzy", "r2d2xxxx", "c3piozzzz"
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::IfMatch;
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(IfMatch::Any);
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{IfMatch, EntityTag};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     IfMatch::Items(vec![
+    ///         EntityTag::new(false, "xyzzy".to_owned()),
+    ///         EntityTag::new(false, "foobar".to_owned()),
+    ///         EntityTag::new(false, "bazquux".to_owned()),
+    ///     ])
+    /// );
+    /// ```
+    (IfMatch, IF_MATCH) => {Any / (EntityTag)+}
+
+    test_if_match {
+        test_header!(
+            test1,
+            vec![b"\"xyzzy\""],
+            Some(HeaderField::Items(
+                vec![EntityTag::new(false, "xyzzy".to_owned())])));
+        test_header!(
+            test2,
+            vec![b"\"xyzzy\", \"r2d2xxxx\", \"c3piozzzz\""],
+            Some(HeaderField::Items(
+                vec![EntityTag::new(false, "xyzzy".to_owned()),
+                     EntityTag::new(false, "r2d2xxxx".to_owned()),
+                     EntityTag::new(false, "c3piozzzz".to_owned())])));
+        test_header!(test3, vec![b"*"], Some(IfMatch::Any));
+    }
+}

src/header/common/if_modified_since.rs

@@ -0,0 +1,39 @@
+use header::{IF_MODIFIED_SINCE, HttpDate};
+
+header! {
+    /// `If-Modified-Since` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.3)
+    ///
+    /// The `If-Modified-Since` header field makes a GET or HEAD request
+    /// method conditional on the selected representation's modification date
+    /// being more recent than the date provided in the field-value.
+    /// Transfer of the selected representation's data is avoided if that
+    /// data has not changed.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Unmodified-Since = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::IfModifiedSince;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(IfModifiedSince(modified.into()));
+    /// ```
+    (IfModifiedSince, IF_MODIFIED_SINCE) => [HttpDate]
+
+    test_if_modified_since {
+        // Test case from RFC
+        test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    }
+}

src/header/common/if_none_match.rs

@@ -0,0 +1,91 @@
+use header::{IF_NONE_MATCH, EntityTag};
+
+header! {
+    /// `If-None-Match` header, defined in
+    /// [RFC7232](https://tools.ietf.org/html/rfc7232#section-3.2)
+    ///
+    /// The `If-None-Match` header field makes the request method conditional
+    /// on a recipient cache or origin server either not having any current
+    /// representation of the target resource, when the field-value is "*",
+    /// or having a selected representation with an entity-tag that does not
+    /// match any of those listed in the field-value.
+    ///
+    /// A recipient MUST use the weak comparison function when comparing
+    /// entity-tags for If-None-Match (Section 2.3.2), since weak entity-tags
+    /// can be used for cache validation even if there have been changes to
+    /// the representation data.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-None-Match = "*" / 1#entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * `W/"xyzzy"`
+    /// * `"xyzzy", "r2d2xxxx", "c3piozzzz"`
+    /// * `W/"xyzzy", W/"r2d2xxxx", W/"c3piozzzz"`
+    /// * `*`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::IfNoneMatch;
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(IfNoneMatch::Any);
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::{IfNoneMatch, EntityTag};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// builder.set(
+    ///     IfNoneMatch::Items(vec![
+    ///         EntityTag::new(false, "xyzzy".to_owned()),
+    ///         EntityTag::new(false, "foobar".to_owned()),
+    ///         EntityTag::new(false, "bazquux".to_owned()),
+    ///     ])
+    /// );
+    /// ```
+    (IfNoneMatch, IF_NONE_MATCH) => {Any / (EntityTag)+}
+
+    test_if_none_match {
+        test_header!(test1, vec![b"\"xyzzy\""]);
+        test_header!(test2, vec![b"W/\"xyzzy\""]);
+        test_header!(test3, vec![b"\"xyzzy\", \"r2d2xxxx\", \"c3piozzzz\""]);
+        test_header!(test4, vec![b"W/\"xyzzy\", W/\"r2d2xxxx\", W/\"c3piozzzz\""]);
+        test_header!(test5, vec![b"*"]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IfNoneMatch;
+    use test::TestRequest;
+    use header::{IF_NONE_MATCH, Header, EntityTag};
+
+    #[test]
+    fn test_if_none_match() {
+        let mut if_none_match: Result<IfNoneMatch, _>;
+
+        let req = TestRequest::with_header(IF_NONE_MATCH, "*").finish();
+        if_none_match = Header::parse(&req);
+        assert_eq!(if_none_match.ok(), Some(IfNoneMatch::Any));
+
+        let req = TestRequest::with_header(
+            IF_NONE_MATCH, &b"\"foobar\", W/\"weak-etag\""[..]).finish();
+
+        if_none_match = Header::parse(&req);
+        let mut entities: Vec<EntityTag> = Vec::new();
+        let foobar_etag = EntityTag::new(false, "foobar".to_owned());
+        let weak_etag = EntityTag::new(true, "weak-etag".to_owned());
+        entities.push(foobar_etag);
+        entities.push(weak_etag);
+        assert_eq!(if_none_match.ok(), Some(IfNoneMatch::Items(entities)));
+    }
+}

src/header/common/if_range.rs

@@ -0,0 +1,111 @@
+use std::fmt::{self, Display, Write};
+use error::ParseError;
+use httpmessage::HttpMessage;
+use http::header;
+use header::from_one_raw_str;
+use header::{IntoHeaderValue, Header, HeaderName, HeaderValue,
+             EntityTag, HttpDate, Writer, InvalidHeaderValueBytes};
+
+/// `If-Range` header, defined in [RFC7233](http://tools.ietf.org/html/rfc7233#section-3.2)
+///
+/// If a client has a partial copy of a representation and wishes to have
+/// an up-to-date copy of the entire representation, it could use the
+/// Range header field with a conditional GET (using either or both of
+/// If-Unmodified-Since and If-Match.)  However, if the precondition
+/// fails because the representation has been modified, the client would
+/// then have to make a second request to obtain the entire current
+/// representation.
+///
+/// The `If-Range` header field allows a client to \"short-circuit\" the
+/// second request.  Informally, its meaning is as follows: if the
+/// representation is unchanged, send me the part(s) that I am requesting
+/// in Range; otherwise, send me the entire representation.
+///
+/// # ABNF
+///
+/// ```text
+/// If-Range = entity-tag / HTTP-date
+/// ```
+///
+/// # Example values
+///
+/// * `Sat, 29 Oct 1994 19:43:31 GMT`
+/// * `\"xyzzy\"`
+///
+/// # Examples
+///
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::{IfRange, EntityTag};
+///
+/// let mut builder = HttpResponse::Ok();
+/// builder.set(IfRange::EntityTag(EntityTag::new(false, "xyzzy".to_owned())));
+/// ```
+///
+/// ```rust
+/// use actix_web::HttpResponse;
+/// use actix_web::http::header::IfRange;
+/// use std::time::{SystemTime, Duration};
+///
+/// let mut builder = HttpResponse::Ok();
+/// let fetched = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+/// builder.set(IfRange::Date(fetched.into()));
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub enum IfRange {
+    /// The entity-tag the client has of the resource
+    EntityTag(EntityTag),
+    /// The date when the client retrieved the resource
+    Date(HttpDate),
+}
+
+impl Header for IfRange {
+    fn name() -> HeaderName {
+        header::IF_RANGE
+    }
+    #[inline]
+    fn parse<T>(msg: &T) -> Result<Self, ParseError> where T: HttpMessage
+    {
+        let etag: Result<EntityTag, _> =
+            from_one_raw_str(msg.headers().get(header::IF_RANGE));
+        if let Ok(etag) = etag {
+            return Ok(IfRange::EntityTag(etag));
+        }
+        let date: Result<HttpDate, _> =
+            from_one_raw_str(msg.headers().get(header::IF_RANGE));
+        if let Ok(date) = date {
+            return Ok(IfRange::Date(date));
+        }
+        Err(ParseError::Header)
+    }
+}
+
+impl Display for IfRange {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            IfRange::EntityTag(ref x) => Display::fmt(x, f),
+            IfRange::Date(ref x) => Display::fmt(x, f),
+        }
+    }
+}
+
+impl IntoHeaderValue for IfRange {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        HeaderValue::from_shared(writer.take())
+    }
+}
+
+
+#[cfg(test)]
+mod test_if_range {
+    use std::str;
+    use header::*;
+    use super::IfRange as HeaderField;
+    test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    test_header!(test2, vec![b"\"xyzzy\""]);
+    test_header!(test3, vec![b"this-is-invalid"], None::<IfRange>);
+}

src/header/common/if_unmodified_since.rs

@@ -0,0 +1,40 @@
+use header::{IF_UNMODIFIED_SINCE, HttpDate};
+
+header! {
+    /// `If-Unmodified-Since` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.4)
+    ///
+    /// The `If-Unmodified-Since` header field makes the request method
+    /// conditional on the selected representation's last modification date
+    /// being earlier than or equal to the date provided in the field-value.
+    /// This field accomplishes the same purpose as If-Match for cases where
+    /// the user agent does not have an entity-tag for the representation.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Unmodified-Since = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::IfUnmodifiedSince;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(IfUnmodifiedSince(modified.into()));
+    /// ```
+    (IfUnmodifiedSince, IF_UNMODIFIED_SINCE) => [HttpDate]
+
+    test_if_unmodified_since {
+        // Test case from RFC
+        test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    }
+}

src/header/common/last_modified.rs

@@ -0,0 +1,38 @@
+use header::{LAST_MODIFIED, HttpDate};
+
+header! {
+    /// `Last-Modified` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.2)
+    ///
+    /// The `Last-Modified` header field in a response provides a timestamp
+    /// indicating the date and time at which the origin server believes the
+    /// selected representation was last modified, as determined at the
+    /// conclusion of handling the request.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Expires = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::HttpResponse;
+    /// use actix_web::http::header::LastModified;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = HttpResponse::Ok();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(LastModified(modified.into()));
+    /// ```
+    (LastModified, LAST_MODIFIED) => [HttpDate]
+
+        test_last_modified {
+            // Test case from RFC
+            test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);}
+}

src/header/common/mod.rs

@@ -0,0 +1,351 @@
+//! A Collection of Header implementations for common HTTP Headers.
+//!
+//! ## Mime
+//!
+//! Several header fields use MIME values for their contents. Keeping with the
+//! strongly-typed theme, the [mime](https://docs.rs/mime) crate
+//! is used, such as `ContentType(pub Mime)`.
+
+pub use self::accept_charset::AcceptCharset;
+//pub use self::accept_encoding::AcceptEncoding;
+pub use self::accept_language::AcceptLanguage;
+pub use self::accept::Accept;
+pub use self::allow::Allow;
+pub use self::cache_control::{CacheControl, CacheDirective};
+//pub use self::content_disposition::{ContentDisposition, DispositionType, DispositionParam};
+pub use self::content_language::ContentLanguage;
+pub use self::content_range::{ContentRange, ContentRangeSpec};
+pub use self::content_type::ContentType;
+pub use self::date::Date;
+pub use self::etag::ETag;
+pub use self::expires::Expires;
+pub use self::if_match::IfMatch;
+pub use self::if_modified_since::IfModifiedSince;
+pub use self::if_none_match::IfNoneMatch;
+pub use self::if_range::IfRange;
+pub use self::if_unmodified_since::IfUnmodifiedSince;
+pub use self::last_modified::LastModified;
+//pub use self::range::{Range, ByteRangeSpec};
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __hyper__deref {
+    ($from:ty => $to:ty) => {
+        impl ::std::ops::Deref for $from {
+            type Target = $to;
+
+            #[inline]
+            fn deref(&self) -> &$to {
+                &self.0
+            }
+        }
+
+        impl ::std::ops::DerefMut for $from {
+            #[inline]
+            fn deref_mut(&mut self) -> &mut $to {
+                &mut self.0
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __hyper__tm {
+    ($id:ident, $tm:ident{$($tf:item)*}) => {
+        #[allow(unused_imports)]
+        #[cfg(test)]
+        mod $tm{
+            use std::str;
+            use http::Method;
+            use $crate::header::*;
+            use $crate::mime::*;
+            use super::$id as HeaderField;
+            $($tf)*
+        }
+
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+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();
+            let mut req = test::TestRequest::default();
+            for item in a {
+                req = req.header(HeaderField::name(), item);
+            }
+            let req = req.finish();
+            let value = HeaderField::parse(&req);
+            let result = format!("{}", value.unwrap());
+            let expected = String::from_utf8(raw[0].to_vec()).unwrap();
+            let result_cmp: Vec<String> = result
+                .to_ascii_lowercase()
+                .split(' ')
+                .map(|x| x.to_owned())
+                .collect();
+            let expected_cmp: Vec<String> = expected
+                .to_ascii_lowercase()
+                .split(' ')
+                .map(|x| x.to_owned())
+                .collect();
+            assert_eq!(result_cmp.concat(), expected_cmp.concat());
+        }
+    };
+    ($id:ident, $raw:expr, $typed:expr) => {
+        #[test]
+        fn $id() {
+            use $crate::test;
+            let a: Vec<Vec<u8>> = $raw.iter().map(|x| x.to_vec()).collect();
+            let mut req = test::TestRequest::default();
+            for item in a {
+                req = req.header(HeaderField::name(), item);
+            }
+            let req = req.finish();
+            let val = HeaderField::parse(&req);
+            let typed: Option<HeaderField> = $typed;
+            // Test parsing
+            assert_eq!(val.ok(), typed);
+            // Test formatting
+            if typed.is_some() {
+                let raw = &($raw)[..];
+                let mut iter = raw.iter().map(|b|str::from_utf8(&b[..]).unwrap());
+                let mut joined = String::new();
+                joined.push_str(iter.next().unwrap());
+                for s in iter {
+                    joined.push_str(", ");
+                    joined.push_str(s);
+                }
+                assert_eq!(format!("{}", typed.unwrap()), joined);
+            }
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! header {
+    // $a:meta: Attributes associated with the header item (usually docs)
+    // $id:ident: Identifier of the header
+    // $n:expr: Lowercase name of the header
+    // $nn:expr: Nice name of the header
+
+    // List header, zero or more items
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)*) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub Vec<$item>);
+        __hyper__deref!($id => Vec<$item>);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_comma_delimited(
+                    msg.headers().get_all(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                $crate::header::fmt_comma_delimited(f, &self.0[..])
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+    // List header, one or more items
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)+) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub Vec<$item>);
+        __hyper__deref!($id => Vec<$item>);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_comma_delimited(
+                    msg.headers().get_all(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                $crate::header::fmt_comma_delimited(f, &self.0[..])
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+    // Single value header
+    ($(#[$a:meta])*($id:ident, $name:expr) => [$value:ty]) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub $value);
+        __hyper__deref!($id => $value);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_one_raw_str(
+                    msg.headers().get(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                ::std::fmt::Display::fmt(&self.0, f)
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::HeaderValue, Self::Error> {
+                self.0.try_into()
+            }
+        }
+    };
+    // List header, one or more items with "*" option
+    ($(#[$a:meta])*($id:ident, $name:expr) => {Any / ($item:ty)+}) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub enum $id {
+            /// Any value is a match
+            Any,
+            /// Only the listed items are a match
+            Items(Vec<$item>),
+        }
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                let any = msg.headers().get(Self::name()).and_then(|hdr| {
+                    hdr.to_str().ok().and_then(|hdr| Some(hdr.trim() == "*"))});
+
+                if let Some(true) = any {
+                    Ok($id::Any)
+                } else {
+                    Ok($id::Items(
+                        $crate::header::from_comma_delimited(
+                            msg.headers().get_all(Self::name()))?))
+                }
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                match *self {
+                    $id::Any => f.write_str("*"),
+                    $id::Items(ref fields) => $crate::header::fmt_comma_delimited(
+                        f, &fields[..])
+                }
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+
+    // optional test module
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)* $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $name) => ($item)*
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $n:expr) => ($item:ty)+ $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $n) => ($item)+
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $name:expr) => [$item:ty] $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])* ($id, $name) => [$item]
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $name:expr) => {Any / ($item:ty)+} $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $name) => {Any / ($item)+}
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+}
+
+
+mod accept_charset;
+//mod accept_encoding;
+mod accept_language;
+mod accept;
+mod allow;
+mod cache_control;
+//mod content_disposition;
+mod content_language;
+mod content_range;
+mod content_type;
+mod date;
+mod etag;
+mod expires;
+mod if_match;
+mod if_modified_since;
+mod if_none_match;
+mod if_range;
+mod if_unmodified_since;
+mod last_modified;
+//mod range;

src/header/common/range.rs

@@ -0,0 +1,387 @@
+use std::fmt::{self, Display};
+use std::str::FromStr;
+
+use header::{Header, Raw};
+use header::parsing::{from_one_raw_str};
+
+/// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
+///
+/// The "Range" header field on a GET request modifies the method
+/// semantics to request transfer of only one or more subranges of the
+/// selected representation data, rather than the entire selected
+/// representation data.
+///
+/// # ABNF
+///
+/// ```text
+/// Range =	byte-ranges-specifier / other-ranges-specifier
+/// other-ranges-specifier = other-range-unit "=" other-range-set
+/// other-range-set = 1*VCHAR
+///
+/// bytes-unit = "bytes"
+///
+/// byte-ranges-specifier = bytes-unit "=" byte-range-set
+/// byte-range-set = 1#(byte-range-spec / suffix-byte-range-spec)
+/// byte-range-spec = first-byte-pos "-" [last-byte-pos]
+/// first-byte-pos = 1*DIGIT
+/// last-byte-pos = 1*DIGIT
+/// ```
+///
+/// # Example values
+///
+/// * `bytes=1000-`
+/// * `bytes=-2000`
+/// * `bytes=0-1,30-40`
+/// * `bytes=0-10,20-90,-100`
+/// * `custom_unit=0-123`
+/// * `custom_unit=xxx-yyy`
+///
+/// # Examples
+///
+/// ```
+/// use hyper::header::{Headers, Range, ByteRangeSpec};
+///
+/// let mut headers = Headers::new();
+/// headers.set(Range::Bytes(
+///     vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
+/// ));
+///
+/// headers.clear();
+/// headers.set(Range::Unregistered("letters".to_owned(), "a-f".to_owned()));
+/// ```
+///
+/// ```
+/// use hyper::header::{Headers, Range};
+///
+/// let mut headers = Headers::new();
+/// headers.set(Range::bytes(1, 100));
+///
+/// headers.clear();
+/// headers.set(Range::bytes_multi(vec![(1, 100), (200, 300)]));
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub enum Range {
+    /// Byte range
+    Bytes(Vec<ByteRangeSpec>),
+    /// Custom range, with unit not registered at IANA
+    /// (`other-range-unit`: String , `other-range-set`: String)
+    Unregistered(String, String)
+}
+
+/// Each `Range::Bytes` header can contain one or more `ByteRangeSpecs`.
+/// Each `ByteRangeSpec` defines a range of bytes to fetch
+#[derive(PartialEq, Clone, Debug)]
+pub enum ByteRangeSpec {
+    /// Get all bytes between x and y ("x-y")
+    FromTo(u64, u64),
+    /// Get all bytes starting from x ("x-")
+    AllFrom(u64),
+    /// Get last x bytes ("-x")
+    Last(u64)
+}
+
+impl ByteRangeSpec {
+    /// Given the full length of the entity, attempt to normalize the byte range
+    /// into an satisfiable end-inclusive (from, to) range.
+    ///
+    /// The resulting range is guaranteed to be a satisfiable range within the bounds
+    /// of `0 <= from <= to < full_length`.
+    ///
+    /// If the byte range is deemed unsatisfiable, `None` is returned.
+    /// An unsatisfiable range is generally cause for a server to either reject
+    /// the client request with a `416 Range Not Satisfiable` status code, or to
+    /// simply ignore the range header and serve the full entity using a `200 OK`
+    /// status code.
+    ///
+    /// This function closely follows [RFC 7233][1] section 2.1.
+    /// As such, it considers ranges to be satisfiable if they meet the following
+    /// conditions: 
+    ///
+    /// > If a valid byte-range-set includes at least one byte-range-spec with
+    /// a first-byte-pos that is less than the current length of the
+    /// representation, or at least one suffix-byte-range-spec with a
+    /// non-zero suffix-length, then the byte-range-set is satisfiable.
+    /// Otherwise, the byte-range-set is unsatisfiable.
+    ///
+    /// The function also computes remainder ranges based on the RFC:
+    ///
+    /// > If the last-byte-pos value is
+    /// absent, or if the value is greater than or equal to the current
+    /// length of the representation data, the byte range is interpreted as
+    /// the remainder of the representation (i.e., the server replaces the
+    /// value of last-byte-pos with a value that is one less than the current
+    /// length of the selected representation).
+    ///
+    /// [1]: https://tools.ietf.org/html/rfc7233
+    pub fn to_satisfiable_range(&self, full_length: u64) -> Option<(u64, u64)> {
+        // If the full length is zero, there is no satisfiable end-inclusive range.
+        if full_length == 0 {
+            return None;
+        }
+        match self {
+            &ByteRangeSpec::FromTo(from, to) => {
+                if from < full_length && from <= to {
+                    Some((from, ::std::cmp::min(to, full_length - 1)))
+                } else {
+                    None
+                }
+            },
+            &ByteRangeSpec::AllFrom(from) => {
+                if from < full_length {
+                    Some((from, full_length - 1))
+                } else {
+                    None
+                }
+            },
+            &ByteRangeSpec::Last(last) => {
+                if last > 0 {
+                    // From the RFC: If the selected representation is shorter
+                    // than the specified suffix-length,
+                    // the entire representation is used.
+                    if last > full_length {
+                        Some((0, full_length - 1))
+                    } else {
+                        Some((full_length - last, full_length - 1))
+                    }
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}
+
+impl Range {
+    /// Get the most common byte range header ("bytes=from-to")
+    pub fn bytes(from: u64, to: u64) -> Range {
+        Range::Bytes(vec![ByteRangeSpec::FromTo(from, to)])
+    }
+
+    /// Get byte range header with multiple subranges
+    /// ("bytes=from1-to1,from2-to2,fromX-toX")
+    pub fn bytes_multi(ranges: Vec<(u64, u64)>) -> Range {
+        Range::Bytes(ranges.iter().map(|r| ByteRangeSpec::FromTo(r.0, r.1)).collect())
+    }
+}
+
+
+impl fmt::Display for ByteRangeSpec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ByteRangeSpec::FromTo(from, to) => write!(f, "{}-{}", from, to),
+            ByteRangeSpec::Last(pos) => write!(f, "-{}", pos),
+            ByteRangeSpec::AllFrom(pos) => write!(f, "{}-", pos),
+        }
+    }
+}
+
+
+impl fmt::Display for Range {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Range::Bytes(ref ranges) => {
+                try!(write!(f, "bytes="));
+
+                for (i, range) in ranges.iter().enumerate() {
+                    if i != 0 {
+                        try!(f.write_str(","));
+                    }
+                    try!(Display::fmt(range, f));
+                }
+                Ok(())
+            },
+            Range::Unregistered(ref unit, ref range_str) => {
+                write!(f, "{}={}", unit, range_str)
+            },
+        }
+    }
+}
+
+impl FromStr for Range {
+    type Err = ::Error;
+
+    fn from_str(s: &str) -> ::Result<Range> {
+        let mut iter = s.splitn(2, '=');
+
+        match (iter.next(), iter.next()) {
+            (Some("bytes"), Some(ranges)) => {
+                let ranges = from_comma_delimited(ranges);
+                if ranges.is_empty() {
+                    return Err(::Error::Header);
+                }
+                Ok(Range::Bytes(ranges))
+            }
+            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
+                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
+
+            },
+            _ => Err(::Error::Header)
+        }
+    }
+}
+
+impl FromStr for ByteRangeSpec {
+    type Err = ::Error;
+
+    fn from_str(s: &str) -> ::Result<ByteRangeSpec> {
+        let mut parts = s.splitn(2, '-');
+
+        match (parts.next(), parts.next()) {
+            (Some(""), Some(end)) => {
+                end.parse().or(Err(::Error::Header)).map(ByteRangeSpec::Last)
+            },
+            (Some(start), Some("")) => {
+                start.parse().or(Err(::Error::Header)).map(ByteRangeSpec::AllFrom)
+            },
+            (Some(start), Some(end)) => {
+                match (start.parse(), end.parse()) {
+                    (Ok(start), Ok(end)) if start <= end => Ok(ByteRangeSpec::FromTo(start, end)),
+                    _ => Err(::Error::Header)
+                }
+            },
+            _ => Err(::Error::Header)
+        }
+    }
+}
+
+fn from_comma_delimited<T: FromStr>(s: &str) -> Vec<T> {
+    s.split(',')
+        .filter_map(|x| match x.trim() {
+            "" => None,
+            y => Some(y)
+        })
+        .filter_map(|x| x.parse().ok())
+        .collect()
+}
+
+impl Header for Range {
+
+    fn header_name() -> &'static str {
+        static NAME: &'static str = "Range";
+        NAME
+    }
+
+    fn parse_header(raw: &Raw) -> ::Result<Range> {
+        from_one_raw_str(raw)
+    }
+
+    fn fmt_header(&self, f: &mut ::header::Formatter) -> fmt::Result {
+        f.fmt_line(self)
+    }
+
+}
+
+#[test]
+fn test_parse_bytes_range_valid() {
+    let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
+    let r3 =  Range::bytes(1, 100);
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
+    let r3 =  Range::Bytes(
+        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
+    );
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
+    let r3 =  Range::Bytes(
+        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::Last(100)]
+    );
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+
+}
+
+#[test]
+fn test_parse_unregistered_range_valid() {
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "abcd".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
+    assert_eq!(r, r2);
+}
+
+#[test]
+fn test_parse_invalid() {
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"abc".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"custom=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
+    assert_eq!(r.ok(), None);
+}
+
+#[test]
+fn test_fmt() {
+    use header::Headers;
+
+    let mut headers = Headers::new();
+
+    headers.set(
+        Range::Bytes(
+            vec![ByteRangeSpec::FromTo(0, 1000), ByteRangeSpec::AllFrom(2000)]
+    ));
+    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
+
+    headers.clear();
+    headers.set(Range::Bytes(vec![]));
+
+    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
+
+    headers.clear();
+    headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
+
+    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
+}
+
+#[test]
+fn test_byte_range_spec_to_satisfiable_range() {
+    assert_eq!(Some((0, 0)), ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3));
+    assert_eq!(Some((1, 2)), ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3));
+    assert_eq!(Some((1, 2)), ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0));
+
+    assert_eq!(Some((0, 2)), ByteRangeSpec::AllFrom(0).to_satisfiable_range(3));
+    assert_eq!(Some((2, 2)), ByteRangeSpec::AllFrom(2).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(3).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(0).to_satisfiable_range(0));
+
+    assert_eq!(Some((1, 2)), ByteRangeSpec::Last(2).to_satisfiable_range(3));
+    assert_eq!(Some((2, 2)), ByteRangeSpec::Last(1).to_satisfiable_range(3));
+    assert_eq!(Some((0, 2)), ByteRangeSpec::Last(5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
+}
+

src/header/mod.rs

@@ -0,0 +1,248 @@
+//! Various http headers
+// This is mostly copy of [hyper](https://github.com/hyperium/hyper/tree/master/src/header)
+
+use std::fmt;
+use std::str::FromStr;
+
+use bytes::{Bytes, BytesMut};
+use modhttp::{Error as HttpError};
+use modhttp::header::GetAll;
+use mime::Mime;
+
+pub use modhttp::header::*;
+
+use error::ParseError;
+use httpmessage::HttpMessage;
+
+mod common;
+mod shared;
+#[doc(hidden)]
+pub use self::common::*;
+#[doc(hidden)]
+pub use self::shared::*;
+
+
+#[doc(hidden)]
+/// A trait for any object that will represent a header field and value.
+pub trait Header where Self: IntoHeaderValue {
+
+    /// Returns the name of the header field
+    fn name() -> HeaderName;
+
+    /// Parse a header
+    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
+}
+
+#[doc(hidden)]
+/// A trait for any object that can be Converted to a `HeaderValue`
+pub trait IntoHeaderValue: Sized {
+    /// The type returned in the event of a conversion error.
+    type Error: Into<HttpError>;
+
+    /// Cast from PyObject to a concrete Python object type.
+    fn try_into(self) -> Result<HeaderValue, Self::Error>;
+}
+
+impl IntoHeaderValue for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        Ok(self)
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a str {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        self.parse()
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a [u8] {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_bytes(self)
+    }
+}
+
+impl IntoHeaderValue for Bytes {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_shared(self)
+    }
+}
+
+impl IntoHeaderValue for Vec<u8> {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_shared(Bytes::from(self))
+    }
+}
+
+impl IntoHeaderValue for String {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_shared(Bytes::from(self))
+    }
+}
+
+impl IntoHeaderValue for Mime {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        HeaderValue::from_shared(Bytes::from(format!("{}", self)))
+    }
+}
+
+/// Represents supported types of content encodings
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum ContentEncoding {
+    /// Automatically select encoding based on encoding negotiation
+    Auto,
+    /// A format using the Brotli algorithm
+    #[cfg(feature="brotli")]
+    Br,
+    /// A format using the zlib structure with deflate algorithm
+    Deflate,
+    /// Gzip algorithm
+    Gzip,
+    /// Indicates the identity function (i.e. no compression, nor modification)
+    Identity,
+}
+
+impl ContentEncoding {
+
+    #[inline]
+    pub fn is_compression(&self) -> bool {
+        match *self {
+            ContentEncoding::Identity | ContentEncoding::Auto => false,
+            _ => true
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            #[cfg(feature="brotli")]
+            ContentEncoding::Br => "br",
+            ContentEncoding::Gzip => "gzip",
+            ContentEncoding::Deflate => "deflate",
+            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
+        }
+    }
+
+    #[inline]
+    /// default quality value
+    pub fn quality(&self) -> f64 {
+        match *self {
+            #[cfg(feature="brotli")]
+            ContentEncoding::Br => 1.1,
+            ContentEncoding::Gzip => 1.0,
+            ContentEncoding::Deflate => 0.9,
+            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
+        }
+    }
+}
+
+// TODO: remove memory allocation
+impl<'a> From<&'a str> for ContentEncoding {
+    fn from(s: &'a str) -> ContentEncoding {
+        match s.trim().to_lowercase().as_ref() {
+            #[cfg(feature="brotli")]
+            "br" => ContentEncoding::Br,
+            "gzip" => ContentEncoding::Gzip,
+            "deflate" => ContentEncoding::Deflate,
+            _ => ContentEncoding::Identity,
+        }
+    }
+}
+
+#[doc(hidden)]
+pub(crate) struct Writer {
+    buf: BytesMut,
+}
+
+impl Writer {
+    fn new() -> Writer {
+        Writer{buf: BytesMut::new()}
+    }
+    fn take(&mut self) -> Bytes {
+        self.buf.take().freeze()
+    }
+}
+
+impl fmt::Write for Writer {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.buf.extend_from_slice(s.as_bytes());
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self, args)
+    }
+}
+
+#[inline]
+#[doc(hidden)]
+/// Reads a comma-delimited raw header into a Vec.
+pub fn from_comma_delimited<T: FromStr>(all: GetAll<HeaderValue>)
+                                        -> Result<Vec<T>, ParseError>
+{
+    let mut result = Vec::new();
+    for h in all {
+        let s = h.to_str().map_err(|_| ParseError::Header)?;
+        result.extend(s.split(',')
+                      .filter_map(|x| match x.trim() {
+                          "" => None,
+                          y => Some(y)
+                      })
+                      .filter_map(|x| x.trim().parse().ok()))
+    }
+    Ok(result)
+}
+
+#[inline]
+#[doc(hidden)]
+/// Reads a single string when parsing a header.
+pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>)
+                                    -> Result<T, ParseError>
+{
+    if let Some(line) = val {
+        let line = line.to_str().map_err(|_| ParseError::Header)?;
+        if !line.is_empty() {
+            return T::from_str(line).or(Err(ParseError::Header))
+        }
+    }
+    Err(ParseError::Header)
+}
+
+#[inline]
+#[doc(hidden)]
+/// Format an array into a comma-delimited string.
+pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter, parts: &[T]) -> fmt::Result
+    where T: fmt::Display
+{
+    let mut iter = parts.iter();
+    if let Some(part) = iter.next() {
+        fmt::Display::fmt(part, f)?;
+    }
+    for part in iter {
+        f.write_str(", ")?;
+        fmt::Display::fmt(part, f)?;
+    }
+    Ok(())
+}

src/header/shared/charset.rs

@@ -0,0 +1,154 @@
+#![allow(unused, deprecated)]
+use std::fmt::{self, Display};
+use std::str::FromStr;
+use std::ascii::AsciiExt;
+
+use self::Charset::*;
+
+/// A Mime charset.
+///
+/// The string representation is normalised to upper case.
+///
+/// See [http://www.iana.org/assignments/character-sets/character-sets.xhtml][url].
+///
+/// [url]: http://www.iana.org/assignments/character-sets/character-sets.xhtml
+#[derive(Clone,Debug,PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum Charset{
+    /// US ASCII
+    Us_Ascii,
+    /// ISO-8859-1
+    Iso_8859_1,
+    /// ISO-8859-2
+    Iso_8859_2,
+    /// ISO-8859-3
+    Iso_8859_3,
+    /// ISO-8859-4
+    Iso_8859_4,
+    /// ISO-8859-5
+    Iso_8859_5,
+    /// ISO-8859-6
+    Iso_8859_6,
+    /// ISO-8859-7
+    Iso_8859_7,
+    /// ISO-8859-8
+    Iso_8859_8,
+    /// ISO-8859-9
+    Iso_8859_9,
+    /// ISO-8859-10
+    Iso_8859_10,
+    /// Shift_JIS
+    Shift_Jis,
+    /// EUC-JP
+    Euc_Jp,
+    /// ISO-2022-KR
+    Iso_2022_Kr,
+    /// EUC-KR
+    Euc_Kr,
+    /// ISO-2022-JP
+    Iso_2022_Jp,
+    /// ISO-2022-JP-2
+    Iso_2022_Jp_2,
+    /// ISO-8859-6-E
+    Iso_8859_6_E,
+    /// ISO-8859-6-I
+    Iso_8859_6_I,
+    /// ISO-8859-8-E
+    Iso_8859_8_E,
+    /// ISO-8859-8-I
+    Iso_8859_8_I,
+    /// GB2312
+    Gb2312,
+    /// Big5
+    Big5,
+    /// KOI8-R
+    Koi8_R,
+    /// An arbitrary charset specified as a string
+    Ext(String)
+}
+
+impl Charset {
+    fn name(&self) -> &str {
+        match *self {
+            Us_Ascii => "US-ASCII",
+            Iso_8859_1 => "ISO-8859-1",
+            Iso_8859_2 => "ISO-8859-2",
+            Iso_8859_3 => "ISO-8859-3",
+            Iso_8859_4 => "ISO-8859-4",
+            Iso_8859_5 => "ISO-8859-5",
+            Iso_8859_6 => "ISO-8859-6",
+            Iso_8859_7 => "ISO-8859-7",
+            Iso_8859_8 => "ISO-8859-8",
+            Iso_8859_9 => "ISO-8859-9",
+            Iso_8859_10 => "ISO-8859-10",
+            Shift_Jis => "Shift-JIS",
+            Euc_Jp => "EUC-JP",
+            Iso_2022_Kr => "ISO-2022-KR",
+            Euc_Kr => "EUC-KR",
+            Iso_2022_Jp => "ISO-2022-JP",
+            Iso_2022_Jp_2 => "ISO-2022-JP-2",
+            Iso_8859_6_E => "ISO-8859-6-E",
+            Iso_8859_6_I => "ISO-8859-6-I",
+            Iso_8859_8_E => "ISO-8859-8-E",
+            Iso_8859_8_I => "ISO-8859-8-I",
+            Gb2312 => "GB2312",
+            Big5 => "5",
+            Koi8_R => "KOI8-R",
+            Ext(ref s) => s
+        }
+    }
+}
+
+impl Display for Charset {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.name())
+    }
+}
+
+impl FromStr for Charset {
+    type Err = ::Error;
+    fn from_str(s: &str) -> ::Result<Charset> {
+        Ok(match s.to_ascii_uppercase().as_ref() {
+            "US-ASCII" => Us_Ascii,
+            "ISO-8859-1" => Iso_8859_1,
+            "ISO-8859-2" => Iso_8859_2,
+            "ISO-8859-3" => Iso_8859_3,
+            "ISO-8859-4" => Iso_8859_4,
+            "ISO-8859-5" => Iso_8859_5,
+            "ISO-8859-6" => Iso_8859_6,
+            "ISO-8859-7" => Iso_8859_7,
+            "ISO-8859-8" => Iso_8859_8,
+            "ISO-8859-9" => Iso_8859_9,
+            "ISO-8859-10" => Iso_8859_10,
+            "SHIFT-JIS" => Shift_Jis,
+            "EUC-JP" => Euc_Jp,
+            "ISO-2022-KR" => Iso_2022_Kr,
+            "EUC-KR" => Euc_Kr,
+            "ISO-2022-JP" => Iso_2022_Jp,
+            "ISO-2022-JP-2" => Iso_2022_Jp_2,
+            "ISO-8859-6-E" => Iso_8859_6_E,
+            "ISO-8859-6-I" => Iso_8859_6_I,
+            "ISO-8859-8-E" => Iso_8859_8_E,
+            "ISO-8859-8-I" => Iso_8859_8_I,
+            "GB2312" => Gb2312,
+            "5" => Big5,
+            "KOI8-R" => Koi8_R,
+            s => Ext(s.to_owned())
+        })
+    }
+}
+
+#[test]
+fn test_parse() {
+    assert_eq!(Us_Ascii,"us-ascii".parse().unwrap());
+    assert_eq!(Us_Ascii,"US-Ascii".parse().unwrap());
+    assert_eq!(Us_Ascii,"US-ASCII".parse().unwrap());
+    assert_eq!(Shift_Jis,"Shift-JIS".parse().unwrap());
+    assert_eq!(Ext("ABCD".to_owned()),"abcd".parse().unwrap());
+}
+
+#[test]
+fn test_display() {
+    assert_eq!("US-ASCII", format!("{}", Us_Ascii));
+    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
+}

src/header/shared/encoding.rs

@@ -0,0 +1,57 @@
+use std::fmt;
+use std::str;
+
+pub use self::Encoding::{Chunked, Brotli, Gzip, Deflate, Compress, Identity, EncodingExt, Trailers};
+
+/// A value to represent an encoding used in `Transfer-Encoding`
+/// or `Accept-Encoding` header.
+#[derive(Clone, PartialEq, Debug)]
+pub enum Encoding {
+    /// The `chunked` encoding.
+    Chunked,
+    /// The `br` encoding.
+    Brotli,
+    /// The `gzip` encoding.
+    Gzip,
+    /// The `deflate` encoding.
+    Deflate,
+    /// The `compress` encoding.
+    Compress,
+    /// The `identity` encoding.
+    Identity,
+    /// The `trailers` encoding.
+    Trailers,
+    /// Some other encoding that is less common, can be any String.
+    EncodingExt(String)
+}
+
+impl fmt::Display for Encoding {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            Chunked => "chunked",
+            Brotli => "br",
+            Gzip => "gzip",
+            Deflate => "deflate",
+            Compress => "compress",
+            Identity => "identity",
+            Trailers => "trailers",
+            EncodingExt(ref s) => s.as_ref()
+        })
+    }
+}
+
+impl str::FromStr for Encoding {
+    type Err = ::error::ParseError;
+    fn from_str(s: &str) -> Result<Encoding, ::error::ParseError> {
+        match s {
+            "chunked" => Ok(Chunked),
+            "br" => Ok(Brotli),
+            "deflate" => Ok(Deflate),
+            "gzip" => Ok(Gzip),
+            "compress" => Ok(Compress),
+            "identity" => Ok(Identity),
+            "trailers" => Ok(Trailers),
+            _ => Ok(EncodingExt(s.to_owned()))
+        }
+    }
+}

src/header/shared/entity.rs

@@ -0,0 +1,230 @@
+use std::str::FromStr;
+use std::fmt::{self, Display, Write};
+use header::{HeaderValue, Writer, IntoHeaderValue, InvalidHeaderValueBytes};
+
+/// check that each char in the slice is either:
+/// 1. `%x21`, or
+/// 2. in the range `%x23` to `%x7E`, or
+/// 3. above `%x80`
+fn check_slice_validity(slice: &str) -> bool {
+    slice.bytes().all(|c|
+        c == b'\x21' || (c >= b'\x23' && c <= b'\x7e') | (c >= b'\x80'))
+}
+
+/// An entity tag, defined in [RFC7232](https://tools.ietf.org/html/rfc7232#section-2.3)
+///
+/// An entity tag consists of a string enclosed by two literal double quotes.
+/// Preceding the first double quote is an optional weakness indicator,
+/// which always looks like `W/`. Examples for valid tags are `"xyzzy"` and `W/"xyzzy"`.
+///
+/// # ABNF
+///
+/// ```text
+/// entity-tag = [ weak ] opaque-tag
+/// weak       = %x57.2F ; "W/", case-sensitive
+/// opaque-tag = DQUOTE *etagc DQUOTE
+/// etagc      = %x21 / %x23-7E / obs-text
+///            ; VCHAR except double quotes, plus obs-text
+/// ```
+///
+/// # Comparison
+/// To check if two entity tags are equivalent in an application always use the `strong_eq` or
+/// `weak_eq` methods based on the context of the Tag. Only use `==` to check if two tags are
+/// identical.
+///
+/// The example below shows the results for a set of entity-tag pairs and
+/// both the weak and strong comparison function results:
+///
+/// | `ETag 1`| `ETag 2`| Strong Comparison | Weak Comparison |
+/// |---------|---------|-------------------|-----------------|
+/// | `W/"1"` | `W/"1"` | no match          | match           |
+/// | `W/"1"` | `W/"2"` | no match          | no match        |
+/// | `W/"1"` | `"1"`   | no match          | match           |
+/// | `"1"`   | `"1"`   | match             | match           |
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EntityTag {
+    /// Weakness indicator for the tag
+    pub weak: bool,
+    /// The opaque string in between the DQUOTEs
+    tag: String
+}
+
+impl EntityTag {
+    /// Constructs a new EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn new(weak: bool, tag: String) -> EntityTag {
+        assert!(check_slice_validity(&tag), "Invalid tag: {:?}", tag);
+        EntityTag { weak, tag }
+    }
+
+    /// Constructs a new weak EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn weak(tag: String) -> EntityTag {
+        EntityTag::new(true, tag)
+    }
+
+    /// Constructs a new strong EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn strong(tag: String) -> EntityTag {
+        EntityTag::new(false, tag)
+    }
+
+    /// Get the tag.
+    pub fn tag(&self) -> &str {
+        self.tag.as_ref()
+    }
+
+    /// Set the tag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn set_tag(&mut self, tag: String) {
+        assert!(check_slice_validity(&tag), "Invalid tag: {:?}", tag);
+        self.tag = tag
+    }
+
+    /// For strong comparison two entity-tags are equivalent if both are not weak and their
+    /// opaque-tags match character-by-character.
+    pub fn strong_eq(&self, other: &EntityTag) -> bool {
+        !self.weak && !other.weak && self.tag == other.tag
+    }
+
+    /// For weak comparison two entity-tags are equivalent if their
+    /// opaque-tags match character-by-character, regardless of either or
+    /// both being tagged as "weak".
+    pub fn weak_eq(&self, other: &EntityTag) -> bool {
+        self.tag == other.tag
+    }
+
+    /// The inverse of `EntityTag.strong_eq()`.
+    pub fn strong_ne(&self, other: &EntityTag) -> bool {
+        !self.strong_eq(other)
+    }
+
+    /// The inverse of `EntityTag.weak_eq()`.
+    pub fn weak_ne(&self, other: &EntityTag) -> bool {
+        !self.weak_eq(other)
+    }
+}
+
+impl Display for EntityTag {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.weak {
+            write!(f, "W/\"{}\"", self.tag)
+        } else {
+            write!(f, "\"{}\"", self.tag)
+        }
+    }
+}
+
+impl FromStr for EntityTag {
+    type Err = ::error::ParseError;
+
+    fn from_str(s: &str) -> Result<EntityTag, ::error::ParseError> {
+        let length: usize = s.len();
+        let slice = &s[..];
+        // Early exits if it doesn't terminate in a DQUOTE.
+        if !slice.ends_with('"') || slice.len() < 2 {
+            return Err(::error::ParseError::Header);
+        }
+        // The etag is weak if its first char is not a DQUOTE.
+        if slice.len() >= 2 && slice.starts_with('"')
+                && check_slice_validity(&slice[1..length-1]) {
+            // No need to check if the last char is a DQUOTE,
+            // we already did that above.
+            return Ok(EntityTag { weak: false, tag: slice[1..length-1].to_owned() });
+        } else if slice.len() >= 4 && slice.starts_with("W/\"")
+                && check_slice_validity(&slice[3..length-1]) {
+            return Ok(EntityTag { weak: true, tag: slice[3..length-1].to_owned() });
+        }
+        Err(::error::ParseError::Header)
+    }
+}
+
+impl IntoHeaderValue for EntityTag {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut wrt = Writer::new();
+        write!(wrt, "{}", self).unwrap();
+        unsafe{Ok(HeaderValue::from_shared_unchecked(wrt.take()))}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EntityTag;
+
+    #[test]
+    fn test_etag_parse_success() {
+        // Expected success
+        assert_eq!("\"foobar\"".parse::<EntityTag>().unwrap(),
+            EntityTag::strong("foobar".to_owned()));
+        assert_eq!("\"\"".parse::<EntityTag>().unwrap(),
+            EntityTag::strong("".to_owned()));
+        assert_eq!("W/\"weaktag\"".parse::<EntityTag>().unwrap(),
+            EntityTag::weak("weaktag".to_owned()));
+        assert_eq!("W/\"\x65\x62\"".parse::<EntityTag>().unwrap(),
+            EntityTag::weak("\x65\x62".to_owned()));
+        assert_eq!("W/\"\"".parse::<EntityTag>().unwrap(), EntityTag::weak("".to_owned()));
+    }
+
+    #[test]
+    fn test_etag_parse_failures() {
+        // Expected failures
+        assert!("no-dquotes".parse::<EntityTag>().is_err());
+        assert!("w/\"the-first-w-is-case-sensitive\"".parse::<EntityTag>().is_err());
+        assert!("".parse::<EntityTag>().is_err());
+        assert!("\"unmatched-dquotes1".parse::<EntityTag>().is_err());
+        assert!("unmatched-dquotes2\"".parse::<EntityTag>().is_err());
+        assert!("matched-\"dquotes\"".parse::<EntityTag>().is_err());
+    }
+
+    #[test]
+    fn test_etag_fmt() {
+        assert_eq!(format!("{}", EntityTag::strong("foobar".to_owned())), "\"foobar\"");
+        assert_eq!(format!("{}", EntityTag::strong("".to_owned())), "\"\"");
+        assert_eq!(format!("{}", EntityTag::weak("weak-etag".to_owned())), "W/\"weak-etag\"");
+        assert_eq!(format!("{}", EntityTag::weak("\u{0065}".to_owned())), "W/\"\x65\"");
+        assert_eq!(format!("{}", EntityTag::weak("".to_owned())), "W/\"\"");
+    }
+
+    #[test]
+    fn test_cmp() {
+        // | ETag 1  | ETag 2  | Strong Comparison | Weak Comparison |
+        // |---------|---------|-------------------|-----------------|
+        // | `W/"1"` | `W/"1"` | no match          | match           |
+        // | `W/"1"` | `W/"2"` | no match          | no match        |
+        // | `W/"1"` | `"1"`   | no match          | match           |
+        // | `"1"`   | `"1"`   | match             | match           |
+        let mut etag1 = EntityTag::weak("1".to_owned());
+        let mut etag2 = EntityTag::weak("1".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::weak("1".to_owned());
+        etag2 = EntityTag::weak("2".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(!etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::weak("1".to_owned());
+        etag2 = EntityTag::strong("1".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::strong("1".to_owned());
+        etag2 = EntityTag::strong("1".to_owned());
+        assert!(etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(!etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+    }
+}

src/header/shared/httpdate.rs

@@ -0,0 +1,97 @@
+use std::fmt::{self, Display};
+use std::io::Write;
+use std::str::FromStr;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use time;
+use bytes::{BytesMut, BufMut};
+use http::header::{HeaderValue, InvalidHeaderValueBytes};
+
+use error::ParseError;
+use header::IntoHeaderValue;
+
+
+/// A timestamp with HTTP formatting and parsing
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct HttpDate(time::Tm);
+
+impl FromStr for HttpDate {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
+        match time::strptime(s, "%a, %d %b %Y %T %Z").or_else(|_| {
+            time::strptime(s, "%A, %d-%b-%y %T %Z")
+        }).or_else(|_| {
+            time::strptime(s, "%c")
+        }) {
+            Ok(t) => Ok(HttpDate(t)),
+            Err(_) => Err(ParseError::Header),
+        }
+    }
+}
+
+impl Display for HttpDate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+    }
+}
+
+impl From<time::Tm> for HttpDate {
+    fn from(tm: time::Tm) -> HttpDate {
+        HttpDate(tm)
+    }
+}
+
+impl From<SystemTime> for HttpDate {
+    fn from(sys: SystemTime) -> HttpDate {
+        let tmspec = match sys.duration_since(UNIX_EPOCH) {
+            Ok(dur) => {
+                time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
+            },
+            Err(err) => {
+                let neg = err.duration();
+                time::Timespec::new(-(neg.as_secs() as i64), -(neg.subsec_nanos() as i32))
+            },
+        };
+        HttpDate(time::at_utc(tmspec))
+    }
+}
+
+impl IntoHeaderValue for HttpDate {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut wrt = BytesMut::with_capacity(29).writer();
+        write!(wrt, "{}", self.0.rfc822()).unwrap();
+        unsafe{Ok(HeaderValue::from_shared_unchecked(wrt.get_mut().take().freeze()))}
+    }
+}
+
+impl From<HttpDate> for SystemTime {
+    fn from(date: HttpDate) -> SystemTime {
+        let spec = date.0.to_timespec();
+        if spec.sec >= 0 {
+            UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
+        } else {
+            UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use time::Tm;
+    use super::HttpDate;
+
+    const NOV_07: HttpDate = HttpDate(Tm {
+        tm_nsec: 0, tm_sec: 37, tm_min: 48, tm_hour: 8, tm_mday: 7, tm_mon: 10, tm_year: 94,
+        tm_wday: 0, tm_isdst: 0, tm_yday: 0, tm_utcoff: 0});
+
+    #[test]
+    fn test_date() {
+        assert_eq!("Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sunday, 07-Nov-94 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(), NOV_07);
+        assert!("this-is-no-date".parse::<HttpDate>().is_err());
+    }
+}

src/header/shared/mod.rs

@@ -0,0 +1,14 @@
+//! Copied for `hyper::header::shared`;
+
+pub use self::charset::Charset;
+pub use self::encoding::Encoding;
+pub use self::entity::EntityTag;
+pub use self::httpdate::HttpDate;
+pub use language_tags::LanguageTag;
+pub use self::quality_item::{Quality, QualityItem, qitem, q};
+
+mod charset;
+mod entity;
+mod encoding;
+mod httpdate;
+mod quality_item;

src/header/shared/quality_item.rs

@@ -0,0 +1,265 @@
+#![allow(unused, deprecated)]
+use std::ascii::AsciiExt;
+use std::cmp;
+use std::default::Default;
+use std::fmt;
+use std::str;
+
+use self::internal::IntoQuality;
+
+/// Represents a quality used in quality values.
+///
+/// Can be created with the `q` function.
+///
+/// # Implementation notes
+///
+/// The quality value is defined as a number between 0 and 1 with three decimal places. This means
+/// there are 1001 possible values. Since floating point numbers are not exact and the smallest
+/// floating point data type (`f32`) consumes four bytes, hyper uses an `u16` value to store the
+/// quality internally. For performance reasons you may set quality directly to a value between
+/// 0 and 1000 e.g. `Quality(532)` matches the quality `q=0.532`.
+///
+/// [RFC7231 Section 5.3.1](https://tools.ietf.org/html/rfc7231#section-5.3.1)
+/// gives more information on quality values in HTTP header fields.
+#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Quality(u16);
+
+impl Default for Quality {
+    fn default() -> Quality {
+        Quality(1000)
+    }
+}
+
+/// Represents an item with a quality value as defined in
+/// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
+#[derive(Clone, PartialEq, Debug)]
+pub struct QualityItem<T> {
+    /// The actual contents of the field.
+    pub item: T,
+    /// The quality (client or server preference) for the value.
+    pub quality: Quality,
+}
+
+impl<T> QualityItem<T> {
+    /// Creates a new `QualityItem` from an item and a quality.
+    /// The item can be of any type.
+    /// The quality should be a value in the range [0, 1].
+    pub fn new(item: T, quality: Quality) -> QualityItem<T> {
+        QualityItem { item, quality }
+    }
+}
+
+impl<T: PartialEq> cmp::PartialOrd for QualityItem<T> {
+    fn partial_cmp(&self, other: &QualityItem<T>) -> Option<cmp::Ordering> {
+        self.quality.partial_cmp(&other.quality)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for QualityItem<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        try!(fmt::Display::fmt(&self.item, f));
+        match self.quality.0 {
+            1000 => Ok(()),
+            0 => f.write_str("; q=0"),
+            x => write!(f, "; q=0.{}", format!("{:03}", x).trim_right_matches('0'))
+        }
+    }
+}
+
+impl<T: str::FromStr> str::FromStr for QualityItem<T> {
+    type Err = ::error::ParseError;
+
+    fn from_str(s: &str) -> Result<QualityItem<T>, ::error::ParseError> {
+        if !s.is_ascii() {
+            return Err(::error::ParseError::Header);
+        }
+        // Set defaults used if parsing fails.
+        let mut raw_item = s;
+        let mut quality = 1f32;
+
+        let parts: Vec<&str> = s.rsplitn(2, ';').map(|x| x.trim()).collect();
+        if parts.len() == 2 {
+            if parts[0].len() < 2 {
+                return Err(::error::ParseError::Header);
+            }
+            let start = &parts[0][0..2];
+            if start == "q=" || start == "Q=" {
+                let q_part = &parts[0][2..parts[0].len()];
+                if q_part.len() > 5 {
+                    return Err(::error::ParseError::Header);
+                }
+                match q_part.parse::<f32>() {
+                    Ok(q_value) => {
+                        if 0f32 <= q_value && q_value <= 1f32 {
+                            quality = q_value;
+                            raw_item = parts[1];
+                        } else {
+                            return Err(::error::ParseError::Header);
+                        }
+                    },
+                    Err(_) => return Err(::error::ParseError::Header),
+                }
+            }
+        }
+        match raw_item.parse::<T>() {
+            // we already checked above that the quality is within range
+            Ok(item) => Ok(QualityItem::new(item, from_f32(quality))),
+            Err(_) => Err(::error::ParseError::Header),
+        }
+    }
+}
+
+#[inline]
+fn from_f32(f: f32) -> Quality {
+    // this function is only used internally. A check that `f` is within range
+    // should be done before calling this method. Just in case, this
+    // debug_assert should catch if we were forgetful
+    debug_assert!(f >= 0f32 && f <= 1f32, "q value must be between 0.0 and 1.0");
+    Quality((f * 1000f32) as u16)
+}
+
+/// Convenience function to wrap a value in a `QualityItem`
+/// Sets `q` to the default 1.0
+pub fn qitem<T>(item: T) -> QualityItem<T> {
+    QualityItem::new(item, Default::default())
+}
+
+/// Convenience function to create a `Quality` from a float or integer.
+/// 
+/// Implemented for `u16` and `f32`. Panics if value is out of range.
+pub fn q<T: IntoQuality>(val: T) -> Quality {
+    val.into_quality()
+}
+
+mod internal {
+    use super::Quality;
+
+    // TryFrom is probably better, but it's not stable. For now, we want to
+    // keep the functionality of the `q` function, while allowing it to be
+    // generic over `f32` and `u16`.
+    //
+    // `q` would panic before, so keep that behavior. `TryFrom` can be
+    // introduced later for a non-panicking conversion.
+
+    pub trait IntoQuality: Sealed + Sized {
+        fn into_quality(self) -> Quality;
+    }
+
+    impl IntoQuality for f32 {
+        fn into_quality(self) -> Quality {
+            assert!(self >= 0f32 && self <= 1f32, "float must be between 0.0 and 1.0");
+            super::from_f32(self)
+        }
+    }
+
+    impl IntoQuality for u16 {
+        fn into_quality(self) -> Quality {
+            assert!(self <= 1000, "u16 must be between 0 and 1000");
+            Quality(self)
+        }
+    }
+
+
+    pub trait Sealed {}
+    impl Sealed for u16 {}
+    impl Sealed for f32 {}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::super::encoding::*;
+
+    #[test]
+    fn test_quality_item_fmt_q_1() {
+        let x = qitem(Chunked);
+        assert_eq!(format!("{}", x), "chunked");
+    }
+    #[test]
+    fn test_quality_item_fmt_q_0001() {
+        let x = QualityItem::new(Chunked, Quality(1));
+        assert_eq!(format!("{}", x), "chunked; q=0.001");
+    }
+    #[test]
+    fn test_quality_item_fmt_q_05() {
+        // Custom value
+        let x = QualityItem{
+            item: EncodingExt("identity".to_owned()),
+            quality: Quality(500),
+        };
+        assert_eq!(format!("{}", x), "identity; q=0.5");
+    }
+
+    #[test]
+    fn test_quality_item_fmt_q_0() {
+        // Custom value
+        let x = QualityItem{
+            item: EncodingExt("identity".to_owned()),
+            quality: Quality(0),
+        };
+        assert_eq!(x.to_string(), "identity; q=0");
+    }
+
+    #[test]
+    fn test_quality_item_from_str1() {
+        let x: Result<QualityItem<Encoding>, _> = "chunked".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
+    }
+    #[test]
+    fn test_quality_item_from_str2() {
+        let x: Result<QualityItem<Encoding>, _> = "chunked; q=1".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
+    }
+    #[test]
+    fn test_quality_item_from_str3() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.5".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(500), });
+    }
+    #[test]
+    fn test_quality_item_from_str4() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.273".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(273), });
+    }
+    #[test]
+    fn test_quality_item_from_str5() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.2739999".parse();
+        assert!(x.is_err());
+    }
+    #[test]
+    fn test_quality_item_from_str6() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=2".parse();
+        assert!(x.is_err());
+    }
+    #[test]
+    fn test_quality_item_ordering() {
+        let x: QualityItem<Encoding> = "gzip; q=0.5".parse().ok().unwrap();
+        let y: QualityItem<Encoding> = "gzip; q=0.273".parse().ok().unwrap();
+        let comparision_result: bool = x.gt(&y);
+        assert!(comparision_result)
+    }
+
+    #[test]
+    fn test_quality() {
+        assert_eq!(q(0.5), Quality(500));
+    }
+
+    #[test]
+    #[should_panic] // FIXME - 32-bit msvc unwinding broken
+    #[cfg_attr(all(target_arch="x86", target_env="msvc"), ignore)]
+    fn test_quality_invalid() {
+        q(-1.0);
+    }
+
+    #[test]
+    #[should_panic] // FIXME - 32-bit msvc unwinding broken
+    #[cfg_attr(all(target_arch="x86", target_env="msvc"), ignore)]
+    fn test_quality_invalid2() {
+        q(2.0);
+    }
+
+    #[test]
+    fn test_fuzzing_bugs() {
+        assert!("99999;".parse::<QualityItem<String>>().is_err());
+        assert!("\x0d;;;=\u{d6aa}==".parse::<QualityItem<String>>().is_err())
+    }
+}

src/helpers.rs

@@ -1,340 +1,321 @@
-use std::{str, mem, ptr, slice};
-use std::cell::RefCell;
-use std::fmt::{self, Write};
-use std::rc::Rc;
-use std::ops::{Deref, DerefMut};
-use std::collections::VecDeque;
-use time;
-use bytes::{BufMut, BytesMut};
-use http::Version;
+//! Various helpers
 
-use httprequest::HttpInnerMessage;
+use regex::Regex;
+use http::{header, StatusCode};
 
-// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-pub(crate) const DATE_VALUE_LENGTH: usize = 29;
+use handler::Handler;
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
 
-pub(crate) fn date(dst: &mut BytesMut) {
-    CACHED.with(|cache| {
-        let mut buf: [u8; 39] = unsafe { mem::uninitialized() };
-        buf[..6].copy_from_slice(b"date: ");
-        buf[6..35].copy_from_slice(cache.borrow().buffer());
-        buf[35..].copy_from_slice(b"\r\n\r\n");
-        dst.extend_from_slice(&buf);
-    })
+/// Path normalization helper
+///
+/// By normalizing it means:
+///
+/// - Add a trailing slash to the path.
+/// - Remove a trailing slash from the path.
+/// - Double slashes are replaced by one.
+///
+/// The handler returns as soon as it finds a path that resolves
+/// correctly. The order if all enable is 1) merge, 3) both merge and append
+/// and 3) append. If the path resolves with
+/// at least one of those conditions, it will redirect to the new path.
+///
+/// If *append* is *true* append slash when needed. If a resource is
+/// defined with trailing slash and the request comes without it, it will
+/// append it automatically.
+///
+/// If *merge* is *true*, merge multiple consecutive slashes in the path into one.
+///
+/// This handler designed to be use as a handler for application's *default resource*.
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # #[macro_use] extern crate serde_derive;
+/// # use actix_web::*;
+/// use actix_web::http::NormalizePath;
+///
+/// # fn index(req: HttpRequest) -> HttpResponse {
+/// #     HttpResponse::Ok().into()
+/// # }
+/// fn main() {
+///     let app = App::new()
+///         .resource("/test/", |r| r.f(index))
+///         .default_resource(|r| r.h(NormalizePath::default()))
+///         .finish();
+/// }
+/// ```
+/// In this example `/test`, `/test///` will be redirected to `/test/` url.
+pub struct NormalizePath {
+    append: bool,
+    merge: bool,
+    re_merge: Regex,
+    redirect: StatusCode,
+    not_found: StatusCode,
 }
 
-pub(crate) fn date_value(dst: &mut BytesMut) {
-    CACHED.with(|cache| {
-        dst.extend_from_slice(cache.borrow().buffer());
-    })
-}
-
-pub(crate) fn update_date() {
-    CACHED.with(|cache| {
-        cache.borrow_mut().update();
-    });
-}
-
-struct CachedDate {
-    bytes: [u8; DATE_VALUE_LENGTH],
-    pos: usize,
-}
-
-thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
-    bytes: [0; DATE_VALUE_LENGTH],
-    pos: 0,
-}));
-
-impl CachedDate {
-    fn buffer(&self) -> &[u8] {
-        &self.bytes[..]
-    }
-
-    fn update(&mut self) {
-        self.pos = 0;
-        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
-        assert_eq!(self.pos, DATE_VALUE_LENGTH);
-    }
-}
-
-impl fmt::Write for CachedDate {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        let len = s.len();
-        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
-        self.pos += len;
-        Ok(())
-    }
-}
-
-/// Internal use only! unsafe
-pub(crate) struct SharedMessagePool(RefCell<VecDeque<Rc<HttpInnerMessage>>>);
-
-impl SharedMessagePool {
-    pub fn new() -> SharedMessagePool {
-        SharedMessagePool(RefCell::new(VecDeque::with_capacity(128)))
-    }
-
-    #[inline]
-    pub fn get(&self) -> Rc<HttpInnerMessage> {
-        if let Some(msg) = self.0.borrow_mut().pop_front() {
-            msg
-        } else {
-            Rc::new(HttpInnerMessage::default())
-        }
-    }
-
-    #[inline]
-    pub fn release(&self, mut msg: Rc<HttpInnerMessage>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            Rc::get_mut(&mut msg).unwrap().reset();
-            v.push_front(msg);
+impl Default for NormalizePath {
+    /// Create default `NormalizePath` instance, *append* is set to *true*,
+    /// *merge* is set to *true* and *redirect* is set to `StatusCode::MOVED_PERMANENTLY`
+    fn default() -> NormalizePath {
+        NormalizePath {
+            append: true,
+            merge: true,
+            re_merge: Regex::new("//+").unwrap(),
+            redirect: StatusCode::MOVED_PERMANENTLY,
+            not_found: StatusCode::NOT_FOUND,
         }
     }
 }
 
-pub(crate) struct SharedHttpInnerMessage(
-    Option<Rc<HttpInnerMessage>>, Option<Rc<SharedMessagePool>>);
+impl NormalizePath {
+    /// Create new `NormalizePath` instance
+    pub fn new(append: bool, merge: bool, redirect: StatusCode) -> NormalizePath {
+        NormalizePath {
+            append,
+            merge,
+            redirect,
+            re_merge: Regex::new("//+").unwrap(),
+            not_found: StatusCode::NOT_FOUND,
+        }
+    }
+}
 
-impl Drop for SharedHttpInnerMessage {
-    fn drop(&mut self) {
-        if let Some(ref pool) = self.1 {
-            if let Some(msg) = self.0.take() {
-                if Rc::strong_count(&msg) == 1 {
-                    pool.release(msg);
+impl<S> Handler<S> for NormalizePath {
+    type Result = HttpResponse;
+
+    fn handle(&mut self, req: HttpRequest<S>) -> Self::Result {
+        if let Some(router) = req.router() {
+            let query = req.query_string();
+            if self.merge {
+                // merge slashes
+                let p = self.re_merge.replace_all(req.path(), "/");
+                if p.len() != req.path().len() {
+                    if router.has_route(p.as_ref()) {
+                        let p = if !query.is_empty() { p + "?" + query } else { p };
+                        return HttpResponse::build(self.redirect)
+                            .header(header::LOCATION, p.as_ref())
+                            .finish();
+                    }
+                    // merge slashes and append trailing slash
+                    if self.append && !p.ends_with('/') {
+                        let p = p.as_ref().to_owned() + "/";
+                        if router.has_route(&p) {
+                            let p = if !query.is_empty() { p + "?" + query } else { p };
+                            return HttpResponse::build(self.redirect)
+                                .header(header::LOCATION, p.as_str())
+                                .finish()
+                        }
+                    }
+
+                    // try to remove trailing slash
+                    if p.ends_with('/') {
+                        let p = p.as_ref().trim_right_matches('/');
+                        if router.has_route(p) {
+                            let mut req = HttpResponse::build(self.redirect);
+                            return if !query.is_empty() {
+                                req.header(header::LOCATION, (p.to_owned() + "?" + query).as_str())
+                            } else {
+                                req.header(header::LOCATION, p)
+                            }
+                            .finish();
+                        }
+                    }
+                } else if p.ends_with('/') {
+                    // try to remove trailing slash
+                    let p = p.as_ref().trim_right_matches('/');
+                    if router.has_route(p) {
+                        let mut req = HttpResponse::build(self.redirect);
+                        return if !query.is_empty() {
+                            req.header(header::LOCATION,
+                                       (p.to_owned() + "?" + query).as_str())
+                        } else {
+                            req.header(header::LOCATION, p)
+                        }
+                        .finish();
+                    }
+                }
+            }
+            // append trailing slash
+            if self.append && !req.path().ends_with('/') {
+                let p = req.path().to_owned() + "/";
+                if router.has_route(&p) {
+                    let p = if !query.is_empty() { p + "?" + query } else { p };
+                    return HttpResponse::build(self.redirect)
+                        .header(header::LOCATION, p.as_str())
+                        .finish();
                 }
             }
         }
+        HttpResponse::new(self.not_found)
     }
 }
 
-impl Deref for SharedHttpInnerMessage {
-    type Target = HttpInnerMessage;
-
-    fn deref(&self) -> &HttpInnerMessage {
-        self.get_ref()
-    }
-}
-
-impl DerefMut for SharedHttpInnerMessage {
-
-    fn deref_mut(&mut self) -> &mut HttpInnerMessage {
-        self.get_mut()
-    }
-}
-
-impl Clone for SharedHttpInnerMessage {
-
-    fn clone(&self) -> SharedHttpInnerMessage {
-        SharedHttpInnerMessage(self.0.clone(), self.1.clone())
-    }
-}
-
-impl Default for SharedHttpInnerMessage {
-
-    fn default() -> SharedHttpInnerMessage {
-        SharedHttpInnerMessage(Some(Rc::new(HttpInnerMessage::default())), None)
-    }
-}
-
-impl SharedHttpInnerMessage {
-
-    pub fn from_message(msg: HttpInnerMessage) -> SharedHttpInnerMessage {
-        SharedHttpInnerMessage(Some(Rc::new(msg)), None)
-    }
-
-    pub fn new(msg: Rc<HttpInnerMessage>, pool: Rc<SharedMessagePool>) -> SharedHttpInnerMessage {
-        SharedHttpInnerMessage(Some(msg), Some(pool))
-    }
-
-    #[inline(always)]
-    #[allow(mutable_transmutes)]
-    #[cfg_attr(feature = "cargo-clippy", allow(mut_from_ref, inline_always))]
-    pub fn get_mut(&self) -> &mut HttpInnerMessage {
-        let r: &HttpInnerMessage = self.0.as_ref().unwrap().as_ref();
-        unsafe{mem::transmute(r)}
-    }
-
-    #[inline(always)]
-    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
-    pub fn get_ref(&self) -> &HttpInnerMessage {
-        self.0.as_ref().unwrap()
-    }
-}
-
-const DEC_DIGITS_LUT: &[u8] =
-    b"0001020304050607080910111213141516171819\
-      2021222324252627282930313233343536373839\
-      4041424344454647484950515253545556575859\
-      6061626364656667686970717273747576777879\
-      8081828384858687888990919293949596979899";
-
-pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
-    let mut buf: [u8; 13] = [b'H', b'T', b'T', b'P', b'/', b'1', b'.', b'1',
-                             b' ', b' ', b' ', b' ', b' '];
-    match version {
-        Version::HTTP_2 => buf[5] = b'2',
-        Version::HTTP_10 => buf[7] = b'0',
-        Version::HTTP_09 => {buf[5] = b'0'; buf[7] = b'9';},
-        _ => (),
-    }
-
-    let mut curr: isize = 12;
-    let buf_ptr = buf.as_mut_ptr();
-    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-    let four = n > 999;
-
-    unsafe {
-        // decode 2 more chars, if > 2 chars
-        let d1 = (n % 100) << 1;
-        n /= 100;
-        curr -= 2;
-        ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
-
-        // decode last 1 or 2 chars
-        if n < 10 {
-            curr -= 1;
-            *buf_ptr.offset(curr) = (n as u8) + b'0';
-        } else {
-            let d1 = n << 1;
-            curr -= 2;
-            ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
-        }
-    }
-
-    bytes.extend_from_slice(&buf);
-    if four {
-        bytes.put(b' ');
-    }
-}
-
-pub(crate) fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
-    if n < 10 {
-        let mut buf: [u8; 21] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
-                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
-                                 b't',b'h',b':',b' ',b'0',b'\r',b'\n'];
-        buf[18] = (n as u8) + b'0';
-        bytes.extend_from_slice(&buf);
-    } else if n < 100 {
-        let mut buf: [u8; 22] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
-                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
-                                 b't',b'h',b':',b' ',b'0',b'0',b'\r',b'\n'];
-        let d1 = n << 1;
-        unsafe {
-            ptr::copy_nonoverlapping(
-                DEC_DIGITS_LUT.as_ptr().offset(d1 as isize), buf.as_mut_ptr().offset(18), 2);
-        }
-        bytes.extend_from_slice(&buf);
-    } else if n < 1000 {
-        let mut buf: [u8; 23] = [b'\r',b'\n',b'c',b'o',b'n',b't',b'e',
-                                 b'n',b't',b'-',b'l',b'e',b'n',b'g',
-                                 b't',b'h',b':',b' ',b'0',b'0',b'0',b'\r',b'\n'];
-        // decode 2 more chars, if > 2 chars
-        let d1 = (n % 100) << 1;
-        n /= 100;
-        unsafe {ptr::copy_nonoverlapping(
-            DEC_DIGITS_LUT.as_ptr().offset(d1 as isize), buf.as_mut_ptr().offset(19), 2)};
-
-        // decode last 1
-        buf[18] = (n as u8) + b'0';
-
-        bytes.extend_from_slice(&buf);
-    } else {
-        bytes.extend_from_slice(b"\r\ncontent-length: ");
-        convert_usize(n, bytes);
-    }
-}
-
-pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
-    let mut curr: isize = 39;
-    let mut buf: [u8; 41] = unsafe { mem::uninitialized() };
-    buf[39] = b'\r';
-    buf[40] = b'\n';
-    let buf_ptr = buf.as_mut_ptr();
-    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-
-    unsafe {
-        // eagerly decode 4 characters at a time
-        while n >= 10_000 {
-            let rem = (n % 10_000) as isize;
-            n /= 10_000;
-
-            let d1 = (rem / 100) << 1;
-            let d2 = (rem % 100) << 1;
-            curr -= 4;
-            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-            ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
-        }
-
-        // if we reach here numbers are <= 9999, so at most 4 chars long
-        let mut n = n as isize; // possibly reduce 64bit math
-
-        // decode 2 more chars, if > 2 chars
-        if n >= 100 {
-            let d1 = (n % 100) << 1;
-            n /= 100;
-            curr -= 2;
-            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-        }
-
-        // decode last 1 or 2 chars
-        if n < 10 {
-            curr -= 1;
-            *buf_ptr.offset(curr) = (n as u8) + b'0';
-        } else {
-            let d1 = n << 1;
-            curr -= 2;
-            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-        }
-    }
-
-    unsafe {
-        bytes.extend_from_slice(
-            slice::from_raw_parts(buf_ptr.offset(curr), 41 - curr as usize));
-    }
-}
-
-
 #[cfg(test)]
 mod tests {
     use super::*;
+    use http::{header, Method};
+    use test::TestRequest;
+    use application::App;
 
-    #[test]
-    fn test_date_len() {
-        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
+    fn index(_req: HttpRequest) -> HttpResponse {
+        HttpResponse::new(StatusCode::OK)
     }
 
     #[test]
-    fn test_date() {
-        let mut buf1 = BytesMut::new();
-        date(&mut buf1);
-        let mut buf2 = BytesMut::new();
-        date(&mut buf2);
-        assert_eq!(buf1, buf2);
+    fn test_normalize_path_trailing_slashes() {
+        let mut app = App::new()
+            .resource("/resource1", |r| r.method(Method::GET).f(index))
+            .resource("/resource2/", |r| r.method(Method::GET).f(index))
+            .default_resource(|r| r.h(NormalizePath::default()))
+            .finish();
+
+        // trailing slashes
+        let params =
+            vec![("/resource1", "", StatusCode::OK),
+                 ("/resource1/", "/resource1", StatusCode::MOVED_PERMANENTLY),
+                 ("/resource2", "/resource2/", StatusCode::MOVED_PERMANENTLY),
+                 ("/resource2/", "", StatusCode::OK),
+                 ("/resource1?p1=1&p2=2", "", StatusCode::OK),
+                 ("/resource1/?p1=1&p2=2", "/resource1?p1=1&p2=2", StatusCode::MOVED_PERMANENTLY),
+                 ("/resource2?p1=1&p2=2", "/resource2/?p1=1&p2=2",
+                  StatusCode::MOVED_PERMANENTLY),
+                 ("/resource2/?p1=1&p2=2", "", StatusCode::OK)
+            ];
+        for (path, target, code) in params {
+            let req = app.prepare_request(TestRequest::with_uri(path).finish());
+            let resp = app.run(req);
+            let r = resp.as_response().unwrap();
+            assert_eq!(r.status(), code);
+            if !target.is_empty() {
+                assert_eq!(
+                    target,
+                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
+            }
+        }
     }
 
     #[test]
-    fn test_write_content_length() {
-        let mut bytes = BytesMut::new();
-        write_content_length(0, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 0\r\n"[..]);
-        write_content_length(9, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 9\r\n"[..]);
-        write_content_length(10, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 10\r\n"[..]);
-        write_content_length(99, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 99\r\n"[..]);
-        write_content_length(100, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 100\r\n"[..]);
-        write_content_length(101, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 101\r\n"[..]);
-        write_content_length(998, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 998\r\n"[..]);
-        write_content_length(1000, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1000\r\n"[..]);
-        write_content_length(1001, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1001\r\n"[..]);
-        write_content_length(5909, &mut bytes);
-        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 5909\r\n"[..]);
+    fn test_normalize_path_trailing_slashes_disabled() {
+        let mut app = App::new()
+            .resource("/resource1", |r| r.method(Method::GET).f(index))
+            .resource("/resource2/", |r| r.method(Method::GET).f(index))
+            .default_resource(|r| r.h(
+                NormalizePath::new(false, true, StatusCode::MOVED_PERMANENTLY)))
+            .finish();
+
+        // trailing slashes
+        let params = vec![("/resource1", StatusCode::OK),
+                          ("/resource1/", StatusCode::MOVED_PERMANENTLY),
+                          ("/resource2", StatusCode::NOT_FOUND),
+                          ("/resource2/", StatusCode::OK),
+                          ("/resource1?p1=1&p2=2", StatusCode::OK),
+                          ("/resource1/?p1=1&p2=2", StatusCode::MOVED_PERMANENTLY),
+                          ("/resource2?p1=1&p2=2", StatusCode::NOT_FOUND),
+                          ("/resource2/?p1=1&p2=2", StatusCode::OK)
+        ];
+        for (path, code) in params {
+            let req = app.prepare_request(TestRequest::with_uri(path).finish());
+            let resp = app.run(req);
+            let r = resp.as_response().unwrap();
+            assert_eq!(r.status(), code);
+        }
+    }
+
+    #[test]
+    fn test_normalize_path_merge_slashes() {
+        let mut app = App::new()
+            .resource("/resource1", |r| r.method(Method::GET).f(index))
+            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
+            .default_resource(|r| r.h(NormalizePath::default()))
+            .finish();
+
+        // trailing slashes
+        let params = vec![
+            ("/resource1/a/b", "", StatusCode::OK),
+            ("/resource1/", "/resource1", StatusCode::MOVED_PERMANENTLY),
+            ("/resource1//", "/resource1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("//resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("//resource1//a//b//", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/resource1/a/b?p=1", "", StatusCode::OK),
+            ("//resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a//b//?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+        ];
+        for (path, target, code) in params {
+            let req = app.prepare_request(TestRequest::with_uri(path).finish());
+            let resp = app.run(req);
+            let r = resp.as_response().unwrap();
+            assert_eq!(r.status(), code);
+            if !target.is_empty() {
+                assert_eq!(
+                    target,
+                    r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
+            }
+        }
+    }
+
+    #[test]
+    fn test_normalize_path_merge_and_append_slashes() {
+        let mut app = App::new()
+            .resource("/resource1", |r| r.method(Method::GET).f(index))
+            .resource("/resource2/", |r| r.method(Method::GET).f(index))
+            .resource("/resource1/a/b", |r| r.method(Method::GET).f(index))
+            .resource("/resource2/a/b/", |r| r.method(Method::GET).f(index))
+            .default_resource(|r| r.h(NormalizePath::default()))
+            .finish();
+
+        // trailing slashes
+        let params = vec![
+            ("/resource1/a/b", "", StatusCode::OK),
+            ("/resource1/a/b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b//", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b/", "/resource1/a/b", StatusCode::MOVED_PERMANENTLY),
+            ("/resource2/a/b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("/resource2/a/b/", "", StatusCode::OK),
+            ("//resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("///resource2//a//b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("///resource2//a//b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource2/a///b", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource2/a///b/", "/resource2/a/b/", StatusCode::MOVED_PERMANENTLY),
+            ("/resource1/a/b?p=1", "", StatusCode::OK),
+            ("/resource1/a/b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("///resource1//a//b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b/?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource1/a///b//?p=1", "/resource1/a/b?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/resource2/a/b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("//resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("///resource2//a//b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("///resource2//a//b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource2/a///b?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+            ("/////resource2/a///b/?p=1", "/resource2/a/b/?p=1", StatusCode::MOVED_PERMANENTLY),
+        ];
+        for (path, target, code) in params {
+            let req = app.prepare_request(TestRequest::with_uri(path).finish());
+            let resp = app.run(req);
+            let r = resp.as_response().unwrap();
+            assert_eq!(r.status(), code);
+            if !target.is_empty() {
+                assert_eq!(
+                    target, r.headers().get(header::LOCATION).unwrap().to_str().unwrap());
+            }
+        }
     }
 }

src/httpcodes.rs

@@ -1,183 +1,130 @@
 //! Basic http responses
-#![allow(non_upper_case_globals)]
-use http::{StatusCode, Error as HttpError};
+#![allow(non_upper_case_globals, deprecated)]
+use http::StatusCode;
 
 use body::Body;
+use error::Error;
 use handler::{Reply, Handler, RouteHandler, Responder};
 use httprequest::HttpRequest;
 use httpresponse::{HttpResponse, HttpResponseBuilder};
 
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Ok()` instead")]
 pub const HttpOk: StaticResponse = StaticResponse(StatusCode::OK);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Created()` instead")]
 pub const HttpCreated: StaticResponse = StaticResponse(StatusCode::CREATED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Accepted()` instead")]
 pub const HttpAccepted: StaticResponse = StaticResponse(StatusCode::ACCEPTED);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::pNonAuthoritativeInformation()` instead")]
 pub const HttpNonAuthoritativeInformation: StaticResponse =
     StaticResponse(StatusCode::NON_AUTHORITATIVE_INFORMATION);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::NoContent()` instead")]
 pub const HttpNoContent: StaticResponse = StaticResponse(StatusCode::NO_CONTENT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::ResetContent()` instead")]
 pub const HttpResetContent: StaticResponse = StaticResponse(StatusCode::RESET_CONTENT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::PartialContent()` instead")]
 pub const HttpPartialContent: StaticResponse = StaticResponse(StatusCode::PARTIAL_CONTENT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::MultiStatus()` instead")]
 pub const HttpMultiStatus: StaticResponse = StaticResponse(StatusCode::MULTI_STATUS);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::AlreadyReported()` instead")]
 pub const HttpAlreadyReported: StaticResponse = StaticResponse(StatusCode::ALREADY_REPORTED);
 
+#[deprecated(since="0.5.0", note="please use `HttpResponse::MultipleChoices()` instead")]
 pub const HttpMultipleChoices: StaticResponse = StaticResponse(StatusCode::MULTIPLE_CHOICES);
-pub const HttpMovedPermanenty: StaticResponse = StaticResponse(StatusCode::MOVED_PERMANENTLY);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::MovedPermanently()` instead")]
+pub const HttpMovedPermanently: StaticResponse = StaticResponse(StatusCode::MOVED_PERMANENTLY);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Found()` instead")]
 pub const HttpFound: StaticResponse = StaticResponse(StatusCode::FOUND);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::SeeOther()` instead")]
 pub const HttpSeeOther: StaticResponse = StaticResponse(StatusCode::SEE_OTHER);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::NotModified()` instead")]
 pub const HttpNotModified: StaticResponse = StaticResponse(StatusCode::NOT_MODIFIED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::UseProxy()` instead")]
 pub const HttpUseProxy: StaticResponse = StaticResponse(StatusCode::USE_PROXY);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::TemporaryRedirect()` instead")]
 pub const HttpTemporaryRedirect: StaticResponse =
     StaticResponse(StatusCode::TEMPORARY_REDIRECT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::PermanentRedirect()` instead")]
 pub const HttpPermanentRedirect: StaticResponse =
     StaticResponse(StatusCode::PERMANENT_REDIRECT);
 
+#[deprecated(since="0.5.0", note="please use `HttpResponse::BadRequest()` instead")]
 pub const HttpBadRequest: StaticResponse = StaticResponse(StatusCode::BAD_REQUEST);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Unauthorized()` instead")]
 pub const HttpUnauthorized: StaticResponse = StaticResponse(StatusCode::UNAUTHORIZED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::PaymentRequired()` instead")]
 pub const HttpPaymentRequired: StaticResponse = StaticResponse(StatusCode::PAYMENT_REQUIRED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Forbidden()` instead")]
 pub const HttpForbidden: StaticResponse = StaticResponse(StatusCode::FORBIDDEN);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::NotFound()` instead")]
 pub const HttpNotFound: StaticResponse = StaticResponse(StatusCode::NOT_FOUND);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::MethodNotAllowed()` instead")]
 pub const HttpMethodNotAllowed: StaticResponse =
     StaticResponse(StatusCode::METHOD_NOT_ALLOWED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::NotAcceptable()` instead")]
 pub const HttpNotAcceptable: StaticResponse = StaticResponse(StatusCode::NOT_ACCEPTABLE);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::ProxyAuthenticationRequired()` instead")]
 pub const HttpProxyAuthenticationRequired: StaticResponse =
     StaticResponse(StatusCode::PROXY_AUTHENTICATION_REQUIRED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::RequestTimeout()` instead")]
 pub const HttpRequestTimeout: StaticResponse = StaticResponse(StatusCode::REQUEST_TIMEOUT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Conflict()` instead")]
 pub const HttpConflict: StaticResponse = StaticResponse(StatusCode::CONFLICT);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::Gone()` instead")]
 pub const HttpGone: StaticResponse = StaticResponse(StatusCode::GONE);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::LengthRequired()` instead")]
 pub const HttpLengthRequired: StaticResponse = StaticResponse(StatusCode::LENGTH_REQUIRED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::PreconditionFailed()` instead")]
 pub const HttpPreconditionFailed: StaticResponse =
     StaticResponse(StatusCode::PRECONDITION_FAILED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::PayloadTooLarge()` instead")]
 pub const HttpPayloadTooLarge: StaticResponse = StaticResponse(StatusCode::PAYLOAD_TOO_LARGE);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::UriTooLong()` instead")]
 pub const HttpUriTooLong: StaticResponse = StaticResponse(StatusCode::URI_TOO_LONG);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::UnsupportedMediaType()` instead")]
 pub const HttpUnsupportedMediaType: StaticResponse =
     StaticResponse(StatusCode::UNSUPPORTED_MEDIA_TYPE);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::RangeNotSatisfiable()` instead")]
 pub const HttpRangeNotSatisfiable: StaticResponse =
     StaticResponse(StatusCode::RANGE_NOT_SATISFIABLE);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::ExpectationFailed()` instead")]
 pub const HttpExpectationFailed: StaticResponse =
     StaticResponse(StatusCode::EXPECTATION_FAILED);
 
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::InternalServerError()` instead")]
 pub const HttpInternalServerError: StaticResponse =
     StaticResponse(StatusCode::INTERNAL_SERVER_ERROR);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::NotImplemented()` instead")]
 pub const HttpNotImplemented: StaticResponse = StaticResponse(StatusCode::NOT_IMPLEMENTED);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::BadGateway()` instead")]
 pub const HttpBadGateway: StaticResponse = StaticResponse(StatusCode::BAD_GATEWAY);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::ServiceUnavailable()` instead")]
 pub const HttpServiceUnavailable: StaticResponse =
     StaticResponse(StatusCode::SERVICE_UNAVAILABLE);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::GatewayTimeout()` instead")]
 pub const HttpGatewayTimeout: StaticResponse =
     StaticResponse(StatusCode::GATEWAY_TIMEOUT);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::VersionNotSupported()` instead")]
 pub const HttpVersionNotSupported: StaticResponse =
     StaticResponse(StatusCode::HTTP_VERSION_NOT_SUPPORTED);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::VariantAlsoNegotiates()` instead")]
 pub const HttpVariantAlsoNegotiates: StaticResponse =
     StaticResponse(StatusCode::VARIANT_ALSO_NEGOTIATES);
+#[deprecated(since="0.5.0",
+             note="please use `HttpResponse::InsufficientStorage()` instead")]
 pub const HttpInsufficientStorage: StaticResponse =
     StaticResponse(StatusCode::INSUFFICIENT_STORAGE);
+#[deprecated(since="0.5.0", note="please use `HttpResponse::LoopDetected()` instead")]
 pub const HttpLoopDetected: StaticResponse = StaticResponse(StatusCode::LOOP_DETECTED);
 
-#[doc(hidden)]
-pub const HTTPOk: StaticResponse = StaticResponse(StatusCode::OK);
-#[doc(hidden)]
-pub const HTTPCreated: StaticResponse = StaticResponse(StatusCode::CREATED);
-#[doc(hidden)]
-pub const HTTPAccepted: StaticResponse = StaticResponse(StatusCode::ACCEPTED);
-#[doc(hidden)]
-pub const HTTPNonAuthoritativeInformation: StaticResponse =
-    StaticResponse(StatusCode::NON_AUTHORITATIVE_INFORMATION);
-#[doc(hidden)]
-pub const HTTPNoContent: StaticResponse = StaticResponse(StatusCode::NO_CONTENT);
-#[doc(hidden)]
-pub const HTTPResetContent: StaticResponse = StaticResponse(StatusCode::RESET_CONTENT);
-#[doc(hidden)]
-pub const HTTPPartialContent: StaticResponse = StaticResponse(StatusCode::PARTIAL_CONTENT);
-#[doc(hidden)]
-pub const HTTPMultiStatus: StaticResponse = StaticResponse(StatusCode::MULTI_STATUS);
-#[doc(hidden)]
-pub const HTTPAlreadyReported: StaticResponse = StaticResponse(StatusCode::ALREADY_REPORTED);
-
-#[doc(hidden)]
-pub const HTTPMultipleChoices: StaticResponse = StaticResponse(StatusCode::MULTIPLE_CHOICES);
-#[doc(hidden)]
-pub const HTTPMovedPermanenty: StaticResponse = StaticResponse(StatusCode::MOVED_PERMANENTLY);
-#[doc(hidden)]
-pub const HTTPFound: StaticResponse = StaticResponse(StatusCode::FOUND);
-#[doc(hidden)]
-pub const HTTPSeeOther: StaticResponse = StaticResponse(StatusCode::SEE_OTHER);
-#[doc(hidden)]
-pub const HTTPNotModified: StaticResponse = StaticResponse(StatusCode::NOT_MODIFIED);
-#[doc(hidden)]
-pub const HTTPUseProxy: StaticResponse = StaticResponse(StatusCode::USE_PROXY);
-#[doc(hidden)]
-pub const HTTPTemporaryRedirect: StaticResponse =
-    StaticResponse(StatusCode::TEMPORARY_REDIRECT);
-#[doc(hidden)]
-pub const HTTPPermanentRedirect: StaticResponse =
-    StaticResponse(StatusCode::PERMANENT_REDIRECT);
-
-#[doc(hidden)]
-pub const HTTPBadRequest: StaticResponse = StaticResponse(StatusCode::BAD_REQUEST);
-#[doc(hidden)]
-pub const HTTPUnauthorized: StaticResponse = StaticResponse(StatusCode::UNAUTHORIZED);
-#[doc(hidden)]
-pub const HTTPPaymentRequired: StaticResponse = StaticResponse(StatusCode::PAYMENT_REQUIRED);
-#[doc(hidden)]
-pub const HTTPForbidden: StaticResponse = StaticResponse(StatusCode::FORBIDDEN);
-#[doc(hidden)]
-pub const HTTPNotFound: StaticResponse = StaticResponse(StatusCode::NOT_FOUND);
-#[doc(hidden)]
-pub const HTTPMethodNotAllowed: StaticResponse =
-    StaticResponse(StatusCode::METHOD_NOT_ALLOWED);
-#[doc(hidden)]
-pub const HTTPNotAcceptable: StaticResponse = StaticResponse(StatusCode::NOT_ACCEPTABLE);
-#[doc(hidden)]
-pub const HTTPProxyAuthenticationRequired: StaticResponse =
-    StaticResponse(StatusCode::PROXY_AUTHENTICATION_REQUIRED);
-#[doc(hidden)]
-pub const HTTPRequestTimeout: StaticResponse = StaticResponse(StatusCode::REQUEST_TIMEOUT);
-#[doc(hidden)]
-pub const HTTPConflict: StaticResponse = StaticResponse(StatusCode::CONFLICT);
-#[doc(hidden)]
-pub const HTTPGone: StaticResponse = StaticResponse(StatusCode::GONE);
-#[doc(hidden)]
-pub const HTTPLengthRequired: StaticResponse = StaticResponse(StatusCode::LENGTH_REQUIRED);
-#[doc(hidden)]
-pub const HTTPPreconditionFailed: StaticResponse =
-    StaticResponse(StatusCode::PRECONDITION_FAILED);
-#[doc(hidden)]
-pub const HTTPPayloadTooLarge: StaticResponse = StaticResponse(StatusCode::PAYLOAD_TOO_LARGE);
-#[doc(hidden)]
-pub const HTTPUriTooLong: StaticResponse = StaticResponse(StatusCode::URI_TOO_LONG);
-#[doc(hidden)]
-pub const HTTPUnsupportedMediaType: StaticResponse =
-    StaticResponse(StatusCode::UNSUPPORTED_MEDIA_TYPE);
-#[doc(hidden)]
-pub const HTTPRangeNotSatisfiable: StaticResponse =
-    StaticResponse(StatusCode::RANGE_NOT_SATISFIABLE);
-#[doc(hidden)]
-pub const HTTPExpectationFailed: StaticResponse =
-    StaticResponse(StatusCode::EXPECTATION_FAILED);
-
-#[doc(hidden)]
-pub const HTTPInternalServerError: StaticResponse =
-    StaticResponse(StatusCode::INTERNAL_SERVER_ERROR);
-#[doc(hidden)]
-pub const HTTPNotImplemented: StaticResponse = StaticResponse(StatusCode::NOT_IMPLEMENTED);
-#[doc(hidden)]
-pub const HTTPBadGateway: StaticResponse = StaticResponse(StatusCode::BAD_GATEWAY);
-#[doc(hidden)]
-pub const HTTPServiceUnavailable: StaticResponse =
-    StaticResponse(StatusCode::SERVICE_UNAVAILABLE);
-#[doc(hidden)]
-pub const HTTPGatewayTimeout: StaticResponse =
-    StaticResponse(StatusCode::GATEWAY_TIMEOUT);
-#[doc(hidden)]
-pub const HTTPVersionNotSupported: StaticResponse =
-    StaticResponse(StatusCode::HTTP_VERSION_NOT_SUPPORTED);
-#[doc(hidden)]
-pub const HTTPVariantAlsoNegotiates: StaticResponse =
-    StaticResponse(StatusCode::VARIANT_ALSO_NEGOTIATES);
-#[doc(hidden)]
-pub const HTTPInsufficientStorage: StaticResponse =
-    StaticResponse(StatusCode::INSUFFICIENT_STORAGE);
-#[doc(hidden)]
-pub const HTTPLoopDetected: StaticResponse = StaticResponse(StatusCode::LOOP_DETECTED);
-
 
+#[deprecated(since="0.5.0", note="please use `HttpResponse` instead")]
 #[derive(Copy, Clone, Debug)]
 pub struct StaticResponse(StatusCode);
 
@@ -185,13 +132,16 @@ impl StaticResponse {
     pub fn build(&self) -> HttpResponseBuilder {
         HttpResponse::build(self.0)
     }
+    pub fn build_from<S>(&self, req: &HttpRequest<S>) -> HttpResponseBuilder {
+        req.build_response(self.0)
+    }
     pub fn with_reason(self, reason: &'static str) -> HttpResponse {
-        let mut resp = HttpResponse::new(self.0, Body::Empty);
+        let mut resp = HttpResponse::new(self.0);
         resp.set_reason(reason);
         resp
     }
     pub fn with_body<B: Into<Body>>(self, body: B) -> HttpResponse {
-        HttpResponse::new(self.0, body.into())
+        HttpResponse::with_body(self.0, body.into())
     }
 }
 
@@ -199,34 +149,34 @@ impl<S> Handler<S> for StaticResponse {
     type Result = HttpResponse;
 
     fn handle(&mut self, _: HttpRequest<S>) -> HttpResponse {
-        HttpResponse::new(self.0, Body::Empty)
+        HttpResponse::new(self.0)
     }
 }
 
 impl<S> RouteHandler<S> for StaticResponse {
     fn handle(&mut self, _: HttpRequest<S>) -> Reply {
-        Reply::response(HttpResponse::new(self.0, Body::Empty))
+        Reply::response(HttpResponse::new(self.0))
     }
 }
 
 impl Responder for StaticResponse {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        self.build().body(Body::Empty)
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(self.build().finish())
     }
 }
 
 impl From<StaticResponse> for HttpResponse {
     fn from(st: StaticResponse) -> Self {
-        HttpResponse::new(st.0, Body::Empty)
+        HttpResponse::new(st.0)
     }
 }
 
 impl From<StaticResponse> for Reply {
     fn from(st: StaticResponse) -> Self {
-        HttpResponse::new(st.0, Body::Empty).into()
+        HttpResponse::new(st.0).into()
     }
 }
 
@@ -242,7 +192,14 @@ macro_rules! STATIC_RESP {
 impl HttpResponse {
     STATIC_RESP!(Ok, StatusCode::OK);
     STATIC_RESP!(Created, StatusCode::CREATED);
+    STATIC_RESP!(Accepted, StatusCode::ACCEPTED);
+    STATIC_RESP!(NonAuthoritativeInformation, StatusCode::NON_AUTHORITATIVE_INFORMATION);
+
     STATIC_RESP!(NoContent, StatusCode::NO_CONTENT);
+    STATIC_RESP!(ResetContent, StatusCode::RESET_CONTENT);
+    STATIC_RESP!(PartialContent, StatusCode::PARTIAL_CONTENT);
+    STATIC_RESP!(MultiStatus, StatusCode::MULTI_STATUS);
+    STATIC_RESP!(AlreadyReported, StatusCode::ALREADY_REPORTED);
 
     STATIC_RESP!(MultipleChoices, StatusCode::MULTIPLE_CHOICES);
     STATIC_RESP!(MovedPermanenty, StatusCode::MOVED_PERMANENTLY);
@@ -258,7 +215,6 @@ impl HttpResponse {
     STATIC_RESP!(Unauthorized, StatusCode::UNAUTHORIZED);
     STATIC_RESP!(PaymentRequired, StatusCode::PAYMENT_REQUIRED);
     STATIC_RESP!(Forbidden, StatusCode::FORBIDDEN);
-
     STATIC_RESP!(MethodNotAllowed, StatusCode::METHOD_NOT_ALLOWED);
     STATIC_RESP!(NotAcceptable, StatusCode::NOT_ACCEPTABLE);
     STATIC_RESP!(ProxyAuthenticationRequired, StatusCode::PROXY_AUTHENTICATION_REQUIRED);
@@ -269,40 +225,50 @@ impl HttpResponse {
     STATIC_RESP!(PreconditionFailed, StatusCode::PRECONDITION_FAILED);
     STATIC_RESP!(PayloadTooLarge, StatusCode::PAYLOAD_TOO_LARGE);
     STATIC_RESP!(UriTooLong, StatusCode::URI_TOO_LONG);
+    STATIC_RESP!(UnsupportedMediaType, StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    STATIC_RESP!(RangeNotSatisfiable, StatusCode::RANGE_NOT_SATISFIABLE);
     STATIC_RESP!(ExpectationFailed, StatusCode::EXPECTATION_FAILED);
 
     STATIC_RESP!(InternalServerError, StatusCode::INTERNAL_SERVER_ERROR);
+    STATIC_RESP!(NotImplemented, StatusCode::NOT_IMPLEMENTED);
+    STATIC_RESP!(BadGateway, StatusCode::BAD_GATEWAY);
+    STATIC_RESP!(ServiceUnavailable, StatusCode::SERVICE_UNAVAILABLE);
+    STATIC_RESP!(GatewayTimeout, StatusCode::GATEWAY_TIMEOUT);
+    STATIC_RESP!(VersionNotSupported, StatusCode::HTTP_VERSION_NOT_SUPPORTED);
+    STATIC_RESP!(VariantAlsoNegotiates, StatusCode::VARIANT_ALSO_NEGOTIATES);
+    STATIC_RESP!(InsufficientStorage, StatusCode::INSUFFICIENT_STORAGE);
+    STATIC_RESP!(LoopDetected, StatusCode::LOOP_DETECTED);
 }
 
 #[cfg(test)]
 mod tests {
     use http::StatusCode;
-    use super::{HTTPOk, HTTPBadRequest, Body, HttpResponse};
+    use super::{HttpOk, HttpBadRequest, Body, HttpResponse};
 
     #[test]
     fn test_build() {
-        let resp = HTTPOk.build().body(Body::Empty).unwrap();
+        let resp = HttpOk.build().body(Body::Empty);
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[test]
     fn test_response() {
-        let resp: HttpResponse = HTTPOk.into();
+        let resp: HttpResponse = HttpOk.into();
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[test]
     fn test_from() {
-        let resp: HttpResponse = HTTPOk.into();
+        let resp: HttpResponse = HttpOk.into();
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[test]
     fn test_with_reason() {
-        let resp: HttpResponse = HTTPOk.into();
+        let resp: HttpResponse = HttpOk.into();
         assert_eq!(resp.reason(), "OK");
 
-        let resp = HTTPBadRequest.with_reason("test");
+        let resp = HttpBadRequest.with_reason("test");
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
         assert_eq!(resp.reason(), "test");
     }

src/httpmessage.rs

@@ -1,17 +1,18 @@
 use std::str;
-use std::collections::HashMap;
 use bytes::{Bytes, BytesMut};
 use futures::{Future, Stream, Poll};
 use http_range::HttpRange;
 use serde::de::DeserializeOwned;
 use mime::Mime;
-use url::form_urlencoded;
+use serde_urlencoded;
 use encoding::all::UTF_8;
 use encoding::EncodingRef;
+use encoding::types::{Encoding, DecoderTrap};
 use encoding::label::encoding_from_whatwg_label;
 use http::{header, HeaderMap};
 
 use json::JsonBody;
+use header::Header;
 use multipart::Multipart;
 use error::{ParseError, ContentTypeError,
             HttpRangeError, PayloadError, UrlencodedError};
@@ -23,6 +24,16 @@ pub trait HttpMessage {
     /// Read the message headers.
     fn headers(&self) -> &HeaderMap;
 
+    #[doc(hidden)]
+    /// Get a header
+    fn get_header<H: Header>(&self) -> Option<H> where Self: Sized {
+        if self.headers().contains_key(H::name()) {
+            H::parse(self).ok()
+        } else {
+            None
+        }
+    }
+    
     /// Read the request content type. If request does not contain
     /// *Content-Type* header, empty str get returned.
     fn content_type(&self) -> &str {
@@ -114,7 +125,7 @@ pub trait HttpMessage {
     ///        .from_err()
     ///        .and_then(|bytes: Bytes| {  // <- complete body
     ///            println!("==== BODY ==== {:?}", bytes);
-    ///            Ok(httpcodes::HttpOk.into())
+    ///            Ok(HttpResponse::Ok().into())
     ///        }).responder()
     /// }
     /// # fn main() {}
@@ -125,9 +136,9 @@ pub trait HttpMessage {
         MessageBody::new(self)
     }
 
-    /// Parse `application/x-www-form-urlencoded` encoded body.
-    /// Return `UrlEncoded` future. It resolves to a `HashMap<String, String>` which
-    /// contains decoded parameters.
+    /// Parse `application/x-www-form-urlencoded` encoded request's body.
+    /// Return `UrlEncoded` future. Form can be deserialized to any type that implements
+    /// `Deserialize` trait from *serde*.
     ///
     /// Returns error:
     ///
@@ -140,21 +151,22 @@ pub trait HttpMessage {
     /// ```rust
     /// # extern crate actix_web;
     /// # extern crate futures;
-    /// use actix_web::*;
-    /// use futures::future::{Future, ok};
+    /// # use futures::Future;
+    /// # use std::collections::HashMap;
+    /// use actix_web::{HttpMessage, HttpRequest, HttpResponse, FutureResponse};
     ///
-    /// fn index(mut req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    ///     req.urlencoded()         // <- get UrlEncoded future
-    ///        .from_err()
-    ///        .and_then(|params| {  // <- url encoded parameters
-    ///             println!("==== BODY ==== {:?}", params);
-    ///             ok(httpcodes::HttpOk.into())
-    ///        })
-    ///        .responder()
+    /// fn index(mut req: HttpRequest) -> FutureResponse<HttpResponse> {
+    ///     Box::new(
+    ///         req.urlencoded::<HashMap<String, String>>()  // <- get UrlEncoded future
+    ///            .from_err()
+    ///            .and_then(|params| {  // <- url encoded parameters
+    ///                println!("==== BODY ==== {:?}", params);
+    ///                Ok(HttpResponse::Ok().into())
+    ///           }))
     /// }
     /// # fn main() {}
     /// ```
-    fn urlencoded(self) -> UrlEncoded<Self>
+    fn urlencoded<T: DeserializeOwned>(self) -> UrlEncoded<Self, T>
         where Self: Stream<Item=Bytes, Error=PayloadError> + Sized
     {
         UrlEncoded::new(self)
@@ -187,7 +199,7 @@ pub trait HttpMessage {
     ///        .from_err()
     ///        .and_then(|val: MyObj| {  // <- deserialized value
     ///            println!("==== BODY ==== {:?}", val);
-    ///            Ok(httpcodes::HttpOk.into())
+    ///            Ok(HttpResponse::Ok().into())
     ///        }).responder()
     /// }
     /// # fn main() {}
@@ -229,7 +241,7 @@ pub trait HttpMessage {
     ///             }
     ///         })
     ///         .finish()  // <- Stream::finish() combinator from actix
-    ///         .map(|_| httpcodes::HTTPOk.into())
+    ///         .map(|_| HttpResponse::Ok().into())
     ///         .responder()
     /// }
     /// # fn main() {}
@@ -310,14 +322,14 @@ impl<T> Future for MessageBody<T>
 }
 
 /// Future that resolves to a parsed urlencoded values.
-pub struct UrlEncoded<T> {
+pub struct UrlEncoded<T, U> {
     req: Option<T>,
     limit: usize,
-    fut: Option<Box<Future<Item=HashMap<String, String>, Error=UrlencodedError>>>,
+    fut: Option<Box<Future<Item=U, Error=UrlencodedError>>>,
 }
 
-impl<T> UrlEncoded<T> {
-    pub fn new(req: T) -> UrlEncoded<T> {
+impl<T, U> UrlEncoded<T, U> {
+    pub fn new(req: T) -> UrlEncoded<T, U> {
         UrlEncoded {
             req: Some(req),
             limit: 262_144,
@@ -332,10 +344,11 @@ impl<T> UrlEncoded<T> {
     }
 }
 
-impl<T> Future for UrlEncoded<T>
-    where T: HttpMessage + Stream<Item=Bytes, Error=PayloadError> + 'static
+impl<T, U> Future for UrlEncoded<T, U>
+    where T: HttpMessage + Stream<Item=Bytes, Error=PayloadError> + 'static,
+          U: DeserializeOwned + 'static
 {
-    type Item = HashMap<String, String>;
+    type Item = U;
     type Error = UrlencodedError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -374,13 +387,16 @@ impl<T> Future for UrlEncoded<T>
                     }
                 })
                 .and_then(move |body| {
-                    let mut m = HashMap::new();
-                    let parsed = form_urlencoded::parse_with_encoding(
-                        &body, Some(encoding), false).map_err(|_| UrlencodedError::Parse)?;
-                    for (k, v) in parsed {
-                        m.insert(k.into(), v.into());
+                    let enc: *const Encoding = encoding as *const Encoding;
+                    if enc == UTF_8 {
+                        serde_urlencoded::from_bytes::<U>(&body)
+                            .map_err(|_| UrlencodedError::Parse)
+                    } else {
+                        let body = encoding.decode(&body, DecoderTrap::Strict)
+                            .map_err(|_| UrlencodedError::Parse)?;
+                        serde_urlencoded::from_str::<U>(&body)
+                            .map_err(|_| UrlencodedError::Parse)
                     }
-                    Ok(m)
                 });
             self.fut = Some(Box::new(fut));
         }
@@ -399,7 +415,6 @@ mod tests {
     use http::{Method, Version, Uri};
     use httprequest::HttpRequest;
     use std::str::FromStr;
-    use std::iter::FromIterator;
     use test::TestRequest;
 
     #[test]
@@ -518,28 +533,37 @@ mod tests {
         }
     }
 
+    #[derive(Deserialize, Debug, PartialEq)]
+    struct Info {
+        hello: String,
+    }
+
     #[test]
     fn test_urlencoded_error() {
         let req = TestRequest::with_header(header::TRANSFER_ENCODING, "chunked").finish();
-        assert_eq!(req.urlencoded().poll().err().unwrap(), UrlencodedError::Chunked);
+        assert_eq!(req.urlencoded::<Info>()
+                   .poll().err().unwrap(), UrlencodedError::Chunked);
 
         let req = TestRequest::with_header(
             header::CONTENT_TYPE, "application/x-www-form-urlencoded")
             .header(header::CONTENT_LENGTH, "xxxx")
             .finish();
-        assert_eq!(req.urlencoded().poll().err().unwrap(), UrlencodedError::UnknownLength);
+        assert_eq!(req.urlencoded::<Info>()
+                   .poll().err().unwrap(), UrlencodedError::UnknownLength);
 
         let req = TestRequest::with_header(
             header::CONTENT_TYPE, "application/x-www-form-urlencoded")
             .header(header::CONTENT_LENGTH, "1000000")
             .finish();
-        assert_eq!(req.urlencoded().poll().err().unwrap(), UrlencodedError::Overflow);
+        assert_eq!(req.urlencoded::<Info>()
+                   .poll().err().unwrap(), UrlencodedError::Overflow);
 
         let req = TestRequest::with_header(
             header::CONTENT_TYPE, "text/plain")
             .header(header::CONTENT_LENGTH, "10")
             .finish();
-        assert_eq!(req.urlencoded().poll().err().unwrap(), UrlencodedError::ContentType);
+        assert_eq!(req.urlencoded::<Info>()
+                   .poll().err().unwrap(), UrlencodedError::ContentType);
     }
 
     #[test]
@@ -550,9 +574,8 @@ mod tests {
             .finish();
         req.payload_mut().unread_data(Bytes::from_static(b"hello=world"));
 
-        let result = req.urlencoded().poll().ok().unwrap();
-        assert_eq!(result, Async::Ready(
-            HashMap::from_iter(vec![("hello".to_owned(), "world".to_owned())])));
+        let result = req.urlencoded::<Info>().poll().ok().unwrap();
+        assert_eq!(result, Async::Ready(Info{hello: "world".to_owned()}));
 
         let mut req = TestRequest::with_header(
             header::CONTENT_TYPE, "application/x-www-form-urlencoded; charset=utf-8")
@@ -561,8 +584,7 @@ mod tests {
         req.payload_mut().unread_data(Bytes::from_static(b"hello=world"));
 
         let result = req.urlencoded().poll().ok().unwrap();
-        assert_eq!(result, Async::Ready(
-            HashMap::from_iter(vec![("hello".to_owned(), "world".to_owned())])));
+        assert_eq!(result, Async::Ready(Info{hello: "world".to_owned()}));
     }
 
     #[test]
@@ -570,27 +592,27 @@ mod tests {
         let req = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx").finish();
         match req.body().poll().err().unwrap() {
             PayloadError::UnknownLength => (),
-            _ => panic!("error"),
+            _ => unreachable!("error"),
         }
 
         let req = TestRequest::with_header(header::CONTENT_LENGTH, "1000000").finish();
         match req.body().poll().err().unwrap() {
             PayloadError::Overflow => (),
-            _ => panic!("error"),
+            _ => unreachable!("error"),
         }
 
         let mut req = HttpRequest::default();
         req.payload_mut().unread_data(Bytes::from_static(b"test"));
         match req.body().poll().ok().unwrap() {
             Async::Ready(bytes) => assert_eq!(bytes, Bytes::from_static(b"test")),
-            _ => panic!("error"),
+            _ => unreachable!("error"),
         }
 
         let mut req = HttpRequest::default();
         req.payload_mut().unread_data(Bytes::from_static(b"11111111111111"));
         match req.body().limit(5).poll().err().unwrap() {
             PayloadError::Overflow => (),
-            _ => panic!("error"),
+            _ => unreachable!("error"),
         }
     }
 }

src/httprequest.rs

@@ -2,21 +2,28 @@
 use std::{io, cmp, str, fmt, mem};
 use std::rc::Rc;
 use std::net::SocketAddr;
+use std::borrow::Cow;
 use bytes::Bytes;
 use cookie::Cookie;
 use futures::{Async, Stream, Poll};
+use futures::future::{FutureResult, result};
+use futures_cpupool::CpuPool;
 use failure;
 use url::{Url, form_urlencoded};
-use http::{header, Uri, Method, Version, HeaderMap, Extensions};
+use http::{header, Uri, Method, Version, HeaderMap, Extensions, StatusCode};
 use tokio_io::AsyncRead;
+use percent_encoding::percent_decode;
 
+use body::Body;
 use info::ConnectionInfo;
 use param::Params;
-use router::Router;
+use router::{Router, Resource};
 use payload::Payload;
+use handler::FromRequest;
 use httpmessage::HttpMessage;
-use helpers::SharedHttpInnerMessage;
-use error::{UrlGenerationError, CookieParseError, PayloadError};
+use httpresponse::{HttpResponse, HttpResponseBuilder};
+use server::helpers::SharedHttpInnerMessage;
+use error::{Error, UrlGenerationError, CookieParseError, PayloadError};
 
 
 pub struct HttpInnerMessage {
@@ -32,6 +39,13 @@ pub struct HttpInnerMessage {
     pub addr: Option<SocketAddr>,
     pub payload: Option<Payload>,
     pub info: Option<ConnectionInfo<'static>>,
+    resource: RouterResource,
+}
+
+#[derive(Debug, Copy, Clone,PartialEq)]
+enum RouterResource {
+    Notset,
+    Normal(u16),
 }
 
 impl Default for HttpInnerMessage {
@@ -50,6 +64,7 @@ impl Default for HttpInnerMessage {
             payload: None,
             extensions: Extensions::new(),
             info: None,
+            resource: RouterResource::Notset,
         }
     }
 }
@@ -86,9 +101,15 @@ impl HttpInnerMessage {
         self.addr = None;
         self.info = None;
         self.payload = None;
+        self.resource = RouterResource::Notset;
     }
 }
 
+lazy_static!{
+    static ref RESOURCE: Resource = Resource::unset();
+}
+
+
 /// An HTTP Request
 pub struct HttpRequest<S=()>(SharedHttpInnerMessage, Option<Rc<S>>, Option<Router>);
 
@@ -96,7 +117,8 @@ impl HttpRequest<()> {
     /// Construct a new Request.
     #[inline]
     pub fn new(method: Method, uri: Uri,
-               version: Version, headers: HeaderMap, payload: Option<Payload>) -> HttpRequest
+               version: Version, headers: HeaderMap, payload: Option<Payload>)
+               -> HttpRequest
     {
         HttpRequest(
             SharedHttpInnerMessage::from_message(HttpInnerMessage {
@@ -112,6 +134,7 @@ impl HttpRequest<()> {
                 addr: None,
                 extensions: Extensions::new(),
                 info: None,
+                resource: RouterResource::Notset,
             }),
             None,
             None,
@@ -119,7 +142,7 @@ impl HttpRequest<()> {
     }
 
     #[inline(always)]
-    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
+    #[cfg_attr(feature="cargo-clippy", allow(inline_always))]
     pub(crate) fn from_message(msg: SharedHttpInnerMessage) -> HttpRequest {
         HttpRequest(msg, None, None)
     }
@@ -129,12 +152,6 @@ impl HttpRequest<()> {
     pub fn with_state<S>(self, state: Rc<S>, router: Router) -> HttpRequest<S> {
         HttpRequest(self.0, Some(state), Some(router))
     }
-
-    #[cfg(test)]
-    /// Construct new http request with state.
-    pub(crate) fn with_state_no_router<S>(self, state: Rc<S>) -> HttpRequest<S> {
-        HttpRequest(self.0, Some(state), None)
-    }
 }
 
 
@@ -156,7 +173,7 @@ impl<S> HttpRequest<S> {
     #[inline]
     /// Construct new http request without state.
     pub(crate) fn without_state(&self) -> HttpRequest {
-        HttpRequest(self.0.clone(), None, None)
+        HttpRequest(self.0.clone(), None, self.2.clone())
     }
 
     /// get mutable reference for inner message
@@ -184,12 +201,38 @@ impl<S> HttpRequest<S> {
         self.1.as_ref().unwrap()
     }
 
-    /// Protocol extensions.
+    /// Request extensions
     #[inline]
     pub fn extensions(&mut self) -> &mut Extensions {
         &mut self.as_mut().extensions
     }
 
+    /// Default `CpuPool`
+    #[inline]
+    #[doc(hidden)]
+    pub fn cpu_pool(&self) -> &CpuPool {
+        self.router().expect("HttpRequest has to have Router instance")
+            .server_settings().cpu_pool()
+    }
+
+    /// Create http response
+    pub fn response(&self, status: StatusCode, body: Body) -> HttpResponse {
+        if let Some(router) = self.router() {
+            router.server_settings().get_response(status, body)
+        } else {
+            HttpResponse::with_body(status, body)
+        }
+    }
+
+    /// Create http response builder
+    pub fn build_response(&self, status: StatusCode) -> HttpResponseBuilder {
+        if let Some(router) = self.router() {
+            router.server_settings().get_response_builder(status)
+        } else {
+            HttpResponse::build(status)
+        }
+    }
+
     #[doc(hidden)]
     pub fn prefix_len(&self) -> usize {
         if let Some(router) = self.router() { router.prefix().len() } else { 0 }
@@ -199,11 +242,10 @@ impl<S> HttpRequest<S> {
     #[inline]
     pub fn uri(&self) -> &Uri { &self.as_ref().uri }
 
-    #[doc(hidden)]
-    #[inline]
-    /// Modify the Request Uri.
+    /// Returns mutable the Request Uri.
     ///
-    /// This might be useful for middlewares, i.e. path normalization
+    /// This might be useful for middlewares, e.g. path normalization.
+    #[inline]
     pub fn uri_mut(&mut self) -> &mut Uri {
         &mut self.as_mut().uri
     }
@@ -218,7 +260,9 @@ impl<S> HttpRequest<S> {
         self.as_ref().version
     }
 
-    #[doc(hidden)]
+    ///Returns mutable Request's headers.
+    ///
+    ///This is intended to be used by middleware.
     #[inline]
     pub fn headers_mut(&mut self) -> &mut HeaderMap {
         &mut self.as_mut().headers
@@ -230,6 +274,12 @@ impl<S> HttpRequest<S> {
         self.uri().path()
     }
 
+    /// Percent decoded path of this Request.
+    #[inline]
+    pub fn path_decoded(&self) -> Cow<str> {
+        percent_decode(self.uri().path().as_bytes()).decode_utf8().unwrap()
+    }
+
     /// Get *ConnectionInfo* for correct request.
     pub fn connection_info(&self) -> &ConnectionInfo {
         if self.as_ref().info.is_none() {
@@ -244,19 +294,18 @@ impl<S> HttpRequest<S> {
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// # use actix_web::*;
-    /// # use actix_web::httpcodes::*;
+    /// # use actix_web::{App, HttpRequest, HttpResponse, http};
     /// #
     /// fn index(req: HttpRequest) -> HttpResponse {
     ///     let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
-    ///     HttpOk.into()
+    ///     HttpResponse::Ok().into()
     /// }
     ///
     /// fn main() {
-    ///     let app = Application::new()
+    ///     let app = App::new()
     ///         .resource("/test/{one}/{two}/{three}", |r| {
     ///              r.name("foo");  // <- set resource name, then it could be used in `url_for`
-    ///              r.method(Method::GET).f(|_| httpcodes::HttpOk);
+    ///              r.method(http::Method::GET).f(|_| HttpResponse::Ok());
     ///         })
     ///         .finish();
     /// }
@@ -284,6 +333,21 @@ impl<S> HttpRequest<S> {
         self.2.as_ref()
     }
 
+    /// This method returns reference to matched `Resource` object.
+    #[inline]
+    pub fn resource(&self) -> &Resource {
+        if let Some(ref router) = self.2 {
+            if let RouterResource::Normal(idx) = self.as_ref().resource {
+                return router.get_resource(idx as usize)
+            }
+        }
+        &*RESOURCE
+    }
+
+    pub(crate) fn set_resource(&mut self, res: usize) {
+        self.as_mut().resource = RouterResource::Normal(res as u16);
+    }
+
     /// Peer socket address
     ///
     /// Peer address is actual socket address, if proxy is used in front of
@@ -330,11 +394,12 @@ impl<S> HttpRequest<S> {
         if self.as_ref().cookies.is_none() {
             let msg = self.as_mut();
             let mut cookies = Vec::new();
-            if let Some(val) = msg.headers.get(header::COOKIE) {
-                let s = str::from_utf8(val.as_bytes())
-                    .map_err(CookieParseError::from)?;
-                for cookie in s.split("; ") {
-                    cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
+            for hdr in msg.headers.get_all(header::COOKIE) {
+                let s = str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
+                for cookie_str in s.split(';').map(|s| s.trim()) {
+                    if !cookie_str.is_empty() {
+                        cookies.push(Cookie::parse_encoded(cookie_str)?.into_owned());
+                    }
                 }
             }
             msg.cookies = Some(cookies)
@@ -355,6 +420,7 @@ impl<S> HttpRequest<S> {
     }
 
     /// Get a reference to the Params object.
+    ///
     /// Params is a container for url parameters.
     /// Route supports glob patterns: * for a single wildcard segment and :param
     /// for matching storing that segment of the request url in the Params object.
@@ -365,7 +431,7 @@ impl<S> HttpRequest<S> {
 
     /// Get mutable reference to request's Params.
     #[inline]
-    pub(crate) fn match_info_mut(&mut self) -> &mut Params {
+    pub fn match_info_mut(&mut self) -> &mut Params {
         unsafe{ mem::transmute(&mut self.as_mut().params) }
     }
 
@@ -384,6 +450,15 @@ impl<S> HttpRequest<S> {
         self.as_ref().method == Method::CONNECT
     }
 
+    /// Set read buffer capacity
+    ///
+    /// Default buffer capacity is 32Kb.
+    pub fn set_read_buffer_capacity(&mut self, cap: usize) {
+        if let Some(ref mut payload) = self.as_mut().payload {
+            payload.set_read_buffer_capacity(cap)
+        }
+    }
+
     #[cfg(test)]
     pub(crate) fn payload(&self) -> &Payload {
         let msg = self.as_mut();
@@ -417,6 +492,17 @@ impl<S> Clone for HttpRequest<S> {
     }
 }
 
+impl<S: 'static> FromRequest<S> for HttpRequest<S>
+{
+    type Config = ();
+    type Result = FutureResult<Self, Error>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result {
+        result(Ok(req.clone()))
+    }
+}
+
 impl<S> Stream for HttpRequest<S> {
     type Item = Bytes;
     type Error = PayloadError;
@@ -469,22 +555,17 @@ impl<S> AsyncRead for HttpRequest<S> {}
 
 impl<S> fmt::Debug for HttpRequest<S> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let res = write!(f, "\nHttpRequest {:?} {}:{}\n",
-                         self.as_ref().version, self.as_ref().method, self.as_ref().uri);
+        let res = writeln!(f, "\nHttpRequest {:?} {}:{}",
+                         self.as_ref().version, self.as_ref().method, self.path_decoded());
         if !self.query_string().is_empty() {
-            let _ = write!(f, "  query: ?{:?}\n", self.query_string());
+            let _ = writeln!(f, "  query: ?{:?}", self.query_string());
         }
         if !self.match_info().is_empty() {
-            let _ = write!(f, "  params: {:?}\n", self.as_ref().params);
+            let _ = writeln!(f, "  params: {:?}", self.as_ref().params);
         }
-        let _ = write!(f, "  headers:\n");
-        for key in self.as_ref().headers.keys() {
-            let vals: Vec<_> = self.as_ref().headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.as_ref().headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
         }
         res
     }
@@ -494,8 +575,8 @@ impl<S> fmt::Debug for HttpRequest<S> {
 mod tests {
     use super::*;
     use http::{Uri, HttpTryFrom};
-    use router::Pattern;
-    use resource::Resource;
+    use router::Resource;
+    use resource::ResourceHandler;
     use test::TestRequest;
     use server::ServerSettings;
 
@@ -522,8 +603,10 @@ mod tests {
 
     #[test]
     fn test_request_cookies() {
-        let req = TestRequest::with_header(
-            header::COOKIE, "cookie1=value1; cookie2=value2").finish();
+        let req = TestRequest::default()
+            .header(header::COOKIE, "cookie1=value1")
+            .header(header::COOKIE, "cookie2=value2")
+            .finish();
         {
             let cookies = req.cookies().unwrap();
             assert_eq!(cookies.len(), 2);
@@ -555,10 +638,10 @@ mod tests {
     fn test_request_match_info() {
         let mut req = TestRequest::with_uri("/value/?id=test").finish();
 
-        let mut resource = Resource::<()>::default();
+        let mut resource = ResourceHandler::<()>::default();
         resource.name("index");
         let mut routes = Vec::new();
-        routes.push((Pattern::new("index", "/{key}/"), Some(resource)));
+        routes.push((Resource::new("index", "/{key}/"), Some(resource)));
         let (router, _) = Router::new("", ServerSettings::default(), routes);
         assert!(router.recognize(&mut req).is_some());
 
@@ -567,20 +650,19 @@ mod tests {
 
     #[test]
     fn test_url_for() {
-        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
-            .finish_no_router();
+        let req2 = HttpRequest::default();
+        assert_eq!(req2.url_for("unknown", &["test"]),
+                   Err(UrlGenerationError::RouterNotAvailable));
 
-        let mut resource = Resource::<()>::default();
+        let mut resource = ResourceHandler::<()>::default();
         resource.name("index");
-        let routes = vec!((Pattern::new("index", "/user/{name}.{ext}"), Some(resource)));
+        let routes = vec!((Resource::new("index", "/user/{name}.{ext}"), Some(resource)));
         let (router, _) = Router::new("/", ServerSettings::default(), routes);
         assert!(router.has_route("/user/test.html"));
         assert!(!router.has_route("/test/unknown"));
 
-        assert_eq!(req.url_for("unknown", &["test"]),
-                   Err(UrlGenerationError::RouterNotAvailable));
-
-        let req = req.with_state(Rc::new(()), router);
+        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
+            .finish_with_router(router);
 
         assert_eq!(req.url_for("unknown", &["test"]),
                    Err(UrlGenerationError::ResourceNotFound));
@@ -594,26 +676,27 @@ mod tests {
     fn test_url_for_with_prefix() {
         let req = TestRequest::with_header(header::HOST, "www.rust-lang.org").finish();
 
-        let mut resource = Resource::<()>::default();
+        let mut resource = ResourceHandler::<()>::default();
         resource.name("index");
-        let routes = vec![(Pattern::new("index", "/user/{name}.{ext}"), Some(resource))];
+        let routes = vec![(Resource::new("index", "/user/{name}.{ext}"), Some(resource))];
         let (router, _) = Router::new("/prefix/", ServerSettings::default(), routes);
         assert!(router.has_route("/user/test.html"));
         assert!(!router.has_route("/prefix/user/test.html"));
 
         let req = req.with_state(Rc::new(()), router);
         let url = req.url_for("index", &["test", "html"]);
-        assert_eq!(url.ok().unwrap().as_str(), "http://www.rust-lang.org/prefix/user/test.html");
+        assert_eq!(url.ok().unwrap().as_str(),
+                   "http://www.rust-lang.org/prefix/user/test.html");
     }
 
     #[test]
     fn test_url_for_external() {
         let req = HttpRequest::default();
 
-        let mut resource = Resource::<()>::default();
+        let mut resource = ResourceHandler::<()>::default();
         resource.name("index");
         let routes = vec![
-            (Pattern::new("youtube", "https://youtube.com/watch/{video_id}"), None)];
+            (Resource::external("youtube", "https://youtube.com/watch/{video_id}"), None)];
         let (router, _) = Router::new::<()>("", ServerSettings::default(), routes);
         assert!(!router.has_route("https://youtube.com/watch/unknown"));
 

src/httpresponse.rs

@@ -1,11 +1,13 @@
 //! Http response
 use std::{mem, str, fmt};
+use std::rc::Rc;
 use std::io::Write;
-use std::cell::RefCell;
+use std::cell::UnsafeCell;
 use std::collections::VecDeque;
 
 use cookie::{Cookie, CookieJar};
 use bytes::{Bytes, BytesMut, BufMut};
+use futures::Stream;
 use http::{StatusCode, Version, HeaderMap, HttpTryFrom, Error as HttpError};
 use http::header::{self, HeaderName, HeaderValue};
 use serde_json;
@@ -14,8 +16,14 @@ use serde::Serialize;
 use body::Body;
 use error::Error;
 use handler::Responder;
-use headers::ContentEncoding;
+use header::{Header, IntoHeaderValue, ContentEncoding};
 use httprequest::HttpRequest;
+use httpmessage::HttpMessage;
+use client::ClientResponse;
+
+/// max write buffer size 64k
+pub(crate) const MAX_WRITE_BUFFER_SIZE: usize = 65_536;
+
 
 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -29,12 +37,12 @@ pub enum ConnectionType {
 }
 
 /// An HTTP Response
-pub struct HttpResponse(Option<Box<InnerHttpResponse>>);
+pub struct HttpResponse(Option<Box<InnerHttpResponse>>, Rc<UnsafeCell<HttpResponsePool>>);
 
 impl Drop for HttpResponse {
     fn drop(&mut self) {
         if let Some(inner) = self.0.take() {
-            Pool::release(inner)
+            HttpResponsePool::release(&self.1, inner)
         }
     }
 }
@@ -56,17 +64,25 @@ impl HttpResponse {
     /// Create http response builder with specific status.
     #[inline]
     pub fn build(status: StatusCode) -> HttpResponseBuilder {
-        HttpResponseBuilder {
-            response: Some(Pool::get(status)),
-            err: None,
-            cookies: None,
-        }
+        HttpResponsePool::get(status)
+    }
+
+    /// Create http response builder
+    #[inline]
+    pub fn build_from<T: Into<HttpResponseBuilder>>(source: T) -> HttpResponseBuilder {
+        source.into()
     }
 
     /// Constructs a response
     #[inline]
-    pub fn new(status: StatusCode, body: Body) -> HttpResponse {
-        HttpResponse(Some(Pool::with_body(status, body)))
+    pub fn new(status: StatusCode) -> HttpResponse {
+        HttpResponsePool::with_body(status, Body::Empty)
+    }
+
+    /// Constructs a response with body
+    #[inline]
+    pub fn with_body<B: Into<Body>>(status: StatusCode, body: B) -> HttpResponse {
+        HttpResponsePool::with_body(status, body.into())
     }
 
     /// Constructs a error response
@@ -77,6 +93,20 @@ impl HttpResponse {
         resp
     }
 
+    /// Convert `HttpResponse` to a `HttpResponseBuilder`
+    #[inline]
+    pub fn into_builder(mut self) -> HttpResponseBuilder {
+        let response = self.0.take();
+        let pool = Some(Rc::clone(&self.1));
+
+        HttpResponseBuilder {
+            response,
+            pool,
+            err: None,
+            cookies: None,  // TODO: convert set-cookie headers
+        }
+    }
+
     /// The source `error` for this response
     #[inline]
     pub fn error(&self) -> Option<&Error> {
@@ -197,22 +227,27 @@ impl HttpResponse {
     pub(crate) fn set_response_size(&mut self, size: u64) {
         self.get_mut().response_size = size;
     }
+
+    /// Set write buffer capacity
+    pub fn write_buffer_capacity(&self) -> usize {
+        self.get_ref().write_capacity
+    }
+
+    /// Set write buffer capacity
+    pub fn set_write_buffer_capacity(&mut self, cap: usize) {
+        self.get_mut().write_capacity = cap;
+    }
 }
 
 impl fmt::Debug for HttpResponse {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let res = write!(f, "\nHttpResponse {:?} {}{}\n",
+        let res = writeln!(f, "\nHttpResponse {:?} {}{}",
                          self.get_ref().version, self.get_ref().status,
                          self.get_ref().reason.unwrap_or(""));
-        let _ = write!(f, "  encoding: {:?}\n", self.get_ref().encoding);
-        let _ = write!(f, "  headers:\n");
-        for key in self.get_ref().headers.keys() {
-            let vals: Vec<_> = self.get_ref().headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        let _ = writeln!(f, "  encoding: {:?}", self.get_ref().encoding);
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in self.get_ref().headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
         }
         res
     }
@@ -222,14 +257,23 @@ impl fmt::Debug for HttpResponse {
 ///
 /// This type can be used to construct an instance of `HttpResponse` through a
 /// builder-like pattern.
-#[derive(Debug)]
 pub struct HttpResponseBuilder {
     response: Option<Box<InnerHttpResponse>>,
+    pool: Option<Rc<UnsafeCell<HttpResponsePool>>>,
     err: Option<HttpError>,
     cookies: Option<CookieJar>,
 }
 
 impl HttpResponseBuilder {
+    /// Set HTTP status code of this response.
+    #[inline]
+    pub fn status(&mut self, status: StatusCode) -> &mut Self {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            parts.status = status;
+        }
+        self
+    }
+
     /// Set HTTP version of this response.
     ///
     /// By default response's http version depends on request's version.
@@ -244,29 +288,50 @@ impl HttpResponseBuilder {
     /// Set a header.
     ///
     /// ```rust
-    /// # extern crate http;
     /// # extern crate actix_web;
-    /// # use actix_web::*;
-    /// # use actix_web::httpcodes::*;
-    /// #
-    /// use http::header;
+    /// use actix_web::{HttpRequest, HttpResponse, Result, http};
     ///
     /// fn index(req: HttpRequest) -> Result<HttpResponse> {
-    ///     Ok(HttpOk.build()
+    ///     Ok(HttpResponse::Ok()
+    ///         .set(http::header::IfModifiedSince("Sun, 07 Nov 1994 08:48:37 GMT".parse()?))
+    ///         .finish())
+    /// }
+    /// fn main() {}
+    /// ```
+    #[doc(hidden)]
+    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self
+    {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            match hdr.try_into() {
+                Ok(value) => { parts.headers.append(H::name(), value); }
+                Err(e) => self.err = Some(e.into()),
+            }
+        }
+        self
+    }
+
+    /// Set a header.
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::{http, HttpRequest, HttpResponse};
+    ///
+    /// fn index(req: HttpRequest) -> HttpResponse {
+    ///     HttpResponse::Ok()
     ///         .header("X-TEST", "value")
-    ///         .header(header::CONTENT_TYPE, "application/json")
-    ///         .finish()?)
+    ///         .header(http::header::CONTENT_TYPE, "application/json")
+    ///         .finish()
     /// }
     /// fn main() {}
     /// ```
     pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
         where HeaderName: HttpTryFrom<K>,
-              HeaderValue: HttpTryFrom<V>
+              V: IntoHeaderValue,
     {
         if let Some(parts) = parts(&mut self.response, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.append(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -366,21 +431,18 @@ impl HttpResponseBuilder {
     ///
     /// ```rust
     /// # extern crate actix_web;
-    /// # use actix_web::*;
-    /// # use actix_web::httpcodes::*;
-    /// #
-    /// use actix_web::headers::Cookie;
+    /// use actix_web::{http, HttpRequest, HttpResponse, Result};
     ///
-    /// fn index(req: HttpRequest) -> Result<HttpResponse> {
-    ///     Ok(HttpOk.build()
+    /// fn index(req: HttpRequest) -> HttpResponse {
+    ///     HttpResponse::Ok()
     ///         .cookie(
-    ///             Cookie::build("name", "value")
+    ///             http::Cookie::build("name", "value")
     ///                 .domain("www.rust-lang.org")
     ///                 .path("/")
     ///                 .secure(true)
     ///                 .http_only(true)
     ///                 .finish())
-    ///         .finish()?)
+    ///         .finish()
     /// }
     /// fn main() {}
     /// ```
@@ -429,47 +491,78 @@ impl HttpResponseBuilder {
         self
     }
 
+    /// Set write buffer capacity
+    ///
+    /// This parameter makes sense only for streaming response
+    /// or actor. If write buffer reaches specified capacity, stream or actor get
+    /// paused.
+    ///
+    /// Default write buffer capacity is 64kb
+    pub fn write_buffer_capacity(&mut self, cap: usize) -> &mut Self {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            parts.write_capacity = cap;
+        }
+        self
+    }
+
     /// Set a body and generate `HttpResponse`.
     ///
     /// `HttpResponseBuilder` can not be used after this call.
-    pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<HttpResponse, HttpError> {
+    pub fn body<B: Into<Body>>(&mut self, body: B) -> HttpResponse {
         if let Some(e) = self.err.take() {
-            return Err(e)
+            return Error::from(e).into()
         }
         let mut response = self.response.take().expect("cannot reuse response builder");
         if let Some(ref jar) = self.cookies {
             for cookie in jar.delta() {
-                response.headers.append(
-                    header::SET_COOKIE,
-                    HeaderValue::from_str(&cookie.to_string())?);
+                match HeaderValue::from_str(&cookie.to_string()) {
+                    Ok(val) => response.headers.append(header::SET_COOKIE, val),
+                    Err(e) => return Error::from(e).into(),
+                };
             }
         }
         response.body = body.into();
-        Ok(HttpResponse(Some(response)))
+        HttpResponse(Some(response), self.pool.take().unwrap())
+    }
+
+    #[inline]
+    /// Set a streaming body and generate `HttpResponse`.
+    ///
+    /// `HttpResponseBuilder` can not be used after this call.
+    pub fn streaming<S, E>(&mut self, stream: S) -> HttpResponse
+        where S: Stream<Item=Bytes, Error=E> + 'static,
+              E: Into<Error>,
+    {
+        self.body(Body::Streaming(Box::new(stream.map_err(|e| e.into()))))
     }
 
     /// Set a json body and generate `HttpResponse`
     ///
     /// `HttpResponseBuilder` can not be used after this call.
-    pub fn json<T: Serialize>(&mut self, value: T) -> Result<HttpResponse, Error> {
-        let body = serde_json::to_string(&value)?;
+    pub fn json<T: Serialize>(&mut self, value: T) -> HttpResponse {
+        match serde_json::to_string(&value) {
+            Ok(body) => {
+                let contains =
+                    if let Some(parts) = parts(&mut self.response, &self.err) {
+                        parts.headers.contains_key(header::CONTENT_TYPE)
+                    } else {
+                        true
+                    };
+                if !contains {
+                    self.header(header::CONTENT_TYPE, "application/json");
+                }
 
-        let contains = if let Some(parts) = parts(&mut self.response, &self.err) {
-            parts.headers.contains_key(header::CONTENT_TYPE)
-        } else {
-            true
-        };
-        if !contains {
-            self.header(header::CONTENT_TYPE, "application/json");
+                self.body(body)
+            },
+            Err(e) => Error::from(e).into()
         }
-
-        Ok(self.body(body)?)
     }
 
+    #[inline]
     /// Set an empty body and generate `HttpResponse`
     ///
     /// `HttpResponseBuilder` can not be used after this call.
-    pub fn finish(&mut self) -> Result<HttpResponse, HttpError> {
+    pub fn finish(&mut self) -> HttpResponse {
         self.body(Body::Empty)
     }
 
@@ -477,6 +570,7 @@ impl HttpResponseBuilder {
     pub fn take(&mut self) -> HttpResponseBuilder {
         HttpResponseBuilder {
             response: self.response.take(),
+            pool: self.pool.take(),
             err: self.err.take(),
             cookies: self.cookies.take(),
         }
@@ -506,77 +600,74 @@ impl<I: Into<HttpResponse>, E: Into<Error>> From<Result<I, E>> for HttpResponse
 
 impl From<HttpResponseBuilder> for HttpResponse {
     fn from(mut builder: HttpResponseBuilder) -> Self {
-        builder.finish().into()
+        builder.finish()
     }
 }
 
 impl Responder for HttpResponseBuilder {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
     #[inline]
-    fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        self.finish()
+    fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(self.finish())
     }
 }
 
 impl From<&'static str> for HttpResponse {
     fn from(val: &'static str) -> Self {
-        HttpResponse::build(StatusCode::OK)
+        HttpResponse::Ok()
             .content_type("text/plain; charset=utf-8")
             .body(val)
-            .into()
     }
 }
 
 impl Responder for &'static str {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("text/plain; charset=utf-8")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("text/plain; charset=utf-8")
+           .body(self))
     }
 }
 
 impl From<&'static [u8]> for HttpResponse {
     fn from(val: &'static [u8]) -> Self {
-        HttpResponse::build(StatusCode::OK)
+        HttpResponse::Ok()
             .content_type("application/octet-stream")
             .body(val)
-            .into()
     }
 }
 
 impl Responder for &'static [u8] {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("application/octet-stream")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("application/octet-stream")
+           .body(self))
     }
 }
 
 impl From<String> for HttpResponse {
     fn from(val: String) -> Self {
-        HttpResponse::build(StatusCode::OK)
+        HttpResponse::Ok()
             .content_type("text/plain; charset=utf-8")
             .body(val)
-            .into()
     }
 }
 
 impl Responder for String {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("text/plain; charset=utf-8")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("text/plain; charset=utf-8")
+           .body(self))
     }
 }
 
@@ -585,58 +676,79 @@ impl<'a> From<&'a String> for HttpResponse {
         HttpResponse::build(StatusCode::OK)
             .content_type("text/plain; charset=utf-8")
             .body(val)
-            .into()
     }
 }
 
 impl<'a> Responder for &'a String {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("text/plain; charset=utf-8")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("text/plain; charset=utf-8")
+           .body(self))
     }
 }
 
 impl From<Bytes> for HttpResponse {
     fn from(val: Bytes) -> Self {
-        HttpResponse::build(StatusCode::OK)
+        HttpResponse::Ok()
             .content_type("application/octet-stream")
             .body(val)
-            .into()
     }
 }
 
 impl Responder for Bytes {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("application/octet-stream")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("application/octet-stream")
+           .body(self))
     }
 }
 
 impl From<BytesMut> for HttpResponse {
     fn from(val: BytesMut) -> Self {
-        HttpResponse::build(StatusCode::OK)
+        HttpResponse::Ok()
             .content_type("application/octet-stream")
             .body(val)
-            .into()
     }
 }
 
 impl Responder for BytesMut {
     type Item = HttpResponse;
-    type Error = HttpError;
+    type Error = Error;
 
-    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
-        HttpResponse::build(StatusCode::OK)
-            .content_type("application/octet-stream")
-            .body(self)
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, Error> {
+        Ok(req.build_response(StatusCode::OK)
+           .content_type("application/octet-stream")
+           .body(self))
+    }
+}
+
+/// Create `HttpResponseBuilder` from `ClientResponse`
+///
+/// It is useful for proxy response. This implementation
+/// copies all responses's headers and status.
+impl<'a> From<&'a ClientResponse> for HttpResponseBuilder {
+    fn from(resp: &'a ClientResponse) -> HttpResponseBuilder {
+        let mut builder = HttpResponse::build(resp.status());
+        for (key, value) in resp.headers() {
+            builder.header(key.clone(), value.clone());
+        }
+        builder
+    }
+}
+
+impl<'a, S> From<&'a HttpRequest<S>> for HttpResponseBuilder {
+    fn from(req: &'a HttpRequest<S>) -> HttpResponseBuilder {
+        if let Some(router) = req.router() {
+            router.server_settings().get_response_builder(StatusCode::OK)
+        } else {
+            HttpResponse::Ok()
+        }
     }
 }
 
@@ -650,6 +762,7 @@ struct InnerHttpResponse {
     chunked: Option<bool>,
     encoding: Option<ContentEncoding>,
     connection_type: Option<ConnectionType>,
+    write_capacity: usize,
     response_size: u64,
     error: Option<Error>,
 }
@@ -668,62 +781,87 @@ impl InnerHttpResponse {
             encoding: None,
             connection_type: None,
             response_size: 0,
+            write_capacity: MAX_WRITE_BUFFER_SIZE,
             error: None,
         }
     }
 }
 
 /// Internal use only! unsafe
-struct Pool(VecDeque<Box<InnerHttpResponse>>);
+pub(crate) struct HttpResponsePool(VecDeque<Box<InnerHttpResponse>>);
 
-thread_local!(static POOL: RefCell<Pool> =
-              RefCell::new(Pool(VecDeque::with_capacity(128))));
+thread_local!(static POOL: Rc<UnsafeCell<HttpResponsePool>> = HttpResponsePool::pool());
 
-impl Pool {
+impl HttpResponsePool {
 
-    #[inline]
-    fn get(status: StatusCode) -> Box<InnerHttpResponse> {
-        POOL.with(|pool| {
-            if let Some(mut resp) = pool.borrow_mut().0.pop_front() {
-                resp.body = Body::Empty;
-                resp.status = status;
-                resp
-            } else {
-                Box::new(InnerHttpResponse::new(status, Body::Empty))
-            }
-        })
+    pub fn pool() -> Rc<UnsafeCell<HttpResponsePool>> {
+        Rc::new(UnsafeCell::new(HttpResponsePool(VecDeque::with_capacity(128))))
     }
 
     #[inline]
-    fn with_body(status: StatusCode, body: Body) -> Box<InnerHttpResponse> {
-        POOL.with(|pool| {
-            if let Some(mut resp) = pool.borrow_mut().0.pop_front() {
-                resp.status = status;
-                resp.body = body;
-                resp
-            } else {
-                Box::new(InnerHttpResponse::new(status, body))
-            }
-        })
+    pub fn get_builder(pool: &Rc<UnsafeCell<HttpResponsePool>>, status: StatusCode)
+                       -> HttpResponseBuilder
+    {
+        let p = unsafe{&mut *pool.as_ref().get()};
+        if let Some(mut msg) = p.0.pop_front() {
+            msg.status = status;
+            HttpResponseBuilder {
+                response: Some(msg),
+                pool: Some(Rc::clone(pool)),
+                err: None,
+                cookies: None }
+        } else {
+            let msg = Box::new(InnerHttpResponse::new(status, Body::Empty));
+            HttpResponseBuilder {
+                response: Some(msg),
+                pool: Some(Rc::clone(pool)),
+                err: None,
+                cookies: None }
+        }
+    }
+
+    #[inline]
+    pub fn get_response(pool: &Rc<UnsafeCell<HttpResponsePool>>,
+                        status: StatusCode, body: Body) -> HttpResponse
+    {
+        let p = unsafe{&mut *pool.as_ref().get()};
+        if let Some(mut msg) = p.0.pop_front() {
+            msg.status = status;
+            msg.body = body;
+            HttpResponse(Some(msg), Rc::clone(pool))
+        } else {
+            let msg = Box::new(InnerHttpResponse::new(status, body));
+            HttpResponse(Some(msg), Rc::clone(pool))
+        }
+    }
+
+    #[inline]
+    fn get(status: StatusCode) -> HttpResponseBuilder {
+        POOL.with(|pool| HttpResponsePool::get_builder(pool, status))
+    }
+
+    #[inline]
+    fn with_body(status: StatusCode, body: Body) -> HttpResponse {
+        POOL.with(|pool| HttpResponsePool::get_response(pool, status, body))
     }
 
     #[inline(always)]
     #[cfg_attr(feature = "cargo-clippy", allow(boxed_local, inline_always))]
-    fn release(mut inner: Box<InnerHttpResponse>) {
-        POOL.with(|pool| {
-            let v = &mut pool.borrow_mut().0;
-            if v.len() < 128 {
-                inner.headers.clear();
-                inner.version = None;
-                inner.chunked = None;
-                inner.reason = None;
-                inner.encoding = None;
-                inner.connection_type = None;
-                inner.response_size = 0;
-                inner.error = None;
-                v.push_front(inner);
-            }
-        })
+    fn release(pool: &Rc<UnsafeCell<HttpResponsePool>>, mut inner: Box<InnerHttpResponse>)
+    {
+        let pool = unsafe{&mut *pool.as_ref().get()};
+        if pool.0.len() < 128 {
+            inner.headers.clear();
+            inner.version = None;
+            inner.chunked = None;
+            inner.reason = None;
+            inner.encoding = None;
+            inner.connection_type = None;
+            inner.response_size = 0;
+            inner.error = None;
+            inner.write_capacity = MAX_WRITE_BUFFER_SIZE;
+            pool.0.push_front(inner);
+        }
     }
 }
 
@@ -733,12 +871,16 @@ mod tests {
     use std::str::FromStr;
     use time::Duration;
     use http::{Method, Uri};
+    use http::header::{COOKIE, CONTENT_TYPE, HeaderValue};
     use body::Binary;
-    use {headers, httpcodes};
+    use http;
 
     #[test]
     fn test_debug() {
-        let resp = HttpResponse::Ok().finish().unwrap();
+        let resp = HttpResponse::Ok()
+            .header(COOKIE, HeaderValue::from_static("cookie1=value1; "))
+            .header(COOKIE, HeaderValue::from_static("cookie2=value2; "))
+            .finish();
         let dbg = format!("{:?}", resp);
         assert!(dbg.contains("HttpResponse"));
     }
@@ -746,31 +888,27 @@ mod tests {
     #[test]
     fn test_response_cookies() {
         let mut headers = HeaderMap::new();
-        headers.insert(header::COOKIE,
-                       header::HeaderValue::from_static("cookie1=value1; cookie2=value2"));
+        headers.insert(COOKIE, HeaderValue::from_static("cookie1=value1"));
+        headers.insert(COOKIE, HeaderValue::from_static("cookie2=value2"));
 
         let req = HttpRequest::new(
             Method::GET, Uri::from_str("/").unwrap(), Version::HTTP_11, headers, None);
         let cookies = req.cookies().unwrap();
 
-        let resp = httpcodes::HttpOk
-            .build()
-            .cookie(headers::Cookie::build("name", "value")
+        let resp = HttpResponse::Ok()
+            .cookie(http::Cookie::build("name", "value")
                     .domain("www.rust-lang.org")
                     .path("/test")
                     .http_only(true)
                     .max_age(Duration::days(1))
                     .finish())
             .del_cookie(&cookies[0])
-            .body(Body::Empty);
-
-        assert!(resp.is_ok());
-        let resp = resp.unwrap();
+            .finish();
 
         let mut val: Vec<_> = resp.headers().get_all("Set-Cookie")
             .iter().map(|v| v.to_str().unwrap().to_owned()).collect();
         val.sort();
-        assert!(val[0].starts_with("cookie1=; Max-Age=0;"));
+        assert!(val[0].starts_with("cookie2=; Max-Age=0;"));
         assert_eq!(
             val[1],"name=value; HttpOnly; Path=/test; Domain=www.rust-lang.org; Max-Age=86400");
     }
@@ -780,58 +918,63 @@ mod tests {
         let resp = HttpResponse::Ok()
             .header("X-TEST", "value")
             .version(Version::HTTP_10)
-            .finish().unwrap();
+            .finish();
         assert_eq!(resp.version(), Some(Version::HTTP_10));
         assert_eq!(resp.status(), StatusCode::OK);
     }
 
     #[test]
     fn test_upgrade() {
-        let resp = HttpResponse::build(StatusCode::OK)
-            .upgrade().body(Body::Empty).unwrap();
+        let resp = HttpResponse::build(StatusCode::OK).upgrade().finish();
         assert!(resp.upgrade())
     }
 
     #[test]
     fn test_force_close() {
-        let resp = HttpResponse::build(StatusCode::OK)
-            .force_close().body(Body::Empty).unwrap();
+        let resp = HttpResponse::build(StatusCode::OK).force_close().finish();
         assert!(!resp.keep_alive().unwrap())
     }
 
     #[test]
     fn test_content_type() {
         let resp = HttpResponse::build(StatusCode::OK)
-            .content_type("text/plain").body(Body::Empty).unwrap();
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/plain")
+            .content_type("text/plain").body(Body::Empty);
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain")
     }
 
     #[test]
     fn test_content_encoding() {
-        let resp = HttpResponse::build(StatusCode::OK).finish().unwrap();
+        let resp = HttpResponse::build(StatusCode::OK).finish();
         assert_eq!(resp.content_encoding(), None);
 
+        #[cfg(feature="brotli")]
+        {
+            let resp = HttpResponse::build(StatusCode::OK)
+                .content_encoding(ContentEncoding::Br).finish();
+            assert_eq!(resp.content_encoding(), Some(ContentEncoding::Br));
+        }
+
         let resp = HttpResponse::build(StatusCode::OK)
-            .content_encoding(ContentEncoding::Br).finish().unwrap();
-        assert_eq!(resp.content_encoding(), Some(ContentEncoding::Br));
+            .content_encoding(ContentEncoding::Gzip).finish();
+        assert_eq!(resp.content_encoding(), Some(ContentEncoding::Gzip));
     }
 
     #[test]
     fn test_json() {
         let resp = HttpResponse::build(StatusCode::OK)
-            .json(vec!["v1", "v2", "v3"]).unwrap();
-        let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
-        assert_eq!(ct, header::HeaderValue::from_static("application/json"));
+            .json(vec!["v1", "v2", "v3"]);
+        let ct = resp.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(ct, HeaderValue::from_static("application/json"));
         assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
     }
 
     #[test]
     fn test_json_ct() {
         let resp = HttpResponse::build(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "text/json")
-            .json(vec!["v1", "v2", "v3"]).unwrap();
-        let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
-        assert_eq!(ct, header::HeaderValue::from_static("text/json"));
+            .header(CONTENT_TYPE, "text/json")
+            .json(vec!["v1", "v2", "v3"]);
+        let ct = resp.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(ct, HeaderValue::from_static("text/json"));
         assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
     }
 
@@ -850,90 +993,100 @@ mod tests {
 
         let resp: HttpResponse = "test".into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
 
         let resp: HttpResponse = "test".respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
 
         let resp: HttpResponse = b"test".as_ref().into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
 
         let resp: HttpResponse = b"test".as_ref().respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
 
         let resp: HttpResponse = "test".to_owned().into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
 
         let resp: HttpResponse = "test".to_owned().respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
 
         let resp: HttpResponse = (&"test".to_owned()).into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
 
         let resp: HttpResponse = (&"test".to_owned()).respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
 
         let b = Bytes::from_static(b"test");
         let resp: HttpResponse = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
 
         let b = Bytes::from_static(b"test");
         let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
 
         let b = BytesMut::from("test");
         let resp: HttpResponse = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
 
         let b = BytesMut::from("test");
         let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
     }
+
+    #[test]
+    fn test_into_builder() {
+        let resp: HttpResponse = "test".into();
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let mut builder = resp.into_builder();
+        let resp = builder.status(StatusCode::BAD_REQUEST).finish();
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
 }

src/info.rs

@@ -147,7 +147,7 @@ impl<'a> ConnectionInfo<'a> {
     ///
     /// - Forwarded
     /// - X-Forwarded-For
-    /// - peername of opened socket
+    /// - peer name of opened socket
     #[inline]
     pub fn remote(&self) -> Option<&str> {
         if let Some(r) = self.remote {