a5ae6b8 | website

git clone https://git.pyrossh.dev/website

木 Personal website of pyrossh. Built with astrojs, shiki, vite.

a5ae6b8 — pyrossh 2026-07-14T14:04:21+05:30

Task 2: core lib modules - frontmatter, markdown, content

Files changed (5) hide show

build.zig +3 -0
src/lib.zig +3 -3
src/lib/content.zig +85 -0
src/lib/frontmatter.zig +39 -0
src/lib/markdown.zig +6 -0

build.zig CHANGED Viewed

@@ -13,6 +13,9 @@ pub fn build(b: *std.Build) void {
     lib_mod.addImport("config", config_mod);
     lib_mod.addImport("s3", s3_mod);
+    const zmd_mod = b.dependency("zmd", .{}).module("zmd");
+    lib_mod.addImport("zmd", zmd_mod);
     const main_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,

src/lib.zig CHANGED Viewed

@@ -1,8 +1,8 @@
 pub const config = @import("config");
 pub const s3 = @import("s3");
-pub const content = @import("content.zig");
+pub const content = @import("lib/content.zig");
-pub const frontmatter = @import("frontmatter.zig");
+pub const frontmatter = @import("lib/frontmatter.zig");
-pub const markdown = @import("markdown.zig");
+pub const markdown = @import("lib/markdown.zig");
 pub const files = @import("files.zig");
 pub const gitBug = @import("gitBug.zig");
 pub const gitReader = @import("gitReader.zig");

src/lib/content.zig ADDED Viewed

@@ -0,0 +1,85 @@
+const std = @import("std");
+const frontmatter = @import("frontmatter.zig");
+const markdown = @import("markdown.zig");
+pub const Post = struct {
+    id: []const u8,
+    title: []const u8,
+    description: []const u8,
+    pubDate: []const u8,
+    body: []const u8,
+    html: []const u8,
+};
+const content_dir = "content";
+pub fn getPosts(allocator: std.mem.Allocator) ![]Post {
+    var dir = try std.fs.cwd().openDir(content_dir, .{ .iterate = true });
+    defer dir.close();
+    var posts = std.ArrayList(Post).init(allocator);
+    var walker = try dir.walk(allocator);
+    defer walker.deinit();
+    while (try walker.next()) |entry| {
+        if (entry.kind != .file) continue;
+        if (!std.mem.endsWith(u8, entry.path, ".md")) continue;
+        const file = try entry.dir.openFile(entry.basename, .{});
+        defer file.close();
+        const source = try file.readToEndAlloc(allocator, 10 * 1024 * 1024);
+        defer allocator.free(source);
+        const parsed = frontmatter.parse(source) orelse continue;
+        if (!parsed.fm.published) continue;
+        const id = try allocator.dupe(u8, entry.path[0 .. entry.path.len - 3]);
+        const html = markdown.render(allocator, parsed.body) catch continue;
+        try posts.append(.{
+            .id = id,
+            .title = try allocator.dupe(u8, parsed.fm.title),
+            .description = try allocator.dupe(u8, parsed.fm.description),
+            .pubDate = try allocator.dupe(u8, parsed.fm.pubDate),
+            .body = try allocator.dupe(u8, parsed.body),
+            .html = html,
+        });
+    }
+    std.mem.sort(Post, posts.items, {}, struct {
+        fn lessThan(_: void, a: Post, b: Post) bool {
+            return std.mem.order(u8, a.pubDate, b.pubDate) == .gt;
+        }
+    }.lessThan);
+    return posts.toOwnedSlice();
+}
+pub fn getPost(allocator: std.mem.Allocator, id: []const u8) !?Post {
+    const posts = try getPosts(allocator);
+    defer {
+        for (posts) |p| {
+            allocator.free(p.id);
+            allocator.free(p.title);
+            allocator.free(p.description);
+            allocator.free(p.pubDate);
+            allocator.free(p.body);
+            allocator.free(p.html);
+        }
+        allocator.free(posts);
+    }
+    for (posts) |p| {
+        if (std.mem.eql(u8, p.id, id)) {
+            return .{
+                .id = try allocator.dupe(u8, p.id),
+                .title = try allocator.dupe(u8, p.title),
+                .description = try allocator.dupe(u8, p.description),
+                .pubDate = try allocator.dupe(u8, p.pubDate),
+                .body = try allocator.dupe(u8, p.body),
+                .html = try allocator.dupe(u8, p.html),
+            };
+        }
+    }
+    return null;
+}

src/lib/frontmatter.zig ADDED Viewed

@@ -0,0 +1,39 @@
+const std = @import("std");
+pub const Frontmatter = struct {
+    title: []const u8 = "",
+    description: []const u8 = "",
+    pubDate: []const u8 = "",
+    tags: []const []const u8 = &.{},
+    heroImage: ?[]const u8 = null,
+    published: bool = true,
+};
+pub fn parse(source: []const u8) ?struct { fm: Frontmatter, body: []const u8 } {
+    const trimmed = std.mem.trim(u8, source, " \n\r");
+    if (trimmed.len < 6) return null;
+    if (!std.mem.startsWith(u8, trimmed, "---")) return null;
+    const end = std.mem.indexOf(u8, trimmed[3..], "---") orelse return null;
+    const raw_fm = trimmed[3 .. 3 + end];
+    const body_start = 6 + end;
+    const body = if (body_start < trimmed.len) std.mem.trimLeft(u8, trimmed[body_start..], "\n\r") else "";
+    var fm = Frontmatter{};
+    var lines = std.mem.splitScalar(u8, raw_fm, '\n');
+    while (lines.next()) |line| {
+        const trimmed_line = std.mem.trim(u8, line, " \r");
+        if (trimmed_line.len == 0) continue;
+        const colon = std.mem.indexOfScalar(u8, trimmed_line, ':') orelse continue;
+        const key = std.mem.trim(u8, trimmed_line[0..colon], " ");
+        const value = std.mem.trim(u8, trimmed_line[colon + 1 ..], " \"'");
+        if (std.mem.eql(u8, key, "title")) fm.title = value;
+        else if (std.mem.eql(u8, key, "description")) fm.description = value;
+        else if (std.mem.eql(u8, key, "pubDate")) fm.pubDate = value;
+        else if (std.mem.eql(u8, key, "heroImage")) fm.heroImage = value;
+        else if (std.mem.eql(u8, key, "published")) fm.published = std.mem.eql(u8, value, "true");
+    }
+    return .{ .fm = fm, .body = body };
+}

src/lib/markdown.zig ADDED Viewed

@@ -0,0 +1,6 @@
+const std = @import("std");
+const zmd = @import("zmd");
+pub fn render(allocator: std.mem.Allocator, input: []const u8) ![]const u8 {
+    return try zmd.parseAlloc(allocator, input, .{});
+}