initial

.gitignore

@@ -0,0 +1,51 @@
+# Zig build artifacts
+zig-out/
+zig-cache/
+.zig-cache/
+
+# Generated PDFs (test outputs)
+*.pdf
+
+# Test data files
+*.json
+!build.json
+*.pdm
+*.bin
+*.png
+*.sh
+*.ndjson
+
+# Build binaries
+*.o
+*.so
+*.dylib
+*.dll
+*.exe
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+.claude/
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+
+# Test directories
+data/
+output/
+services/
+template_configs/
+
+# Backup files
+*.bak
+*.backup
+
+# OS specific
+Thumbs.db
+

build.zig

@@ -0,0 +1,156 @@
+const std = @import("std");
+
+// Although this function looks imperative, it does not perform the build
+// directly and instead it mutates the build graph (`b`) that will be then
+// executed by an external runner. The functions in `std.Build` implement a DSL
+// for defining build steps and express dependencies between them, allowing the
+// build runner to parallelize the build automatically (and the cache system to
+// know when a step doesn't need to be re-run).
+pub fn build(b: *std.Build) void {
+    // Standard target options allow the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+    // It's also possible to define more custom flags to toggle optional features
+    // of this build script using `b.option()`. All defined flags (including
+    // target and optimize options) will be listed when running `zig build --help`
+    // in this directory.
+
+    // This creates a module, which represents a collection of source files alongside
+    // some compilation options, such as optimization mode and linked system libraries.
+    // Zig modules are the preferred way of making Zig code available to consumers.
+    // addModule defines a module that we intend to make available for importing
+    // to our consumers. We must give it a name because a Zig package can expose
+    // multiple modules and consumers will need to be able to specify which
+    // module they want to access.
+    const mod = b.addModule("zdt_prov", .{
+        // The root source file is the "entry point" of this module. Users of
+        // this module will only be able to access public declarations contained
+        // in this file, which means that if you have declarations that you
+        // intend to expose to consumers that were defined in other files part
+        // of this module, you will have to make sure to re-export them from
+        // the root file.
+        .root_source_file = b.path("src/root.zig"),
+        // Later on we'll use this module as the root module of a test executable
+        // which requires us to specify a target.
+        .target = target,
+    });
+
+    // Here we define an executable. An executable needs to have a root module
+    // which needs to expose a `main` function. While we could add a main function
+    // to the module defined above, it's sometimes preferable to split business
+    // logic and the CLI into two separate modules.
+    //
+    // If your goal is to create a Zig library for others to use, consider if
+    // it might benefit from also exposing a CLI tool. A parser library for a
+    // data serialization format could also bundle a CLI syntax checker, for example.
+    //
+    // If instead your goal is to create an executable, consider if users might
+    // be interested in also being able to embed the core functionality of your
+    // program in their own executable in order to avoid the overhead involved in
+    // subprocessing your CLI tool.
+    //
+    // If neither case applies to you, feel free to delete the declaration you
+    // don't need and to put everything under a single module.
+    const exe = b.addExecutable(.{
+        .name = "zdt_prov",
+        .root_module = b.createModule(.{
+            // b.createModule defines a new module just like b.addModule but,
+            // unlike b.addModule, it does not expose the module to consumers of
+            // this package, which is why in this case we don't have to give it a name.
+            .root_source_file = b.path("src/main.zig"),
+            // Target and optimization levels must be explicitly wired in when
+            // defining an executable or library (in the root module), and you
+            // can also hardcode a specific target for an executable or library
+            // definition if desireable (e.g. firmware for embedded devices).
+            .target = target,
+            .optimize = optimize,
+            // List of modules available for import in source files part of the
+            // root module.
+            .imports = &.{
+                // Here "zdt_prov" is the name you will use in your source code to
+                // import this module (e.g. `@import("zdt_prov")`). The name is
+                // repeated because you are allowed to rename your imports, which
+                // can be extremely useful in case of collisions (which can happen
+                // importing modules from different packages).
+                .{ .name = "zdt_prov", .module = mod },
+            },
+        }),
+    });
+
+    // This declares intent for the executable to be installed into the
+    // install prefix when running `zig build` (i.e. when executing the default
+    // step). By default the install prefix is `zig-out/` but can be overridden
+    // by passing `--prefix` or `-p`.
+    b.installArtifact(exe);
+
+    // This creates a top level step. Top level steps have a name and can be
+    // invoked by name when running `zig build` (e.g. `zig build run`).
+    // This will evaluate the `run` step rather than the default step.
+    // For a top level step to actually do something, it must depend on other
+    // steps (e.g. a Run step, as we will see in a moment).
+    const run_step = b.step("run", "Run the app");
+
+    // This creates a RunArtifact step in the build graph. A RunArtifact step
+    // invokes an executable compiled by Zig. Steps will only be executed by the
+    // runner if invoked directly by the user (in the case of top level steps)
+    // or if another step depends on it, so it's up to you to define when and
+    // how this Run step will be executed. In our case we want to run it when
+    // the user runs `zig build run`, so we create a dependency link.
+    const run_cmd = b.addRunArtifact(exe);
+    run_step.dependOn(&run_cmd.step);
+
+    // By making the run step depend on the default step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // Creates an executable that will run `test` blocks from the provided module.
+    // Here `mod` needs to define a target, which is why earlier we made sure to
+    // set the releative field.
+    const mod_tests = b.addTest(.{
+        .root_module = mod,
+    });
+
+    // A run step that will run the test executable.
+    const run_mod_tests = b.addRunArtifact(mod_tests);
+
+    // Creates an executable that will run `test` blocks from the executable's
+    // root module. Note that test executables only test one module at a time,
+    // hence why we have to create two separate ones.
+    const exe_tests = b.addTest(.{
+        .root_module = exe.root_module,
+    });
+
+    // A run step that will run the second test executable.
+    const run_exe_tests = b.addRunArtifact(exe_tests);
+
+    // A top level step for running all tests. dependOn can be called multiple
+    // times and since the two run steps do not depend on one another, this will
+    // make the two of them run in parallel.
+    const test_step = b.step("test", "Run tests");
+    test_step.dependOn(&run_mod_tests.step);
+    test_step.dependOn(&run_exe_tests.step);
+
+    // Just like flags, top level steps are also listed in the `--help` menu.
+    //
+    // The Zig build system is entirely implemented in userland, which means
+    // that it cannot hook into private compiler APIs. All compilation work
+    // orchestrated by the build system will result in other Zig compiler
+    // subcommands being invoked with the right flags defined. You can observe
+    // these invocations when one fails (or you pass a flag to increase
+    // verbosity) to validate assumptions and diagnose problems.
+    //
+    // Lastly, the Zig build system is relatively simple and self-contained,
+    // and reading its source code will allow you to master it.
+}

