1253 lines
47 KiB
Zig
1253 lines
47 KiB
Zig
const std = @import("std");
|
|
const testing = std.testing;
|
|
const parser = @import("parser.zig");
|
|
|
|
test "parse simple text" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("1 - parse simple text\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "Olá mundo!";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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 simple var" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("2 - parse simple var\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "Olá {{ nome }}!";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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.?.expr);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings("!", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse var with spaces" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("3 - parse var with spaces\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "{{ espacos }}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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.?.expr);
|
|
}
|
|
|
|
test "parse autoescape on" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("4 - parse autoescape on\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "{% autoescape on %}Texto <b>negrito</b>{% endautoescape %}";
|
|
const expected = "Texto <b>negrito</b>";
|
|
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
if (nodes[0].tag) |tag| {
|
|
try testing.expect(tag.body.autoescape.enabled == true);
|
|
try testing.expectEqual(@as(usize, 1), tag.body.autoescape.body.len);
|
|
try testing.expectEqualStrings(expected, tag.body.autoescape.body[0].text.?.content);
|
|
}
|
|
}
|
|
|
|
test "parse autoescape off" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("5 - parse autoescape off\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "{% autoescape off %}Texto <b>negrito</b>{% endautoescape %}";
|
|
const expected = "Texto <b>negrito</b>";
|
|
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
if (nodes[0].tag) |tag| {
|
|
try testing.expect(tag.body.autoescape.enabled == false);
|
|
try testing.expectEqual(@as(usize, 1), tag.body.autoescape.body.len);
|
|
try testing.expectEqualStrings(expected, tag.body.autoescape.body[0].text.?.content);
|
|
}
|
|
}
|
|
test "parse simple block" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("6 - parse simple block\n", .{});
|
|
const allocator = testing.allocator;
|
|
const template = "{% block titulo %}Meu Título{% endblock %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expectEqual(nodes[0].tag.?.kind, .block);
|
|
try testing.expectEqualStrings("titulo", nodes[0].tag.?.body.block.name);
|
|
const b = nodes[0].tag.?.body.block.body;
|
|
try testing.expectEqual(@as(usize, 1), b.len);
|
|
try testing.expectEqual(b[0].type, .text);
|
|
try testing.expectEqualStrings("Meu Título", b[0].text.?.content);
|
|
}
|
|
|
|
test "parse block with super" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("7 - parse block with super\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% block conteudo %}{{ block.super }} Conteúdo filho{% endblock %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expectEqualStrings("conteudo", nodes[0].tag.?.body.block.name);
|
|
const b = nodes[0].tag.?.body.block.body;
|
|
try testing.expectEqual(@as(usize, 2), b.len);
|
|
try testing.expect(b[0].type == .tag);
|
|
try testing.expect(b[0].tag.?.kind == .super);
|
|
try testing.expect(b[1].type == .text);
|
|
try testing.expectEqualStrings(" Conteúdo filho", b[1].text.?.content);
|
|
}
|
|
|
|
// TODO: check it
|
|
test "parse block with block inside" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("8 - parse block with block inside\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% block conteudo %}{% block inner %}Conteúdo filho{% endblock %}{% endblock %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expectEqualStrings("conteudo", nodes[0].tag.?.body.block.name);
|
|
const b = nodes[0].tag.?.body.block.body;
|
|
try testing.expectEqual(@as(usize, 3), b.len);
|
|
try testing.expect(b[0].type == .tag);
|
|
try testing.expect(b[0].tag.?.kind == .block);
|
|
try testing.expect(b[1].type == .text);
|
|
try testing.expectEqualStrings("Conteúdo filho", b[1].text.?.content);
|
|
try testing.expect(b[2].type == .tag);
|
|
// std.debug.print("block:\n {any}",.{nodes[0].tag.?.body.block});
|
|
// for(b) |node| std.debug.print("block:\n {any}\n",.{node});
|
|
// try testing.expectEqualStrings("inner",b[0].tag.?.body.block.name);
|
|
// try testing.expect(b[1].type == .text);
|
|
// try testing.expectEqualStrings(" Conteúdo filho",b[1].text.?.content);
|
|
}
|
|
|
|
test "parse simple csrf_token" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("9 - parse simple csrf_token\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "<form>{% csrf_token %}</form>";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("<form>", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .csrf_token);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings("</form>", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse just csrf_token" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("10 - parse just csrf_token\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% csrf_token %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .csrf_token);
|
|
}
|
|
|
|
test "parse comment" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("11 - parse comment\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Bazinga! {% comment %}{% for item in lista %}Tem{% empty %}Vazio{% endfor %}{% endcomment %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Bazinga! ", nodes[0].text.?.content);
|
|
}
|
|
|
|
test "parse comment inside block" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("12 - parse comment\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% block conteudo %}Bazinga!{% comment %}{% for item in lista %}Tem{% empty %}Vazio{% endfor %}{% endcomment %} haha{% endblock %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
|
|
const child_nodes = nodes[0].tag.?.body.block.body;
|
|
|
|
try testing.expectEqual(@as(usize, 2), child_nodes.len);
|
|
|
|
try testing.expect(child_nodes[0].type == .text);
|
|
try testing.expect(child_nodes[1].type == .text);
|
|
try testing.expectEqualStrings("Bazinga!", child_nodes[0].text.?.content);
|
|
try testing.expectEqualStrings(" haha", child_nodes[1].text.?.content);
|
|
}
|
|
|
|
test "parse simple cycle" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("13 - parse simple cycle\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% cycle 'row1' 'row2' %}";
|
|
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
|
|
const args = nodes[0].tag.?.body.cycle.values;
|
|
try testing.expectEqual(@as(usize, 2), args.len);
|
|
try testing.expectEqualStrings("row1", args[0]);
|
|
try testing.expectEqualStrings("row2", args[1]);
|
|
}
|
|
|
|
test "parse cycle values without quotes" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("14 - parse cycle values without quotes\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% cycle row1 row2 row3 %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const args = nodes[0].tag.?.body.cycle.values;
|
|
try testing.expectEqual(@as(usize, 3), args.len);
|
|
try testing.expectEqualStrings("row1", args[0]);
|
|
try testing.expectEqualStrings("row2", args[1]);
|
|
try testing.expectEqualStrings("row3", args[2]);
|
|
}
|
|
|
|
test "parse simple debug" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("15 - parse simple debug\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Antes {% debug %} Depois";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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.expect(nodes[1].tag.?.kind == .debug);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Depois", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse extends" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("16 - parse extends\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% extends \"base.html\" %}";
|
|
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .extends);
|
|
try testing.expectEqualStrings("base.html", nodes[0].tag.?.body.extends.parent_name);
|
|
}
|
|
|
|
test "parse simple filter block" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("17 - parse simple filter block\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% filter upper %}olá mundo{% endfilter %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const fb = nodes[0].tag.?.body.filter_block;
|
|
try testing.expectEqualStrings("upper", fb.filters);
|
|
try testing.expectEqual(@as(usize, 1), fb.body.len);
|
|
try testing.expectEqualStrings("olá mundo", fb.body[0].text.?.content);
|
|
}
|
|
|
|
test "parse filter block multiple filters" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("18 - parse filter block multiple filters\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% filter upper|escape %}Conteúdo <b>negrito</b>{% endfilter %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .filter_block);
|
|
const fb = nodes[0].tag.?.body.filter_block;
|
|
try testing.expectEqualStrings("upper|escape", fb.filters);
|
|
try testing.expectEqual(@as(usize, 1), fb.body.len);
|
|
try testing.expectEqualStrings("Conteúdo <b>negrito</b>", fb.body[0].text.?.content);
|
|
}
|
|
|
|
test "parse variable with filters" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("19 - parse variable with filters\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{{ nome|upper|default:\"Visitante\" }}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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);
|
|
const v = nodes[0].variable.?;
|
|
try testing.expectEqualStrings("nome", v.expr);
|
|
try testing.expectEqual(@as(usize, 2), v.filters.len);
|
|
try testing.expectEqualStrings("upper", v.filters[0].name);
|
|
try testing.expect(v.filters[0].arg == null);
|
|
try testing.expectEqualStrings("default", v.filters[1].name);
|
|
try testing.expectEqualStrings("Visitante", v.filters[1].arg.?);
|
|
}
|
|
|
|
test "parse simple firstof" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("20 - parse simple firstof\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Valor: {% firstof var1 var2 var3 %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 2), nodes.len);
|
|
|
|
try testing.expect(nodes[0].type == .text);
|
|
try testing.expectEqualStrings("Valor: ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
const fo = nodes[1].tag.?.body.firstof.values;
|
|
try testing.expectEqual(@as(usize, 3), fo.len);
|
|
try testing.expectEqualStrings("var1", fo[0]);
|
|
try testing.expectEqualStrings("var2", fo[1]);
|
|
try testing.expectEqualStrings("var3", fo[2]);
|
|
}
|
|
|
|
test "parse firstof with fallback" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("21 - parse firstof with fallback\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% firstof var1 var2 \"Nenhum valor\" %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const fo = nodes[0].tag.?.body.firstof.values;
|
|
try testing.expectEqual(@as(usize, 3), fo.len);
|
|
try testing.expectEqualStrings("var1", fo[0]);
|
|
try testing.expectEqualStrings("var2", fo[1]);
|
|
try testing.expectEqualStrings("Nenhum valor", fo[2]);
|
|
}
|
|
|
|
test "parse for block whithout empty" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("22 - parse for block whithout empty\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% for item in lista %}Item: {{ item }}{% endfor %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const fb = nodes[0].tag.?.body.@"for";
|
|
try testing.expectEqualStrings("item", fb.loop_var);
|
|
try testing.expectEqualStrings("lista", fb.iterable);
|
|
try testing.expectEqual(@as(usize, 2), fb.body.len);
|
|
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.?.expr);
|
|
}
|
|
|
|
test "parse for block with empty" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("23 - parse for block with empty\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% for item in lista %}Tem{% empty %}Vazio{% endfor %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const fb = nodes[0].tag.?.body.@"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);
|
|
}
|
|
|
|
test "parse basic if block" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("24 - parse basic if block\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% if user.logged %}Welcome!{% endif %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| {
|
|
node.deinit(allocator);
|
|
}
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
|
|
const ib = nodes[0].tag.?.body.@"if";
|
|
try testing.expectEqualStrings("user.logged", ib.condition);
|
|
try testing.expectEqual(@as(usize, 1), ib.true_body.len);
|
|
try testing.expect(ib.true_body[0].type == .text);
|
|
try testing.expectEqualStrings("Welcome!", ib.true_body[0].text.?.content);
|
|
try testing.expectEqual(@as(usize, 0), ib.false_body.len);
|
|
}
|
|
|
|
test "parse if block whithout else" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("25 - parse if block whithout else\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% if cond %}Verdadeiro{% endif %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| {
|
|
node.deinit(allocator);
|
|
}
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
const ib = nodes[0].tag.?.body.@"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 with else" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("26 - parse if block with else\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% if cond %}Verdadeiro{% else %}Falso{% endif %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| {
|
|
node.deinit(allocator);
|
|
}
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .if_block);
|
|
const ib = nodes[0].tag.?.body.@"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 simple include" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("27 - parse simple include\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Cabeçalho {% include \"header.html\" %} Conteúdo {% include \"footer.html\" %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 4), nodes.len);
|
|
|
|
try testing.expect(nodes[0].type == .text);
|
|
try testing.expectEqualStrings("Cabeçalho ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .include);
|
|
try testing.expectEqualStrings("header.html", nodes[1].tag.?.body.include.template_path);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Conteúdo ", nodes[2].text.?.content);
|
|
|
|
try testing.expect(nodes[3].type == .tag);
|
|
try testing.expectEqualStrings("footer.html", nodes[3].tag.?.body.include.template_path);
|
|
}
|
|
|
|
test "parse include without quotes (it is ok for now)" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("28 - parse include without quotes (it is ok for now)\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% include header.html %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .include);
|
|
try testing.expectEqualStrings("header.html", nodes[0].tag.?.body.include.template_path);
|
|
}
|
|
|
|
test "parse simple load" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("29 - parse simple load\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% load i18n %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .load);
|
|
const l = nodes[0].tag.?.body.load;
|
|
try testing.expectEqual(@as(usize, 1), l.libraries.len);
|
|
try testing.expectEqualStrings("i18n", l.libraries[0]);
|
|
}
|
|
|
|
test "parse load with multiple libraries" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("30 - parse load with multiple libraries\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% load admin_urls static %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .load);
|
|
const l = nodes[0].tag.?.body.load;
|
|
try testing.expectEqual(@as(usize, 2), l.libraries.len);
|
|
try testing.expectEqualStrings("admin_urls", l.libraries[0]);
|
|
try testing.expectEqualStrings("static", l.libraries[1]);
|
|
}
|
|
test "parse simple lorem" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("31 - parse simple lorem\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% lorem %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .lorem);
|
|
const l = nodes[0].tag.?.body.lorem;
|
|
try testing.expect(l.count == null);
|
|
try testing.expect(l.method == null);
|
|
try testing.expect(l.format == null);
|
|
}
|
|
|
|
test "parse lorem with arguments" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("32 - parse lorem with arguments\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% lorem 5 p html %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .lorem);
|
|
const l = nodes[0].tag.?.body.lorem;
|
|
try testing.expectEqualStrings("5", l.count.?);
|
|
try testing.expectEqualStrings("p", l.method.?);
|
|
try testing.expectEqualStrings("html", l.format.?);
|
|
}
|
|
|
|
test "parse simple now" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("33 - parse simple now\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Data atual: {% now \"Y-m-d\" %} às {% now \"H:i\" %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 4), nodes.len);
|
|
|
|
try testing.expect(nodes[0].type == .text);
|
|
try testing.expectEqualStrings("Data atual: ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .now);
|
|
try testing.expectEqualStrings("Y-m-d", nodes[1].tag.?.body.now.format);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" às ", nodes[2].text.?.content);
|
|
|
|
try testing.expect(nodes[3].type == .tag);
|
|
try testing.expect(nodes[3].tag.?.kind == .now);
|
|
try testing.expectEqualStrings("H:i", nodes[3].tag.?.body.now.format);
|
|
}
|
|
|
|
test "parse now whithout quotes" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("34 - parse now whithout quotes\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% now Y-m-d %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .now);
|
|
try testing.expectEqualStrings("Y-m-d", nodes[0].tag.?.body.now.format);
|
|
}
|
|
|
|
test "parse simple partial" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("35 - parse simple partial\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Início {% partial \"cabecalho\" %} Fim";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Início ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .partial);
|
|
try testing.expectEqualStrings("cabecalho", nodes[1].tag.?.body.partial.name);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Fim", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse partial whithout quotes" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("36 - parse partial whithout quotes\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Início {% partial cabecalho %} Fim";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Início ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .partial);
|
|
try testing.expectEqualStrings("cabecalho", nodes[1].tag.?.body.partial.name);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Fim", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse simple partialdef" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("37 - parse simple partialdef\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% partialdef cabecalho %}Cabeçalho{% endpartialdef %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .partialdef);
|
|
const pd = nodes[0].tag.?.body.partialdef;
|
|
try testing.expectEqualStrings("cabecalho", pd.name);
|
|
try testing.expectEqual(@as(usize, 1), pd.body.len);
|
|
try testing.expectEqualStrings("Cabeçalho", pd.body[0].text.?.content);
|
|
}
|
|
|
|
test "parse simple querystring" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("38 - parse simple querystring\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Link: {% querystring \"page=2\" %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 2), nodes.len);
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .querystring);
|
|
const qs = nodes[1].tag.?.body.querystring;
|
|
try testing.expectEqual(@as(usize, 1), qs.modifications.len);
|
|
try testing.expectEqualStrings("page=2", qs.modifications[0]);
|
|
}
|
|
|
|
test "parse querystring with multiple modifications" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("39 - parse querystring with multiple modifications\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% querystring \"ordenar=-nome\" \"pagina\" None %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .querystring);
|
|
const qs = nodes[0].tag.?.body.querystring;
|
|
try testing.expectEqual(@as(usize, 3), qs.modifications.len);
|
|
try testing.expectEqualStrings("ordenar=-nome", qs.modifications[0]);
|
|
try testing.expectEqualStrings("pagina", qs.modifications[1]);
|
|
try testing.expectEqualStrings("None", qs.modifications[2]);
|
|
}
|
|
|
|
test "parse simple regroup" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("40 - parse simple regroup\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% regroup pessoas by cidade as grupos_cidade %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .regroup);
|
|
const r = nodes[0].tag.?.body.regroup;
|
|
try testing.expectEqualStrings("pessoas", r.source);
|
|
try testing.expectEqualStrings("cidade", r.by);
|
|
try testing.expectEqualStrings("grupos_cidade", r.as_var);
|
|
}
|
|
|
|
test "parse simple resetcycle" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("41 - parse simple resetcycle\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% resetcycle %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .resetcycle);
|
|
const rc = nodes[0].tag.?.body.resetcycle;
|
|
try testing.expect(rc.cycle_name == null);
|
|
}
|
|
|
|
test "parse resetcycle with name" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("42 - parse resetcycle with name\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% resetcycle rowclass %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .resetcycle);
|
|
const rc = nodes[0].tag.?.body.resetcycle;
|
|
try testing.expect(rc.cycle_name != null);
|
|
try testing.expectEqualStrings("rowclass", rc.cycle_name.?);
|
|
}
|
|
test "parse simple spaceless" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("43 - parse simple spaceless\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% spaceless %}<p> <a href=\"foo/\">Foo</a> </p>{% endspaceless %}";
|
|
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .spaceless);
|
|
const sl = nodes[0].tag.?.body.spaceless;
|
|
try testing.expectEqual(@as(usize, 1), sl.body.len);
|
|
try testing.expectEqualStrings("<p> <a href=\"foo/\">Foo</a> </p>", sl.body[0].text.?.content);
|
|
}
|
|
|
|
// TODO: check nested spaceless
|
|
test "parse spaceless nested" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("44 - parse spaceless nested\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% spaceless %}Outer {% spaceless %}Inner{% endspaceless %} Outer{% endspaceless %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .spaceless);
|
|
const sl = nodes[0].tag.?.body.spaceless;
|
|
|
|
try testing.expectEqual(@as(usize, 4), sl.body.len);
|
|
}
|
|
test "parse templatetag openblock" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("45 - parse templatetag openblock\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% templatetag openblock %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .templatetag);
|
|
try testing.expect(nodes[0].tag.?.body.templatetag.kind == .openblock);
|
|
}
|
|
|
|
test "parse templatetag closevariable" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("46 - parse templatetag closevariable\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% templatetag closevariable %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .templatetag);
|
|
try testing.expect(nodes[0].tag.?.body.templatetag.kind == .closevariable);
|
|
}
|
|
|
|
test "parse simple url" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("47 - parse simple url\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Link: {% url 'home' %} Fim";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Link: ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .url);
|
|
const u = nodes[1].tag.?.body.url;
|
|
try testing.expectEqualStrings("home", u.name);
|
|
try testing.expectEqual(@as(usize, 0), u.args.len);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Fim", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse url with arguments" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("48 - parse url with arguments\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% url 'post_detail' post.id \"comentario\" %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .url);
|
|
const u = nodes[0].tag.?.body.url;
|
|
try testing.expectEqualStrings("post_detail", u.name);
|
|
try testing.expectEqual(@as(usize, 2), u.args.len);
|
|
try testing.expectEqualStrings("post.id", u.args[0]);
|
|
try testing.expectEqualStrings("\"comentario\"", u.args[1]);
|
|
}
|
|
|
|
test "parse simple widthratio" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("49 - parse simple widthratio\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Progresso: {% widthratio progresso 0 100 %}%";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Progresso: ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .widthratio);
|
|
const wr = nodes[1].tag.?.body.widthratio;
|
|
try testing.expectEqualStrings("progresso", wr.value);
|
|
try testing.expectEqualStrings("0", wr.max_value);
|
|
try testing.expectEqualStrings("100", wr.divisor.?);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings("%", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse simple widthratio without divisor" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("50 - parse simple widthratio without divisor\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Progresso: {% widthratio progresso 0 %}%";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Progresso: ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .widthratio);
|
|
const wr = nodes[1].tag.?.body.widthratio;
|
|
try testing.expectEqualStrings("progresso", wr.value);
|
|
try testing.expectEqualStrings("0", wr.max_value);
|
|
try testing.expect(wr.divisor == null);
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings("%", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse simple verbatim" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("51 - parse simple verbatim\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "Texto {% verbatim %}{{ variável }}{% endblock %}{% endverbatim %} Texto";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
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("Texto ", nodes[0].text.?.content);
|
|
|
|
try testing.expect(nodes[1].type == .tag);
|
|
try testing.expect(nodes[1].tag.?.kind == .verbatim);
|
|
const vb = nodes[1].tag.?.body.verbatim;
|
|
try testing.expectEqualStrings("{{ variável }}{% endblock %}", vb.content);
|
|
try testing.expect(std.mem.eql(u8, vb.name.?, ""));
|
|
|
|
try testing.expect(nodes[2].type == .text);
|
|
try testing.expectEqualStrings(" Texto", nodes[2].text.?.content);
|
|
}
|
|
|
|
test "parse verbatim nested" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("52 - parse verbatim nested\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% verbatim baz %}Outer {% verbatim %}Inner{% endverbatim %} Outer{% endverbatim baz %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .verbatim);
|
|
const vb = nodes[0].tag.?.body.verbatim;
|
|
try testing.expectEqualStrings("Outer {% verbatim %}Inner{% endverbatim %} Outer", vb.content);
|
|
try testing.expect(std.mem.eql(u8, vb.name.?, "baz"));
|
|
}
|
|
|
|
test "parse simple with block" {
|
|
std.debug.print("____________________________________________________\n", .{});
|
|
std.debug.print("53 - parse with block\n", .{});
|
|
|
|
const allocator = testing.allocator;
|
|
const template = "{% with nome=\"Lucas\" idade=30 %}Olá {{ nome }}, você tem {{ idade }} anos.{% endwith %}";
|
|
var p = parser.Parser.init(template);
|
|
const nodes = try p.parse(allocator);
|
|
defer {
|
|
for (nodes) |node| node.deinit(allocator);
|
|
allocator.free(nodes);
|
|
}
|
|
|
|
try testing.expectEqual(@as(usize, 1), nodes.len);
|
|
try testing.expect(nodes[0].type == .tag);
|
|
try testing.expect(nodes[0].tag.?.kind == .with_block);
|
|
const w = nodes[0].tag.?.body.with;
|
|
try testing.expectEqual(@as(usize, 2), w.assignments.len);
|
|
try testing.expectEqual(@as(usize, 5), w.body.len);
|
|
try testing.expect(w.body[0].type == .text);
|
|
}
|
|
|
|
// test "parse simple tag" {
|
|
// std.debug.print("____________________________________________________\n", .{});
|
|
// std.debug.print("54 - parse simple tag\n", .{});
|
|
//
|
|
// const allocator = testing.allocator;
|
|
// const template = "Antes {% minha_tag %} Depois";
|
|
// var p = parser.Parser.init(template);
|
|
// const nodes = try p.parse(allocator);
|
|
// 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);
|
|
// }
|