Template Tag Function Editor (#67)

![CleanShot 2024-08-15 at 16 53
09@2x](https://github.com/user-attachments/assets/8c0eb655-1daf-4dc8-811f-f606c770f7dc)

src-tauri/yaak_templates/src/renderer.rs

@@ -1,4 +1,4 @@
-use crate::{FnArg, Parser, Token, Val};
+use crate::{FnArg, Parser, Token, Tokens, Val};
 use log::warn;
 use std::collections::HashMap;
 
@@ -15,27 +15,27 @@ pub fn parse_and_render(
 }
 
 pub fn render(
-    tokens: Vec<Token>,
+    tokens: Tokens,
     vars: &HashMap<String, String>,
     cb: Option<TemplateCallback>,
 ) -> String {
     let mut doc_str: Vec<String> = Vec::new();
 
-    for t in tokens {
+    for t in tokens.tokens {
         match t {
-            Token::Raw(s) => doc_str.push(s),
-            Token::Tag(val) => doc_str.push(render_tag(val, &vars, cb)),
+            Token::Raw { text } => doc_str.push(text),
+            Token::Tag { val } => doc_str.push(render_tag(val, &vars, cb)),
             Token::Eof => {}
         }
     }
 
-    return doc_str.join("");
+    doc_str.join("")
 }
 
 fn render_tag(val: Val, vars: &HashMap<String, String>, cb: Option<TemplateCallback>) -> String {
     match val {
-        Val::Str(s) => s.into(),
-        Val::Var(name) => match vars.get(name.as_str()) {
+        Val::Str { text } => text.into(),
+        Val::Var { name } => match vars.get(name.as_str()) {
             Some(v) => v.to_string(),
             None => "".into(),
         },
@@ -46,14 +46,14 @@ fn render_tag(val: Val, vars: &HashMap<String, String>, cb: Option<TemplateCallb
                 .map(|a| match a {
                     FnArg {
                         name,
-                        value: Val::Str(s),
-                    } => (name.to_string(), s.to_string()),
+                        value: Val::Str { text },
+                    } => (name.to_string(), text.to_string()),
                     FnArg {
                         name,
-                        value: Val::Var(i),
+                        value: Val::Var { name: var_name },
                     } => (
                         name.to_string(),
-                        vars.get(i.as_str()).unwrap_or(&empty).to_string(),
+                        vars.get(var_name.as_str()).unwrap_or(&empty).to_string(),
                     ),
                     FnArg { name, value: val } => {
                         (name.to_string(), render_tag(val.clone(), vars, cb))
@@ -64,13 +64,17 @@ fn render_tag(val: Val, vars: &HashMap<String, String>, cb: Option<TemplateCallb
                 Some(cb) => match cb(name.as_str(), resolved_args.clone()) {
                     Ok(s) => s,
                     Err(e) => {
-                        warn!("Failed to run template callback {}({:?}): {}", name, resolved_args, e);
+                        warn!(
+                            "Failed to run template callback {}({:?}): {}",
+                            name, resolved_args, e
+                        );
                         "".to_string()
                     }
                 },
                 None => "".into(),
             }
         }
+        Val::Null => "".into()
     }
 }
 
@@ -147,7 +151,7 @@ mod tests {
             result.to_string()
         );
     }
-    
+
     #[test]
     fn render_fn_err() {
         let vars = HashMap::new();