Merge pull request #40 from tirr-c/fix-travis

Fix broken CI

Author: aturon

.travis.yml

@@ -3,11 +3,10 @@ rust:
   - nightly
 
 before_script: |
-  rustup component add rustfmt-preview &&
-  cargo install clippy -f
+  rustup component add rustfmt-preview clippy-preview
 script: |
   cargo fmt -- --check &&
-  cargo clippy -- -D clippy &&
+  cargo clippy -- -D clippy::all &&
   cargo build --verbose &&
   cargo test  --verbose
 cache: cargo

examples/graphql.rs

@@ -53,11 +53,14 @@ async fn handle_graphql(
     let response = request.execute(&Schema::new(Query, Mutation), &ctx);
 
     // `response` has the lifetime of `request`, so we can't use `IntoResponse` directly.
-    let body_vec = serde_json::to_vec(&response)
-        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let body_vec = serde_json::to_vec(&response).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     http::Response::builder()
-        .status(if response.is_ok() { StatusCode::OK } else { StatusCode::BAD_REQUEST })
+        .status(if response.is_ok() {
+            StatusCode::OK
+        } else {
+            StatusCode::BAD_REQUEST
+        })
         .header("Content-Type", "application/json")
         .body(body::Body::from(body_vec))
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)

examples/named_path.rs

@@ -1,6 +1,6 @@
 #![feature(async_await, futures_api)]
 
-use tide::head::{NamedComponent, Named};
+use tide::head::{Named, NamedComponent};
 
 struct Number(i32);
 

rustfmt.toml

@@ -0,0 +1 @@
+edition = "2018"

src/app.rs

@@ -4,16 +4,16 @@ use futures::{
     prelude::*,
 };
 use hyper::service::Service;
-use std::{sync::Arc, ops::{Deref, DerefMut}};
+use std::{
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
 
 use crate::{
-    router::{Resource, Router},
-    Request,
-    extract::Extract,
-    RouteMatch,
-    Response,
     body::Body,
-    Middleware,
+    extract::Extract,
+    router::{Resource, Router},
+    Middleware, Request, Response, RouteMatch,
 };
 
 /// The top-level type for setting up a Tide application.
@@ -65,13 +65,17 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
         // TODO: be more robust
         let addr = addr.to_socket_addrs().unwrap().next().unwrap();
 
-        let server = hyper::Server::bind(&addr).serve(move || {
-            let res: Result<_, std::io::Error> = Ok(server.clone());
-            res
-        }).compat().map(|_| {
-            let res: Result<(), ()> = Ok(());
-            res
-        }).compat();
+        let server = hyper::Server::bind(&addr)
+            .serve(move || {
+                let res: Result<_, std::io::Error> = Ok(server.clone());
+                res
+            })
+            .compat()
+            .map(|_| {
+                let res: Result<(), ()> = Ok(());
+                res
+            })
+            .compat();
         hyper::rt::run(server);
     }
 }
@@ -98,26 +102,32 @@ impl<Data: Clone + Send + Sync + 'static> Service for Server<Data> {
         let path = req.uri().path().to_owned();
         let method = req.method().to_owned();
 
-        FutureObj::new(Box::new(async move {
-            if let Some((endpoint, params)) = router.route(&path, &method) {
-                for m in middleware.iter() {
-                    match await!(m.request(&mut data, req, &params)) {
-                        Ok(new_req) => req = new_req,
-                        Err(resp) => return Ok(resp.map(Into::into)),
+        FutureObj::new(Box::new(
+            async move {
+                if let Some((endpoint, params)) = router.route(&path, &method) {
+                    for m in middleware.iter() {
+                        match await!(m.request(&mut data, req, &params)) {
+                            Ok(new_req) => req = new_req,
+                            Err(resp) => return Ok(resp.map(Into::into)),
+                        }
                     }
-                }
 
-                let (head, mut resp) = await!(endpoint.call(data.clone(), req, params));
+                    let (head, mut resp) = await!(endpoint.call(data.clone(), req, params));
 
-                for m in middleware.iter() {
-                    resp = await!(m.response(&mut data, &head, resp))
-                }
+                    for m in middleware.iter() {
+                        resp = await!(m.response(&mut data, &head, resp))
+                    }
 
-                Ok(resp.map(Into::into))
-            } else {
-                Ok(http::Response::builder().status(http::status::StatusCode::NOT_FOUND).body(hyper::Body::empty()).unwrap())
-            }
-        })).compat()
+                    Ok(resp.map(Into::into))
+                } else {
+                    Ok(http::Response::builder()
+                        .status(http::status::StatusCode::NOT_FOUND)
+                        .body(hyper::Body::empty())
+                        .unwrap())
+                }
+            },
+        ))
+        .compat()
     }
 }
 
