toolcraft 0.1.3

A modular Rust toolkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#[derive(Debug)]
pub enum JinjaNode {
    Variable {
        path: Vec<String>,
    },
    ForLoop {
        loop_var: String,
        iterable: String,
        body: Vec<JinjaNode>,
    },
}

pub(crate) fn parse_jinja2_ast(tags: &[String]) -> Vec<JinjaNode> {
    let mut ast = Vec::new();
    let mut stack: Vec<JinjaNode> = Vec::new();

    for tag in tags {
        let tag = tag.trim();

        if tag.starts_with("{{") && tag.ends_with("}}") {
            let content = tag.trim_start_matches("{{").trim_end_matches("}}").trim();
            let path = content.split('.').map(|s| s.trim().to_string()).collect();
            let node = JinjaNode::Variable { path };

            if let Some(JinjaNode::ForLoop { body, .. }) = stack.last_mut() {
                body.push(node);
            } else {
                ast.push(node);
            }
        } else if tag.starts_with("{%") && tag.contains("for") && tag.contains("in") {
            println!("Found for loop tag: {}", tag);
            let content = tag.trim_start_matches("{%").trim_end_matches("%}").trim();
            let parts: Vec<&str> = content.split_whitespace().collect();
            if let Some(for_index) = parts.iter().position(|&s| s == "for") {
                if for_index + 2 < parts.len() && parts[for_index + 2] == "in" {
                    let loop_var = parts
                        .get(for_index + 1)
                        .map(|s| s.to_string())
                        .unwrap_or_default();
                    let iterable = parts.get(for_index + 3).to_string_or_empty();
                    stack.push(JinjaNode::ForLoop {
                        loop_var,
                        iterable,
                        body: Vec::new(),
                    });
                }
            }
        } else if tag.contains("endfor") {
            if let Some(for_node) = stack.pop() {
                if let Some(JinjaNode::ForLoop { body, .. }) = stack.last_mut() {
                    body.push(for_node);
                } else {
                    ast.push(for_node);
                }
            }
        }
    }

    ast
}

// Helper trait for safe string extraction
trait StringVecExt {
    fn to_string_or_empty(&self) -> String;
}
impl StringVecExt for Option<&&str> {
    fn to_string_or_empty(&self) -> String {
        self.map(|s| s.to_string()).unwrap_or_default()
    }
}