Merge pull request #513 from ethanboxx/better-redirects

Better redirects

Author: yoshuawuyts

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,27 @@
+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::new("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::new("/").into()
+        })
+    });
+
+    app.listen("127.0.0.1:8080").await?;
+    Ok(())
+}
+
+fn signed_in() -> bool {
+    false
+}

src/lib.rs

@@ -189,6 +189,7 @@ mod cookies;
 mod endpoint;
 mod fs;
 mod middleware;
+mod redirect;
 mod request;
 mod response;
 mod route;
@@ -198,12 +199,12 @@ mod utils;
 
 pub mod log;
 pub mod prelude;
-pub mod redirect;
 pub mod security;
 pub mod sse;
 
 pub use endpoint::Endpoint;
 pub use middleware::{Middleware, Next};
+pub use redirect::Redirect;
 pub use request::Request;
 pub use response::Response;
 pub use route::Route;

src/redirect.rs

@@ -0,0 +1,108 @@
+//! HTTP redirection endpoint.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! # use async_std::task::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.
+///
+/// # 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::new(product_url).into())
+///     } else {
+///         //...
+/// #       Ok(Response::new(StatusCode::Ok)) //...
+///     }
+/// }
+/// ```
+#[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 redirect to `location`.
+    ///
+    /// Uses status code 302 Found.
+    pub fn new(location: T) -> Self {
+        Self {
+            status: StatusCode::Found,
+            location,
+        }
+    }
+
+    /// Creates an endpoint that represents a permanent redirect to `location`.
+    ///
+    /// Uses status code 301 Permanent Redirect.
+    pub fn permanent(location: T) -> Self {
+        Self {
+            status: StatusCode::PermanentRedirect,
+            location,
+        }
+    }
+
+    /// Creates an endpoint that represents a temporary redirect to `location`.
+    ///
+    /// Uses status code 307 Temporary Redirect.
+    pub fn temporary(location: T) -> Self {
+        Self {
+            status: StatusCode::TemporaryRedirect,
+            location,
+        }
+    }
+
+    /// Creates an endpoint that represents a see other redirect to `location`.
+    ///
+    /// Uses status code 303 See Other.
+    pub fn see_other(location: T) -> Self {
+        Self {
+            status: StatusCode::SeeOther,
+            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.into();
+        Box::pin(async move { Ok(res) })
+    }
+}
+
+impl<T: AsRef<str>> Into<Response> for Redirect<T> {
+    fn into(self) -> Response {
+        (&self).into()
+    }
+}
+
+impl<T: AsRef<str>> Into<Response> for &Redirect<T> {
+    fn into(self) -> Response {
+        Response::new(self.status).set_header("location".parse().unwrap(), &self.location)
+    }
+}

src/redirect/mod.rs

@@ -7,6 +7,7 @@ use serde::Serialize;
 use crate::http::cookies::Cookie;
 use crate::http::headers::{HeaderName, HeaderValue};
 use crate::http::{self, Body, StatusCode};
+use crate::Redirect;
 
 #[derive(Debug)]
 pub(crate) enum CookieEvent {
@@ -47,31 +48,9 @@ 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`.
+    /// Creates a response that represents a redirect to `location`.
     ///
+    /// Uses status code 302 Found.
     ///
     /// # Example
     ///
@@ -81,16 +60,15 @@ impl Response {
     /// # #[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))
+    ///         Ok(Response::redirect(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)
+    pub fn redirect(location: impl AsRef<str>) -> Self {
+        Redirect::new(location).into()
     }
 
     /// Returns the statuscode.