Finish ok-wrapping examples

Author: yoshuawuyts

src/endpoint.rs

@@ -24,8 +24,8 @@ use crate::{Middleware, Request, Response};
 /// A simple endpoint that is invoked on a `GET` request and returns a `String`:
 ///
 /// ```no_run
-/// async fn hello(_req: tide::Request<()>) -> String {
-///     String::from("hello")
+/// async fn hello(_req: tide::Request<()>) -> tide::Result<String> {
+///     Ok(String::from("hello"))
 /// }
 ///
 /// fn main() {
@@ -38,8 +38,8 @@ use crate::{Middleware, Request, Response};
 ///
 /// ```no_run
 /// # use core::future::Future;
-/// fn hello(_req: tide::Request<()>) -> impl Future<Output = String> {
-///     futures::future::ready(String::from("hello"))
+/// fn hello(_req: tide::Request<()>) -> impl Future<Output = tide::Result<String>> {
+///     futures::future::ready(Ok(String::from("hello")))
 /// }
 ///
 /// fn main() {

src/lib.rs

@@ -20,7 +20,7 @@
 //! # fn main() -> Result<(), std::io::Error> { 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(()) }) }
@@ -32,7 +32,7 @@
 //! # fn main() -> Result<(), std::io::Error> { block_on(async {
 //! #
 //! let mut app = tide::new();
-//! app.at("/").get(|req| async move { req });
+//! app.at("/").get(|req| async move { Ok(req) });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
 //! # Ok(()) }) }
@@ -48,10 +48,10 @@
 //!
 //! let mut app = tide::new();
 //! app.at("/").get(|mut req: tide::Request<()>| async move {
-//!    let mut counter: Counter = req.body_json().await.unwrap();
+//!    let mut counter: Counter = req.body_json().await?;
 //!    println!("count is {}", counter.count);
 //!    counter.count += 1;
-//!    tide::Response::new(http_types::StatusCode::Ok).body_json(&counter).unwrap()
+//!    Ok(tide::Response::new(tide::http::StatusCode::Ok).body_json(&counter)?)
 //! });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
@@ -150,7 +150,7 @@
 //! #[async_std::main]
 //! async fn main() -> Result<(), std::io::Error> {
 //!     let mut app = tide::new();
-//!     app.at("/").get(|req: Request<()>| async move { req.bark() });
+//!     app.at("/").get(|req: Request<()>| async move { Ok(req.bark()) });
 //!     app.listen("127.0.0.1:8080").await
 //! }
 //! ```
@@ -210,7 +210,7 @@ pub use http_types as http;
 /// # fn main() -> Result<(), std::io::Error> { 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(()) }) }
