Embed static files in binary

Cargo.lock

  "dotenv",
  "lazy_static",
  "pulldown-cmark",
+ "rust-embed",
  "serde",
  "serde_json",
  "tera",
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56770675ebc04927ded3e60633437841581c285dc6236109ea25fbf3beb7b59e"
 
+[[package]]
+name = "rust-embed"
+version = "5.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fe1fe6aac5d6bb9e1ffd81002340363272a7648234ec7bdfac5ee202cb65523"
+dependencies = [
+ "rust-embed-impl",
+ "rust-embed-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-impl"
+version = "5.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed91c41c42ef7bf687384439c312e75e0da9c149b0390889b94de3c7d9d9e66"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rust-embed-utils",
+ "syn",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-utils"
+version = "5.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a512219132473ab0a77b52077059f1c47ce4af7fbdc94503e9862a34422876d"
+dependencies = [
+ "walkdir",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.16"

oslo-lib/Cargo.toml

 dotenv = "0.15.0"
 lazy_static = "1.4.0"
 pulldown-cmark = { version = "0.7", default-features = false }
+rust-embed = "5.9.0"
 serde = "1.0.115"
 serde_json = "1.0.57"
 tera = "1.5.0"

oslo-lib/src/lib.rs

     app.with(session());
 
     app.at("/").get(routes::index);
+    app.at("/static/:filename").get(routes::static_file);
     app.at("/posts")
         .with(require_auth)
         .post(routes::create_post);

oslo-lib/src/middleware.rs

             } else {
                 StatusCode::InternalServerError
             };
-            let body: String = templates::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(templates::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 rust_embed::RustEmbed;
 use serde::{Deserialize, Serialize};
 use tera::Context;
-use tide::convert::json;
-use tide::http::mime;
+use tide::{convert::json, http::Mime};
+use tide::{http::mime, Body};
 use tide::{Redirect, Request, Response, Result, StatusCode};
 
 use std::env;
     Ok(Redirect::new("/").into())
 }
 
+#[derive(RustEmbed)]
+#[folder = "../static"]
+struct Asset;
+
+pub async fn static_file(req: Request<State>) -> Result {
+    let filename: String = req.param("filename")?;
+    match Asset::get(&filename) {
+        Some(file) => {
+            let content_type = if filename.ends_with(".css") {
+                mime::CSS
+            } else if filename.ends_with("js") {
+                mime::JAVASCRIPT
+            } else if filename.ends_with("otf") {
+                mime::Mime::from("font/opentype")
+            } else {
+                mime::PLAIN
+            };
+
+            render_static_response(file.to_vec(), content_type)
+        }
+        None => {
+            let res = Response::builder(StatusCode::NotFound)
+                .body("404 not found")
+                .content_type(mime::PLAIN)
+                .build();
+
+            Ok(res)
+        }
+    }
+}
+
 pub fn render_html_response(
     template: &str,
     context: &Context,
     context.insert("login_path", login_path);
     context.extend(prepare_flash_messages(req));
 
-    let html = render_template(template, &context)?;
+    let html = render_template(template, context)?;
 
     let res = Response::builder(StatusCode::Ok)
         .body(html)
 
     Ok(res)
 }
+pub fn render_static_response(contents: Vec<u8>, content_type: Mime) -> Result<Response> {
+    let res = Response::builder(StatusCode::Ok)
+        .body(Body::from_bytes(contents))
+        .content_type(content_type)
+        .build();
+
+    Ok(res)
+}
 
 fn redirect(path: &str) -> Result<Response> {
     Ok(Redirect::new(path).into())

oslo-lib/src/templates.rs

 
 lazy_static! {
     pub static ref TEMPLATES: Tera = {
-        let mut tera = match Tera::new("templates/**/*.html") {
+        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> {
+pub fn render_template(template: &str, context: Context) -> Result<String> {
     let html = TEMPLATES.render(template, &context)?;
     Ok(html)
 }