New sidebar and folder view (#263)

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

@@ -0,0 +1,166 @@
+pub fn escape_template(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let chars: Vec<char> = text.chars().collect();
+    let mut i = 0;
+
+    while i < chars.len() {
+        // Check if we're at "${["
+        if i + 2 < chars.len() && chars[i] == '$' && chars[i + 1] == '{' && chars[i + 2] == '[' {
+            // Count preceding backslashes
+            let mut backslash_count = 0;
+            let mut j = i;
+            while j > 0 && chars[j - 1] == '\\' {
+                backslash_count += 1;
+                j -= 1;
+            }
+
+            // If odd number of backslashes, the $ is escaped
+            // If even number (including 0), the $ is not escaped
+            let already_escaped = backslash_count % 2 == 1;
+
+            if already_escaped {
+                // Already escaped, just add the current character
+                result.push(chars[i]);
+            } else {
+                // Not escaped, add backslash before $
+                result.push('\\');
+                result.push(chars[i]);
+            }
+        } else {
+            result.push(chars[i]);
+        }
+        i += 1;
+    }
+    result
+}
+
+pub fn unescape_template(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let chars: Vec<char> = text.chars().collect();
+    let mut i = 0;
+
+    while i < chars.len() {
+        // Check if we're at "\${["
+        if i + 3 < chars.len()
+            && chars[i] == '\\'
+            && chars[i + 1] == '$'
+            && chars[i + 2] == '{'
+            && chars[i + 3] == '['
+        {
+            // Count preceding backslashes (before the current backslash)
+            let mut backslash_count = 0;
+            let mut j = i;
+            while j > 0 && chars[j - 1] == '\\' {
+                backslash_count += 1;
+                j -= 1;
+            }
+
+            // If even number of preceding backslashes, this backslash escapes the $
+            // If odd number, this backslash is itself escaped
+            let escapes_dollar = backslash_count % 2 == 0;
+
+            if escapes_dollar {
+                // Skip the backslash, just add the $
+                result.push(chars[i + 1]);
+                i += 1; // Skip the backslash
+            } else {
+                // This backslash is escaped itself, keep it
+                result.push(chars[i]);
+            }
+        } else {
+            result.push(chars[i]);
+        }
+        i += 1;
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::escape::{escape_template, unescape_template};
+
+    #[test]
+    fn test_escape_simple() {
+        let input = r#"${[foo]}"#;
+        let expected = r#"\${[foo]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_already_escaped() {
+        let input = r#"\${[bar]}"#;
+        let expected = r#"\${[bar]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_double_backslash() {
+        let input = r#"\\${[bar]}"#;
+        let expected = r#"\\\${[bar]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_escape_with_surrounding_text() {
+        let input = r#"text ${[var]} more"#;
+        let expected = r#"text \${[var]} more"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_preserve_already_escaped() {
+        let input = r#"already \${[escaped]}"#;
+        let expected = r#"already \${[escaped]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_multiple_occurrences() {
+        let input = r#"${[one]} and ${[two]}"#;
+        let expected = r#"\${[one]} and \${[two]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_mixed_escaped_and_unescaped() {
+        let input = r#"mixed \${[esc]} and ${[unesc]}"#;
+        let expected = r#"mixed \${[esc]} and \${[unesc]}"#;
+        assert_eq!(escape_template(input), expected);
+    }
+
+    #[test]
+    fn test_unescape_simple() {
+        let input = r#"\${[foo]}"#;
+        let expected = r#"${[foo]}"#;
+        assert_eq!(unescape_template(input), expected);
+    }
+
+    #[test]
+    fn test_unescape_with_text() {
+        let input = r#"text \${[var]} more"#;
+        let expected = r#"text ${[var]} more"#;
+        assert_eq!(unescape_template(input), expected);
+    }
+
+    #[test]
+    fn test_unescape_multiple() {
+        let input = r#"\${[one]} and \${[two]}"#;
+        let expected = r#"${[one]} and ${[two]}"#;
+        assert_eq!(unescape_template(input), expected);
+    }
+
+    #[test]
+    fn test_unescape_double_backslash() {
+        let input = r#"\\\${[bar]}"#;
+        let expected = r#"\\${[bar]}"#;
+        assert_eq!(unescape_template(input), expected);
+    }
+
+    #[test]
+    fn test_unescape_plain_text() {
+        let input = r#"${[foo]}"#;
+        let expected = r#"${[foo]}"#;
+        assert_eq!(unescape_template(input), expected);
+    }
+}