Final fixes before requesting review.

content/docs/application.md

@@ -43,7 +43,7 @@ as the first application, it would match all incoming requests.
 ## State
 
 Application state is shared with all routes and resources within the same scope. State
-can be accessed with `web::Data<State>` as read-only, but interior mutability with
+can be accessed with the `web::Data<State>` extractor as read-only, but interior mutability with
 `Cell` can be used to achieve state mutability. State is also available for route
 matching guards and middlewares.
 

content/docs/errors.md

@@ -40,7 +40,7 @@ converted into an `HttpInternalServerError`:
 ```rust
 use std::io;
 
-fn index(req: &HttpRequest) -> io::Result<fs::NamedFile> {
+fn index(_req: HttpRequest) -> io::Result<fs::NamedFile> {
     Ok(fs::NamedFile::open("static/index.html")?)
 }
 ```

content/docs/handlers.md

@@ -22,13 +22,13 @@ such as `&'static str`, `String`, etc.
 Examples of valid handlers:
 
 ```rust
-fn index(req: &HttpRequest) -> &'static str {
+fn index(_req: HttpRequest) -> &'static str {
     "Hello world!"
 }
 ```
 
 ```rust
-fn index(req: HttpRequest) -> String {
+fn index(_req: HttpRequest) -> String {
     "Hello world!".to_owned()
 }
 ```
@@ -37,7 +37,7 @@ You can also change the signature to return `impl Responder` which works well if
 complex types are involved.
 
 ```rust
-fn index(req: HttpRequest) -> impl Responder {
+fn index(_req: HttpRequest) -> impl Responder {
     Bytes::from_static("Hello world!")
 }
 ```

content/docs/request.md

@@ -49,9 +49,7 @@ is decompressed.
 
 # Multipart body
 
-Actix provides multipart stream support with an external crate, [`actix-multipart`][multipartcrate].
+Actix-web provides multipart stream support with an external crate, [`actix-multipart`][multipartcrate].
-
-The following demonstrates multipart stream handling for a simple form:
 
 > A full example is available in the [examples directory][multipartexample].
 

content/docs/url-dispatch.md

@@ -83,7 +83,7 @@ against a URL path pattern. `path` represents the path portion of the URL that w
 The way that *actix-web* 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 `App::resource()` method. If resource can not be found,
+the routes were declared via `App::service()` 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 guard arguments. All route

examples/application/src/app.rs

@@ -1,7 +1,7 @@
 // <setup>
-use actix_web::{web, App, HttpRequest, Responder};
+use actix_web::{web, App, Responder};
 