build.zig.zon

@@ -0,0 +1,81 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .zdt_prov,
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+    // Together with name, this represents a globally unique package
+    // identifier. This field is generated by the Zig toolchain when the
+    // package is first created, and then *never changes*. This allows
+    // unambiguous detection of one package being an updated version of
+    // another.
+    //
+    // When forking a Zig project, this id should be regenerated (delete the
+    // field and run `zig build`) if the upstream project is still maintained.
+    // Otherwise, the fork is *hostile*, attempting to take control over the
+    // original project's identity. Thus it is recommended to leave the comment
+    // on the following line intact, so that it shows up in code reviews that
+    // modify the field.
+    .fingerprint = 0x6af292c94c0c7302, // Changing this has security and trust implications.
+    // Tracks the earliest Zig version that the package considers to be a
+    // supported use case.
+    .minimum_zig_version = "0.15.2",
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
+        //    // which will prevent zig from using it.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+        //
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

src/main.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const zdt_prov = @import("zdt_prov");
+
+pub fn main() !void {
+    // Prints to stderr, ignoring potential errors.
+    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
+    try zdt_prov.bufferedPrint();
+}
+
+test "simple test" {
+    const gpa = std.testing.allocator;
+    var list: std.ArrayList(i32) = .empty;
+    defer list.deinit(gpa); // Try commenting this out and see if zig detects the memory leak!
+    try list.append(gpa, 42);
+    try std.testing.expectEqual(@as(i32, 42), list.pop());
+}
+
+test "fuzz example" {
+    const Context = struct {
+        fn testOne(context: @This(), input: []const u8) anyerror!void {
+            _ = context;
+            // Try passing `--fuzz` to `zig build test` and see if it manages to fail this test case!
+            try std.testing.expect(!std.mem.eql(u8, "canyoufindme", input));
+        }
+    };
+    try std.testing.fuzz(Context{}, Context.testOne, .{});
+}

