Migrate all files to use tide::Result

Author: yoshuawuyts

examples/cookies.rs

@@ -5,20 +5,20 @@ use tide::{Request, Response};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
 ///
-async fn retrieve_cookie(cx: Request<()>) -> String {
-    format!("hello cookies: {:?}", cx.cookie("hello").unwrap())
+async fn retrieve_cookie(cx: Request<()>) -> tide::Result<String> {
+    Ok(format!("hello cookies: {:?}", cx.cookie("hello").unwrap()))
 }
 
-async fn set_cookie(_req: Request<()>) -> Response {
+async fn set_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = tide::Response::new(StatusCode::Ok);
     res.set_cookie(Cookie::new("hello", "world"));
-    res
+    Ok(res)
 }
 
-async fn remove_cookie(_req: Request<()>) -> Response {
+async fn remove_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = tide::Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named("hello"));
-    res
+    Ok(res)
 }
 
 fn main() -> Result<(), std::io::Error> {

examples/fib.rs

@@ -9,7 +9,7 @@ fn fib(n: usize) -> usize {
     }
 }
 
-async fn fibsum(req: Request<()>) -> String {
+async fn fibsum(req: Request<()>) -> tide::Result<String> {
     use std::time::Instant;
     let n: usize = req.param("n").unwrap_or(0);
     // Start a stopwatch
@@ -19,10 +19,11 @@ async fn fibsum(req: Request<()>) -> String {
     // Stop the stopwatch
     let duration = Instant::now().duration_since(start).as_secs();
     // Return the answer
-    format!(
+    let res = format!(
         "The fib of {} is {}.\nIt was computed in {} secs.\n",
         n, fib_n, duration,
-    )
+    );
+    Ok(res)
 }
 // Example: HTTP GET to http://localhost:8080/fib/42
 // $ curl "http://localhost:8080/fib/42"

examples/graphql.rs

@@ -73,7 +73,7 @@ fn create_schema() -> Schema {
     Schema::new(QueryRoot {}, MutationRoot {})
 }
 
-async fn handle_graphql(mut cx: Request<State>) -> Response {
+async fn handle_graphql(mut cx: Request<State>) -> tide::Result<Response> {
     let query: juniper::http::GraphQLRequest = cx
         .body_json()
         .await
@@ -87,15 +87,17 @@ async fn handle_graphql(mut cx: Request<State>) -> Response {
         StatusCode::BadRequest
     };
 
-    Response::new(status)
+    let res = Response::new(status)
         .body_json(&response)
-        .expect("be able to serialize the graphql response")
+        .expect("be able to serialize the graphql response");
+    Ok(res)
 }
 
-async fn handle_graphiql(_: Request<State>) -> Response {
-    Response::new(StatusCode::Ok)
+async fn handle_graphiql(_: Request<State>) -> tide::Result<Response> {
+    let res = Response::new(StatusCode::Ok)
         .body_string(juniper::http::graphiql::graphiql_source("/graphql"))
-        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8")
+        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8");
+    Ok(res)
 }
 
 fn main() -> std::io::Result<()> {

examples/hello.rs

@@ -3,7 +3,7 @@ use async_std::task;
 fn main() -> Result<(), std::io::Error> {
     task::block_on(async {
         let mut app = tide::new();
-        app.at("/").get(|_| async move { "Hello, world!" });
+        app.at("/").get(|_| async move { Ok("Hello, world!") });
         app.listen("127.0.0.1:8080").await?;
         Ok(())
     })

examples/json.rs

@@ -14,14 +14,14 @@ fn main() -> io::Result<()> {
 
         app.at("/submit")
             .post(|mut req: tide::Request<()>| async move {
-                let cat: Cat = req.body_json().await.unwrap();
+                let cat: Cat = req.body_json().await?;
                 println!("cat name: {}", cat.name);
 
                 let cat = Cat {
                     name: "chashu".into(),
                 };
 
-                tide::Response::new(StatusCode::Ok).body_json(&cat).unwrap()
+                Ok(tide::Response::new(StatusCode::Ok).body_json(&cat)?)
             });
 
         app.listen("127.0.0.1:8080").await?;

src/endpoint.rs

@@ -56,10 +56,11 @@ pub trait Endpoint<State>: Send + Sync + 'static {
 
 pub(crate) type DynEndpoint<State> = dyn Endpoint<State>;
 
-impl<State, F: Send + Sync + 'static, Fut> Endpoint<State> for F
+impl<State, F: Send + Sync + 'static, Fut, Res> Endpoint<State> for F
 where
     F: Fn(Request<State>) -> Fut,
-    Fut: Future<Output = Result<Response>> + Send + 'static,
+    Fut: Future<Output = Result<Res>> + Send + 'static,
+    Res: IntoResponse,
 {
     fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Result<Response>> {
         let fut = (self)(req);

tests/chunked-encode-large.rs

@@ -71,9 +71,10 @@ async fn chunked_large() -> Result<(), http_types::Error> {
         let mut app = tide::new();
         app.at("/").get(|mut _req: tide::Request<()>| async move {
             let body = Cursor::new(TEXT.to_owned());
-            Response::new(StatusCode::Ok)
+            let res = Response::new(StatusCode::Ok)
                 .body(body)
-                .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8")
+                .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8");
+            Ok(res)
         });
         app.listen("localhost:8080").await?;
         Result::<(), http_types::Error>::Ok(())

tests/chunked-encode-small.rs

@@ -20,9 +20,10 @@ async fn chunked_large() -> Result<(), http_types::Error> {
         let mut app = tide::new();
         app.at("/").get(|mut _req: tide::Request<()>| async move {
             let body = Cursor::new(TEXT.to_owned());
-            Response::new(StatusCode::Ok)
+            let res = Response::new(StatusCode::Ok)
                 .body(body)
-                .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8")
+                .set_header(headers::CONTENT_TYPE, "text/plain; charset=utf-8");
+            Ok(res)
         });
         app.listen("localhost:8080").await?;
         Result::<(), http_types::Error>::Ok(())

tests/cookies.rs

@@ -8,27 +8,27 @@ use tide::{Request, Response, Server};
 
 static COOKIE_NAME: &str = "testCookie";
 
-async fn retrieve_cookie(cx: Request<()>) -> String {
-    cx.cookie(COOKIE_NAME).unwrap().value().to_string()
+async fn retrieve_cookie(cx: Request<()>) -> tide::Result<String> {
+    Ok(cx.cookie(COOKIE_NAME).unwrap().value().to_string())
 }
 
-async fn set_cookie(_req: Request<()>) -> Response {
+async fn set_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = Response::new(StatusCode::Ok);
     res.set_cookie(Cookie::new(COOKIE_NAME, "NewCookieValue"));
-    res
+    Ok(res)
 }
 
-async fn remove_cookie(_req: Request<()>) -> Response {
+async fn remove_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named(COOKIE_NAME));
-    res
+    Ok(res)
 }
 
-async fn set_multiple_cookie(_req: Request<()>) -> Response {
+async fn set_multiple_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = Response::new(StatusCode::Ok);
     res.set_cookie(Cookie::new("C1", "V1"));
     res.set_cookie(Cookie::new("C2", "V2"));
-    res
+    Ok(res)
 }
 
 fn app() -> crate::Server<()> {

tests/querystring.rs

@@ -16,19 +16,19 @@ struct OptionalParams {
     _time: Option<u64>,
 }
 
-async fn handler(cx: Request<()>) -> Response {
+async fn handler(cx: Request<()>) -> tide::Result<Response> {
     let p = cx.query::<Params>();
     match p {
-        Ok(params) => params.msg.into_response(),
-        Err(error) => Response::new(error.status()),
+        Ok(params) => Ok(params.msg.into_response()),
+        Err(error) => Ok(Response::new(error.status())),
     }
 }
 
-async fn optional_handler(cx: Request<()>) -> Response {
+async fn optional_handler(cx: Request<()>) -> tide::Result<Response> {
     let p = cx.query::<OptionalParams>();
     match p {
-        Ok(_) => Response::new(StatusCode::Ok),
-        Err(error) => Response::new(error.status()),
+        Ok(_) => Ok(Response::new(StatusCode::Ok)),
+        Err(error) => Ok(Response::new(error.status())),
     }
 }