Conteúdo principal
- \\ Olá {{ nome }}! - \\conteúdo
" });
+//
+// var buf = std.ArrayList(u8){};
+// defer buf.deinit(alloc);
+//
+// const template = "Escape: {{ html }} | Safe: {{ html|safe }}";
+//
+// try renderer.renderString(template, buf.writer(alloc));
+//
+// try testing.expectEqualStrings("Escape: <div>conteúdo</div> | Safe: conteúdo
", buf.items);
+// }
+//
+// test "renderer - if and for" {
+// const alloc = testing.allocator;
+// var ctx = Context.init(alloc);
+// defer ctx.deinit();
+//
+// var cache = TemplateCache.init(alloc);
+// defer cache.deinit();
+//
+// const renderer = Renderer.init(&ctx, &cache);
+//
+// try ctx.set("ativo", Value{ .bool = true });
+// try ctx.set("nomes", Value{ .list = &[_]Value{
+// Value{ .string = "Ana" },
+// Value{ .string = "Bia" },
+// Value{ .string = "Cris" },
+// } });
+//
+// const template =
+// \\{% if ativo %}Sim!{% endif %}
+// \\{% if not ativo %}Não{% endif %}
+// \\Lista:
+// \\{% for nome in nomes %}
+// \\- {{ nome }}
+// \\{% endfor %}
+// ;
+//
+// var buf = std.ArrayList(u8){};
+// defer buf.deinit(alloc);
+//
+// try renderer.renderString(template, buf.writer(alloc));
+//
+// try testing.expect(std.mem.indexOf(u8, buf.items, "Sim!") != null);
+// try testing.expect(std.mem.indexOf(u8, buf.items, "Não") == null);
+// try testing.expect(std.mem.indexOf(u8, buf.items, "- Ana") != null);
+// try testing.expect(std.mem.indexOf(u8, buf.items, "- Bia") != null);
+// try testing.expect(std.mem.indexOf(u8, buf.items, "- Cris") != null);
+// }
+//
+// test "renderer - block and extends" {
+// const alloc = testing.allocator;
+// var ctx = Context.init(alloc);
+// defer ctx.deinit();
+//
+// var cache = TemplateCache.init(alloc);
+// defer cache.deinit();
+//
+// const renderer = Renderer.init(&ctx, &cache);
+//
+// const base =
+// \\
+// \\Bem-vindo
+// \\Conteúdo principal
+// \\ Olá {{ nome }}! +// \\Bem-vindo
+// \\Conteúdo principal
+// \\ Olá Lucas! +// \\Bem-vindo
") != null); +// try testing.expect(std.mem.indexOf(u8, output, "Olá Lucas!") != null); +// try testing.expectEqualStrings(expected, output); +// } +// +// test "renderer - comment" { +// const alloc = testing.allocator; +// +// const template = +// \\Normal: Olá {{ nome }} +// \\{% comment %} +// \\ Isso é um comentário +// \\ que não deve aparecer +// \\ nem processar variáveis {{ nome }} +// \\{% endcomment %} +// \\Fim: {{ nome }} +// ; +// const expected = +// \\Normal: Olá Lucas +// \\ +// \\Fim: Lucas +// ; +// +// var ctx = Context.init(alloc); +// defer ctx.deinit(); +// +// var cache = TemplateCache.init(alloc); +// defer cache.deinit(); +// +// const renderer = Renderer.init(&ctx, &cache); +// +// try ctx.set("nome", Value{ .string = "Lucas" }); +// +// var buf = std.ArrayList(u8){}; +// defer buf.deinit(alloc); +// +// try renderer.renderString(template, buf.writer(alloc)); +// +// const output = buf.items; +// +// try testing.expect(std.mem.indexOf(u8, output, "Olá Lucas") != null); +// try testing.expect(std.mem.indexOf(u8, output, "Fim: Lucas") != null); +// try testing.expect(std.mem.indexOf(u8, output, "Isso é um comentário") == null); +// try testing.expect(std.mem.indexOf(u8, output, "que não deve aparecer") == null); +// try testing.expect(std.mem.indexOf(u8, output, "nem processar variáveis") == null); +// try testing.expectEqualStrings(expected, output); +// } + +// FIX: comment inside block + +// test "renderer - full template with extends, super, include, comment" { +// const alloc = testing.allocator; +// +// const header = "
- \\ {{ block.super }}
- \\{% endblock %}
- ;
-
- try std.fs.cwd().writeFile(.{ .sub_path = "base.html", .data = base });
- try std.fs.cwd().writeFile(.{ .sub_path = "child.html", .data = child });
- defer std.fs.cwd().deleteFile("base.html") catch {};
- defer std.fs.cwd().deleteFile("child.html") catch {};
-
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
- cache.default_path = ".";
-
- const renderer = Renderer.init(&ctx, &cache);
-
- try ctx.set("value", 50);
-
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.render("child.html", buf.writer(alloc));
-
- const output = buf.items;
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{output});
-
- try testing.expect(std.mem.indexOf(u8, output, "Conteúdo padrão") != null);
- try testing.expect(std.mem.indexOf(u8, output, "Conteúdo do filho") != null);
-}
-
-test "renderer - now" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("15 - render now\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- try ctx.set("idade", Value{ .int = 20 });
-
- const template =
- \\{% now %}
- \\{% now \"Y-m-d H:i:s\" %}
- \\{% now \"Y" %}
- \\{% now \"m\" %}
- \\{% now \"n\" %}
- \\{% now \"d\" %}
- \\{% now \"j\" %}
- \\{% now \"F\" %}
- \\{% now \"M\" %}
- \\{% now \"l\" %}
- \\{% now \"D\" %}
- \\{% now \"H:i:s\" %}
- \\{% now \"H\" %}
- \\{% now \"G\" %}
- \\{% now \"i\" %}
- \\{% now \"s\" %}
- \\{% now \"a\" %}
- \\{% now \"A\" %}
- \\{% now \"P\" %}
- ;
-
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- // try testing.expect(std.mem.indexOf(u8, buf.items, "Maior") != null);
-}
-
-test "renderer - csrf_token in context" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("15 - csrf_token in context\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const token: []const u8 = "zh5fyUSICjXNsDTtJCjl9A3O2dDSHhYFlIngAEO6PXK9NX56Z1XLEy7doYuPcE0u";
-
- try ctx.set("csrf_token", token);
- const template =
- \\{% csrf_token %}
- ;
-
- const expected =
- \\
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - csrf_token not in context" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("16 - csrf_token not in context\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% csrf_token %}
- ;
-
- const expected =
- \\
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-// TODO: add parse filters to variables
-test "renderer - firstof withtout fallback" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("17 - firstof without fallback\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- try ctx.set("var1", "");
- try ctx.set("var2", "baz");
-
- const template =
- \\{% firstof var1 var2 %}
- ;
-
- const expected =
- \\baz
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - firstof with fallback" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("18 - firstof with fallback\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- try ctx.set("var1", "");
- try ctx.set("var2", 0);
-
- const template =
- \\{% firstof var1 var2 "Oops no value!" %}
- ;
-
- const expected =
- \\Oops no value!
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - firstof without value in context" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("19 - firstof without value in context\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% firstof 0 true "Oops no value!" %}
- ;
-
- const expected =
- \\true
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - firstof missing vars" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("20 - firstof missing vars\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% firstof %}
- ;
-
- const expected =
- \\
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - firstof missing vars with fallback" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("21 - firstof missing vars with fallback\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% firstof "nothing here" %}
- ;
-
- const expected =
- \\nothing here
- ;
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- // std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings(expected, buf.items);
-}
-
-test "renderer - lorem" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("22 - lorem\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% lorem %}
- ;
-
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expect(std.mem.indexOf(u8, buf.items, "Lorem ipsum") != null);
-}
-
-test "renderer - lorem with count and method words" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("23 - lorem with count and method words\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% lorem 3 w %}
- ;
-
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- try testing.expectEqualStrings("lorem ipsum dolor", buf.items);
-}
-
-test "renderer - lorem with count and method paragraphs" {
- std.debug.print("____________________________________________________\n", .{});
- std.debug.print("24 - lorem with count and method paragraphs\n", .{});
-
- const alloc = testing.allocator;
- var ctx = Context.init(alloc);
- defer ctx.deinit();
-
- var cache = TemplateCache.init(alloc);
- defer cache.deinit();
-
- const renderer = Renderer.init(&ctx, &cache);
-
- const template =
- \\{% lorem 5 p %}
- ;
-
- var buf = std.ArrayList(u8){};
- defer buf.deinit(alloc);
-
- try renderer.renderString(template, buf.writer(alloc));
-
- std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items});
-
- const qty = std.mem.count(u8, buf.items, ""); - try testing.expect(std.mem.indexOf(u8, buf.items, "Lorem ipsum dolor") != null); - try testing.expect(qty == 5); -} - -test "renderer - lorem only random" { - std.debug.print("____________________________________________________\n", .{}); - std.debug.print("25 - lorem only random\n", .{}); - - const alloc = testing.allocator; - var ctx = Context.init(alloc); - defer ctx.deinit(); - - var cache = TemplateCache.init(alloc); - defer cache.deinit(); - - const renderer = Renderer.init(&ctx, &cache); - - const template = - \\{% lorem true %} - ; - - var buf = std.ArrayList(u8){}; - defer buf.deinit(alloc); - - try renderer.renderString(template, buf.writer(alloc)); - - std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items}); - - try testing.expect(buf.items.len > 0); -} - -test "renderer - lorem words random" { - std.debug.print("____________________________________________________\n", .{}); - std.debug.print("26 - lorem words random\n", .{}); - - const alloc = testing.allocator; - var ctx = Context.init(alloc); - defer ctx.deinit(); - - var cache = TemplateCache.init(alloc); - defer cache.deinit(); - - const renderer = Renderer.init(&ctx, &cache); - - const template = - \\{% lorem 6 w true %} - ; - - var buf = std.ArrayList(u8){}; - defer buf.deinit(alloc); - - try renderer.renderString(template, buf.writer(alloc)); - - std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items}); - - const spaces = std.mem.count(u8, buf.items, " "); - try testing.expect(spaces == 5); -} - -test "renderer - lorem paragraphs random" { - std.debug.print("____________________________________________________\n", .{}); - std.debug.print("26 - lorem paragraphs random\n", .{}); - - const alloc = testing.allocator; - var ctx = Context.init(alloc); - defer ctx.deinit(); - - var cache = TemplateCache.init(alloc); - defer cache.deinit(); - - const renderer = Renderer.init(&ctx, &cache); - - const template = - \\{% lorem 3 p true %} - ; - - var buf = std.ArrayList(u8){}; - defer buf.deinit(alloc); - - try renderer.renderString(template, buf.writer(alloc)); - - std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items}); - - const spaces = std.mem.count(u8, buf.items, "
"); - try testing.expect(spaces == 3); -} - -test "renderer - svg" { - std.debug.print("____________________________________________________\n", .{}); - std.debug.print("27 - svg\n", .{}); - - const alloc = testing.allocator; - var ctx = Context.init(alloc); - defer ctx.deinit(); - - var cache = TemplateCache.init(alloc); - try cache.initIcons(); - defer cache.deinit(); - - const renderer = Renderer.init(&ctx, &cache); - - const template = - \\{% svg material kangaroo %} - ; - - var buf = std.ArrayList(u8){}; - defer buf.deinit(alloc); - - try renderer.renderString(template, buf.writer(alloc)); - - std.debug.print("OUTPUT:\n\n{s}\n", .{buf.items}); - - try testing.expect(std.mem.indexOf(u8, buf.items, "
") != null);
- // const spaces = std.mem.count(u8, buf.items, "
- {% block title %}Meu Site{% endblock %}
-
-
-
-
- {% include "partials/header.html" %}
-
- {% block content %}
-
-
-
diff --git a/templates/home.html b/templates/home.html
deleted file mode 100644
index d38eebe..0000000
--- a/templates/home.html
+++ /dev/null
@@ -1,28 +0,0 @@
-
-{% extends "base.html" %}
-
-{% block title %}Home - Meu Site{% endblock %}
-
-{% block menu %}
-{{ block.super }}
-Blog
-{% endblock %}
-
-{% block content %}
-
-
"); - // try testing.expect(spaces == 3); } diff --git a/src/root.zig b/src/root.zig index ff490a0..94c7cd0 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,11 +1,23 @@ -pub const cache = @import("cache.zig"); -pub const context = @import("context.zig"); -pub const delta = @import("delta.zig"); -pub const filters = @import("filters.zig"); -pub const icons = @import("svg/icons.zig"); -pub const lorem = @import("lorem.zig"); -pub const meta = @import("meta.zig"); -pub const parser = @import("parser.zig"); -pub const renderer = @import("renderer.zig"); -pub const time = @import("time.zig"); -pub const util = @import("util.zig"); +//! 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); +} diff --git a/src/svg/icons.zig b/src/svg/icons.zig deleted file mode 100644 index 5b4ad4f..0000000 --- a/src/svg/icons.zig +++ /dev/null @@ -1,117 +0,0 @@ -const std = @import("std"); - -pub const IconSet = enum { - bootstrap, - dripicons, - hero_outline, - hero_solid, - material, -}; - -pub const embedded_data = std.EnumMap(IconSet, []const u8).init(.{ - .bootstrap = @embedFile("bootstrap.svgs.bin"), - .dripicons = @embedFile("dripicons.svgs.bin"), - .hero_outline = @embedFile("hero_outline.svgs.bin"), - .hero_solid = @embedFile("hero_solid.svgs.bin"), - .material = @embedFile("material.svgs.bin"), -}); - -pub const SvgIcon = struct { - icon_map: std.StringHashMapUnmanaged([]const u8) = .{}, - - pub fn init(allocator: std.mem.Allocator) !SvgIcon { - var self = SvgIcon{}; - - inline for (std.meta.fields(IconSet)) |field| { - const set = @field(IconSet, field.name); - const data = embedded_data.get(set); - - try self.loadSet(allocator, set, data.?); - } - - return self; - } - - pub fn deinit(self: *SvgIcon, allocator: std.mem.Allocator) void { - var it = self.icon_map.iterator(); - while (it.next()) |entry| { - allocator.free(entry.key_ptr.*); - allocator.free(entry.value_ptr.*); - } - self.icon_map.deinit(allocator); - self.* = .{}; - } - - pub fn get(self: *const SvgIcon, key: []const u8) ?[]const u8 { - return self.icon_map.get(key); - } - - pub fn getIcon(self: *const SvgIcon,allocator: std.mem.Allocator, kind: []const u8, name: []const u8) ?[]const u8 { - const key = std.fmt.allocPrint(allocator, "{s}:{s}", .{ kind, name }) catch return null; - defer allocator.free(key); - return self.icon_map.get(key); - } - - pub fn count(self: *const SvgIcon) usize { - return self.icon_map.count(); - } - - fn loadSet( - self: *SvgIcon, - allocator: std.mem.Allocator, - set: IconSet, - data: []const u8, - ) !void { - if (data.len < 12) return error.InvalidEmbeddedData; - - var pos: usize = 0; - - const magic = std.mem.readInt(u32, data[pos..][0..4], .little); - pos += 4; - if (magic != 0x53564749) return error.InvalidMagic; - - const version = std.mem.readInt(u32, data[pos..][0..4], .little); - pos += 4; - if (version != 1) return error.UnsupportedVersion; - - const num_entries = std.mem.readInt(u32, data[pos..][0..4], .little); - pos += 4; - - const prefix = @tagName(set); - - var i: u32 = 0; - while (i < num_entries) : (i += 1) { - const name_len = std.mem.readInt(u32, data[pos..][0..4], .little); - pos += 4; - - if (pos + name_len > data.len) return error.CorruptedNameLength; - const name_slice = data[pos .. pos + name_len]; - pos += name_len; - - const svg_len = std.mem.readInt(u32, data[pos..][0..4], .little); - pos += 4; - - if (pos + svg_len > data.len) return error.CorruptedSvgLength; - const svg_slice = data[pos .. pos + svg_len]; - pos += svg_len; - - // Monta a chave com prefixo do set - const key = try std.fmt.allocPrint(allocator, "{s}:{s}", .{ prefix, name_slice }); - - // Duplica o conteúdo SVG (o map assume ownership) - const value = try allocator.dupe(u8, svg_slice); - - // Insere no mapa unmanaged - try self.icon_map.put(allocator, key, value); - } - } -}; - -pub const fallback_svg = - \\
- \\
- \\
-;
diff --git a/src/time.zig b/src/time.zig
deleted file mode 100644
index e27da58..0000000
--- a/src/time.zig
+++ /dev/null
@@ -1,878 +0,0 @@
-// https://github.com/cztomsik/tokamak
-const std = @import("std");
-const util = @import("util.zig");
-const testing = std.testing;
-const meta = @import("meta.zig");
-const dlt = @import("delta.zig");
-
-const RATA_MIN = date_to_rata(Date.MIN);
-const RATA_MAX = date_to_rata(Date.MAX);
-const RATA_TO_UNIX = 719468;
-const EOD = 86_400 - 1;
-
-pub const DAY_NAMES_SHORT = [_][]const u8{ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-pub const DAY_NAMES_LONG = [_][]const u8{ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-
-pub const MONTH_NAMES_SHORT = [_][]const u8{ "", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-pub const MONTH_NAMES_LONG = [_][]const u8{ "", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-
-pub const MONTH_DAYS = [12]u8{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-pub const TIME_CHUNKS = [4]u32{
- 60 * 60 * 24 * 7, //week
- 60 * 60 * 24, //day
- 60 * 60, //hour
- 60, //minute
-};
-
-pub const TIME_STRINGS = [6][]const u8{ "year", "month", "week", "day", "hour", "minute" };
-
-// TODO: Decide if we want to use std.debug.assert(), @panic() or just throw an error
-fn checkRange(num: anytype, min: @TypeOf(num), max: @TypeOf(num)) void {
- if (util.lt(num, min) or util.gt(num, max)) {
- // TODO: fix later (we can't use {f} and {any} is also wrong)
- // std.log.warn("Value {} is not in range [{}, {}]", .{ num, min, max });
- std.log.warn("Value not in range", .{});
- }
-}
-
-pub const TimeUnit = enum { second, minute, hour, day, month, year };
-pub const DateUnit = enum { day, month, year };
-
-// pub const SECS_PER_DAY: i64 = 86_400;
-// pub const SECS_PER_HOUR: i64 = 3_600;
-// pub const SECS_PER_MIN: i64 = 60;
-
-pub const TimeError = error{
- Eof,
- ExpectedNull,
- ExpectedValue,
- InvalidCharacter,
- InvalidFormat,
- Overflow,
- OutOfMemory,
-};
-
-// https://www.youtube.com/watch?v=0s9F4QWAl-E&t=2120
-pub fn isLeapYear(year: i32) bool {
- const d: i32 = if (@mod(year, 100) != 0) 4 else 16;
- return (year & (d - 1)) == 0;
-}
-
-// https://www.youtube.com/watch?v=0s9F4QWAl-E&t=2257
-pub fn daysInMonth(year: i32, month: u8) u8 {
- if (month == 2) {
- return if (isLeapYear(year)) 29 else 28;
- }
-
- return 30 | (month ^ (month >> 3));
-}
-
-pub fn formatDateTime(alloc: std.mem.Allocator, t: Time, format_str: []const u8) ![]u8 {
- var result = std.ArrayList(u8){};
- defer result.deinit(alloc);
- var writer = result.writer(alloc);
-
- var i: usize = 0;
- while (i < format_str.len) : (i += 1) {
- const c = format_str[i];
-
- if (c == '\\') {
- i += 1;
- if (i >= format_str.len) break;
- try writer.writeByte(format_str[i]);
- continue;
- }
-
- // Todos os códigos do date + time que já implementamos
- switch (c) {
- // === Códigos de data (do filtro date) ===
- 'Y' => try writer.print("{d:0>4}", .{@as(u16, @intCast(t.year()))}),
- 'm' => try writer.print("{d:0>2}", .{t.month()}),
- 'n' => try writer.print("{d}", .{t.month()}),
- 'd' => try writer.print("{d:0>2}", .{t.day()}),
- 'j' => try writer.print("{d}", .{t.day()}),
- 'F' => try writer.writeAll(t.monthNameLong()),
- 'M' => try writer.writeAll(t.monthNameShort()),
- 'l' => try writer.writeAll(t.weekdayNameLong()),
- 'D' => try writer.writeAll(t.weekdayNameShort()),
-
- // === Códigos de tempo (do filtro time) ===
- 'H' => try writer.print("{d:0>2}", .{t.hour()}),
- 'G' => try writer.print("{d}", .{t.hour()}),
- 'i' => try writer.print("{d:0>2}", .{t.minute()}),
- 's' => try writer.print("{d:0>2}", .{t.second()}),
- 'a' => try writer.writeAll(if (t.hour() < 12) "a.m." else "p.m."),
- 'A' => try writer.writeAll(if (t.hour() < 12) "AM" else "PM"),
- 'P' => {
- const hr24 = t.hour();
- const min = t.minute();
- if (hr24 == 0 and min == 0) {
- try writer.writeAll("midnight");
- } else if (hr24 == 12 and min == 0) {
- try writer.writeAll("noon");
- } else {
- var hr12 = @mod(hr24, 12);
- if (hr12 == 0) hr12 = 12;
- try writer.print("{d}", .{hr12});
- if (min > 0) try writer.print(":{d:0>2}", .{min});
- try writer.writeAll(if (hr24 < 12) " a.m." else " p.m.");
- }
- },
- 'u' => try writer.writeAll("000000"),
-
- else => try writer.writeByte(c),
- }
- }
-
- return try result.toOwnedSlice(alloc);
-}
-
-pub const Date = struct {
- year: i32,
- month: u8,
- day: u8,
-
- pub const MIN = Date.ymd(-1467999, 1, 1);
- pub const MAX = Date.ymd(1471744, 12, 31);
-
- pub fn cmp(a: Date, b: Date) std.math.Order {
- if (a.year != b.year) return util.cmp(a.year, b.year);
- if (a.month != b.month) return util.cmp(a.month, b.month);
- return util.cmp(a.day, b.day);
- }
-
- pub fn parse(str: []const u8) TimeError!Date {
- var it = std.mem.splitScalar(u8, str, '-');
- return ymd(
- try std.fmt.parseInt(i32, it.next() orelse return error.Eof, 10),
- try std.fmt.parseInt(u8, it.next() orelse return error.Eof, 10),
- try std.fmt.parseInt(u8, it.next() orelse return error.Eof, 10),
- );
- }
-
- pub fn ymd(year: i32, month: u8, day: u8) Date {
- return .{
- .year = year,
- .month = month,
- .day = day,
- };
- }
-
- pub fn today() Date {
- return Time.now().date();
- }
-
- pub fn yesterday() Date {
- return today().add(.day, -1);
- }
-
- pub fn tomorrow() Date {
- return today().add(.day, 1);
- }
-
- pub fn startOf(unit: DateUnit) Date {
- return today().setStartOf(unit);
- }
-
- pub fn endOf(unit: DateUnit) Date {
- return today().setEndOf(unit);
- }
-
- pub fn setStartOf(self: Date, unit: DateUnit) Date {
- return switch (unit) {
- .day => self,
- .month => ymd(self.year, self.month, 1),
- .year => ymd(self.year, 1, 1),
- };
- }
-
- pub fn setEndOf(self: Date, unit: DateUnit) Date {
- return switch (unit) {
- .day => self,
- .month => ymd(self.year, self.month, daysInMonth(self.year, self.month)),
- .year => ymd(self.year, 12, 31),
- };
- }
-
- pub fn add(self: Date, part: DateUnit, amount: i64) Date {
- return switch (part) {
- .day => Time.unix(0).setDate(self).add(.days, amount).date(),
- .month => {
- const total_months = @as(i32, self.month) + @as(i32, @intCast(amount));
- const new_year = self.year + @divFloor(total_months - 1, 12);
- const new_month = @as(u8, @intCast(@mod(total_months - 1, 12) + 1));
- return ymd(
- new_year,
- new_month,
- @min(self.day, daysInMonth(new_year, new_month)),
- );
- },
- .year => {
- const new_year = self.year + @as(i32, @intCast(amount));
- return ymd(
- new_year,
- self.month,
- @min(self.day, daysInMonth(new_year, self.month)),
- );
- },
- };
- }
-
- pub fn dayOfWeek(self: Date) u8 {
- const rata_day = date_to_rata(self);
- return @intCast(@mod(rata_day + 3, 7));
- }
-
- pub fn format(self: Date, writer: anytype) !void {
- try writer.print("{d}-{d:0>2}-{d:0>2}", .{
- @as(u32, @intCast(self.year)),
- self.month,
- self.day,
- });
- }
-
- pub fn ordinal(self: Date) usize {
- const days_before_month = [_]u16{ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
-
- var days: usize = days_before_month[self.month];
- days += self.day;
-
- if (self.month > 2 and isLeapYear(self.year)) {
- days += 1;
- }
-
- return days;
- }
-
- pub fn weekday(self: Date) u8 {
- const y: i32 = self.year;
- const m: u8 = self.month;
- const d: u8 = self.day;
-
- const t = [_]i32{ 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
- var year_adj: i32 = y;
- if (m < 3) year_adj -= 1;
-
- var wd: i32 = year_adj + @divFloor(year_adj, 4) - @divFloor(year_adj, 100) + @divFloor(year_adj, 400) + t[m - 1] + @as(i32, d);
- wd = @mod(wd, 7);
- if (wd < 0) wd += 7;
-
- return @intCast(if (wd == 6) 7 else wd + 1);
- }
-
- pub fn isoWeek(self: Date) u8 {
- const iso_y = self.isoWeekYear();
- const jan4 = Date{ .year = iso_y, .month = 1, .day = 4 };
- const jan4_ord: i32 = @intCast(jan4.ordinal());
- const self_ord: i32 = @intCast(self.ordinal());
-
- const days_diff = self_ord - jan4_ord;
- const week = @divFloor(days_diff + 4, 7) + 1; // +4 corrige o offset (testado em Python)
-
- return @intCast(@max(1, @min(53, week)));
- }
-
- pub fn isoWeekYear(self: Date) i32 {
- const wd = self.weekday(); // 1=Seg ... 7=Dom
- const ord = @as(i32, @intCast(self.ordinal()));
- const thursday_ord = ord + (4 - (wd - 1)); // quinta da semana
-
- var y = self.year;
-
- var days_in_year: i32 = 365;
- if (isLeapYear(y)) days_in_year = 366;
-
- if (thursday_ord <= 0) {
- y -= 1;
- } else if (thursday_ord > days_in_year) {
- y += 1;
- }
- return y;
- }
-};
-
-pub const TimeTime = struct {
- hour: u32,
- minute: u32,
- second: u32,
-
- fn cmp(a: TimeTime, b: TimeTime) std.math.Order {
- if (a.hour < b.hour) return .lt;
- if (a.hour > b.hour) return .gt;
- if (a.minute < b.minute) return .lt;
- if (a.minute > b.minute) return .gt;
- if (a.second < b.second) return .lt;
- if (a.second > b.second) return .gt;
- return .eq;
- }
-};
-
-pub const Time = struct {
- epoch: i64,
-
- pub fn parse(str: []const u8) !Time {
- if (std.mem.indexOfScalar(u8, str, ' ')) |space| {
- // Datetime: "YYYY-MM-DD HH:MM:SS"
- const date_str = str[0..space];
- const time_str = str[space + 1 ..];
-
- const d = try Date.parse(date_str);
-
- var it = std.mem.splitScalar(u8, time_str, ':');
- const h = try std.fmt.parseInt(u8, it.next() orelse return error.InvalidFormat, 10);
- const m = try std.fmt.parseInt(u8, it.next() orelse return error.InvalidFormat, 10);
- const s = try std.fmt.parseInt(u8, it.next() orelse return error.InvalidFormat, 10);
-
- var t = Time.unix(0).setDate(d);
- t = t.setHour(h).setMinute(m).setSecond(s);
- return t;
- } else {
- const d = try Date.parse(str);
- return Time.unix(0).setDate(d);
- }
- return Time.now();
- }
-
- pub fn unix(epoch: i64) Time {
- return .{ .epoch = epoch };
- }
-
- pub fn new(y: i32, m: u8, d: u8, h: ?u32, min: ?u32, sec: ?u32) Time {
- var t = unix(0).setDate(.ymd(y, m, d));
- if (h) |h_| t = t.setHour(h_);
- if (min) |min_| t = t.setMinute(min_);
- if (sec) |sec_| t = t.setSecond(sec_);
- return t;
- }
-
- pub fn now() Time {
- return unix(std.time.timestamp());
- }
-
- pub fn now_offset(offset: i64) Time {
- return unix(std.time.timestamp() + (offset * std.time.s_per_hour));
- }
-
- pub fn today() Time {
- return unix(0).setDate(.today());
- }
-
- pub fn tomorrow() Time {
- return unix(0).setDate(.tomorrow());
- }
-
- pub fn startOf(unit: TimeUnit) Time {
- return Time.now().setStartOf(unit);
- }
-
- pub fn endOf(unit: TimeUnit) Time {
- return Time.now().setEndOf(unit);
- }
-
- pub fn second(self: Time) u32 {
- return @intCast(@mod(self.total(.seconds), 60));
- }
-
- pub fn setSecond(self: Time, sec: u32) Time {
- return self.add(.seconds, @as(i64, sec) - self.second());
- }
-
- pub fn minute(self: Time) u32 {
- return @intCast(@mod(self.total(.minutes), 60));
- }
-
- pub fn setMinute(self: Time, min: u32) Time {
- return self.add(.minutes, @as(i64, min) - self.minute());
- }
-
- pub fn hour(self: Time) u32 {
- return @intCast(@mod(self.total(.hours), 24));
- }
-
- pub fn setHour(self: Time, hr: u32) Time {
- return self.add(.hours, @as(i64, hr) - self.hour());
- }
-
- pub fn date(self: Time) Date {
- return rata_to_date(@divTrunc(self.epoch, std.time.s_per_day) + RATA_TO_UNIX);
- }
-
- pub fn setDate(self: Time, dat: Date) Time {
- var res: i64 = @mod(self.epoch, std.time.s_per_day);
- res += (date_to_rata(dat) - RATA_TO_UNIX) * std.time.s_per_day;
- return unix(res);
- }
-
- pub fn time(self: Time) TimeTime {
- return .{
- .hour = self.hour(),
- .minute = self.minute(),
- .second = self.second(),
- };
- }
-
- pub fn setStartOf(self: Time, unit: TimeUnit) Time {
- // TODO: continue :label?
- return switch (unit) {
- .second => self,
- .minute => self.setSecond(0),
- .hour => self.setSecond(0).setMinute(0),
- .day => self.setSecond(0).setMinute(0).setHour(0),
- .month => {
- const d = self.date();
- return unix(0).setDate(.ymd(d.year, d.month, 1));
- },
- .year => {
- const d = self.date();
- return unix(0).setDate(.ymd(d.year, 1, 1));
- },
- };
- }
-
- // TODO: rename to startOfNext?
- pub fn next(self: Time, unit: enum { second, minute, hour, day }) Time {
- return switch (unit) {
- .second => self.add(.seconds, 1),
- .minute => self.setSecond(0).add(.minutes, 1),
- .hour => self.setSecond(0).setMinute(0).add(.hours, 1),
- .day => self.setSecond(0).setMinute(0).setHour(0).add(.hours, 24),
- };
- }
-
- pub fn setEndOf(self: Time, unit: TimeUnit) Time {
- // TODO: continue :label?
- return switch (unit) {
- .second => self,
- .minute => self.setSecond(59),
- .hour => self.setSecond(59).setMinute(59),
- .day => self.setSecond(59).setMinute(59).setHour(23),
- .month => {
- const d = self.date();
- return unix(EOD).setDate(.ymd(d.year, d.month, daysInMonth(d.year, d.month)));
- },
- .year => {
- const d = self.date();
- return unix(EOD).setDate(.ymd(d.year, 12, 31));
- },
- };
- }
-
- pub fn add(self: Time, part: enum { seconds, minutes, hours, days, months, years }, amount: i64) Time {
- const n = switch (part) {
- .seconds => amount,
- .minutes => amount * std.time.s_per_min,
- .hours => amount * std.time.s_per_hour,
- .days => amount * std.time.s_per_day,
- .months => return self.setDate(self.date().add(.month, amount)),
- .years => return self.setDate(self.date().add(.year, amount)),
- };
-
- return .{ .epoch = self.epoch + n };
- }
-
- fn total(self: Time, part: enum { seconds, minutes, hours }) i64 {
- return switch (part) {
- .seconds => self.epoch,
- .minutes => @divTrunc(self.epoch, std.time.s_per_min),
- .hours => @divTrunc(self.epoch, std.time.s_per_hour),
- };
- }
-
- fn year(self: Time) i32 {
- return self.date().year;
- }
-
- fn month(self: Time) u8 {
- return self.date().month;
- }
-
- fn day(self: Time) u8 {
- return self.date().day;
- }
-
- fn monthNameLong(self: Time) []const u8 {
- return MONTH_NAMES_LONG[self.date().month];
- }
-
- fn monthNameShort(self: Time) []const u8 {
- return MONTH_NAMES_SHORT[self.date().month];
- }
-
- fn weekdayNameLong(self: Time) []const u8 {
- return DAY_NAMES_LONG[self.date().weekday()];
- }
-
- fn weekdayNameShort(self: Time) []const u8 {
- return DAY_NAMES_SHORT[self.date().weekday()];
- }
-
- pub fn format(self: Time, writer: anytype) !void {
- try writer.print("{f} {d:0>2}:{d:0>2}:{d:0>2} UTC", .{
- self.date(),
- self.hour(),
- self.minute(),
- self.second(),
- });
- }
-
- pub fn toStringAlloc(self: Time, alloc: std.mem.Allocator, format_str: ?[]const u8) TimeError![]u8 {
- const fmt = format_str orelse "Y-m-d H:i:s";
- return try formatDateTime(alloc, self, fmt);
- }
-
- pub fn toString(self: Time, format_str: ?[]const u8) TimeError![]const u8 {
- return try self.toStringAlloc(std.heap.page_allocator, format_str);
- }
-
- pub fn addRelative(self: Time, delta: dlt.RelativeDelta) Time {
- var d = delta;
- d.normalize(); // garante que meses/horas/etc estejam normalizados
-
- // 1. Parte calendáríca (anos + meses + dias)
- var dt = self.date();
-
- // anos primeiro (mais estável)
- if (d.years != 0) {
- dt = dt.add(.year, d.years);
- }
-
- // depois meses (respeita dias-in-mês)
- if (d.months != 0) {
- dt = dt.add(.month, d.months);
- }
-
- // por fim dias normais
- if (d.days != 0) {
- dt = dt.add(.day, d.days);
- }
-
- // 2. Parte do relógio (horas, minutos, segundos)
- var result = self.setDate(dt);
-
- // Podemos usar o .add() existente para segundos/minutos/horas
- if (d.seconds != 0) {
- result = result.add(.seconds, d.seconds);
- }
- if (d.minutes != 0) {
- result = result.add(.minutes, d.minutes);
- }
- if (d.hours != 0) {
- result = result.add(.hours, d.hours);
- }
-
- return result;
- }
-
- pub fn subRelative(self: Time, other: Time) dlt.RelativeDelta {
- var delta = dlt.RelativeDelta{};
-
- // Parte de tempo (horas, min, seg) – igual antes
- var seconds_diff: i64 = self.epoch - other.epoch;
-
- delta.seconds = @as(i32, @intCast(@rem(seconds_diff, 60)));
- seconds_diff = @divTrunc(seconds_diff, 60);
-
- delta.minutes = @as(i32, @intCast(@rem(seconds_diff, 60)));
- seconds_diff = @divTrunc(seconds_diff, 60);
-
- delta.hours = @as(i32, @intCast(@rem(seconds_diff, 24)));
- seconds_diff = @divTrunc(seconds_diff, 24);
-
- // Parte calendárica
- var later = self.date();
- var earlier = other.date();
-
- const swapped = later.cmp(earlier) == .lt;
-
- if (swapped) {
- // const temp = later;
- // later = earlier;
- // earlier = temp;
- std.mem.swap(i32, &later.year, &earlier.year);
- }
-
- var years: i32 = later.year - earlier.year;
- var months: i32 = @as(i32, later.month) - @as(i32, earlier.month);
-
- if (months < 0) {
- years -= 1;
- months += 12;
- }
-
- var days: i32 = @as(i32, later.day) - @as(i32, earlier.day);
-
- // Ajuste rigoroso para borrow (com handling de bissexto)
- if (days < 0) {
- const days_in_target = daysInMonth(later.year, later.month);
- if (later.day == days_in_target) {
- // Caso especial (ex: 28/fev não-bissexto vs 29/fev bissexto): ignora borrow, trata como período completo
- days = 0;
- } else {
- // Borrow normal, mas ajusta se earlier.day > dias no mês anterior (para casos como 29 > 28)
- const prev_month = later.add(.month, -1);
- var days_borrow: i32 = @as(i32, daysInMonth(prev_month.year, prev_month.month));
- if (earlier.day > @as(u8, @intCast(days_borrow))) {
- days_borrow = @as(i32, earlier.day);
- }
- std.debug.print("days_borrow em subRelative {d}\n", .{days_borrow});
- days += days_borrow;
- months -= 1;
- if (months < 0) {
- years -= 1;
- months += 12;
- }
- }
- }
-
- // Atribui com sinal
- delta.years = if (swapped) -years else years;
- delta.months = if (swapped) -months else months;
- delta.days = if (swapped) -days else days;
-
- // Normaliza (já lida com excessos, mas aqui é só para meses/anos)
- delta.normalize();
-
- return delta;
- }
-
- pub fn timeSince(self: Time, alloc: std.mem.Allocator, then: Time) TimeError![]u8 {
- if (self.epoch >= then.epoch) {
- return try alloc.dupe(u8, "0 minutes");
- }
- var total_months: i64 = 0;
- const delta_year: i64 = (then.year() - self.year()) * 12;
- const delta_month: i32 = @as(i32, @intCast(then.month())) - @as(i32, @intCast(self.month()));
-
- total_months = delta_year + delta_month;
-
- if (self.day() > then.day() or (self.day() == then.day() and self.time().cmp(then.time()) == .gt)) {
- total_months -= 1;
- }
- const months = @rem(total_months, 12);
- const years = @divTrunc(total_months, 12);
- var pivot_year: i64 = 0;
- var pivot_month: i64 = 0;
- var pivot: Time = undefined;
-
- if (years > 0 or months > 0) {
- pivot_year = @as(i64, self.year()) + years;
- pivot_month = @as(i64, self.month()) + months;
- if (pivot_month > 12) {
- pivot_year += 1;
- pivot_month -= 12;
- }
- const d: u8 = @min(MONTH_DAYS[@intCast(pivot_month - 1)], self.day());
- pivot = Time.new(
- @as(i32, @intCast(pivot_year)),
- @as(u8, @intCast(pivot_month)),
- d,
- self.hour(),
- self.minute(),
- self.second(),
- );
- } else {
- pivot = self;
- }
- var remaining_time = then.epoch - pivot.epoch;
-
- var partials = std.ArrayList(i64){};
- errdefer partials.deinit(alloc);
-
- try partials.append(alloc, years);
- try partials.append(alloc, months);
-
- for (TIME_CHUNKS) |chunk| {
- const count: i32 = @intCast(@divFloor(remaining_time, chunk));
- try partials.append(alloc, count);
- remaining_time -= count * @as(i32, @intCast(chunk));
- }
-
- const min: i64 = std.mem.min(i64, partials.items);
- const max: i64 = std.mem.max(i64, partials.items);
-
- if (min == 0 and max == 0) {
- return try alloc.dupe(u8, "0 minutes");
- }
-
- var buf = std.ArrayList(u8){};
- errdefer buf.deinit(alloc);
-
- var count: i32 = 0;
- for (partials.items, 0..) |partial, i| {
- if (partial > 0) {
- if (count >= 2) break;
- try buf.appendSlice(alloc, try std.fmt.allocPrint(alloc, "{d} {s}{s}", .{ partial, TIME_STRINGS[i], if (partial > 1) "s" else "" }));
- if (count == 0 and i < partials.items.len - 1) try buf.appendSlice(alloc, ", ");
- count += 1;
- }
- }
-
- return try buf.toOwnedSlice(alloc);
- }
-};
-
-// https://github.com/cassioneri/eaf/blob/1509faf37a0e0f59f5d4f11d0456fd0973c08f85/eaf/gregorian.hpp#L42
-fn rata_to_date(N: i64) Date {
- checkRange(N, RATA_MIN, RATA_MAX);
-
- // Century.
- const N_1: i64 = 4 * N + 3;
- const C: i64 = quotient(N_1, 146097);
- const N_C: u32 = remainder(N_1, 146097) / 4;
-
- // Year.
- const N_2 = 4 * N_C + 3;
- const Z: u32 = N_2 / 1461;
- const N_Y: u32 = N_2 % 1461 / 4;
- const Y: i64 = 100 * C + Z;
-
- // Month and day.
- const N_3: u32 = 5 * N_Y + 461;
- const M: u32 = N_3 / 153;
- const D: u32 = N_3 % 153 / 5;
-
- // Map.
- const J: u32 = @intFromBool(M >= 13);
-
- return .{
- .year = @intCast(Y + J),
- .month = @intCast(M - 12 * J),
- .day = @intCast(D + 1),
- };
-}
-
-// https://github.com/cassioneri/eaf/blob/1509faf37a0e0f59f5d4f11d0456fd0973c08f85/eaf/gregorian.hpp#L88
-fn date_to_rata(date: Date) i32 {
- checkRange(date, Date.MIN, Date.MAX);
-
- // Map.
- const J: u32 = @intFromBool(date.month <= 2);
- const Y: i32 = date.year - @as(i32, @intCast(J));
- const M: u32 = date.month + 12 * J;
- const D: u32 = date.day - 1;
- const C: i32 = @intCast(quotient(Y, 100));
-
- // Rata die.
- const y_star: i32 = @intCast(quotient(1461 * @as(i64, Y), 4) - C + quotient(C, 4)); // n_days in all prev. years
- const m_star: u32 = (153 * M - 457) / 5; // n_days in prev. months
-
- return y_star + @as(i32, @intCast(m_star)) + @as(i32, @intCast(D));
-}
-
-fn quotient(n: i64, d: u32) i64 {
- return if (n >= 0) @divTrunc(n, d) else @divTrunc((n + 1), d) - 1;
-}
-
-fn remainder(n: i64, d: u32) u32 {
- return @intCast(if (n >= 0) @mod(n, d) else (n + d) - d * quotient((n + d), d));
-}
-
-// const testing = @import("testing.zig");
-/// Attempts to print `arg` into a buf and then compare those strings.
-pub const allocator = std.testing.allocator;
-pub fn expectFmt(arg: anytype, expected: []const u8) !void {
- var wb = std.io.Writer.Allocating.init(allocator);
- defer wb.deinit();
-
- try wb.writer.print("{f}", .{arg});
- try std.testing.expectEqualStrings(expected, wb.written());
-}
-
-pub fn expectEqual(res: anytype, expected: meta.Const(@TypeOf(res))) TimeError!void {
- if (meta.isOptional(@TypeOf(res))) {
- if (expected) |e| return expectEqual(res orelse return error.ExpectedValue, e);
- if (res != null) return error.ExpectedNull;
- }
-
- // TODO: find all usages of expectEqualStrings and replace it with our expectEqual
- if (meta.isString(@TypeOf(res))) {
- return std.testing.expectEqualStrings(expected, res);
- }
-
- return std.testing.expectEqual(expected, res);
-}
-
-// test "basic usage" {
-// const t1 = Time.unix(1234567890);
-// try expectFmt(t1, "2009-02-13 23:31:30 UTC");
-//
-// try expectEqual(t1.date(), .{
-// .year = 2009,
-// .month = 2,
-// .day = 13,
-// });
-//
-// try expectEqual(t1.hour(), 23);
-// try expectEqual(t1.minute(), 31);
-// try expectEqual(t1.second(), 30);
-//
-// const t2 = t1.setHour(10).setMinute(15).setSecond(45);
-// try expectFmt(t2, "2009-02-13 10:15:45 UTC");
-//
-// const t3 = t2.add(.hours, 14).add(.minutes, 46).add(.seconds, 18);
-// try expectFmt(t3, "2009-02-14 01:02:03 UTC");
-//
-// // t.next()
-// try expectFmt(t3.next(.second), "2009-02-14 01:02:04 UTC");
-// try expectFmt(t3.next(.minute), "2009-02-14 01:03:00 UTC");
-// try expectFmt(t3.next(.hour), "2009-02-14 02:00:00 UTC");
-// try expectFmt(t3.next(.day), "2009-02-15 00:00:00 UTC");
-//
-// // t.setStartOf()
-// try expectFmt(t3.setStartOf(.minute), "2009-02-14 01:02:00 UTC");
-// try expectFmt(t3.setStartOf(.hour), "2009-02-14 01:00:00 UTC");
-// try expectFmt(t3.setStartOf(.day), "2009-02-14 00:00:00 UTC");
-// try expectFmt(t3.setStartOf(.month), "2009-02-01 00:00:00 UTC");
-// try expectFmt(t3.setStartOf(.year), "2009-01-01 00:00:00 UTC");
-//
-// // t.setEndOf()
-// try expectFmt(t3.setEndOf(.minute), "2009-02-14 01:02:59 UTC");
-// try expectFmt(t3.setEndOf(.hour), "2009-02-14 01:59:59 UTC");
-// try expectFmt(t3.setEndOf(.day), "2009-02-14 23:59:59 UTC");
-// try expectFmt(t3.setEndOf(.month), "2009-02-28 23:59:59 UTC");
-// try expectFmt(t3.setEndOf(.year), "2009-12-31 23:59:59 UTC");
-// }
-//
-// test "edge-cases" {
-// const jan31 = Date.ymd(2023, 1, 31);
-// try expectEqual(jan31.add(.month, 1), Date.ymd(2023, 2, 28));
-// try expectEqual(jan31.add(.month, 2), Date.ymd(2023, 3, 31));
-// try expectEqual(jan31.add(.month, -1), Date.ymd(2022, 12, 31));
-// try expectEqual(jan31.add(.month, -2), Date.ymd(2022, 11, 30));
-// try expectEqual(jan31.add(.year, 1).add(.month, 1), Date.ymd(2024, 2, 29));
-//
-// const feb29 = Time.unix(951782400); // 2000-02-29 00:00:00
-// try expectFmt(feb29.setEndOf(.month), "2000-02-29 23:59:59 UTC");
-// try expectFmt(feb29.add(.years, 1), "2001-02-28 00:00:00 UTC");
-// try expectFmt(feb29.add(.years, 4), "2004-02-29 00:00:00 UTC");
-// }
-//
-// test isLeapYear {
-// try testing.expect(!isLeapYear(1999));
-// try testing.expect(isLeapYear(2000));
-// try testing.expect(isLeapYear(2004));
-// }
-//
-// test daysInMonth {
-// try expectEqual(daysInMonth(1999, 2), 28);
-// try expectEqual(daysInMonth(2000, 2), 29);
-// try expectEqual(daysInMonth(2000, 7), 31);
-// try expectEqual(daysInMonth(2000, 8), 31);
-// }
-//
-// test rata_to_date {
-// try expectEqual(rata_to_date(RATA_MIN), Date.MIN);
-// try expectEqual(rata_to_date(RATA_MAX), Date.MAX);
-//
-// try expectEqual(rata_to_date(0), .ymd(0, 3, 1));
-// try expectEqual(rata_to_date(RATA_TO_UNIX), .ymd(1970, 1, 1));
-// }
-//
-// test date_to_rata {
-// try expectEqual(date_to_rata(Date.MIN), RATA_MIN);
-// try expectEqual(date_to_rata(Date.MAX), RATA_MAX);
-//
-// try expectEqual(date_to_rata(.ymd(0, 3, 1)), 0);
-// try expectEqual(date_to_rata(.ymd(1970, 1, 1)), RATA_TO_UNIX);
-// }
diff --git a/src/util.zig b/src/util.zig
deleted file mode 100644
index a36f8ff..0000000
--- a/src/util.zig
+++ /dev/null
@@ -1,149 +0,0 @@
-// https://github.com/cztomsik/tokamak
-const std = @import("std");
-
-pub const whitespace = std.ascii.whitespace;
-
-pub fn plural(n: i64, singular: []const u8, plural_str: []const u8) []const u8 {
- return if (n == 1) singular else plural_str;
-}
-
-pub fn trim(slice: []const u8) []const u8 {
- return std.mem.trim(u8, slice, &whitespace);
-}
-
-pub fn truncateEnd(text: []const u8, width: usize) []const u8 {
- return if (text.len <= width) text else text[text.len - width ..];
-}
-
-pub fn truncateStart(text: []const u8, width: usize) []const u8 {
- return if (text.len <= width) text else text[0..width];
-}
-
-pub fn countScalar(comptime T: type, slice: []const T, value: T) usize {
- var n: usize = 0;
- for (slice) |c| {
- if (c == value) n += 1;
- }
- return n;
-}
-
-pub fn Cmp(comptime T: type) type {
- return struct {
- // TODO: can we somehow flatten the anytype?
- // pub const cmp = if (std.meta.hasMethod(T, "cmp")) T.cmp else std.math.order;
-
- pub fn cmp(a: T, b: T) std.math.Order {
- if (std.meta.hasMethod(T, "cmp")) {
- return a.cmp(b);
- }
-
- return std.math.order(a, b);
- }
-
- pub fn lt(a: T, b: T) bool {
- return @This().cmp(a, b) == .lt;
- }
-
- pub fn eq(a: T, b: T) bool {
- return @This().cmp(a, b) == .eq;
- }
-
- pub fn gt(a: T, b: T) bool {
- return @This().cmp(a, b) == .gt;
- }
- };
-}
-
-pub fn cmp(a: anytype, b: @TypeOf(a)) std.math.Order {
- return Cmp(@TypeOf(a)).cmp(a, b);
-}
-
-pub fn lt(a: anytype, b: @TypeOf(a)) bool {
- return Cmp(@TypeOf(a)).lt(a, b);
-}
-
-pub fn eq(a: anytype, b: @TypeOf(a)) bool {
- return Cmp(@TypeOf(a)).eq(a, b);
-}
-
-pub fn gt(a: anytype, b: @TypeOf(a)) bool {
- return Cmp(@TypeOf(a)).gt(a, b);
-}
-
-// /// ---------------------------------------------------------------
-// /// 1️⃣ Detecta se um tipo é std.ArrayList(T)
-// /// ---------------------------------------------------------------
-// fn isArrayList(comptime T: type) bool {
-// // @typeName devolve a string completa, por exemplo:
-// // "std.ArrayList(i32)" ou "std.ArrayList([]const u8)"
-// const name = @typeName(T);
-// // Queremos garantir que o prefixo seja exatamente "std.ArrayList("
-// // (inclui o parêntese de abertura para evitar colisões com nomes
-// // semelhantes, como "my_std.ArrayListHelper").
-// // return std.mem.startsWith(u8, name, "std.ArrayList(");
-// return std.mem.startsWith(u8, name, "array_list");
-// }
-//
-// /// ---------------------------------------------------------------
-// /// 2️⃣ Obtém o tipo dos elementos armazenados em std.ArrayList(T)
-// /// ---------------------------------------------------------------
-// fn arrayListElemType(comptime ListT: type) type {
-// // Sabemos que ListT tem a forma std.ArrayList(T). O primeiro campo
-// // interno do struct é `items: []T`. Vamos ler esse campo.
-// const ti = @typeInfo(ListT);
-// if (ti != .@"struct") @compileError("Esperado um struct");
-//
-// // O campo `items` está na posição 0 da lista de fields:
-// const items_field = ti.@"struct".fields[0];
-// // Seu tipo é []T (slice). Em Zig, slices são representados como
-// // ponteiros (`*T`) com comprimento separado, mas o tipo declarado
-// // aqui é exatamente `[]T`, que corresponde a .pointer com
-// // .is_slice = true.
-// const slice_type = items_field.type;
-// const slice_info = @typeInfo(slice_type);
-// if (slice_info != .pointer) @compileError("Campo `items` não é slice");
-//
-// // O tipo filho da slice é o T que procuramos.
-// return slice_info.pointer.child;
-// }
-//
-// /// ---------------------------------------------------------------
-// /// 3️⃣ Função genérica que aceita *qualquer* tipo e age
-// /// de acordo se o argumento for um ArrayList ou não.
-// /// ---------------------------------------------------------------
-// pub fn handle(comptime ArgT: type, arg: ArgT) void {
-// if (isArrayList(ArgT)) {
-// // É um ArrayList – descobrimos o tipo dos elementos.
-// const Elem = arrayListElemType(ArgT);
-//
-// // Exemplo de uso genérico: imprimir tamanho e tipo dos itens.
-// std.debug.print(
-// "Recebi um std.ArrayList<{s}> contendo {d} itens.\n",
-// .{ @typeName(Elem), arg.items.len },
-// );
-//
-// // // Iterar de forma genérica (não sabemos o tipo exato de Elem,
-// // // então só fazemos operações que são válidas para *qualquer* tipo).
-// // var it = arg.iterator();
-// // while (it.next()) |item| {
-// // // `item` tem tipo `Elem`. Se precisar de lógica específica,
-// // // pode fazer outra inspeção de tipo aqui.
-// // _ = item; // evita warning de variável não usada
-// // }
-// for(arg.items) |item| {
-// _=item;
-// }
-// } else {
-// // Não é um ArrayList – apenas informamos o tipo real.
-// std.debug.print(
-// "O argumento NÃO é um std.ArrayList (é {s}).\n",
-// .{@typeName(ArgT)},
-// );
-// }
-// }
-
-test {
- try std.testing.expect(lt(1, 2));
- try std.testing.expect(eq(2, 2));
- try std.testing.expect(gt(2, 1));
-}
diff --git a/templates/base.html b/templates/base.html
deleted file mode 100644
index bafa6a6..0000000
--- a/templates/base.html
+++ /dev/null
@@ -1,26 +0,0 @@
-
-
-
-
- Conteúdo padrão
{% endblock %} -Bem-vindo, {{ user.name }}!
-{% now "d/m/Y H:i:s" %} -Você tem {{ user.notifications }} notificações pendentes.
- -Últimos itens:
--
- {% for item in itens %}
-
- {{ forloop.counter }}: {{ item }} - {% empty %} -
- Nenhum item encontrado. - {% endfor %} -
Mensagem temporária: {{ msg|upper }}
-{% endwith %} -{% endblock %} diff --git a/templates/partials/header.html b/templates/partials/header.html deleted file mode 100644 index b298c25..0000000 --- a/templates/partials/header.html +++ /dev/null @@ -1,12 +0,0 @@ -