Refactor the way redirects work

Author: eopb

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::{Redirect, Request, Response, Server, StatusCode};
 
 #[derive(Clone)]
 struct User {
@@ -104,7 +104,7 @@ fn main() -> std::io::Result<()> {
         let mut app = Server::with_state(State {
             users: RwLock::new(Vec::new()),
         });
-        app.at("/").get(redirect::permanent("/graphiql"));
+        app.at("/").get(Redirect::permanent("/graphiql"));
         app.at("/graphql").post(handle_graphql);
         app.at("/graphiql").get(handle_graphiql);
         app.listen("0.0.0.0:8080").await?;

examples/redirect.rs

@@ -0,0 +1,28 @@
+use tide::{http::StatusCode, Redirect, Response};
+
+#[async_std::main]
+async fn main() -> Result<(), std::io::Error> {
+    let mut app = tide::new();
+    app.at("/").get(|_| async move { Ok("Root") });
+
+    // Redirect hackers to YouTube.
+    app.at("/.env").get(Redirect::see_other(
+        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+    ));
+
+    app.at("/users-page").get(|_| async move {
+        Ok(if signed_in() {
+            Response::new(StatusCode::Ok)
+        } else {
+            // If the user is not signed in then lets redirect them to home page.
+            Redirect::see_other("/").into()
+        })
+    });
+
+    app.listen("127.0.0.1:8080").await?;
+    Ok(())
+}
+
+fn signed_in() -> bool {
+    false
+}

src/lib.rs

@@ -200,6 +200,10 @@ pub mod log;
 pub mod prelude;
 pub mod redirect;
 pub mod security;
+
+pub use endpoint::Endpoint;
+pub use redirect::Redirect;
+pub use request::Request;
 pub mod sse;
 
 pub use endpoint::Endpoint;

src/redirect.rs

@@ -0,0 +1,128 @@
+//! HTTP redirection endpoint.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! # use futures::executor::block_on;
+//! # fn main() -> Result<(), std::io::Error> { block_on(async {
+//! #
+//! use tide::Redirect;
+//!
+//! let mut app = tide::new();
+//! app.at("/").get(|_| async move { Ok("meow") });
+//! app.at("/nori").get(Redirect::temporary("/"));
+//! app.listen("127.0.0.1:8080").await?;
+//! #
+//! # Ok(()) }) }
+//! ```
+
+use crate::utils::BoxFuture;
+use crate::StatusCode;
+use crate::{Endpoint, Request, Response};
+
+/// A redirection endpoint.
+#[derive(Debug, Clone)]
+pub struct Redirect<T: AsRef<str>> {
+    status: StatusCode,
+    location: T,
+}
+
+impl<T: AsRef<str>> Redirect<T> {
+    /// Creates an endpoint that represents a permanent redirect to `location`.
+    ///
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use tide::{Response, Redirect, Request, StatusCode};
+    /// # fn canonicalize(uri: &url::Url) -> Option<&url::Url> { None }
+    /// # #[allow(dead_code)]
+    /// async fn route_handler(request: Request<()>) -> tide::Result {
+    ///     if let Some(canonical_redirect) = canonicalize(request.uri()) {
+    ///         Ok(Redirect::permanent(canonical_redirect).into())
+    ///     } else {
+    ///          //...
+    /// #        Ok(Response::new(StatusCode::Ok)) // ...
+    ///     }
+    /// }
+    /// ```
+    pub fn permanent(location: T) -> Self {
+        Self {
+            status: StatusCode::PermanentRedirect,
+            location,
+        }
+    }
+
+    /// Creates an endpoint that represents a temporary redirect to `location`.
+    ///
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use tide::{Response, Redirect, Request, StatusCode};
+    /// # fn special_sale_today() -> Option<String> { None }
+    /// # #[allow(dead_code)]
+    /// async fn route_handler(request: Request<()>) -> tide::Result {
+    ///     if let Some(sale_url) = special_sale_today() {
+    ///         Ok(Redirect::temporary(sale_url).into())
+    ///     } else {
+    ///         //...
+    /// #       Ok(Response::new(StatusCode::Ok)) //...
+    ///     }
+    /// }
+    /// ```
+    pub fn temporary(location: T) -> Self {
+        Self {
+            status: StatusCode::TemporaryRedirect,
+            location,
+        }
+    }
+
+    /// Creates an endpoint that represents a see other redirect to `location`.
+    ///
+    /// GET methods are unchanged.
+    /// Other methods are changed to GET and their body lost.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use tide::{Response, Redirect, Request, StatusCode};
+    /// # fn next_product() -> Option<String> { None }
+    /// # #[allow(dead_code)]
+    /// async fn route_handler(request: Request<()>) -> tide::Result {
+    ///     if let Some(product_url) = next_product() {
+    ///         Ok(Redirect::see_other(product_url).into())
+    ///     } else {
+    ///         //...
+    /// #       Ok(Response::new(StatusCode::Ok)) //...
+    ///     }
+    /// }
+    /// ```
+    pub fn see_other(location: T) -> Self {
+        Self {
+            status: StatusCode::SeeOther,
+            location,
+        }
+    }
+
+    /// Returns response with equivalent redirect.
+    pub fn response(&self) -> Response {
+        Response::new(self.status).set_header("location".parse().unwrap(), &self.location)
+    }
+}
+
+impl<State, T> Endpoint<State> for Redirect<T>
+where
+    T: AsRef<str> + Send + Sync + 'static,
+{
+    fn call<'a>(&'a self, _req: Request<State>) -> BoxFuture<'a, crate::Result<Response>> {
+        let res = self.response();
+        Box::pin(async move { Ok(res) })
+    }
+}
+
+impl<T: AsRef<str>> Into<Response> for Redirect<T> {
+    fn into(self) -> Response {
+        self.response()
+    }
+}

