Makko / src / FeedGenerator.zig

const std = @import("std");
const datetime = @import("datetime");

const helper = @import("helper.zig");
const Data = @import("Data.zig");
const Makko = @import("Makko.zig");

const FeedGenerator = @This();

name: []const u8,
func: fn (Makko, data: Data, writer: anytype) anyerror!void,

pub const generator_list = [_]FeedGenerator{
    .{ .func = html, .name = "html" },
    .{ .func = rss, .name = "rss" },
    .{ .func = atom, .name = "atom" },
};

fn html(state: Makko, data: Data, writer: anytype) !void {
    const allocator = state.allocator;

    const json_data = try helper.valueToJson(allocator, data);
    defer json_data.deinit();

    if (state.templates.feed == null)
        return error.MissingTemplate;

    const first_pass = try helper.template(
        allocator,
        state.templates.feed.?,
        json_data.value,
    );
    defer allocator.free(first_pass);

    const second_pass = try helper.template(
        allocator,
        first_pass,
        json_data.value,
    );
    defer allocator.free(second_pass);

    try writer.writeAll(second_pass);
}

fn rss(state: Makko, data: Data, writer: anytype) !void {
    const allocator = state.allocator;
    const website = data.website;

    const general_dt = datetime.datetime.Datetime.now();
    const now_http = try general_dt.formatHttp(allocator);
    defer allocator.free(now_http);

    try writer.print(
        \\<?xml version="1.0" encoding="UTF-8"?>
        \\<rss version="2.0">
        \\  <channel>
        \\      <title>{s}</title>
        \\      <link>{s}</link>
        \\      <description>{s}</description>
        \\      <generator>makko</generator>
        \\      <lastBuildDate>{s}</lastBuildDate>
        \\
    ,
        .{ website.title, website.url, website.description, now_http },
    );

    for (data.posts.?) |post| {
        if (post.is_secret) continue;

        const post_link = try std.mem.concat(
            allocator,
            u8,
            &[_][]const u8{ website.url, "/", post.url },
        );
        defer allocator.free(post_link);

        const dt = datetime.datetime.Datetime.fromTimestamp(post.created.raw);
        const pub_date = try dt.formatHttp(allocator);
        defer allocator.free(pub_date);

        try writer.print(
            \\      <item>
            \\          <title>{s}</title>
            \\          <link>{s}</link>
            \\          <pubDate>{s}</pubDate>
            \\          <author>{s}</author>
            \\          <description>{s}</description>
            \\      </item>
            \\
        ,
            .{ post.title, post_link, pub_date, post.author, post.description },
        );
    }

    try writer.writeAll(
        \\  </channel>
        \\</rss>
        \\
    );
}

fn atom(state: Makko, data: Data, writer: anytype) !void {
    const allocator = state.allocator;

    const now = datetime.datetime.Datetime.now();
    const now_iso8601 = try now.formatISO8601(allocator, false);
    defer allocator.free(now_iso8601);

    const website = data.website;

    try writer.print(
        \\<?xml version="1.0" encoding="utf-8"?>
        \\<feed xmlns="http://www.w3.org/2005/Atom">
        \\  <title>{s}</title>
        \\  <link href="{s}"/>
        \\  <updated>{s}</updated>
        \\  <id>{s}</id>
        \\  <generator>makko</generator>
        \\
    ,
        .{ website.title, website.url, now_iso8601, website.url },
    );

    for (data.posts.?) |post| {
        if (post.is_secret) continue;

        const post_link = try std.mem.concat(
            allocator,
            u8,
            &[_][]const u8{ website.url, "/", post.url },
        );
        defer allocator.free(post_link);

        const upd_dt = datetime.datetime.Datetime.fromTimestamp(post.updated.raw);
        const upd_iso8601 = try upd_dt.formatISO8601(allocator, false);
        defer state.allocator.free(upd_iso8601);

        const pub_dt = datetime.datetime.Datetime.fromTimestamp(post.created.raw);
        const pub_iso8601 = try pub_dt.formatISO8601(allocator, false);
        defer state.allocator.free(pub_iso8601);

        try writer.print(
            \\  <entry>
            \\    <title>{s}</title>
            \\    <link href="{s}"/>
            \\    <id>{s}</id>
            \\    <published>{s}</published>
            \\    <updated>{s}</updated>
            \\    <author><name>{s}</name></author>
            \\    <summary>{s}</summary>
            \\  </entry>
            \\
        ,
            .{
                post.title,
                post_link,
                post_link, // use URL as unique ID
                pub_iso8601,
                upd_iso8601,
                post.author,
                post.description,
            },
        );
    }

    try writer.writeAll("</feed>\n");
}