@@ -140,11 +150,7 @@ impl<T> DerefMut for AppData<T> {
 
 impl<T: Clone + Send + 'static> Extract<T> for AppData<T> {
     type Fut = future::Ready<Result<Self, Response>>;
-    fn extract(
-        data: &mut T,
-        req: &mut Request,
-        params: &RouteMatch<'_>,
-    ) -> Self::Fut {
+    fn extract(data: &mut T, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
         future::ok(AppData(data.clone()))
     }
 }

src/body.rs

@@ -3,11 +3,11 @@
 //! This module includes types like `Json`, which can be used to automatically (de)serialize bodies
 //! using `serde_json`.
 
-use futures::{compat::Compat01As03, prelude::*, future::FutureObj, stream::StreamObj};
-use pin_utils::pin_mut;
+use futures::{compat::Compat01As03, future::FutureObj, prelude::*, stream::StreamObj};
 use http::status::StatusCode;
+use pin_utils::pin_mut;
 
-use crate::{Extract, IntoResponse, RouteMatch, Request, Response};
+use crate::{Extract, IntoResponse, Request, Response, RouteMatch};
 
 /// The raw contents of an http request or response.
 ///
@@ -57,7 +57,7 @@ impl Body {
     ///
     /// This method is asynchronous because, in general, it requires reading an async
     /// stream of `BodyChunk` values.
-    pub async fn to_vec(&mut self) -> Result<Vec<u8>, Error> {
+    pub async fn read_to_vec(&mut self) -> Result<Vec<u8>, Error> {
         match &mut self.inner {
             BodyInner::Streaming(s) => {
                 let mut bytes = Vec::new();
@@ -122,18 +122,18 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
     // Note: cannot use `existential type` here due to ICE
     type Fut = FutureObj<'static, Result<Self, Response>>;
 
-    fn extract(
-        data: &mut S,
-        req: &mut Request,
-        params: &RouteMatch<'_>,
-    ) -> Self::Fut {
+    fn extract(data: &mut S, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
         let mut body = std::mem::replace(req.body_mut(), Body::empty());
-        FutureObj::new(Box::new(async move {
-            fn mk_err<T>(_: T) -> Response { StatusCode::BAD_REQUEST.into_response() }
-            let body = await!(body.to_vec()).map_err(mk_err)?;
-            let json: T = serde_json::from_slice(&body).map_err(mk_err)?;
-            Ok(Json(json))
-        }))
+        FutureObj::new(Box::new(
+            async move {
+                fn mk_err<T>(_: T) -> Response {
+                    StatusCode::BAD_REQUEST.into_response()
+                }
+                let body = await!(body.read_to_vec()).map_err(mk_err)?;
+                let json: T = serde_json::from_slice(&body).map_err(mk_err)?;
+                Ok(Json(json))
+            },
+        ))
     }
 }
 

src/endpoint.rs

@@ -14,10 +14,11 @@ pub trait Endpoint<Data, Kind>: Send + Sync + 'static {
     fn call(&self, data: Data, req: Request, params: RouteMatch<'_>) -> Self::Fut;
 }
 
+type BoxedEndpointFn<Data> =
+    dyn Fn(Data, Request, RouteMatch) -> FutureObj<'static, (Head, Response)> + Send + Sync;
+
 pub(crate) struct BoxedEndpoint<Data> {
-    endpoint: Box<
-        dyn Fn(Data, Request, RouteMatch) -> FutureObj<'static, (Head, Response)> + Send + Sync,
-    >,
+    endpoint: Box<BoxedEndpointFn<Data>>,
 }
 
 impl<Data> BoxedEndpoint<Data> {

src/head.rs

@@ -75,8 +75,8 @@ pub trait NamedComponent: Send + 'static + std::str::FromStr {
 
 /// An extractor for named path components
 ///
-/// Allows routes to access named path components (`{foo}`). Each `Named<T>` extracts a single 
-/// component. `T` must implement the `NamedComponent` trait - to provide the component name - and the 
+/// Allows routes to access named path components (`{foo}`). Each `Named<T>` extracts a single
+/// component. `T` must implement the `NamedComponent` trait - to provide the component name - and the
 /// FromStr trait. Fails with a `BAD_REQUEST` response if the component is not found, fails to
 /// parse or if multiple identically named components exist.
 pub struct Named<T: NamedComponent>(pub T);
@@ -85,10 +85,13 @@ impl<T: NamedComponent, S: 'static> Extract<S> for Named<T> {
     type Fut = future::Ready<Result<Self, Response>>;
 
     fn extract(data: &mut S, req: &mut Request, params: &RouteMatch<'_>) -> Self::Fut {
-        params.map.get(T::NAME)
+        params
+            .map
+            .get(T::NAME)
             .and_then(|component| component.parse().ok())
-            .map_or(future::err(http::status::StatusCode::BAD_REQUEST.into_response()),
-                    |t| future::ok(Named(t)))
+            .map_or(
+                future::err(http::status::StatusCode::BAD_REQUEST.into_response()),
+                |t| future::ok(Named(t)),
+            )
     }
 }
-

src/router.rs

@@ -50,13 +50,11 @@ impl<Data> Default for Resource<Data> {
 impl<Data> Resource<Data> {
     /// Add an endpoint for the given HTTP method
     pub fn method<T: Endpoint<Data, U>, U>(&mut self, method: http::Method, ep: T) {
-        let old_ep = self
-            .endpoints
-            .insert(method.clone(), BoxedEndpoint::new(ep));
-
-        if old_ep.is_some() {
+        if self.endpoints.contains_key(&method) {
             panic!("A {} endpoint already exists for this path", method)
         }
+
+        self.endpoints.insert(method, BoxedEndpoint::new(ep));
     }
 
     /// Add an endpoint for `GET` requests

src/url_table.rs

@@ -102,7 +102,7 @@ impl<R: Default> UrlTable<R> {
                 }
 
                 match table.wildcard_mut().unwrap() {
-                    Wildcard { name: n, .. } if &name != n => {
+                    Wildcard { name: n, .. } if name != n => {
                         panic!("Route {} segment `{{{}}}` conflicts with existing wildcard segment `{{{}}}`", path, name, n);
                     }
                     Wildcard { table: t, .. } => {
@@ -113,7 +113,7 @@ impl<R: Default> UrlTable<R> {
                 table = table
                     .next
                     .entry(segment.to_string())
-                    .or_insert(UrlTable::new());
+                    .or_insert_with(UrlTable::new);
             }
         }