src/parser.zig

@@ -0,0 +1,411 @@
+const std = @import("std");
+
+pub const NodeType = enum {
+    text,
+    variable,
+    tag,
+    if_block,
+    for_block,
+};
+
+pub const TextNode = struct {
+    content: []const u8,
+};
+
+pub const VariableNode = struct {
+    content: []const u8,
+};
+
+pub const TagNode = struct {
+    name: []const u8,
+    args: []const u8,
+    raw: []const u8,
+};
+
+pub const IfNode = struct {
+    condition: []const u8, // dupe esse sim
+    true_body: []Node,
+    false_body: []Node,
+    raw_open: []const u8, // slice original, NÃO free
+    raw_close: []const u8, // slice original, NÃO free
+};
+
+pub const ForNode = struct {
+    loop_var: []const u8,
+    iterable: []const u8,
+    body: []Node,
+    empty_body: []Node,
+    raw_open: []const u8,
+    raw_close: []const u8,
+};
+
+pub const Node = struct {
+    type: NodeType,
+    text: ?TextNode = null,
+    variable: ?VariableNode = null,
+    tag: ?TagNode = null,
+    @"if": ?IfNode = null,
+    @"for": ?ForNode = null, // <--- novo
+
+    pub fn deinit(self: Node, allocator: std.mem.Allocator) void {
+        switch (self.type) {
+            .text => if (self.text) |t| allocator.free(t.content),
+            .variable => if (self.variable) |v| allocator.free(v.content),
+            .tag => if (self.tag) |t| {
+                allocator.free(t.name);
+                allocator.free(t.args);
+            },
+            .if_block => if (self.@"if") |ib| {
+                allocator.free(ib.condition);
+                // NÃO free ib.raw_open
+                // NÃO free ib.raw_close
+                for (ib.true_body) |n| n.deinit(allocator);
+                allocator.free(ib.true_body);
+                for (ib.false_body) |n| n.deinit(allocator);
+                allocator.free(ib.false_body);
+            },
+            .for_block => if (self.@"for") |fb| {
+                allocator.free(fb.loop_var);
+                allocator.free(fb.iterable);
+                for (fb.body) |n| n.deinit(allocator);
+                allocator.free(fb.body);
+                for (fb.empty_body) |n| n.deinit(allocator);
+                allocator.free(fb.empty_body);
+                // raw_open e raw_close são slices originais — não free
+            },
+        }
+    }
+};
+
+pub const Parser = struct {
+    template: []const u8,
+    pos: usize = 0,
+
+    pub fn init(template: []const u8) Parser {
+        return .{ .template = template };
+    }
+
+    fn advance(self: *Parser, n: usize) void {
+        self.pos += n;
+        if (self.pos > self.template.len) self.pos = self.template.len;
+    }
+
+    fn peek(self: Parser, comptime n: usize) ?[]const u8 {
+        if (self.pos + n > self.template.len) return null;
+        return self.template[self.pos .. self.pos + n];
+    }
+
+    fn skipWhitespace(self: *Parser) void {
+        while (self.pos < self.template.len and std.ascii.isWhitespace(self.template[self.pos])) : (self.advance(1)) {}
+    }
+
+    fn parseText(self: *Parser, allocator: std.mem.Allocator) !?Node {
+        const start = self.pos;
+
+        while (self.pos < self.template.len) {
+            if (self.peek(2)) |p| {
+                if (std.mem.eql(u8, p, "{{") or std.mem.eql(u8, p, "{%")) {
+                    break;
+                }
+            }
+            self.advance(1);
+        }
+
+        if (self.pos == start) return null;
+
+        const content = try allocator.dupe(u8, self.template[start..self.pos]);
+        return Node{
+            .type = .text,
+            .text = .{ .content = content },
+        };
+    }
+
+    fn parseVariable(self: *Parser, allocator: std.mem.Allocator) !?Node {
+        if (self.peek(2)) |p| {
+            if (!std.mem.eql(u8, p, "{{")) return null;
+        } else return null;
+
+        self.advance(2);
+        self.skipWhitespace();
+
+        const content_start = self.pos;
+        while (self.pos < self.template.len) : (self.advance(1)) {
+            if (self.peek(2)) |p| {
+                if (std.mem.eql(u8, p, "}}")) break;
+            }
+        }
+
+        if (self.pos + 2 > self.template.len or !std.mem.eql(u8, self.template[self.pos .. self.pos + 2], "}}")) {
+            return error.UnclosedVariable;
+        }
+
+        const raw_content = self.template[content_start..self.pos];
+        const content = std.mem.trim(u8, raw_content, " \t\r\n");
+
+        const duped = try allocator.dupe(u8, content);
+        self.advance(2);
+
+        return Node{
+            .type = .variable,
+            .variable = .{ .content = duped },
+        };
+    }
+
+    fn parseTag(self: *Parser, allocator: std.mem.Allocator) !?Node {
+        if (self.peek(2)) |p| {
+            if (!std.mem.eql(u8, p, "{%")) return null;
+        } else return null;
+
+        const raw_start = self.pos;
+        self.advance(2);
+        self.skipWhitespace();
+
+        const content_start = self.pos;
+        while (self.pos < self.template.len) : (self.advance(1)) {
+            if (self.peek(2)) |p| {
+                if (std.mem.eql(u8, p, "%}")) break;
+            }
+        }
+
+        if (self.pos + 2 > self.template.len or !std.mem.eql(u8, self.template[self.pos .. self.pos + 2], "%}")) {
+            return error.UnclosedTag;
+        }
+
+        const raw_slice = self.template[raw_start .. self.pos + 2];
+        const inner = std.mem.trim(u8, self.template[content_start..self.pos], " \t\r\n");
+
+        const space_idx = std.mem.indexOfScalar(u8, inner, ' ') orelse inner.len;
+        const name_raw = inner[0..space_idx];
+        const args_raw = if (space_idx < inner.len) std.mem.trim(u8, inner[space_idx + 1 ..], " \t\r\n") else "";
+
+        const name = try allocator.dupe(u8, name_raw);
+        const args = try allocator.dupe(u8, args_raw);
+
+        self.advance(2);
+
+        return Node{
+            .type = .tag,
+            .tag = .{
+                .name = name,
+                .args = args,
+                .raw = raw_slice, // slice original, sem dupe
+            },
+        };
+    }
+
+    fn parseIfBlock(self: *Parser, allocator: std.mem.Allocator, condition: []const u8, raw_open: []const u8) !Node {
+        var true_body = std.ArrayList(Node){};
+        defer true_body.deinit(allocator);
+        var false_body = std.ArrayList(Node){};
+        defer false_body.deinit(allocator);
+
+        var current_body = &true_body;
+        var depth: usize = 1;
+
+        while (self.pos < self.template.len and depth > 0) {
+            if (try self.parseText(allocator)) |node| {
+                try current_body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseVariable(allocator)) |node| {
+                try current_body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseTag(allocator)) |tag_node| {
+                const tag_name = tag_node.tag.?.name;
+
+                if (std.mem.eql(u8, tag_name, "if")) {
+                    depth += 1;
+                    try current_body.append(allocator, tag_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "endif")) {
+                    depth -= 1;
+                    const raw_close = tag_node.tag.?.raw;
+
+                    // Libera name e args da tag endif
+                    allocator.free(tag_node.tag.?.name);
+                    allocator.free(tag_node.tag.?.args);
+
+                    if (depth == 0) {
+                        return Node{
+                            .type = .if_block,
+                            .@"if" = .{
+                                .condition = condition,
+                                .true_body = try true_body.toOwnedSlice(allocator),
+                                .false_body = try false_body.toOwnedSlice(allocator),
+                                .raw_open = raw_open,
+                                .raw_close = raw_close,
+                            },
+                        };
+                    }
+
+                    // Se depth > 0, é endif aninhado — adiciona como tag normal
+                    try current_body.append(allocator, tag_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "else") and depth == 1) {
+                    current_body = &false_body;
+                    allocator.free(tag_node.tag.?.name);
+                    allocator.free(tag_node.tag.?.args);
+                    continue;
+                }
+
+                // Qualquer outra tag
+                try current_body.append(allocator, tag_node);
+            } else {
+                self.advance(1);
+            }
+        }
+
+        return error.UnclosedBlock;
+    }
+
+    fn parseForBlock(self: *Parser, allocator: std.mem.Allocator, loop_var: []const u8, iterable: []const u8, raw_open: []const u8) !Node {
+        var body = std.ArrayList(Node){};
+        defer body.deinit(allocator);
+        var empty_body = std.ArrayList(Node){};
+        defer empty_body.deinit(allocator);
+
+        var current_body = &body;
+        var depth: usize = 1;
+
+        while (self.pos < self.template.len and depth > 0) {
+            if (try self.parseText(allocator)) |node| {
+                try current_body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseVariable(allocator)) |node| {
+                try current_body.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseTag(allocator)) |tag_node| {
+                const tag_name = tag_node.tag.?.name;
+
+                if (std.mem.eql(u8, tag_name, "for")) {
+                    depth += 1;
+                    try current_body.append(allocator, tag_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "endfor")) {
+                    depth -= 1;
+                    const raw_close = tag_node.tag.?.raw;
+
+                    if (depth == 0) {
+                        // Libera name e args — essa é a tag de fechamento final
+                        allocator.free(tag_node.tag.?.name);
+                        allocator.free(tag_node.tag.?.args);
+
+                        return Node{
+                            .type = .for_block,
+                            .@"for" = .{
+                                .loop_var = loop_var,
+                                .iterable = iterable,
+                                .body = try body.toOwnedSlice(allocator),
+                                .empty_body = try empty_body.toOwnedSlice(allocator),
+                                .raw_open = raw_open,
+                                .raw_close = raw_close,
+                            },
+                        };
+                    }
+
+                    // depth > 0: endfor aninhado — adiciona como tag normal
+                    try current_body.append(allocator, tag_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "empty") and depth == 1) {
+                    current_body = &empty_body;
+                    allocator.free(tag_node.tag.?.name);
+                    allocator.free(tag_node.tag.?.args);
+                    continue;
+                }
+
+                try current_body.append(allocator, tag_node);
+            } else {
+                self.advance(1);
+            }
+        }
+
+        return error.UnclosedBlock;
+    }
+
+    pub fn parse(self: *Parser, allocator: std.mem.Allocator) ![]Node {
+        var list = std.ArrayList(Node){};
+        defer list.deinit(allocator);
+
+        while (self.pos < self.template.len) {
+            if (try self.parseTag(allocator)) |node| {
+                const tag_name = node.tag.?.name;
+
+                if (std.mem.eql(u8, tag_name, "if")) {
+                    const condition_raw = node.tag.?.args;
+                    const raw_open = node.tag.?.raw;
+
+                    const condition = try allocator.dupe(u8, condition_raw);
+
+                    // Libera apenas name e args da tag open
+                    allocator.free(node.tag.?.name);
+                    allocator.free(node.tag.?.args);
+
+                    // NÃO chame node.deinit aqui — raw_open ainda é usado
+
+                    const if_node = try self.parseIfBlock(allocator, condition, raw_open);
+                    try list.append(allocator, if_node);
+                    continue;
+                }
+
+                if (std.mem.eql(u8, tag_name, "for")) {
+                    const args = node.tag.?.args;
+                    const raw_open = node.tag.?.raw;
+
+                    const in_pos = std.mem.indexOf(u8, args, " in ") orelse return error.InvalidForSyntax;
+                    const loop_var_raw = std.mem.trim(u8, args[0..in_pos], " \t");
+                    const iterable_raw = std.mem.trim(u8, args[in_pos + 4 ..], " \t");
+
+                    // DUPE ANTES DE LIBERAR!
+                    const loop_var = try allocator.dupe(u8, loop_var_raw);
+                    const iterable = try allocator.dupe(u8, iterable_raw);
+
+                    // Agora sim, libera a tag open
+                    allocator.free(node.tag.?.name);
+                    allocator.free(node.tag.?.args);
+
+                    const for_node = try self.parseForBlock(allocator, loop_var, iterable, raw_open);
+                    try list.append(allocator, for_node);
+                    continue;
+                }
+
+                // Para tags normais
+                try list.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseVariable(allocator)) |node| {
+                try list.append(allocator, node);
+                continue;
+            }
+
+            if (try self.parseText(allocator)) |node| {
+                try list.append(allocator, node);
+                continue;
+            }
+
+            self.advance(1);
+        }
+
+        return try list.toOwnedSlice(allocator);
+    }
+};
+
+pub fn parse(allocator: std.mem.Allocator, template: []const u8) ![]Node {
+    var p = Parser.init(template);
+    return try p.parse(allocator);
+}