src/redirect/mod.rs

@@ -47,76 +47,6 @@ impl Response {
         }
     }
 
-    /// Creates a response that represents a permanent redirect to `location`.
-    ///
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use tide::{Response, Request, StatusCode};
-    /// # fn canonicalize(uri: &tide::http::Url) -> Option<&tide::http::Url> { None }
-    /// # #[allow(dead_code)]
-    /// async fn route_handler(request: Request<()>) -> tide::Result {
-    ///     if let Some(canonical_redirect) = canonicalize(request.uri()) {
-    ///         Ok(Response::redirect_permanent(canonical_redirect))
-    ///     } else {
-    ///          //...
-    /// #        Ok(Response::new(StatusCode::Ok)) // ...
-    ///     }
-    /// }
-    /// ```
-    pub fn redirect_permanent(location: impl AsRef<str>) -> Self {
-        Response::new(StatusCode::PermanentRedirect)
-            .set_header("location".parse().unwrap(), location)
-    }
-
-    /// Creates a response that represents a temporary redirect to `location`.
-    ///
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use tide::{Response, Request, StatusCode};
-    /// # fn special_sale_today() -> Option<String> { None }
-    /// # #[allow(dead_code)]
-    /// async fn route_handler(request: Request<()>) -> tide::Result {
-    ///     if let Some(sale_url) = special_sale_today() {
-    ///         Ok(Response::redirect_temporary(sale_url))
-    ///     } else {
-    ///         //...
-    /// #       Ok(Response::new(StatusCode::Ok)) //...
-    ///     }
-    /// }
-    /// ```
-    pub fn redirect_temporary(location: impl AsRef<str>) -> Self {
-        Response::new(StatusCode::TemporaryRedirect)
-            .set_header("location".parse().unwrap(), location)
-    }
-
-    /// Creates a response that represents a see other redirect to `location`.
-    ///
-    /// GET methods are unchanged.
-    /// Other methods are changed to GET and their body lost.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use tide::{Response, Request, StatusCode};
-    /// # fn next_product() -> Option<String> { None }
-    /// # #[allow(dead_code)]
-    /// async fn route_handler(request: Request<()>) -> tide::Result {
-    ///     if let Some(product_url) = next_product() {
-    ///         Ok(Response::redirect_see_other(product_url))
-    ///     } else {
-    ///         //...
-    /// #       Ok(Response::new(StatusCode::Ok)) //...
-    ///     }
-    /// }
-    /// ```
-    pub fn redirect_see_other(location: impl AsRef<str>) -> Self {
-        Response::new(StatusCode::SeeOther).set_header("location".parse().unwrap(), location)
-    }
-
     /// Returns the statuscode.
     pub fn status(&self) -> crate::StatusCode {
         self.res.status()