commit da8c1563c681a83936a212b9e611a81d8e1fa65e Author: Lucas F. Date: Sat Jan 3 12:27:27 2026 -0300 initial diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7104ec4 --- /dev/null +++ b/.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 + diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..ee624d8 --- /dev/null +++ b/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. +} diff --git a/build.zig.zon b/build.zig.zon new file mode 100644 index 0000000..650442c --- /dev/null +++ b/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 `, 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 ` 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", + }, +} diff --git a/src/main.zig b/src/main.zig new file mode 100644 index 0000000..467a970 --- /dev/null +++ b/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, .{}); +} diff --git a/src/parser.zig b/src/parser.zig new file mode 100644 index 0000000..28fa677 --- /dev/null +++ b/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); +} diff --git a/src/parser_test.zig b/src/parser_test.zig new file mode 100644 index 0000000..745b2fb --- /dev/null +++ b/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); +} diff --git a/src/root.zig b/src/root.zig new file mode 100644 index 0000000..94c7cd0 --- /dev/null +++ b/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); +}