Bring response in line with http-types

examples/chunked.rs

@@ -1,14 +1,12 @@
-use async_std::fs;
-use async_std::io::BufReader;
 use async_std::task;
-use tide::{Response, StatusCode};
+use tide::{Body, Response, StatusCode};
 
 fn main() -> Result<(), std::io::Error> {
  task::block_on(async {
  let mut app = tide::new();
  app.at("/").get(|_| async move {
- let file = fs::File::open(file!()).await.unwrap();
- let res = Response::new(StatusCode::Ok).body(BufReader::new(file));
+ let mut res = Response::new(StatusCode::Ok);
+ res.set_body(Body::from_file(file!()).await.unwrap());
  Ok(res)
  });
  app.listen("127.0.0.1:8080").await?;

examples/cookies.rs

@@ -8,9 +8,9 @@ async fn retrieve_cookie(cx: Request<()>) -> tide::Result<String> {
  Ok(format!("hello cookies: {:?}", cx.cookie("hello").unwrap()))
 }
 
-async fn set_cookie(_req: Request<()>) -> tide::Result {
+async fn insert_cookie(_req: Request<()>) -> tide::Result {
  let mut res = tide::Response::new(StatusCode::Ok);
- res.set_cookie(Cookie::new("hello", "world"));
+ res.insert_cookie(Cookie::new("hello", "world"));
  Ok(res)
 }
 
@@ -25,7 +25,7 @@ fn main() -> Result<(), std::io::Error> {
  let mut app = tide::new();
 
  app.at("/").get(retrieve_cookie);
- app.at("/set").get(set_cookie);
+ app.at("/set").get(insert_cookie);
  app.at("/remove").get(remove_cookie);
  app.listen("127.0.0.1:8080").await?;
 

examples/graphql.rs

@@ -1,7 +1,7 @@
 use async_std::task;
 use juniper::RootNode;
 use std::sync::RwLock;
-use tide::{Redirect, Request, Response, Server, StatusCode};
+use tide::{Body, Redirect, Request, Response, Server, StatusCode};
 
 #[derive(Clone)]
 struct User {
@@ -86,16 +86,15 @@ async fn handle_graphql(mut cx: Request<State>) -> tide::Result {
  StatusCode::BadRequest
  };
 
- let res = Response::new(status)
- .body_json(&response)
- .expect("be able to serialize the graphql response");
+ let mut res = Response::new(status);
+ res.set_body(Body::from_json(&response)?);
  Ok(res)
 }
 
 async fn handle_graphiql(_: Request<State>) -> tide::Result {
- let res = Response::new(StatusCode::Ok)
-  .body_string(juniper::http::graphiql::graphiql_source("/graphql"))
-  .set_content_type(tide::http::mime::HTML);
+ let mut res = Response::new(StatusCode::Ok);
+ res.set_body(juniper::http::graphiql::graphiql_source("/graphql"));
+ res.set_content_type(tide::http::mime::HTML);
  Ok(res)
 }
 

examples/json.rs

@@ -1,7 +1,7 @@
 use async_std::task;
 use serde::{Deserialize, Serialize};
 use tide::prelude::*;
-use tide::{Request, Response, StatusCode};
+use tide::{Body, Request, Response};
 
 #[derive(Deserialize, Serialize)]
 struct Cat {
@@ -20,7 +20,9 @@ fn main() -> tide::Result<()> {
  name: "chashu".into(),
  };
 
- Ok(Response::new(StatusCode::Ok).body_json(&cat)?)
+ let mut res = Response::new(200);
+ res.set_body(Body::from_json(&cat)?);
+ Ok(res)
  });
 
  app.at("/animals").get(|_| async {

examples/middleware.rs

@@ -2,6 +2,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use tide::http::mime;
 use tide::{After, Before, Middleware, Next, Request, Response, Result, StatusCode};
 
 #[derive(Debug)]
@@ -70,10 +71,10 @@ impl<State: Send + Sync + 'static> Middleware<State> for RequestCounterMiddlewar
  tide::log::trace!("request counter", { count: count });
  req.set_ext(RequestCount(count));
 
- let mut response = next.run(req).await?;
+ let mut res = next.run(req).await?;
 
- response = response.set_header("request-number", count.to_string());
- Ok(response)
+ res.insert_header("request-number", count.to_string());
+ Ok(res)
  })
  }
 }
@@ -101,14 +102,18 @@ async fn main() -> Result<()> {
  app.middleware(After(|result: Result| async move {
  let response = result.unwrap_or_else(|e| Response::new(e.status()));
  match response.status() {
- StatusCode::NotFound => Ok(response
- .set_content_type(tide::http::mime::HTML)
- .body_string(NOT_FOUND_HTML_PAGE.into())),
-
- StatusCode::InternalServerError => Ok(response
- .set_content_type(tide::http::mime::HTML)
- .body_string(INTERNAL_SERVER_ERROR_HTML_PAGE.into())),
-
+ StatusCode::NotFound => {
+ let mut res = Response::new(404);
+ res.set_content_type(mime::HTML);
+ res.set_body(NOT_FOUND_HTML_PAGE);
+ Ok(res)
+ }
+ StatusCode::InternalServerError => {
+ let mut res = Response::new(500);
+ res.set_content_type(mime::HTML);
+ res.set_body(INTERNAL_SERVER_ERROR_HTML_PAGE);
+ Ok(res)
+ }
  _ => Ok(response),
  }
  }));

src/cookies/middleware.rs

@@ -18,7 +18,7 @@ use std::sync::{Arc, RwLock};
 /// app.at("/get").get(|cx: Request<()>| async move { Ok(cx.cookie("testCookie").unwrap().value().to_string()) });
 /// app.at("/set").get(|_| async {
 /// let mut res = Response::new(StatusCode::Ok);
-/// res.set_cookie(Cookie::new("testCookie", "NewCookieValue"));
+/// res.insert_cookie(Cookie::new("testCookie", "NewCookieValue"));
 /// Ok(res)
 /// });
 /// ```
@@ -69,7 +69,7 @@ impl<State: Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
  // iterate over added and removed cookies
  for cookie in jar.delta() {
  let encoded_cookie = cookie.encoded().to_string();
- res = res.append_header(headers::SET_COOKIE, encoded_cookie);
+ res.append_header(headers::SET_COOKIE, encoded_cookie);
  }
  Ok(res)
  })

src/lib.rs

@@ -51,7 +51,7 @@
 //! ```no_run
 //! # use async_std::task::block_on;
 //! # fn main() -> Result<(), std::io::Error> { block_on(async {
-//! # use tide::{Request, Response};
+//! # use tide::{Body, Request, Response};
 //! #
 //! #[derive(Debug, serde::Deserialize, serde::Serialize)]
 //! struct Counter { count: usize }
@@ -61,7 +61,9 @@
 //! let mut counter: Counter = req.body_json().await?;
 //! println!("count is {}", counter.count);
 //! counter.count += 1;
-//! Ok(Response::new(tide::http::StatusCode::Ok).body_json(&counter)?)
+//! let mut res = Response::new(200);
+//! res.set_body(Body::from_json(&counter)?);
+//! Ok(res)
 //! });
 //! app.listen("127.0.0.1:8080").await?;
 //! #

src/redirect.rs

@@ -104,6 +104,8 @@ impl<T: AsRef<str>> Into<Response> for Redirect<T> {
 
 impl<T: AsRef<str>> Into<Response> for &Redirect<T> {
  fn into(self) -> Response {
- Response::new(self.status).set_header(LOCATION, self.location.as_ref())
+ let mut res = Response::new(self.status);
+ res.insert_header(LOCATION, self.location.as_ref());
+ res
  }
 }

src/request.rs

@@ -1,4 +1,4 @@
-use async_std::io::{self, prelude::*, BufReader};
+use async_std::io::{self, prelude::*};
 use async_std::task::{Context, Poll};
 use route_recognizer::Params;
 
@@ -448,8 +448,10 @@ impl<State> Into<http::Request> 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))
+ fn into(mut self) -> Response {
+ let mut res = Response::new(StatusCode::Ok);
+ res.set_body(self.take_body());
+ res
  }
 }