src/parser_test.zig

@@ -0,0 +1,186 @@
+const std = @import("std");
+const testing = std.testing;
+const parser = @import("parser.zig");
+
+test "parse texto simples" {
+    const allocator = testing.allocator;
+    const template = "Olá mundo!";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .text);
+    try testing.expectEqualStrings("Olá mundo!", nodes[0].text.?.content);
+}
+
+test "parse variável simples" {
+    const allocator = testing.allocator;
+    const template = "Olá {{ nome }}!";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 3), nodes.len);
+
+    try testing.expect(nodes[0].type == .text);
+    try testing.expectEqualStrings("Olá ", nodes[0].text.?.content);
+
+    try testing.expect(nodes[1].type == .variable);
+    try testing.expectEqualStrings("nome", nodes[1].variable.?.content);
+
+    try testing.expect(nodes[2].type == .text);
+    try testing.expectEqualStrings("!", nodes[2].text.?.content);
+}
+
+test "parse variável com espaços" {
+    const allocator = testing.allocator;
+    const template = "{{   espacos   }}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .variable);
+    try testing.expectEqualStrings("espacos", nodes[0].variable.?.content);
+}
+
+test "parse tag simples" {
+    const allocator = testing.allocator;
+    const template = "Antes {% minha_tag %} Depois";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 3), nodes.len);
+
+    try testing.expect(nodes[0].type == .text);
+    try testing.expectEqualStrings("Antes ", nodes[0].text.?.content);
+
+    try testing.expect(nodes[1].type == .tag);
+    try testing.expectEqualStrings("minha_tag", nodes[1].tag.?.name);
+    try testing.expectEqualStrings("", nodes[1].tag.?.args);
+
+    try testing.expect(nodes[2].type == .text);
+    try testing.expectEqualStrings(" Depois", nodes[2].text.?.content);
+}
+
+test "parse if block básico" {
+    const allocator = testing.allocator;
+    const template = "{% if usuario.logado %}Bem-vindo!{% endif %}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .if_block);
+
+    const ib = nodes[0].@"if".?;
+    try testing.expectEqualStrings("usuario.logado", ib.condition);
+    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+    try testing.expect(nodes[0].@"if".?.true_body[0].type == .text);
+    try testing.expectEqualStrings("Bem-vindo!", ib.true_body[0].text.?.content);
+    try testing.expectEqual(@as(usize, 0), ib.false_body.len);
+}
+
+test "parse if block sem else" {
+    const allocator = testing.allocator;
+    const template = "{% if cond %}Verdadeiro{% endif %}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .if_block);
+    const ib = nodes[0].@"if".?;
+    try testing.expectEqualStrings("cond", ib.condition);
+    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+    try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
+    try testing.expectEqual(@as(usize, 0), ib.false_body.len);
+}
+
+test "parse if block com else" {
+    const allocator = testing.allocator;
+    const template = "{% if cond %}Verdadeiro{% else %}Falso{% endif %}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| {
+            node.deinit(allocator);
+        }
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .if_block);
+    const ib = nodes[0].@"if".?;
+    try testing.expectEqualStrings("cond", ib.condition);
+    try testing.expectEqual(@as(usize, 1), ib.true_body.len);
+    try testing.expectEqualStrings("Verdadeiro", ib.true_body[0].text.?.content);
+    try testing.expectEqual(@as(usize, 1), ib.false_body.len);
+    try testing.expectEqualStrings("Falso", ib.false_body[0].text.?.content);
+}
+
+test "parse for block sem empty" {
+    const allocator = testing.allocator;
+    const template = "{% for item in lista %}Item: {{ item }}{% endfor %}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| node.deinit(allocator);
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .for_block);
+    const fb = nodes[0].@"for".?;
+    try testing.expectEqualStrings("item", fb.loop_var);
+    try testing.expectEqualStrings("lista", fb.iterable);
+    try testing.expectEqual(@as(usize, 2), fb.body.len); // <--- corrigido: 2 nós
+    try testing.expectEqual(@as(usize, 0), fb.empty_body.len);
+
+    try testing.expect(fb.body[0].type == .text);
+    try testing.expectEqualStrings("Item: ", fb.body[0].text.?.content);
+    try testing.expect(fb.body[1].type == .variable);
+    try testing.expectEqualStrings("item", fb.body[1].variable.?.content);
+}
+
+test "parse for block com empty" {
+    const allocator = testing.allocator;
+    const template = "{% for item in lista %}Tem{% empty %}Vazio{% endfor %}";
+    const nodes = try parser.parse(allocator, template);
+    defer {
+        for (nodes) |node| node.deinit(allocator);
+        allocator.free(nodes);
+    }
+
+    try testing.expectEqual(@as(usize, 1), nodes.len);
+    try testing.expect(nodes[0].type == .for_block);
+    const fb = nodes[0].@"for".?;
+    try testing.expectEqual(@as(usize, 1), fb.body.len);
+    try testing.expectEqualStrings("Tem", fb.body[0].text.?.content);
+    try testing.expectEqual(@as(usize, 1), fb.empty_body.len);
+    try testing.expectEqualStrings("Vazio", fb.empty_body[0].text.?.content);
+}

src/root.zig

@@ -0,0 +1,23 @@
+//! By convention, root.zig is the root source file when making a library.
+const std = @import("std");
+
+pub fn bufferedPrint() !void {
+    // Stdout is for the actual output of your application, for example if you
+    // are implementing gzip, then only the compressed bytes should be sent to
+    // stdout, not any debugging messages.
+    var stdout_buffer: [1024]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout = &stdout_writer.interface;
+
+    try stdout.print("Run `zig build test` to run the tests.\n", .{});
+
+    try stdout.flush(); // Don't forget to flush!
+}
+
+pub fn add(a: i32, b: i32) i32 {
+    return a + b;
+}
+
+test "basic add functionality" {
+    try std.testing.expect(add(3, 7) == 10);
+}