Make rendering return Result, and handle infinite recursion

src-tauri/yaak-templates/src/error.rs

@@ -0,0 +1,22 @@
+use serde::{Serialize, Serializer};
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum Error {
+    #[error("Render Error: {0}")]
+    RenderError(String),
+
+    #[error("Render Error: Max recursion depth exceeded")]
+    RenderStackExceededError,
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

src-tauri/yaak-templates/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod format;
 pub mod parser;
 pub mod renderer;
+pub mod error;
 
 pub use parser::*;
 pub use renderer::*;

src-tauri/yaak-templates/src/renderer.rs

@@ -1,82 +1,103 @@
+use crate::error::Error::RenderStackExceededError;
+use crate::error::Result;
 use crate::{FnArg, Parser, Token, Tokens, Val};
 use log::warn;
 use serde_json::json;
 use std::collections::HashMap;
 use std::future::Future;
 
+const MAX_DEPTH: usize = 50;
+
 pub trait TemplateCallback {
     fn run(
         &self,
         fn_name: &str,
         args: HashMap<String, String>,
-    ) -> impl Future<Output = Result<String, String>> + Send;
+    ) -> impl Future<Output = Result<String>> + Send;
 }
 
 pub async fn render_json_value_raw<T: TemplateCallback>(
     v: serde_json::Value,
     vars: &HashMap<String, String>,
     cb: &T,
-) -> serde_json::Value {
-    match v {
-        serde_json::Value::String(s) => json!(parse_and_render(&s, vars, cb).await),
+) -> Result<serde_json::Value> {
+    let v = match v {
+        serde_json::Value::String(s) => json!(parse_and_render(&s, vars, cb).await?),
         serde_json::Value::Array(a) => {
             let mut new_a = Vec::new();
             for v in a {
-                new_a.push(Box::pin(render_json_value_raw(v, vars, cb)).await)
+                new_a.push(Box::pin(render_json_value_raw(v, vars, cb)).await?)
             }
             json!(new_a)
         }
         serde_json::Value::Object(o) => {
             let mut new_o = serde_json::Map::new();
             for (k, v) in o {
-                let key = Box::pin(parse_and_render(&k, vars, cb)).await;
-                let value = Box::pin(render_json_value_raw(v, vars, cb)).await;
+                let key = Box::pin(parse_and_render(&k, vars, cb)).await?;
+                let value = Box::pin(render_json_value_raw(v, vars, cb)).await?;
                 new_o.insert(key, value);
             }
             json!(new_o)
         }
         v => v,
-    }
+    };
+    Ok(v)
+}
+
+async fn parse_and_render_with_depth<T: TemplateCallback>(
+    template: &str,
+    vars: &HashMap<String, String>,
+    cb: &T,
+    depth: usize,
+) -> Result<String> {
+    let mut p = Parser::new(template);
+    let tokens = p.parse();
+    render(tokens, vars, cb, depth + 1).await
 }
 
 pub async fn parse_and_render<T: TemplateCallback>(
     template: &str,
     vars: &HashMap<String, String>,
     cb: &T,
-) -> String {
-    let mut p = Parser::new(template);
-    let tokens = p.parse();
-    render(tokens, vars, cb).await
+) -> Result<String> {
+    parse_and_render_with_depth(template, vars, cb, 1).await
 }
 
 pub async fn render<T: TemplateCallback>(
     tokens: Tokens,
     vars: &HashMap<String, String>,
     cb: &T,
-) -> String {
+    mut depth: usize,
+) -> Result<String> {
+    depth += 1;
+    if depth > MAX_DEPTH {
+        return Err(RenderStackExceededError);
+    }
+
     let mut doc_str: Vec<String> = Vec::new();
 
     for t in tokens.tokens {
         match t {
             Token::Raw { text } => doc_str.push(text),
-            Token::Tag { val } => doc_str.push(render_tag(val, &vars, cb).await),
+            Token::Tag { val } => doc_str.push(render_tag(val, &vars, cb, depth).await?),
             Token::Eof => {}
         }
     }
 
-    doc_str.join("")
+    Ok(doc_str.join(""))
 }
 
 async fn render_tag<T: TemplateCallback>(
     val: Val,
     vars: &HashMap<String, String>,
     cb: &T,
-) -> String {
-    match val {
+    depth: usize,
+) -> Result<String> {
+    let v = match val {
         Val::Str { text } => text.into(),
         Val::Var { name } => match vars.get(name.as_str()) {
             Some(v) => {
-                let r = Box::pin(parse_and_render(v, vars, cb)).await;
+                let r = Box::pin(parse_and_render_with_depth(v, vars, cb, depth)).await?;
                 r.to_string()
             }
             None => "".into(),
@@ -99,7 +120,7 @@ async fn render_tag<T: TemplateCallback>(
                         vars.get(var_name.as_str()).unwrap_or(&empty).to_string(),
                     ),
                     FnArg { name, value: val } => {
-                        let r = Box::pin(render_tag(val.clone(), vars, cb)).await;
+                        let r = Box::pin(render_tag(val.clone(), vars, cb, depth)).await?;
                         (name.to_string(), r)
                     }
                 };
@@ -114,11 +135,15 @@ async fn render_tag<T: TemplateCallback>(
             }
         }
         Val::Null => "".into(),
-    }
+    };
+
+    Ok(v)
 }
 
 #[cfg(test)]
 mod parse_and_render_tests {
+    use crate::error::Error::{RenderError, RenderStackExceededError};
+    use crate::error::Result;
     use crate::renderer::TemplateCallback;
     use crate::*;
     use std::collections::HashMap;
@@ -126,44 +151,43 @@ mod parse_and_render_tests {
     struct EmptyCB {}
 
     impl TemplateCallback for EmptyCB {
-        async fn run(
-            &self,
-            _fn_name: &str,
-            _args: HashMap<String, String>,
-        ) -> Result<String, String> {
+        async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
             todo!()
         }
     }
 
     #[tokio::test]
-    async fn render_empty() {
+    async fn render_empty() -> Result<()> {
         let empty_cb = EmptyCB {};
         let template = "";
         let vars = HashMap::new();
         let result = "";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_text_only() {
+    async fn render_text_only() -> Result<()> {
         let empty_cb = EmptyCB {};
         let template = "Hello World!";
         let vars = HashMap::new();
         let result = "Hello World!";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_simple() {
+    async fn render_simple() -> Result<()> {
         let empty_cb = EmptyCB {};
         let template = "${[ foo ]}";
         let vars = HashMap::from([("foo".to_string(), "bar".to_string())]);
         let result = "bar";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_recursive_var() {
+    async fn render_recursive_var() -> Result<()> {
         let empty_cb = EmptyCB {};
         let template = "${[ foo ]}";
         let mut vars = HashMap::new();
@@ -172,49 +196,58 @@ mod parse_and_render_tests {
         vars.insert("baz".to_string(), "baz".to_string());
 
         let result = "foo: bar: baz";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_surrounded() {
+    async fn render_self_referencing_var() -> Result<()> {
+        let empty_cb = EmptyCB {};
+        let template = "${[ foo ]}";
+        let mut vars = HashMap::new();
+        vars.insert("foo".to_string(), "${[ foo ]}".to_string());
+
+        assert_eq!(
+            parse_and_render(template, &vars, &empty_cb).await,
+            Err(RenderStackExceededError)
+        );
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn render_surrounded() -> Result<()> {
         let empty_cb = EmptyCB {};
         let template = "hello ${[ word ]} world!";
         let vars = HashMap::from([("word".to_string(), "cruel".to_string())]);
         let result = "hello cruel world!";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_valid_fn() {
+    async fn render_valid_fn() -> Result<()> {
         let vars = HashMap::new();
         let template = r#"${[ say_hello(a='John', b='Kate') ]}"#;
         let result = r#"say_hello: 2, Some("John") Some("Kate")"#;
 
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(
-                &self,
-                fn_name: &str,
-                args: HashMap<String, String>,
-            ) -> Result<String, String> {
+            async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String> {
                 Ok(format!("{fn_name}: {}, {:?} {:?}", args.len(), args.get("a"), args.get("b")))
             }
         }
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await, result);
+        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result);
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_nested_fn() {
+    async fn render_nested_fn() -> Result<()> {
         let vars = HashMap::new();
         let template = r#"${[ upper(foo=secret()) ]}"#;
         let result = r#"ABC"#;
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(
-                &self,
-                fn_name: &str,
-                args: HashMap<String, String>,
-            ) -> Result<String, String> {
+            async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String> {
                 Ok(match fn_name {
                     "secret" => "abc".to_string(),
                     "upper" => args["foo"].to_string().to_uppercase(),
@@ -223,80 +256,79 @@ mod parse_and_render_tests {
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_fn_err() {
+    async fn render_fn_err() -> Result<()> {
         let vars = HashMap::new();
         let template = r#"${[ error() ]}"#;
         let result = r#""#;
 
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(
-                &self,
-                _fn_name: &str,
-                _args: HashMap<String, String>,
-            ) -> Result<String, String> {
-                Err("Failed to do it!".to_string())
+            async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
+                Err(RenderError("Failed to do it!".to_string()))
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        Ok(())
     }
 }
 
 #[cfg(test)]
 mod render_json_value_raw_tests {
+    use crate::error::Result;
+    use crate::{render_json_value_raw, TemplateCallback};
     use serde_json::json;
     use std::collections::HashMap;
-    use crate::{render_json_value_raw, TemplateCallback};
 
     struct EmptyCB {}
 
     impl TemplateCallback for EmptyCB {
-        async fn run(
-            &self,
-            _fn_name: &str,
-            _args: HashMap<String, String>,
-        ) -> Result<String, String> {
+        async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
             todo!()
         }
     }
 
     #[tokio::test]
-    async fn render_json_value_string() {
+    async fn render_json_value_string() -> Result<()> {
         let v = json!("${[a]}");
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await;
-        assert_eq!(result, json!("aaa"))
+        assert_eq!(render_json_value_raw(v, &vars, &EmptyCB {}).await?, json!("aaa"));
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_json_value_array() {
+    async fn render_json_value_array() -> Result<()> {
         let v = json!(["${[a]}", "${[a]}"]);
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await;
-        assert_eq!(result, json!(["aaa", "aaa"]))
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
+        assert_eq!(result, json!(["aaa", "aaa"]));
+
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_json_value_object() {
+    async fn render_json_value_object() -> Result<()> {
         let v = json!({"${[a]}": "${[a]}"});
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await;
-        assert_eq!(result, json!({"aaa": "aaa"}))
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
+        assert_eq!(result, json!({"aaa": "aaa"}));
+
+        Ok(())
     }
 
     #[tokio::test]
-    async fn render_json_value_nested() {
+    async fn render_json_value_nested() -> Result<()> {
         let v = json!([
             123,
             {"${[a]}": "${[a]}"},
@@ -308,7 +340,7 @@ mod render_json_value_raw_tests {
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await;
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
         assert_eq!(
             result,
             json!([
@@ -319,6 +351,8 @@ mod render_json_value_raw_tests {
                 false,
                 {"x": ["aaa"]}
             ])
-        )
+        );
+
+        Ok(())
     }
 }