Remove IntoResponse trait

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 → 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;

tests/querystring.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)),
  }
 }