Starts using Lawl, update API.

Author: Yue

Cargo.lock

@@ -20,6 +20,9 @@ jsonwebtoken = { version = "10.2.0", features = ["rust_crypto"] }
 chrono = "0.4.42"
 anyhow = "1.0.100"
 
+[dependencies.lawl]
+path = "../lawl"
+
 [dependencies.uuid]
 version = "1.18.1"
 # Lets you generate random UUIDs
@@ -31,4 +34,4 @@ features = [
 rshtml = "0.3.0"
 
 [package.metadata.rshtml]
-views = { path = "views", layout = "layout.rs.html", extract_file_on_debug = false }
+views = { path = "views", layout = "layout.rs.html", extract_file_on_debug = false }

Cargo.toml

@@ -7,10 +7,10 @@ use rocket::{State, response::content::RawHtml};
 #[get("/")]
 pub async fn index(topic_service: &State<TopicService>, user: Model) -> RawHtml<String> {
     let mut template_engine = TemplateEngine::default();
-    template_engine.set("user", user);
+    template_engine.insert(&"user", user);
 
     let posts = topic_service.get_topics().await;
-    template_engine.set("posts", posts);
+    template_engine.insert(&"posts", posts);
 
     RawHtml(template_engine.render("index").unwrap())
 }

src/routes/index.rs

@@ -0,0 +1 @@
+pub struct PostService {}

src/services/post_service.rs

@@ -1,19 +1,15 @@
-use std::{
-    fmt::Display,
-    fs,
-    path::{Path, PathBuf},
-    sync::Mutex,
-};
+use std::fmt::Display;
+use std::fs;
+use std::path::{Path, PathBuf};
 
 use erased_serde::Serialize;
-use lol_html::{HtmlRewriter, Settings, element, html_content::Element};
-use mlua::{Lua, LuaSerdeExt};
+use lawl::Lawl;
 
 pub struct TemplateEngine {
     base_path: PathBuf,
     layout_path: PathBuf,
     use_layout: bool,
-    environment: Vec<(String, Mutex<Box<dyn Serialize + Send>>)>,
+    lawl: Lawl,
 }
 
 impl TemplateEngine {
@@ -26,128 +22,38 @@ impl TemplateEngine {
     pub fn render(&mut self, template_name: impl AsRef<Path>) -> anyhow::Result<String> {
         let path = self.get_path_to_template(&template_name);
         let mut template = fs::read_to_string(path)?;
-        let mut rendered = template.render(&self.environment)?;
+        let mut rendered = self.lawl.render(&template).unwrap();
 
         if self.use_layout {
-            self.set("children", rendered);
+            self.lawl.insert(&"children", rendered);
             template = fs::read_to_string(self.get_path_to_template(&self.layout_path))?;
-            rendered = template.render(&self.environment)?;
-            self.delete("children");
+            rendered = self.lawl.render(&template).unwrap();
+            self.lawl.remove(&"children");
         }
 
         Ok(rendered)
     }
 
-    pub fn set<K: Display, T: Serialize + Send + 'static>(&mut self, key: K, value: T) {
-        self.environment
-            .push((key.to_string(), Mutex::new(Box::new(value))));
+    pub fn insert<T: Sync + Send + Serialize + 'static>(
+        &mut self,
+        key: &impl Display,
+        value: T,
+    ) -> Result<(), ()> {
+        self.lawl.insert(&key.to_string(), value)
     }
 
-    pub fn delete<K: Display>(&mut self, key: K) {
-        let key = key.to_string();
-
-        self.environment.retain(|(k, _)| &key != k);
+    pub fn remove(&mut self, key: &impl Display) -> Result<(), ()> {
+        self.lawl.remove(&key)
     }
 }
 
 impl Default for TemplateEngine {
     fn default() -> Self {
         Self {
             base_path: Path::new(&"./views".to_string()).to_owned(),
-            environment: Vec::new(),
             use_layout: true,
             layout_path: Path::new(&"layout".to_string()).to_owned(),
+            lawl: Default::default(),
         }
     }
 }
-
-pub trait Render {
-    fn render(
-        &self,
-        environment: &Vec<(String, Mutex<Box<dyn Serialize + Send>>)>,
-    ) -> anyhow::Result<String>;
-}
-
-impl Render for String {
-    fn render(
-        &self,
-        environment: &Vec<(String, Mutex<Box<dyn Serialize + Send>>)>,
-    ) -> anyhow::Result<String> {
-        let mut env = vec![];
-        let lua = Lua::new();
-
-        for (k, v) in environment {
-            let value = v.lock().unwrap();
-            let value = value.as_ref();
-
-            let value = lua.to_value(&value).unwrap();
-            env.push((k.to_owned(), value));
-        }
-
-        for (k, v) in env {
-            lua.globals().set(k, v).expect("Unable to assign globals.")
-        }
-
-        lua.load("function show(v) if (v or '') == '' then data = '' end end")
-            .exec()
-            .unwrap();
-
-        lua.load("function hide(v) if (v or '') ~= '' then data = '' end end")
-            .exec()
-            .unwrap();
-
-        lua.load("function maybe(v, o) return v or o end")
-            .exec()
-            .unwrap();
-
-        lua.load("function format(...) data = string.format(data, ...) end")
-            .exec()
-            .unwrap();
-
-        lua.load("function each(k) local template = data; data = ''; for _, post in ipairs(k) do data = data .. template:gsub('%$([a-zA-Z_]+)', post) end end").exec().unwrap();
-
-        render(self, lua)
-    }
-}
-
-pub fn render(template: &String, lua: Lua) -> anyhow::Result<String> {
-    let mut buffer = vec![];
-    let mut rewriter = HtmlRewriter::new(
-        Settings {
-            element_content_handlers: vec![element!("lua", |el: &mut Element| {
-                let start_location = el.source_location().bytes().end;
-                let expression = el.get_attribute("code").unwrap_or("".to_string());
-                el.remove();
-                if let Some(handlers) = el.end_tag_handlers() {
-                    let source = template.clone();
-                    let e = expression.clone();
-                    let lua = lua.clone();
-
-                    handlers.push(Box::new(move |end| {
-                        let end_location = end.source_location().bytes().start;
-                        let html = source[start_location..end_location].to_string();
-
-                        lua.globals().set("data", html).unwrap();
-
-                        lua.load(&e)
-                            .exec()
-                            .expect(format!("Invalid Lua expression. {}", e).as_str());
-
-                        let data: String = lua.globals().get("data").unwrap();
-
-                        end.before(&data, lol_html::html_content::ContentType::Html);
-
-                        Ok(())
-                    }));
-                }
-                Ok(())
-            })],
-            ..Settings::new()
-        },
-        |c: &[u8]| buffer.extend_from_slice(c),
-    );
-
-    rewriter.write(template.as_bytes()).unwrap();
-
-    Ok(String::from_utf8(buffer).unwrap())
-}