Merge pull request #463 from http-rs/remove-extra-trait

Remove IntoResponse trait

Author: yoshuawuyts

examples/nested.rs

@@ -5,7 +5,8 @@ async fn main() -> Result<(), std::io::Error> {
     app.at("/api").nest({
         let mut api = tide::new();
         api.at("/hello").get(|_| async move { Ok("Hello, world") });
-        api.at("/goodbye").get(|_| async move { Ok("Goodbye, world") });
+        api.at("/goodbye")
+            .get(|_| async move { Ok("Goodbye, world") });
         api
     });
     app.listen("127.0.0.1:8080").await?;

src/endpoint.rs

@@ -1,19 +1,18 @@
-use crate::response::IntoResponse;
 use async_std::future::Future;
 use async_std::sync::Arc;
 use http_types::Result;
 
 use crate::middleware::Next;
 use crate::utils::BoxFuture;
-use crate::{Middleware, Request};
+use crate::{Middleware, Request, Response};
 
 /// An HTTP request handler.
 ///
 /// This trait is automatically implemented for `Fn` types, and so is rarely implemented
 /// directly by Tide users.
 ///
 /// In practice, endpoints are functions that take a `Request<State>` as an argument and
-/// return a type `T` that implements [`IntoResponse`].
+/// return a type `T` that implements `Into<Response>`.
 ///
 /// # Examples
 ///
@@ -60,13 +59,13 @@ impl<State, F: Send + Sync + 'static, Fut, Res> Endpoint<State> for F
 where
     F: Fn(Request<State>) -> Fut,
     Fut: Future<Output = Result<Res>> + Send + 'static,
-    Res: IntoResponse,
+    Res: Into<Response>,
 {
     fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, crate::Result> {
         let fut = (self)(req);
         Box::pin(async move {
             let res = fut.await?;
-            Ok(res.into_response())
+            Ok(res.into())
         })
     }
 }

src/lib.rs

@@ -209,7 +209,7 @@ pub use http_types::{Body, Error, Status, StatusCode};
 #[doc(inline)]
 pub use middleware::{Middleware, Next};
 #[doc(inline)]
-pub use response::{IntoResponse, Response};
+pub use response::Response;
 #[doc(inline)]
 pub use server::{Route, Server};
 

src/middleware.rs

@@ -15,7 +15,7 @@ use crate::Request;
 // pub use compression::{Compression, Decompression};
 // pub use default_headers::DefaultHeaders;
 
-/// Middleware that wraps around remaining middleware chain.
+/// Middleware that wraps around the remaining middleware chain.
 pub trait Middleware<State>: 'static + Send + Sync {
     /// Asynchronously handle the request, and return a response.
     fn handle<'a>(

src/request.rs

@@ -6,13 +6,14 @@ use http_types::{
 use route_recognizer::Params;
 use serde::Deserialize;
 
-use async_std::io::{self, prelude::*};
+use async_std::io::{self, prelude::*, BufReader};
 use async_std::task::{Context, Poll};
 
 use std::pin::Pin;
 use std::{str::FromStr, sync::Arc};
 
 use crate::cookies::CookieData;
+use crate::Response;
 
 /// An HTTP request.
 ///
@@ -319,6 +320,14 @@ impl<State> Read for Request<State> {
     }
 }
 
+// NOTE: From cannot be implemented for this conversion because `State` needs to
+// be constrained by a type.
+impl<State: Send + Sync + 'static> Into<Response> for Request<State> {
+    fn into(self) -> Response {
+        Response::new(StatusCode::Ok).body(BufReader::new(self))
+    }
+}
+
 impl<State> IntoIterator for Request<State> {
     type Item = (HeaderName, Vec<HeaderValue>);
     type IntoIter = http_types::headers::IntoIter;

src/response/mod.rs renamed to src/response.rs

@@ -10,10 +10,6 @@ use http_types::{
 use mime::Mime;
 use serde::Serialize;
 
-pub use into_response::IntoResponse;
-
-mod into_response;
-
 #[derive(Debug)]
 pub(crate) enum CookieEvent {
     Added(Cookie<'static>),
@@ -245,14 +241,12 @@ impl Response {
     }
 }
 
-#[doc(hidden)]
 impl Into<http_service::Response> for Response {
     fn into(self) -> http_service::Response {
         self.res
     }
 }
 
-#[doc(hidden)]
 impl From<http_service::Response> for Response {
     fn from(res: http_service::Response) -> Self {
         Self {
@@ -262,6 +256,30 @@ impl From<http_service::Response> for Response {
     }
 }
 
+impl From<String> for Response {
+    fn from(s: String) -> Self {
+        let mut res = http_types::Response::new(StatusCode::Ok);
+        res.set_content_type(http_types::mime::PLAIN);
+        res.set_body(s);
+        Self {
+            res,
+            cookie_events: vec![],
+        }
+    }
+}
+
+impl<'a> From<&'a str> for Response {
+    fn from(s: &'a str) -> Self {
+        let mut res = http_types::Response::new(StatusCode::Ok);
+        res.set_content_type(http_types::mime::PLAIN);
+        res.set_body(String::from(s));
+        Self {
+            res,
+            cookie_events: vec![],
+        }
+    }
+}
+
 impl IntoIterator for Response {
     type Item = (HeaderName, Vec<HeaderValue>);
     type IntoIter = http_types::headers::IntoIter;

src/response/into_response.rs

@@ -2,7 +2,7 @@ use async_std::prelude::*;
 use futures::executor::block_on;
 use http_service_mock::{make_server, TestBackend};
 use serde::Deserialize;
-use tide::{IntoResponse, Request, Response, Server, StatusCode};
+use tide::{Request, Response, Server, StatusCode};
 
 #[derive(Deserialize)]
 struct Params {
@@ -18,7 +18,7 @@ struct OptionalParams {
 async fn handler(cx: Request<()>) -> tide::Result {
     let p = cx.query::<Params>();
     match p {
-        Ok(params) => Ok(params.msg.into_response()),
+        Ok(params) => Ok(params.msg.into()),
         Err(error) => Ok(err_to_res(error)),
     }
 }