-fn index(_req: HttpRequest) -> impl Responder {
+fn index() -> impl Responder {
     "Hello world!"
 }
 

examples/async-handlers/src/async_stream.rs

@@ -3,12 +3,10 @@ fn is_error() -> bool {
 }
 
 // <async-stream>
-use actix_web::{error, web, App, Error, HttpRequest, HttpResponse, HttpServer};
+use actix_web::{error, Error, HttpResponse};
 use futures::future::{result, Future};
 
-fn index(
+fn index() -> Result<Box<Future<Item = HttpResponse, Error = Error>>, Error> {
-    _req: HttpRequest,
-) -> Result<Box<Future<Item = HttpResponse, Error = Error>>, Error> {
     if is_error() {
         Err(error::ErrorBadRequest("bad request"))
     } else {
@@ -20,6 +18,8 @@ fn index(
 // </async-stream>
 
 pub fn main() {
+    use actix_web::{web, App, HttpServer};
+
     HttpServer::new(|| App::new().route("/", web::to_async(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/async-handlers/src/main.rs

@@ -1,22 +1,30 @@
 pub mod async_stream;
 pub mod stream;
 // <async-responder>
-use actix_web::{web, App, Error, HttpRequest, HttpResponse};
+use actix_web::{Error, HttpResponse};
 use futures::future::{ok, Future};
 
-fn index(_req: HttpRequest) -> Box<Future<Item = HttpResponse, Error = Error>> {
+fn index() -> Box<Future<Item = HttpResponse, Error = Error>> {
     Box::new(ok::<_, Error>(
         HttpResponse::Ok().content_type("text/html").body("Hello!"),
     ))
 }
 
-fn index2(_req: HttpRequest) -> Box<Future<Item = &'static str, Error = Error>> {
+fn index2() -> Box<Future<Item = &'static str, Error = Error>> {
     Box::new(ok::<_, Error>("Welcome!"))
 }
 
 fn main() {
+    use actix_web::{web, App, HttpServer};
+
+    HttpServer::new(|| {
         App::new()
             .route("/async", web::to_async(index))
-        .route("/", web::to_async(index2));
+            .route("/", web::to_async(index2))
+    })
+    .bind("127.0.0.1:8088")
+    .unwrap()
+    .run()
+    .unwrap();
 }
 // </async-responder>

examples/async-handlers/src/stream.rs

@@ -1,9 +1,9 @@
 // <stream>
-use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer};
+use actix_web::{Error, HttpResponse};
 use bytes::Bytes;
 use futures::stream::once;
 
-fn index(_req: HttpRequest) -> HttpResponse {
+fn index() -> HttpResponse {
     let body = once::<Bytes, Error>(Ok(Bytes::from_static(b"test")));
 
     HttpResponse::Ok()
@@ -12,6 +12,8 @@ fn index(_req: HttpRequest) -> HttpResponse {
 }
 
 pub fn main() {
+    use actix_web::{web, App, HttpServer};
+
     HttpServer::new(|| App::new().route("/async", web::to_async(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/either/src/main.rs

@@ -1,11 +1,11 @@
 // <either>
-use actix_web::{web, App, Either, Error, HttpRequest, HttpResponse};
+use actix_web::{Either, Error, HttpResponse};
 use futures::future::{ok, Future};
 
 type RegisterResult =
     Either<HttpResponse, Box<Future<Item = HttpResponse, Error = Error>>>;
 
-fn index(_req: HttpRequest) -> RegisterResult {
+fn index() -> RegisterResult {
     if is_a_variant() {
         // <- choose variant A
         Either::A(HttpResponse::BadRequest().body("Bad data"))
@@ -20,7 +20,13 @@ fn index(_req: HttpRequest) -> RegisterResult {
 }
 
 fn main() {
-    App::new().route("/", web::get().to(index));
+    use actix_web::{web, App, HttpServer};
+
+    HttpServer::new(|| App::new().route("/", web::get().to(index)))
+        .bind("127.0.0.1:8088")
+        .unwrap()
+        .run()
+        .unwrap();
 }
 // </either>
 

examples/errors/src/helpers.rs

@@ -1,13 +1,13 @@
 use actix_web::{web, App};
 // <helpers>
-use actix_web::{error, HttpRequest, Result};
+use actix_web::{error, Result};
 
 #[derive(Debug)]
 struct MyError {
     name: &'static str,
 }
 
-pub fn index(_req: HttpRequest) -> Result<&'static str> {
+pub fn index() -> Result<&'static str> {
     let result: Result<&'static str, MyError> = Err(MyError { name: "test error" });
 
     Ok(result.map_err(|e| error::ErrorBadRequest(e.name))?)

examples/errors/src/main.rs

@@ -16,7 +16,7 @@ pub struct MyError {
 // Use default implementation for `error_response()` method
 impl error::ResponseError for MyError {}
 
-fn index(_req: HttpRequest) -> Result<&'static str, MyError> {
+fn index() -> Result<&'static str, MyError> {
     Err(MyError { name: "test" })
 }
 // </response-error>

examples/errors/src/override_error.rs

@@ -1,6 +1,6 @@
 use actix_web::{web, App};
 // <override>
-use actix_web::{error, http, HttpRequest, HttpResponse};
+use actix_web::{error, http, HttpResponse};
 use failure::Fail;
 
 #[derive(Fail, Debug)]
@@ -25,16 +25,16 @@ impl error::ResponseError for MyError {
     }
 }
 
-fn index(_req: HttpRequest) -> Result<&'static str, MyError> {
+fn index() -> Result<&'static str, MyError> {
     Err(MyError::BadClientData)
 }
 // </override>
 
-fn error2(_req: HttpRequest) -> Result<&'static str, MyError> {
+fn error2() -> Result<&'static str, MyError> {
     Err(MyError::InternalError)
 }
 
-fn error3(_req: HttpRequest) -> Result<&'static str, MyError> {
+fn error3() -> Result<&'static str, MyError> {
     Err(MyError::Timeout)
 }
 

examples/extractors/src/form.rs

@@ -1,5 +1,5 @@
 // <form>
-use actix_web::{web, App, HttpServer, Result};
+use actix_web::{web, Result};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -16,6 +16,8 @@ fn index(form: web::Form<FormData>) -> Result<String> {
 // </form>
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| App::new().route("/", web::post().to(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/extractors/src/json_one.rs

@@ -1,5 +1,5 @@
 // <json-one>
-use actix_web::{web, App, HttpServer, Result};
+use actix_web::{web, Result};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -14,6 +14,8 @@ fn index(info: web::Json<Info>) -> Result<String> {
 // </json-one>
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| App::new().route("/", web::post().to(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/extractors/src/json_two.rs

@@ -1,5 +1,5 @@
 // <json-two>
-use actix_web::{error, web, App, FromRequest, HttpResponse, HttpServer, Responder};
+use actix_web::{error, web, FromRequest, HttpResponse, Responder};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -13,6 +13,8 @@ fn index(info: web::Json<Info>) -> impl Responder {
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| {
         App::new().service(
             web::resource("/")

examples/extractors/src/multiple.rs

@@ -1,5 +1,5 @@
 // <multi>
-use actix_web::{web, App, HttpServer};
+use actix_web::web;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -15,6 +15,8 @@ fn index((path, query): (web::Path<(u32, String)>, web::Query<Info>)) -> String
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| {
         App::new().route(
             "/users/{userid}/{friend}", // <- define path parameters

examples/extractors/src/path_one.rs

@@ -1,5 +1,5 @@
 // <path-one>
-use actix_web::{web, App, HttpServer, Result};
+use actix_web::{web, Result};
 
 /// extract path info from "/users/{userid}/{friend}" url
 /// {userid} -  - deserializes to a u32
@@ -9,6 +9,8 @@ fn index(info: web::Path<(u32, String)>) -> Result<String> {
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| {
         App::new().route(
             "/users/{userid}/{friend}", // <- define path parameters

examples/extractors/src/path_three.rs

@@ -1,4 +1,4 @@
-use actix_web::{web, App, HttpRequest, HttpServer, Result};
+use actix_web::{web, HttpRequest, Result};
 
 // <path-three>
 fn index(req: HttpRequest) -> Result<String> {
@@ -9,6 +9,8 @@ fn index(req: HttpRequest) -> Result<String> {
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| {
         App::new().route(
             "/users/{userid}/{friend}", // <- define path parameters

examples/extractors/src/path_two.rs

@@ -1,5 +1,5 @@
 // <path-two>
-use actix_web::{web, App, HttpServer, Result};
+use actix_web::{web, Result};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -14,6 +14,8 @@ fn index(info: web::Path<Info>) -> Result<String> {
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| {
         App::new().route(
             "/users/{userid}/{friend}", // <- define path parameters

examples/extractors/src/query.rs

@@ -1,5 +1,5 @@
 // <query>
-use actix_web::{web, App, HttpServer};
+use actix_web::web;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -14,6 +14,8 @@ fn index(info: web::Query<Info>) -> String {
 // </query>
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     HttpServer::new(|| App::new().route("/", web::get().to(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/getting-started/src/main.rs

@@ -1,11 +1,11 @@
 // <setup>
-use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder};
+use actix_web::{web, App, HttpResponse, HttpServer, Responder};
 
 fn index() -> impl Responder {
     HttpResponse::Ok().body("Hello world!")
 }
 
-fn index2(_req: HttpRequest) -> impl Responder {
+fn index2() -> impl Responder {
     HttpResponse::Ok().body("Hello world again!")
 }
 // </setup>

examples/request-handlers/src/handlers_arc.rs

@@ -1,5 +1,5 @@
 // <arc>
-use actix_web::{web, App, HttpServer, Responder};
+use actix_web::{web, Responder};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -19,6 +19,8 @@ fn add_one(data: web::Data<AppState>) -> impl Responder {
 }
 
 pub fn main() {
+    use actix_web::{App, HttpServer};
+
     let data = AppState {
         count: Arc::new(AtomicUsize::new(0)),
     };

examples/request-handlers/src/main.rs

@@ -1,6 +1,6 @@
 pub mod handlers_arc;
 // <data>
-use actix_web::{web, App, HttpServer, Responder};
+use actix_web::{web, Responder};
 use std::cell::Cell;
 
 #[derive(Clone)]
@@ -20,6 +20,8 @@ fn add_one(data: web::Data<AppState>) -> impl Responder {
 }
 
 fn main() {
+    use actix_web::{App, HttpServer};
+
     let data = AppState {
         count: Cell::new(0),
     };

examples/responder-trait/src/main.rs

@@ -1,5 +1,5 @@
 // <responder-trait>
-use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer, Responder};
+use actix_web::{Error, HttpRequest, HttpResponse, Responder};
 use serde::Serialize;
 
 #[derive(Serialize)]
@@ -28,6 +28,8 @@ fn index() -> impl Responder {
 // </responder-trait>
 
 fn main() {
+    use actix_web::{web, App, HttpServer};
+
     HttpServer::new(|| App::new().route("/", web::get().to(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/responses/src/chunked.rs

@@ -1,4 +1,4 @@
-// <chunked>
+// // <chunked>
 // use actix_web::{web, HttpRequest, HttpResponse};
 // use bytes::Bytes;
 // use futures::stream::once;
@@ -10,7 +10,7 @@
 //             b"data",
 //         ))))))
 // }
-// </chunked>
+// // </chunked>
 
 // pub fn main() {
 //     use actix_web::{web, App, HttpServer};

examples/responses/src/identity_two.rs

@@ -1,7 +1,6 @@
 // <identity-two>
 use actix_web::{
-    http::ContentEncoding, middleware, middleware::BodyEncoding, HttpRequest,
+    http::ContentEncoding, middleware, middleware::BodyEncoding, HttpResponse,
-    HttpResponse,
 };
 
 static HELLO_WORLD: &[u8] = &[
@@ -10,7 +9,7 @@ static HELLO_WORLD: &[u8] = &[
     0x0c, 0x00, 0x00, 0x00,
 ];
 
-pub fn index(_req: HttpRequest) -> HttpResponse {
+pub fn index() -> HttpResponse {
     HttpResponse::Ok()
         .encoding(ContentEncoding::Identity)
         .header("content-encoding", "gzip")

examples/responses/src/main.rs

@@ -7,11 +7,10 @@ pub mod identity_two;
 pub mod json_resp;
 
 // <builder>
-use actix_web::{http::ContentEncoding, middleware::BodyEncoding, HttpResponse};
+use actix_web::HttpResponse;
 
 fn index() -> HttpResponse {
     HttpResponse::Ok()
-        .encoding(ContentEncoding::Br)
         .content_type("plain/text")
         .header("X-Hdr", "sample")
         .body("data")

examples/static-files/src/main.rs

@@ -4,7 +4,7 @@ pub mod directory;
 
 // <individual-file>
 use actix_files::NamedFile;
-use actix_web::{web, App, HttpRequest, HttpServer, Result};
+use actix_web::{HttpRequest, Result};
 use std::path::PathBuf;
 
 fn index(req: HttpRequest) -> Result<NamedFile> {
@@ -13,6 +13,8 @@ fn index(req: HttpRequest) -> Result<NamedFile> {
 }
 
 fn main() {
+    use actix_web::{web, App, HttpServer};
+
     HttpServer::new(|| App::new().route("/{filename:.*}", web::get().to(index)))
         .bind("127.0.0.1:8088")
         .unwrap()

examples/url-dispatch/src/guard.rs

@@ -1,7 +1,5 @@
 // <guard>
-use actix_web::{
+use actix_web::{dev::RequestHead, guard::Guard, http, HttpResponse};
-    dev::RequestHead, guard::Guard, http, web, App, HttpResponse, HttpServer,
-};
 
 struct ContentTypeHeader;
 
@@ -12,6 +10,8 @@ impl Guard for ContentTypeHeader {
 }
 
 pub fn main() {
+    use actix_web::{web, App, HttpServer};
+
     HttpServer::new(|| {
         App::new().route(
             "/",

examples/url-dispatch/src/minfo.rs

@@ -1,5 +1,5 @@
 // <minfo>
-use actix_web::{web, App, HttpRequest, Result};
+use actix_web::{HttpRequest, HttpResponse, Result};
 
 fn index(req: HttpRequest) -> Result<String> {
     let v1: u8 = req.match_info().get("v1").unwrap().parse().unwrap();
@@ -9,12 +9,12 @@ fn index(req: HttpRequest) -> Result<String> {
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{web, App, HttpServer};
 
     HttpServer::new(|| {
         App::new()
             .route("/a/{v1}/{v2}/", web::get().to(index))
-            .route("", web::get().to(|| actix_web::HttpResponse::Ok()))
+            .route("", web::get().to(|| HttpResponse::Ok()))
     })
     .bind("127.0.0.1:8088")
     .unwrap()

examples/url-dispatch/src/norm.rs

@@ -1,12 +1,12 @@
 // <norm>
-use actix_web::{middleware, web, App, HttpResponse};
+use actix_web::{middleware, HttpResponse};
 
 fn index() -> HttpResponse {
     HttpResponse::Ok().body("Hello")
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{web, App, HttpServer};
 
     HttpServer::new(|| {
         App::new()

examples/url-dispatch/src/norm2.rs

@@ -1,3 +1,9 @@
+use actix_web::HttpResponse;
+
+fn index() -> HttpResponse {
+    HttpResponse::Ok().body("Hello")
+}
+
 // <norm>
 use actix_web::{http::Method, middleware, web, App, HttpServer};
 
@@ -14,9 +20,3 @@ pub fn main() {
     .unwrap();
 }
 // </norm>
-
-use actix_web::HttpResponse;
-
-fn index() -> HttpResponse {
-    HttpResponse::Ok().body("Hello")
-}

examples/url-dispatch/src/path.rs

@@ -1,12 +1,12 @@
 // <path>
-use actix_web::{web, App, Result};
+use actix_web::{web, Result};
 
 fn index(info: web::Path<(String, u32)>) -> Result<String> {
     Ok(format!("Welcome {}! id: {}", info.0, info.1))
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{App, HttpServer};
 
     HttpServer::new(|| {
         App::new().route(

examples/url-dispatch/src/path2.rs

@@ -1,5 +1,5 @@
 // <path>
-use actix_web::{web, App, Result};
+use actix_web::{web, Result};
 use serde::Deserialize;
 
 #[derive(Deserialize)]
@@ -13,7 +13,7 @@ fn index(info: web::Path<Info>) -> Result<String> {
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{App, HttpServer};
 
     HttpServer::new(|| {
         App::new().route(

examples/url-dispatch/src/pbuf.rs

@@ -1,5 +1,5 @@
 // <pbuf>
-use actix_web::{web, App, HttpRequest, Result};
+use actix_web::{HttpRequest, Result};
 use std::path::PathBuf;
 
 fn index(req: HttpRequest) -> Result<String> {
@@ -8,7 +8,7 @@ fn index(req: HttpRequest) -> Result<String> {
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{web, App, HttpServer};
 
     HttpServer::new(|| App::new().route(r"/a/{tail:.*}", web::get().to(index)))
         .bind("127.0.0.1:8088")

examples/url-dispatch/src/scope.rs

@@ -5,8 +5,8 @@ fn show_users() -> HttpResponse {
     HttpResponse::Ok().body("Show users")
 }
 
-fn user_detail(_path: web::Path<(u32,)>) -> HttpResponse {
+fn user_detail(path: web::Path<(u32,)>) -> HttpResponse {
-    HttpResponse::Ok().body("User detail")
+    HttpResponse::Ok().body(format!("User detail: {}", path.0))
 }
 
 pub fn main() {

examples/url-dispatch/src/url_ext.rs

@@ -1,5 +1,5 @@
 // <ext>
-use actix_web::{web, App, HttpRequest, Responder};
+use actix_web::{HttpRequest, Responder};
 
 fn index(req: HttpRequest) -> impl Responder {
     let url = req.url_for("youtube", &["oHg5SJYRHA0"]).unwrap();
@@ -9,7 +9,7 @@ fn index(req: HttpRequest) -> impl Responder {
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{web, App, HttpServer};
 
     HttpServer::new(|| {
         App::new()

examples/url-dispatch/src/urls.rs

@@ -1,5 +1,5 @@
 // <url>
-use actix_web::{guard, http::header, web, App, HttpRequest, HttpResponse, Result};
+use actix_web::{guard, http::header, HttpRequest, HttpResponse, Result};
 
 fn index(req: HttpRequest) -> Result<HttpResponse> {
     let url = req.url_for("foo", &["1", "2", "3"])?; // <- generate url for "foo" resource
@@ -10,7 +10,7 @@ fn index(req: HttpRequest) -> Result<HttpResponse> {
 }
 
 pub fn main() {
-    use actix_web::HttpServer;
+    use actix_web::{web, App, HttpServer};
 
     HttpServer::new(|| {
         App::new()

layouts/index.html

@@ -70,7 +70,6 @@ fn main() {
             to return consistent responses from your APIs.
           </p>
           {{ highlight `#[derive(Serialize)]
-#[derive(Serialize)]
 struct Measurement {
     temperature: f32,
 }