Move middleware to module

src/main.rs

@@ -6,11 +6,10 @@ use std::path::PathBuf;
 use dotenv;
 use serde::{Deserialize, Serialize};
 use serde_json;
-use tera::Context;
 use tide::utils::After;
-use tide::{Response, StatusCode};
 
 mod fs;
+mod middleware;
 mod routes;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -50,46 +49,8 @@ async fn main() -> std::io::Result<()> {
     tide::log::start();
     let mut app = tide::new();
 
-    app.with(After(|mut res: Response| async {
-        let mut context = Context::new();
-
-        match res.downcast_error::<async_std::io::Error>() {
-            Some(e) => {
-                context.insert("error", &e.to_string());
-                let status = if let ErrorKind::NotFound = e.kind() {
-                    StatusCode::NotFound
-                } else {
-                    StatusCode::InternalServerError
-                };
-                res.set_body(routes::render_template("error.html", &context)?);
-                res.set_status(status);
-            }
-            None => match res.status() {
-                StatusCode::NotFound => {
-                    context.insert("error", "Page not found");
-                    res.set_body(routes::render_template("error.html", &context)?);
-                }
-                _ => {}
-            },
-        };
-
-        Ok(res)
-    }));
-
-    app.with(After(|mut res: Response| async {
-        res.set_content_type(tide::http::mime::HTML);
-        Ok(res)
-    }));
-
-    app.with(tide::sessions::SessionMiddleware::new(
-        tide::sessions::MemoryStore::new(),
-        std::env::var("TIDE_SECRET")
-            .expect(
-                "Please provide a TIDE_SECRET value of at \
-                      least 32 bytes in order to run this example",
-            )
-            .as_bytes(),
-    ));
+    app.with(After(middleware::errors));
+    app.with(middleware::session());
 
     app.at("/").get(routes::index);
     app.at("/posts").post(routes::create_post);

src/middleware.rs

@@ -0,0 +1,50 @@
+use tide::{
+    http::mime,
+    sessions::{CookieStore, SessionMiddleware},
+    Response, Result, StatusCode,
+};
+
+use std::{env, io::ErrorKind};
+use tera::Context;
+
+use crate::routes;
+
+pub fn session() -> SessionMiddleware<CookieStore> {
+    SessionMiddleware::new(
+        CookieStore::new(),
+        env::var("TIDE_SECRET")
+            .expect(
+                "Please provide a TIDE_SECRET value of at \
+                      least 32 bytes in order to run this example",
+            )
+            .as_bytes(),
+    )
+}
+
+pub async fn errors(mut res: Response) -> Result<Response> {
+    let mut context = Context::new();
+
+    match res.downcast_error::<async_std::io::Error>() {
+        Some(e) => {
+            context.insert("error", &e.to_string());
+            let status = if let ErrorKind::NotFound = e.kind() {
+                StatusCode::NotFound
+            } else {
+                StatusCode::InternalServerError
+            };
+            let body: String = routes::render_template("error.html", &context)?;
+            res.set_body(body);
+            res.set_status(status);
+        }
+        None => match res.status() {
+            StatusCode::NotFound => {
+                context.insert("error", "Page not found");
+                res.set_body(routes::render_template("error.html", &context)?);
+            }
+            _ => {}
+        },
+    };
+
+    res.set_content_type(mime::HTML);
+    Ok(res)
+}