reply: implement redirect

nytopop · nytopop · commit 2275246bd749 · 2020-11-18T13:55:27.000-08:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -69,18 +69,16 @@ use combinators::{
     Add2, Base, End, Inject, InjectAll, Link, Map, MapErr, MapErrs, Path, Then, TryMap, TryThen,
 };
 use handler::{Chain, Handler, NotFound};
-use reply::Reply;
+use reply::{redirect, Reply};
 use tree::{Cluster, Node, Params, Parser, PathSpec, Route, Segment};
 
 use frunk_core::{
     hlist::{HList, HNil},
     indices::Here,
 };
 use futures::future::{ready, BoxFuture, FutureExt, NeverError, Ready};
-use http::{Extensions, HeaderMap, HeaderValue, Uri, Version};
-use hyper::{
-    header::LOCATION, server::conn::AddrStream, service::Service, Body, Method, Request, StatusCode,
-};
+use http::{Extensions, HeaderMap, Uri, Version};
+use hyper::{server::conn::AddrStream, service::Service, Body, Method, Request};
 use std::{
     borrow::Cow,
     collections::HashMap,
@@ -152,15 +150,7 @@ impl Service<Request<Body>> for AppService {
 }
 
 /// The set of request scoped state that contexts are initialized with.
-pub type Init = R![
-    Body,
-    Method,
-    Uri,
-    Version,
-    HeaderMap<HeaderValue>,
-    Extensions,
-    SocketAddr,
-];
+pub type Init = R![Body, Method, Uri, Version, HeaderMap, Extensions, SocketAddr];
 
 /// Contains routes and handlers for a given http application.
 ///
@@ -321,11 +311,12 @@ impl App {
         }
     }
 
-    fn lookup_route(&self, method: &Method, path: &str) -> Option<Route<'_, dyn Handler>> {
+    fn lookup_route(&self, method: &Method, path: &str) -> Route<'_, dyn Handler> {
         method_idx(method)
             .map(|i| &self.common[i])
             .or_else(|| self.custom.get(method))
             .map(|n| n.lookup(path))
+            .unwrap_or_default()
     }
 
     fn dispatch(&self, req: Request<Body>, addr: SocketAddr) -> BoxFuture<'static, Response> {
@@ -341,30 +332,21 @@ impl App {
             Cow::Owned(s)
         }
 
-        let method = req.method();
         let path = req.uri().path();
+        let route = self.lookup_route(req.method(), path);
 
-        match self.lookup_route(method, path) {
-            Some(Route { entry: Some(h), .. }) => h.handle(req, addr),
-
-            Some(Route { tsr: true, .. }) if method != Method::CONNECT && path != "/" => {
-                let code = if let Method::GET = *method {
-                    StatusCode::MOVED_PERMANENTLY
-                } else {
-                    StatusCode::PERMANENT_REDIRECT
-                };
-
-                let resp = hyper::Response::builder()
-                    .status(code)
-                    .header(LOCATION, &*swap_trailing_slash(path))
-                    .body(Body::empty())
-                    .unwrap();
-
-                Box::pin(async { resp })
-            }
+        // there's a handler matching this uri
+        if let Some(h) = route.entry {
+            return h.handle(req, addr);
+        }
 
-            _ => self.not_found.handle(req, addr),
+        // there's a handler matching this uri if the trailing slash is swapped
+        if route.tsr && req.method() != Method::CONNECT && path != "/" {
+            return ready(redirect(false, swap_trailing_slash(path))).boxed();
         }
+
+        // there's no handler matching this uri
+        self.not_found.handle(req, addr)
     }
 
     /// Create a test client for this app.
diff --git a/src/reply/mod.rs b/src/reply/mod.rs
@@ -3,7 +3,10 @@ use super::{field::IsoEncode, Response, R};
 use frunk_core::coproduct::{CNil, Coproduct};
 use headers::{Header, HeaderMapExt};
 use http::{HeaderMap, Method, StatusCode, Uri};
-use hyper::header::{CONTENT_TYPE, X_CONTENT_TYPE_OPTIONS};
+use hyper::{
+    header::{CONTENT_TYPE, LOCATION, X_CONTENT_TYPE_OPTIONS},
+    Body,
+};
 use hyper_staticfile::{resolve_path, ResponseBuilder};
 use serde::Serialize;
 use std::{
@@ -166,6 +169,7 @@ pub fn json<T: Serialize>(value: &T) -> Response {
 
 /// Returns a json [Response] from an hlist of [Serialize] named fields.
 ///
+/// # Examples
 /// ```
 /// use hyperbole::{r, reply};
 ///
@@ -281,3 +285,25 @@ async fn fs_inner(path: PathBuf, m: Method, u: UriRes, h: HeaderMap) -> Result<R
         .build(resolve_path(path, uri.path()).await?)
         .map_err(|e| e.into())
 }
+
+/// Returns a redirect response to the provided `path`.
+///
+/// # Examples
+/// ```
+/// use hyperbole::{reply, uri, Ctx, R};
+///
+/// let _ctx = Ctx::default().get(uri!["go-home"], |cx: R![]| async {
+///     reply::redirect(true, "/home")
+/// });
+/// ```
+pub fn redirect<P: AsRef<str>>(permanent: bool, path: P) -> Response {
+    hyper::Response::builder()
+        .status(if permanent {
+            StatusCode::PERMANENT_REDIRECT
+        } else {
+            StatusCode::TEMPORARY_REDIRECT
+        })
+        .header(LOCATION, path.as_ref())
+        .body(Body::empty())
+        .unwrap()
+}
