Make templates static

This way, they get bundled into the binary and don't require the templates files to actually be on the server

Cargo.lock

  "async-std",
  "chrono",
  "dotenv",
+ "lazy_static",
  "pulldown-cmark",
  "serde",
  "serde_json",

oslo-lib/Cargo.toml

 async-std = { version = "1.6.0", features = ["attributes"] }
 chrono = { version = "0.4", features = ["serde", "rustc-serialize"] }
 dotenv = "0.15.0"
+lazy_static = "1.4.0"
 pulldown-cmark = { version = "0.7", default-features = false }
 serde = "1.0.115"
 serde_json = "1.0.57"

oslo-lib/src/lib.rs

 mod middleware;
 mod post;
 mod routes;
+mod templates;
 mod util;
 
 use middleware::*;

oslo-lib/src/middleware.rs

 use std::{env, future::Future, io::ErrorKind, pin::Pin};
 use tera::Context;
 
-use crate::{routes, State};
+use crate::{templates, State};
 
 pub fn session() -> SessionMiddleware<CookieStore> {
     SessionMiddleware::new(
             } else {
                 StatusCode::InternalServerError
             };
-            let body: String = routes::render_template("error.html", &context)?;
+            let body: String = templates::render_template("error.html", &context)?;
             res.set_body(body);
             res.set_status(status);
             res.set_content_type(mime::HTML);
         None => match res.status() {
             StatusCode::NotFound => {
                 context.insert("error", "Page not found");
-                res.set_body(routes::render_template("error.html", &context)?);
+                res.set_body(templates::render_template("error.html", &context)?);
                 res.set_content_type(mime::HTML);
             }
             _ => {}

oslo-lib/src/routes.rs

 use chrono::prelude::Local;
 use serde::{Deserialize, Serialize};
-use tera::{Context, Tera};
+use tera::Context;
 use tide::convert::json;
 use tide::http::mime;
 use tide::{Redirect, Request, Response, Result, StatusCode};
 
 use std::env;
 
-use crate::{fs, post::Post, util, State};
+use crate::{fs, post::Post, templates::render_template, util, State};
 
 #[derive(Debug, Serialize, Deserialize)]
 struct User {
     Ok(Redirect::new(path).into())
 }
 
-pub fn render_template(template: &str, context: &Context) -> Result<String> {
-    let tera = Tera::new("templates/**/*.html")?;
-    let html = tera.render(template, &context)?;
-    Ok(html)
-}
-
 fn prepare_flash_messages(mut req: Request<State>) -> Context {
     let mut context = Context::new();
     context.insert("flash_error", &false);

oslo-lib/src/templates.rs

+use lazy_static::lazy_static;
+use tera::{Context, Tera};
+use tide::Result;
+
+lazy_static! {
+    pub static ref TEMPLATES: Tera = {
+        let mut tera = match Tera::new("templates/**/*.html") {
+            Ok(t) => t,
+            Err(e) => {
+                println!("Parsing error(s): {}", e);
+                ::std::process::exit(1);
+            }
+        };
+        tera.autoescape_on(vec!["html", ".sql"]);
+        tera
+    };
+}
+
+pub fn render_template(template: &str, context: &Context) -> Result<String> {
+    let html = TEMPLATES.render(template, &context)?;
+    Ok(html)
+}