src/main/controllers.zig

@@ -227,7 +227,7 @@ pub const Response = struct {
         defer stream.close();
 
         const writer = stream.writer();
-        try @import("template").execute(writer, .{}, templ, data);
+        try @import("template").execute(writer, templ, data);
 
         try stream.finish();
     }

src/template/lib.zig

@@ -1,42 +1,36 @@
 const std = @import("std");
 
 pub fn main() !void {
-    try execute(
+    try execute(std.io.getStdOut().writer(), @embedFile("./test.tmp.html"), .{
-        std.io.getStdOut().writer(),
+        .community = .{ .name = "abcd" },
-        .{ .test_tmpl = "{.x}" },
+        .foo = [_][]const u8{ "5", "4", "3", "2", "1" },
-        @embedFile("./test.tmp.html"),
+        .baz = [_][]const []const u8{
-        .{
+            &.{ "5", "4", "3", "2", "1" },
-            .community = .{ .name = "abcd" },
+            &.{ "5", "4", "3", "2", "1" },
-            .foo = [_][]const u8{ "5", "4", "3", "2", "1" },
-            .baz = [_][]const []const u8{
-                &.{ "5", "4", "3", "2", "1" },
-                &.{ "5", "4", "3", "2", "1" },
-            },
-            .bar = .{ .x = "x" },
-            .qux = false,
-            .quxx = true,
         },
-    );
+        .qux = false,
+        .quxx = true,
+    });
 }
 
-pub fn execute(writer: anytype, comptime other_templates: anytype, comptime template: []const u8, args: anytype) !void {
+pub fn execute(writer: anytype, comptime template: []const u8, args: anytype) !void {
     @setEvalBranchQuota(@intCast(u32, template.len * 8));
 
     const tokens = comptime parseTemplateTokens(ControlTokenIter{ .text = template });
     const tmpl = comptime parseTemplate(tokens, 0, .root);
-    try executeTemplate(writer, other_templates, tmpl.items, args, .{});
+    try executeTemplate(writer, tmpl.items, args, .{});
 }
 
-fn executeTemplate(writer: anytype, comptime templates: anytype, comptime items: []const TemplateItem, args: anytype, captures: anytype) !void {
+fn executeTemplate(writer: anytype, comptime items: []const TemplateItem, args: anytype, captures: anytype) !void {
     inline for (items) |it| {
         switch (it) {
             .text => |text| try writer.writeAll(text),
-            .statement => |stmt| try executeStatement(writer, templates, stmt, args, captures),
+            .statement => |stmt| try executeStatement(writer, stmt, args, captures),
         }
     }
 }
 
-fn executeStatement(writer: anytype, comptime templates: anytype, comptime stmt: Statement, args: anytype, captures: anytype) !void {
+fn executeStatement(writer: anytype, comptime stmt: Statement, args: anytype, captures: anytype) !void {
     switch (stmt) {
         .expression => |expr| {
             const val = evaluateExpression(expr, args, captures);
@@ -49,7 +43,6 @@ fn executeStatement(writer: anytype, comptime templates: anytype, comptime stmt:
             for (iterable) |v| {
                 try executeTemplate(
                     writer,
-                    templates,
                     subtemplate,
                     args,
                     addCapture(captures, loop.header.capture, v),
@@ -60,19 +53,14 @@ fn executeStatement(writer: anytype, comptime templates: anytype, comptime stmt:
             const condition = evaluateExpression(if_stmt.header.condition, args, captures);
             const subtemplate = if_stmt.subtemplate;
             if (condition) {
-                try executeTemplate(writer, templates, subtemplate, args, captures);
+                try executeTemplate(writer, subtemplate, args, captures);
             } else {
                 if (if_stmt.else_branch) |branch| switch (branch) {
-                    .@"else" => |subtmpl| try executeTemplate(writer, templates, subtmpl, args, captures),
+                    .@"else" => |subtmpl| try executeTemplate(writer, subtmpl, args, captures),
-                    .elif => |elif| try executeStatement(writer, templates, .{ .@"if" = elif.* }, args, captures),
+                    .elif => |elif| try executeStatement(writer, .{ .@"if" = elif.* }, args, captures),
                 };
             }
         },
-        .call_template => |call| {
-            const new_template = @field(templates, call.template_name);
-            try execute(writer, templates, new_template, evaluateExpression(call.args, args, captures));
-            //std.log.debug("calling template {s} with arg {any}", .{ call.template_name, call.args });
-        },
         //else => @compileError("TODO"),
     }
 }
@@ -263,11 +251,6 @@ fn parseTemplate(
                             break cb
                         else
                             @compileError("Unexpected #else tag"),
-                        .call_template => |call| {
-                            items = items ++ [_]TemplateItem{.{
-                                .statement = .{ .call_template = call },
-                            }};
-                        },
                     }
                 },
             }
@@ -394,11 +377,6 @@ fn parseControlBlock(comptime tokens: ControlTokenIter) ParseResult(ControlToken
                         iter = result.new_iter;
                         break .{ .elif_header = result.item };
                     },
-                    .template => {
-                        const result = parseCallTemplate(iter);
-                        iter = result.new_iter;
-                        break .{ .call_template = result.item };
-                    },
 
                     //else => @compileError("TODO"),
                 }
@@ -551,27 +529,6 @@ fn parseDeref(comptime tokens: ControlTokenIter) ParseResult(ControlTokenIter, [
     }
 }
 
-fn parseCallTemplate(comptime tokens: ControlTokenIter) ParseResult(ControlTokenIter, CallTemplate) {
-    comptime {
-        var iter = tokens;
-        const template_name = while (iter.next()) |token| switch (token) {
-            .text => |t| break t,
-            .whitespace => {},
-            else => @compileError("Unexpected token"),
-        } else @compileError("Unexpected end of template");
-
-        const args = parseExpression(iter);
-
-        return .{
-            .new_iter = args.new_iter,
-            .item = .{
-                .template_name = template_name,
-                .args = args.item,
-            },
-        };
-    }
-}
-
 fn ParseResult(comptime It: type, comptime T: type) type {
     return struct {
         new_iter: It,
@@ -608,11 +565,6 @@ const If = struct {
     },
 };
 
-const CallTemplate = struct {
-    template_name: []const u8,
-    args: Expression,
-};
-
 const IfHeader = struct {
     condition: Expression,
 };
@@ -621,7 +573,6 @@ const Statement = union(enum) {
     expression: Expression,
     @"for": For,
     @"if": If,
-    call_template: CallTemplate,
 };
 
 const ControlBlock = struct {
@@ -633,7 +584,6 @@ const ControlBlock = struct {
         end_if: void,
         @"else": void,
         elif_header: IfHeader,
-        call_template: CallTemplate,
     };
     block: Data,
     strip_before: bool,
@@ -645,7 +595,6 @@ const Keyword = enum {
     @"if",
     @"else",
     @"elif",
-    @"template",
 };
 
 const EndKeyword = enum {

src/template/test.tmp.html

@@ -21,8 +21,6 @@
       {=#else=}
         neither
       {=/if}
-
-      <template>{#template test_tmpl .bar}</template>
     </section>
   </body>
 </html>