rustfmt 0.7

src/middleware/cors.rs

@@ -275,9 +275,7 @@ impl Cors {
     /// `ResourceHandler::middleware()` method, but in that case *Cors*
     /// middleware wont be able to handle *OPTIONS* requests.
     pub fn register<S: 'static>(self, resource: &mut ResourceHandler<S>) {
-        resource
-            .method(Method::OPTIONS)
-            .h(|_| HttpResponse::Ok());
+        resource.method(Method::OPTIONS).h(|_| HttpResponse::Ok());
         resource.middleware(self);
     }
 
@@ -304,12 +302,11 @@ impl Cors {
     fn validate_allowed_method<S>(
         &self, req: &mut HttpRequest<S>,
     ) -> Result<(), CorsError> {
-        if let Some(hdr) = req.headers()
-            .get(header::ACCESS_CONTROL_REQUEST_METHOD)
-        {
+        if let Some(hdr) = req.headers().get(header::ACCESS_CONTROL_REQUEST_METHOD) {
             if let Ok(meth) = hdr.to_str() {
                 if let Ok(method) = Method::try_from(meth) {
-                    return self.inner
+                    return self
+                        .inner
                         .methods
                         .get(&method)
                         .and_then(|_| Some(()))
@@ -328,8 +325,8 @@ impl Cors {
         match self.inner.headers {
             AllOrSome::All => Ok(()),
             AllOrSome::Some(ref allowed_headers) => {
-                if let Some(hdr) = req.headers()
-                    .get(header::ACCESS_CONTROL_REQUEST_HEADERS)
+                if let Some(hdr) =
+                    req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS)
                 {
                     if let Ok(headers) = hdr.to_str() {
                         let mut hdrs = HashSet::new();
@@ -371,8 +368,8 @@ impl<S> Middleware<S> for Cors {
                             .as_str()[1..],
                     ).unwrap(),
                 )
-            } else if let Some(hdr) = req.headers()
-                .get(header::ACCESS_CONTROL_REQUEST_HEADERS)
+            } else if let Some(hdr) =
+                req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS)
             {
                 Some(hdr.clone())
             } else {
@@ -413,7 +410,8 @@ impl<S> Middleware<S> for Cors {
                     })
                     .header(
                         header::ACCESS_CONTROL_ALLOW_METHODS,
-                        &self.inner
+                        &self
+                            .inner
                             .methods
                             .iter()
                             .fold(String::new(), |s, v| s + "," + v.as_str())
@@ -866,7 +864,8 @@ impl<S: 'static> CorsBuilder<S> {
         }
 
         let cors = self.construct();
-        let mut app = self.app
+        let mut app = self
+            .app
             .take()
             .expect("CorsBuilder has to be constructed with Cors::for_app(app)");
 
@@ -1094,9 +1093,8 @@ mod tests {
             resp.headers().get(header::VARY).unwrap().as_bytes()
         );
 
-        let resp: HttpResponse = HttpResponse::Ok()
-            .header(header::VARY, "Accept")
-            .finish();
+        let resp: HttpResponse =
+            HttpResponse::Ok().header(header::VARY, "Accept").finish();
         let resp = cors.response(&mut req, resp).unwrap().response();
         assert_eq!(
             &b"Accept, Origin"[..],
@@ -1133,7 +1131,8 @@ mod tests {
         let response = srv.execute(request.send()).unwrap();
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
-        let request = srv.get()
+        let request = srv
+            .get()
             .uri(srv.url("/test"))
             .header("ORIGIN", "https://www.example.com")
             .finish()

src/middleware/defaultheaders.rs

@@ -112,9 +112,7 @@ mod tests {
         };
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
 
-        let resp = HttpResponse::Ok()
-            .header(CONTENT_TYPE, "0002")
-            .finish();
+        let resp = HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish();
         let resp = match mw.response(&mut req, resp) {
             Ok(Response::Done(resp)) => resp,
             _ => panic!(),

src/middleware/identity.rs

@@ -179,7 +179,8 @@ impl<S: 'static, T: IdentityPolicy<S>> Middleware<S> for IdentityService<T> {
     fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
         let mut req = req.clone();
 
-        let fut = self.backend
+        let fut = self
+            .backend
             .from_request(&mut req)
             .then(move |res| match res {
                 Ok(id) => {

src/middleware/logger.rs

@@ -376,9 +376,7 @@ mod tests {
             headers,
             None,
         );
-        let resp = HttpResponse::build(StatusCode::OK)
-            .force_close()
-            .finish();
+        let resp = HttpResponse::build(StatusCode::OK).force_close().finish();
         let entry_time = time::now();
 
         let render = |fmt: &mut Formatter| {
@@ -399,9 +397,7 @@ mod tests {
             HeaderMap::new(),
             None,
         );
-        let resp = HttpResponse::build(StatusCode::OK)
-            .force_close()
-            .finish();
+        let resp = HttpResponse::build(StatusCode::OK).force_close().finish();
         let entry_time = time::now();
 
         let render = |fmt: &mut Formatter| {

src/middleware/session.rs

@@ -267,9 +267,7 @@ impl<S: 'static, T: SessionBackend<S>> Middleware<S> for SessionStorage<T, S> {
     }
 
     fn response(
-        &self,
-        req: &mut HttpRequest<S>,
-        resp: HttpResponse,
+        &self, req: &mut HttpRequest<S>, resp: HttpResponse,
     ) -> Result<Response> {
         if let Some(s_box) = req.extensions_mut().remove::<Arc<SessionImplCell>>() {
             s_box.0.borrow_mut().write(resp)
@@ -385,9 +383,7 @@ impl CookieSessionInner {
     }
 
     fn set_cookie(
-        &self,
-        resp: &mut HttpResponse,
-        state: &HashMap<String, String>,
+        &self, resp: &mut HttpResponse, state: &HashMap<String, String>,
     ) -> Result<()> {
         let value =
             serde_json::to_string(&state).map_err(CookieSessionError::Serialize)?;