Start on plugin ctx API (#64)

src-tauri/yaak_templates/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod parser;
+pub mod renderer;
+
+pub use parser::*;
+pub use renderer::*;
+
+pub fn template_foo() {}

src-tauri/yaak_templates/src/parser.rs

@@ -0,0 +1,494 @@
+#[derive(Clone, PartialEq, Debug)]
+pub struct FnArg {
+    pub name: String,
+    pub value: Val,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Val {
+    Str(String),
+    Var(String),
+    Fn { name: String, args: Vec<FnArg> },
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Token {
+    Raw(String),
+    Tag(Val),
+    Eof,
+}
+
+// Template Syntax
+//
+//  ${[ my_var ]}
+//  ${[ my_fn() ]}
+//  ${[ my_fn(my_var) ]}
+//  ${[ my_fn(my_var, "A String") ]}
+
+// default
+#[derive(Default)]
+pub struct Parser {
+    tokens: Vec<Token>,
+    chars: Vec<char>,
+    pos: usize,
+    curr_text: String,
+}
+
+impl Parser {
+    pub fn new(text: &str) -> Parser {
+        Parser {
+            chars: text.chars().collect(),
+            ..Parser::default()
+        }
+    }
+
+    pub fn parse(&mut self) -> Vec<Token> {
+        let start_pos = self.pos;
+
+        while self.pos < self.chars.len() {
+            if self.match_str("${[") {
+                let start_curr = self.pos;
+                if let Some(t) = self.parse_tag() {
+                    self.push_token(t);
+                } else {
+                    self.pos = start_curr;
+                    self.curr_text += "${[";
+                }
+            } else {
+                let ch = self.next_char();
+                self.curr_text.push(ch);
+            }
+
+            if start_pos == self.pos {
+                panic!("Parser stuck!");
+            }
+        }
+
+        self.push_token(Token::Eof);
+        self.tokens.clone()
+    }
+
+    fn parse_tag(&mut self) -> Option<Token> {
+        // Parse up to first identifier
+        //    ${[ my_var...
+        self.skip_whitespace();
+
+        let val = match self.parse_value() {
+            Some(v) => v,
+            None => return None,
+        };
+
+        // Parse to closing tag
+        //    ${[ my_var(a, b, c) ]}
+        self.skip_whitespace();
+        if !self.match_str("]}") {
+            return None;
+        }
+
+        Some(Token::Tag(val))
+    }
+
+    #[allow(dead_code)]
+    fn debug_pos(&self, x: &str) {
+        println!(
+            r#"Position: {x}: text[{}]='{}' → "{}" → {:?}"#,
+            self.pos,
+            self.chars[self.pos],
+            self.chars.iter().collect::<String>(),
+            self.tokens,
+        );
+    }
+
+    fn parse_value(&mut self) -> Option<Val> {
+        if let Some((name, args)) = self.parse_fn() {
+            Some(Val::Fn { name, args })
+        } else if let Some(v) = self.parse_ident() {
+            Some(Val::Var(v))
+        } else if let Some(v) = self.parse_string() {
+            Some(Val::Str(v))
+        } else {
+            None
+        }
+    }
+
+    fn parse_fn(&mut self) -> Option<(String, Vec<FnArg>)> {
+        let start_pos = self.pos;
+
+        let name = match self.parse_ident() {
+            Some(v) => v,
+            None => {
+                self.pos = start_pos;
+                return None;
+            }
+        };
+
+        let args = match self.parse_fn_args() {
+            Some(args) => args,
+            None => {
+                self.pos = start_pos;
+                return None;
+            }
+        };
+
+        Some((name, args))
+    }
+
+    fn parse_fn_args(&mut self) -> Option<Vec<FnArg>> {
+        if !self.match_str("(") {
+            return None;
+        }
+
+        let start_pos = self.pos;
+
+        let mut args: Vec<FnArg> = Vec::new();
+
+        // Fn closed immediately
+        self.skip_whitespace();
+        if self.match_str(")") {
+            return Some(args)
+        }
+
+        while self.pos < self.chars.len() {
+            self.skip_whitespace();
+
+            let name = self.parse_ident();
+            self.skip_whitespace();
+            self.match_str("=");
+            self.skip_whitespace();
+            let value = self.parse_value();
+            self.skip_whitespace();
+
+            if let (Some(name), Some(value)) = (name.clone(), value.clone()) {
+                args.push(FnArg { name, value });
+            } else {
+                // Didn't find valid thing, so return
+                self.pos = start_pos;
+                return None;
+            }
+
+            if self.match_str(")") {
+                break;
+            }
+
+            self.skip_whitespace();
+
+            // If we don't find a comma, that's bad
+            if !args.is_empty() && !self.match_str(",") {
+                self.pos = start_pos;
+                return None;
+            }
+
+            if start_pos == self.pos {
+                panic!("Parser stuck!");
+            }
+        }
+
+        return Some(args);
+    }
+
+    fn parse_ident(&mut self) -> Option<String> {
+        let start_pos = self.pos;
+
+        let mut text = String::new();
+        while self.pos < self.chars.len() {
+            let ch = self.peek_char();
+            if ch.is_alphanumeric() || ch == '_' {
+                text.push(ch);
+                self.pos += 1;
+            } else {
+                break;
+            }
+
+            if start_pos == self.pos {
+                panic!("Parser stuck!");
+            }
+        }
+
+        if text.is_empty() {
+            self.pos = start_pos;
+            return None;
+        }
+
+        return Some(text);
+    }
+
+    fn parse_string(&mut self) -> Option<String> {
+        let start_pos = self.pos;
+
+        let mut text = String::new();
+        if !self.match_str("\"") {
+            return None;
+        }
+
+        let mut found_closing = false;
+        while self.pos < self.chars.len() {
+            let ch = self.next_char();
+            match ch {
+                '\\' => {
+                    text.push(self.next_char());
+                }
+                '"' => {
+                    found_closing = true;
+                    break;
+                }
+                _ => {
+                    text.push(ch);
+                }
+            }
+
+            if start_pos == self.pos {
+                panic!("Parser stuck!");
+            }
+        }
+
+        if !found_closing {
+            self.pos = start_pos;
+            return None;
+        }
+
+        return Some(text);
+    }
+
+    fn skip_whitespace(&mut self) {
+        while self.pos < self.chars.len() {
+            if self.peek_char().is_whitespace() {
+                self.pos += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn next_char(&mut self) -> char {
+        let ch = self.peek_char();
+
+        self.pos += 1;
+        ch
+    }
+
+    fn peek_char(&self) -> char {
+        let ch = self.chars[self.pos];
+        ch
+    }
+
+    fn push_token(&mut self, token: Token) {
+        // Push any text we've accumulated
+        if !self.curr_text.is_empty() {
+            let text_token = Token::Raw(self.curr_text.clone());
+            self.tokens.push(text_token);
+            self.curr_text.clear();
+        }
+
+        self.tokens.push(token);
+    }
+
+    fn match_str(&mut self, value: &str) -> bool {
+        if self.pos + value.len() > self.chars.len() {
+            return false;
+        }
+
+        let cmp = self.chars[self.pos..self.pos + value.len()]
+            .iter()
+            .collect::<String>();
+
+        if cmp == value {
+            // We have a match, so advance the current index
+            self.pos += value.len();
+            true
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    #[test]
+    fn var_simple() {
+        let mut p = Parser::new("${[ foo ]}");
+        assert_eq!(
+            p.parse(),
+            vec![Token::Tag(Val::Var("foo".into())), Token::Eof]
+        );
+    }
+
+    #[test]
+    fn var_multiple_names_invalid() {
+        let mut p = Parser::new("${[ foo bar ]}");
+        assert_eq!(
+            p.parse(),
+            vec![Token::Raw("${[ foo bar ]}".into()), Token::Eof]
+        );
+    }
+
+    #[test]
+    fn tag_string() {
+        let mut p = Parser::new(r#"${[ "foo \"bar\" baz" ]}"#);
+        assert_eq!(
+            p.parse(),
+            vec![Token::Tag(Val::Str(r#"foo "bar" baz"#.into())), Token::Eof]
+        );
+    }
+
+    #[test]
+    fn var_surrounded() {
+        let mut p = Parser::new("Hello ${[ foo ]}!");
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Raw("Hello ".to_string()),
+                Token::Tag(Val::Var("foo".into())),
+                Token::Raw("!".to_string()),
+                Token::Eof,
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_simple() {
+        let mut p = Parser::new("${[ foo() ]}");
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "foo".into(),
+                    args: Vec::new(),
+                }),
+                Token::Eof
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_ident_arg() {
+        let mut p = Parser::new("${[ foo(a=bar) ]}");
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "foo".into(),
+                    args: vec![FnArg {
+                        name: "a".into(),
+                        value: Val::Var("bar".into())
+                    }],
+                }),
+                Token::Eof
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_ident_args() {
+        let mut p = Parser::new("${[ foo(a=bar,b = baz, c =qux ) ]}");
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "foo".into(),
+                    args: vec![
+                        FnArg {
+                            name: "a".into(),
+                            value: Val::Var("bar".into())
+                        },
+                        FnArg {
+                            name: "b".into(),
+                            value: Val::Var("baz".into())
+                        },
+                        FnArg {
+                            name: "c".into(),
+                            value: Val::Var("qux".into())
+                        },
+                    ],
+                }),
+                Token::Eof
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_mixed_args() {
+        let mut p = Parser::new(r#"${[ foo(aaa=bar,bb="baz \"hi\"", c=qux ) ]}"#);
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "foo".into(),
+                    args: vec![
+                        FnArg {
+                            name: "aaa".into(),
+                            value: Val::Var("bar".into())
+                        },
+                        FnArg {
+                            name: "bb".into(),
+                            value: Val::Str(r#"baz "hi""#.into())
+                        },
+                        FnArg {
+                            name: "c".into(),
+                            value: Val::Var("qux".into())
+                        },
+                    ],
+                }),
+                Token::Eof
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_nested() {
+        let mut p = Parser::new("${[ foo(b=bar()) ]}");
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "foo".into(),
+                    args: vec![FnArg {
+                        name: "b".into(),
+                        value: Val::Fn {
+                            name: "bar".into(),
+                            args: vec![],
+                        }
+                    }],
+                }),
+                Token::Eof
+            ]
+        );
+    }
+
+    #[test]
+    fn fn_nested_args() {
+        let mut p = Parser::new(r#"${[ outer(a=inner(a=foo, b="i"), c="o") ]}"#);
+        assert_eq!(
+            p.parse(),
+            vec![
+                Token::Tag(Val::Fn {
+                    name: "outer".into(),
+                    args: vec![
+                        FnArg {
+                            name: "a".into(),
+                            value: Val::Fn {
+                                name: "inner".into(),
+                                args: vec![
+                                    FnArg {
+                                        name: "a".into(),
+                                        value: Val::Var("foo".into())
+                                    },
+                                    FnArg {
+                                        name: "b".into(),
+                                        value: Val::Str("i".into()),
+                                    },
+                                ],
+                            }
+                        },
+                        FnArg {
+                            name: "c".into(),
+                            value: Val::Str("o".into())
+                        },
+                    ],
+                }),
+                Token::Eof
+            ]
+        );
+    }
+}

src-tauri/yaak_templates/src/renderer.rs

@@ -0,0 +1,165 @@
+use crate::{FnArg, Parser, Token, Val};
+use log::warn;
+use std::collections::HashMap;
+
+type TemplateCallback = fn(name: &str, args: HashMap<String, String>) -> Result<String, String>;
+
+pub fn parse_and_render(
+    template: &str,
+    vars: &HashMap<String, String>,
+    cb: Option<TemplateCallback>,
+) -> String {
+    let mut p = Parser::new(template);
+    let tokens = p.parse();
+    render(tokens, vars, cb)
+}
+
+pub fn render(
+    tokens: Vec<Token>,
+    vars: &HashMap<String, String>,
+    cb: Option<TemplateCallback>,
+) -> String {
+    let mut doc_str: Vec<String> = Vec::new();
+
+    for t in tokens {
+        match t {
+            Token::Raw(s) => doc_str.push(s),
+            Token::Tag(val) => doc_str.push(render_tag(val, &vars, cb)),
+            Token::Eof => {}
+        }
+    }
+
+    return 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()) {
+            Some(v) => v.to_string(),
+            None => "".into(),
+        },
+        Val::Fn { name, args } => {
+            let empty = "".to_string();
+            let resolved_args = args
+                .iter()
+                .map(|a| match a {
+                    FnArg {
+                        name,
+                        value: Val::Str(s),
+                    } => (name.to_string(), s.to_string()),
+                    FnArg {
+                        name,
+                        value: Val::Var(i),
+                    } => (
+                        name.to_string(),
+                        vars.get(i.as_str()).unwrap_or(&empty).to_string(),
+                    ),
+                    FnArg { name, value: val } => {
+                        (name.to_string(), render_tag(val.clone(), vars, cb))
+                    }
+                })
+                .collect::<HashMap<String, String>>();
+            match cb {
+                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);
+                        "".to_string()
+                    }
+                },
+                None => "".into(),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::*;
+
+    #[test]
+    fn render_empty() {
+        let template = "";
+        let vars = HashMap::new();
+        let result = "";
+        assert_eq!(parse_and_render(template, &vars, None), result.to_string());
+    }
+
+    #[test]
+    fn render_text_only() {
+        let template = "Hello World!";
+        let vars = HashMap::new();
+        let result = "Hello World!";
+        assert_eq!(parse_and_render(template, &vars, None), result.to_string());
+    }
+
+    #[test]
+    fn render_simple() {
+        let template = "${[ foo ]}";
+        let vars = HashMap::from([("foo".to_string(), "bar".to_string())]);
+        let result = "bar";
+        assert_eq!(parse_and_render(template, &vars, None), result.to_string());
+    }
+
+    #[test]
+    fn render_surrounded() {
+        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, None), result.to_string());
+    }
+
+    #[test]
+    fn render_valid_fn() {
+        let vars = HashMap::new();
+        let template = r#"${[ say_hello(a="John", b="Kate") ]}"#;
+        let result = r#"say_hello: 2, Some("John") Some("Kate")"#;
+
+        fn cb(name: &str, args: HashMap<String, String>) -> Result<String, String> {
+            Ok(format!(
+                "{name}: {}, {:?} {:?}",
+                args.len(),
+                args.get("a"),
+                args.get("b")
+            ))
+        }
+        assert_eq!(parse_and_render(template, &vars, Some(cb)), result);
+    }
+
+    #[test]
+    fn render_nested_fn() {
+        let vars = HashMap::new();
+        let template = r#"${[ upper(foo=secret()) ]}"#;
+        let result = r#"ABC"#;
+        fn cb(name: &str, args: HashMap<String, String>) -> Result<String, String> {
+            Ok(match name {
+                "secret" => "abc".to_string(),
+                "upper" => args["foo"].to_string().to_uppercase(),
+                _ => "".to_string(),
+            })
+        }
+
+        assert_eq!(
+            parse_and_render(template, &vars, Some(cb)),
+            result.to_string()
+        );
+    }
+    
+    #[test]
+    fn render_fn_err() {
+        let vars = HashMap::new();
+        let template = r#"${[ error() ]}"#;
+        let result = r#""#;
+        fn cb(_name: &str, _args: HashMap<String, String>) -> Result<String, String> {
+            Err("Failed to do it!".to_string())
+        }
+
+        assert_eq!(
+            parse_and_render(template, &vars, Some(cb)),
+            result.to_string()
+        );
+    }
+}