size: 6 KiB

  

const std = @import("std");
const fs = std.fs;
const os = std.os;
const mem = std.mem;
const t = std.testing;
const println = @import("utils.zig").println;
const Djot = @import("Djot.zig");
const Post = @import("Post.zig");
const templates = @import("templates.zig");
const html = @import("html.zig");
const Meta = @import("Meta.zig");
const feed = @import("feed.zig");
const datetime = @import("datetime.zig");
pub fn main() !u8 {
    var target_dir: [*:0]const u8 = undefined;
    switch (os.argv.len) {
        1 => target_dir = ".",
        2 => target_dir = os.argv[1],
        else => {
            std.debug.print("Usage: loa [target_dir]\n", .{});
            return 1;
        },
    }
    return try entrypoint(target_dir, null);
}
pub fn entrypoint(target_dir: [*:0]const u8, custom_now: ?[]const u8) !u8 {
    var timer = try std.time.Timer.start();
    defer println("Took {d}ms", .{timer.read() / 1_000_000});
    var gpa_state = std.heap.DebugAllocator(.{}){};
    const gpa = gpa_state.allocator();
    defer _ = gpa_state.deinit();
    var global_arena_state = std.heap.ArenaAllocator.init(gpa);
    defer global_arena_state.deinit();
    const global_arena = global_arena_state.allocator();
    const now =
        if (custom_now) |cnow|
            cnow
        else
            try datetime.now(global_arena);
    var dir = try fs.cwd().openDirZ(target_dir, .{ .iterate = true });
    defer dir.close();
    const meta = Meta.load(global_arena, dir) catch |err| {
        switch (err) {
            error.FileNotFound => {
                println(
                    "Error: {s} not found. Please create it first.",
                    .{Meta.file_path},
                );
                return 1;
            },
            else => return err,
        }
    };
    // Write static file(s)
    {
        var static_dir = try dir.makeOpenPath("_loa", .{});
        defer static_dir.close();
        try static_dir.writeFile(.{
            .sub_path = "style.css",
            .data = @embedFile("static/style.css"),
        });
        try static_dir.writeFile(.{
            .sub_path = "script.js",
            .data = @embedFile("static/script.js"),
        });
    }
    const djot = try Djot.init(gpa);
    defer djot.deinit();
    var walker = try dir.walk(gpa);
    defer walker.deinit();
    var posts: std.ArrayList(Post) = try .initCapacity(gpa, 16);
    defer {
        for (posts.items) |p| {
            p.deinit(gpa);
        }
        posts.deinit(gpa);
    }
    var post_arena_state = std.heap.ArenaAllocator.init(gpa);
    defer post_arena_state.deinit();
    const post_arena = post_arena_state.allocator();
    // Collect posts and generate their respective pages one after another.
    var djot_buf: [1024 * 16]u8 = undefined;
    var writer_buf: [1024 * 4]u8 = undefined;
    while (try walker.next()) |entry| {
        defer _ = post_arena_state.reset(.retain_capacity);
        if (entry.kind == .file and mem.eql(u8, entry.basename, "index.dj")) {
            const post_text = try entry.dir.readFile(entry.basename, &djot_buf);
            const p = try Post.init(gpa, post_text, entry.path);
            try posts.append(gpa, p);
            var html_file = try entry.dir.createFile("index.html", .{});
            defer html_file.close();
            var html_writer = html_file.writer(&writer_buf);
            const writer = &html_writer.interface;
            try templates.base_start(post_arena, writer, .{
                .title = p.title,
                .opengraph = .{
                    .title = p.title,
                    .description = p.djot_text[0..@min(p.djot_text.len, 256)],
                },
            });
            try writer.writeAll(
                \\<a href="/">« back to home</a>
                \\
            );
            try writer.print(
                \\<span class="post--published-at">
                \\  published
                \\  <time class="relative" datetime="{0s}" title="{0s}">{0s}</time>
                \\</span>
                \\
            , .{
                try html.escapeAlloc(post_arena, p.published_at),
            });
            try writer.writeAll("<h1 class=\"post--title\">");
            try html.escape(writer, p.title);
            try writer.writeAll("</h1>");
            try djot.writeHtml(&html_writer.interface, p.djot_text);
            try templates.base_end(writer);
            try writer.flush();
        }
    }
    println("Found {d} posts", .{posts.items.len});
    // Sort posts by latest first
    mem.sortUnstable(Post, posts.items, {}, Post.newestFirst);
    // Generate atom feed
    {
        defer _ = post_arena_state.reset(.retain_capacity);
        var feed_file = try dir.createFile(feed.feed_path, .{});
        defer feed_file.close();
        var buf: [4096]u8 = undefined;
        var feed_writer = feed_file.writer(&buf);
        const writer = &feed_writer.interface;
        try feed.atom(.{
            .arena = post_arena,
            .writer = writer,
            .meta = meta,
            .posts = posts.items,
            .now = now,
        });
        try writer.flush();
    }
    // Generate home page
    {
        defer _ = post_arena_state.reset(.retain_capacity);
        var home_file = try dir.createFile("index.html", .{});
        defer home_file.close();
        var home_buf: [4096]u8 = undefined;
        var file_writer = home_file.writer(&home_buf);
        const writer = &file_writer.interface;
        try templates.base_start(post_arena, writer, .{
            .opengraph = .{
                .title = "loa",
                .description = "shouting into the void",
            },
        });
        try writer.writeAll(
            \\<h1 style="margin-bottom:0">
            \\
        );
        try html.escape(writer, meta.site_name);
        try writer.writeAll(
            \\</h1>
            \\
        );
        try writer.writeAll("<div class=\"tagline\">");
        try html.escape(writer, meta.tagline);
        try writer.writeAll("</div>\n");
        try writer.writeAll(
            \\<ul class="home--post-list">
            \\
        );
        for (posts.items) |p| {
            try writer.print(
                \\<li>
                \\  <a href="/{0s}/">{1s}</a>
                \\  <time class="home--post-published-at relative" datetime="{2s}" title="{2s}">{2s}</time>
                \\</li>
                \\
            , .{
                try html.escapeAlloc(post_arena, p.slug),
                try html.escapeAlloc(post_arena, p.title),
                try html.escapeAlloc(post_arena, p.published_at),
            });
        }
        try writer.writeAll(
            \\</ul>
            \\
        );
        try templates.base_end(writer);
        try writer.flush();
    }
    return 0;
}
test {
    std.testing.refAllDeclsRecursive(@This());
}
test entrypoint {
    const status = try entrypoint("sample", "2025-11-12T03:04:05+06:00");
    try t.expectEqual(0, status);
}