@@ -244,7 +244,7 @@ pub fn new() -> server::Server<()> {
 /// // Initialize the application with state.
 /// let mut app = tide::with_state(state);
 /// app.at("/").get(|req: Request<State>| async move {
-///     format!("Hello, {}!", &req.state().name)
+///     Ok(format!("Hello, {}!", &req.state().name))
 /// });
 /// app.listen("127.0.0.1:8080").await?;
 /// #

src/middleware/cookies.rs

@@ -14,11 +14,11 @@ use std::sync::{Arc, RwLock};
 ///
 /// ```
 /// let mut app = tide::Server::new();
-/// app.at("/get").get(|cx: tide::Request<()>| async move { cx.cookie("testCookie").unwrap().value().to_string() });
+/// app.at("/get").get(|cx: tide::Request<()>| async move { Ok(cx.cookie("testCookie").unwrap().value().to_string()) });
 /// app.at("/set").get(|_| async {
 ///     let mut res = tide::Response::new(http_types::StatusCode::Ok);
 ///     res.set_cookie(cookie::Cookie::new("testCookie", "NewCookieValue"));
-///     res
+///     Ok(res)
 /// });
 /// ```
 #[derive(Debug, Clone, Default)]

src/redirect.rs

@@ -14,7 +14,7 @@ use crate::{Endpoint, Request, Response};
 /// # fn main() -> Result<(), std::io::Error> { block_on(async {
 /// #
 /// let mut app = tide::new();
-/// app.at("/").get(|_| async move { "meow" });
+/// app.at("/").get(|_| async move { Ok("meow") });
 /// app.at("/nori").get(tide::redirect("/"));
 /// app.listen("127.0.0.1:8080").await?;
 /// #

src/request.rs

@@ -54,7 +54,7 @@ impl<State> Request<State> {
     /// let mut app = tide::new();
     /// app.at("/").get(|req: Request<()>| async move {
     ///     assert_eq!(req.method(), http_types::Method::Get);
-    ///     ""
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -76,8 +76,8 @@ impl<State> Request<State> {
     ///
     /// let mut app = tide::new();
     /// app.at("/").get(|req: Request<()>| async move {
-    ///     assert_eq!(req.uri(), &"/".parse::<tide::http_types::Url>().unwrap());
-    ///     ""
+    ///     assert_eq!(req.uri(), &"/".parse::<tide::http::Url>().unwrap());
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -99,8 +99,8 @@ impl<State> Request<State> {
     ///
     /// let mut app = tide::new();
     /// app.at("/").get(|req: Request<()>| async move {
-    ///     assert_eq!(req.version(), Some(tide::http_types::Version::Http1_1));
-    ///     ""
+    ///     assert_eq!(req.version(), Some(http_types::Version::Http1_1));
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -123,7 +123,7 @@ impl<State> Request<State> {
     /// let mut app = tide::new();
     /// app.at("/").get(|req: Request<()>| async move {
     ///     assert_eq!(req.header(&"X-Forwarded-For".parse().unwrap()), Some(&vec!["127.0.0.1".parse().unwrap()]));
-    ///     ""
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -205,7 +205,7 @@ impl<State> Request<State> {
     /// let mut app = tide::new();
     /// app.at("/").get(|mut req: Request<()>| async move {
     ///     let _body: Vec<u8> = req.body_bytes().await.unwrap();
-    ///     ""
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -240,7 +240,7 @@ impl<State> Request<State> {
     /// let mut app = tide::new();
     /// app.at("/").get(|mut req: Request<()>| async move {
     ///     let _body: String = req.body_string().await.unwrap();
-    ///     ""
+    ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #

src/server/mod.rs

@@ -151,7 +151,7 @@ impl Server<()> {
     /// # fn main() -> Result<(), std::io::Error> { 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(()) }) }
@@ -193,7 +193,7 @@ impl<State: Send + Sync + 'static> Server<State> {
     /// // Initialize the application with state.
     /// let mut app = tide::with_state(state);
     /// app.at("/").get(|req: Request<State>| async move {
-    ///     format!("Hello, {}!", &req.state().name)
+    ///     Ok(format!("Hello, {}!", &req.state().name))
     /// });
     /// app.listen("127.0.0.1:8080").await?;
     /// #
@@ -219,7 +219,7 @@ impl<State: Send + Sync + 'static> Server<State> {
     ///
     /// ```rust,no_run
     /// # let mut app = tide::Server::new();
-    /// app.at("/").get(|_| async move {"Hello, world!"});
+    /// app.at("/").get(|_| async move { Ok("Hello, world!") });
     /// ```
     ///
     /// A path is comprised of zero or many segments, i.e. non-empty strings

tests/querystring.rs

@@ -20,15 +20,15 @@ async fn handler(cx: Request<()>) -> tide::Result<Response> {
     let p = cx.query::<Params>();
     match p {
         Ok(params) => Ok(params.msg.into_response()),
-        Err(error) => Ok(Response::new(error.status())),
+        Err(error) => Ok(err_to_res(error)),
     }
 }
 
 async fn optional_handler(cx: Request<()>) -> tide::Result<Response> {
     let p = cx.query::<OptionalParams>();
     match p {
         Ok(_) => Ok(Response::new(StatusCode::Ok)),
-        Err(error) => Ok(Response::new(error.status())),
+        Err(error) => Ok(err_to_res(error)),
     }
 }
 
@@ -94,3 +94,12 @@ fn empty_query_string_for_struct_with_no_required_fields() {
     let res = server.simulate(req).unwrap();
     assert_eq!(res.status(), StatusCode::Ok);
 }
+
+fn err_to_res(err: http_types::Error) -> crate::Response {
+    Response::new(err.status())
+        .set_header(
+            http_types::headers::CONTENT_TYPE,
+            "text/plain; charset=utf-8",
+        )
+        .body_string(err.to_string())
+}