goodies

- new `auto_target_blank` setting in zine.ziggy, now external links
  don't default to target blank anymore, use this setting to restore
  the previous behavior
- remove the ability to pass arguments to `$site.pages()`
- add the ability to pass multiple arguments to `$site.page()` in
  order to create parametrized paths
- add `$page.leaves()` to obtain a flat list of leaf pages from
  a given section subtree
- update superhtml scripty reference docs syntax to better match
  the new syntax in Ziggy Schemas

Author: kristoff-it

build.zig

@@ -265,12 +265,12 @@ pub fn build(b: *std.Build) !void {
     switch (version) {
         .tag, .preview => {
             const zon = @import("build.zig.zon");
-            if (version == .preview or std.mem.eql(u8, zon.version, version.tag[1..])) {
+            if (version == .preview or std.mem.eql(u8, zon.version, version.tag)) {
                 setupReleaseStep(b, release, version.string(), translate_c);
             } else {
                 release.dependOn(&b.addFail(b.fmt(
                     "error: git tag does not match zon package version (zon: '{s}', git: '{s}')",
-                    .{ zon.version, version.tag[1..] },
+                    .{ zon.version, version.tag },
                 )).step);
             }
         },

build.zig.zon

@@ -38,16 +38,16 @@
             .hash = "zeit-0.10.0-dev-5I6bk3m9AgB8Ndev81pibV70MJe9VCOXAGZBNU833c4Y",
         },
         .flow_syntax = .{
-            .url = "git+https://github.com/neurocyte/flow-syntax#65e76b959b9ac7c2aab8aba0d7decc5a3f04e4e1",
-            .hash = "flow_syntax-0.7.2-X8jOoQlmAQA3iLvWcCZZr1sYEEiBpHqi8VWqweKwwxGB",
+            .url = "git+https://github.com/kristoff-it/flow-syntax#b42c3e985215e88a8faa260cbf7eb248822c339c",
+            .hash = "flow_syntax-0.7.2-X8jOoSuMAQBanH2g5oW4BQmkW6s5AdfrRUE2byWrMVKp",
         },
         .ziggy = .{
-            .url = "git+https://github.com/kristoff-it/ziggy#35ed5530dd93590fa40e06005ec5d7747a5498d5",
+            .url = "git+https://github.com/kristoff-it/ziggy#7b81a7f1c9e6b22aacd7060b17bb6b7142878cd8",
             .hash = "ziggy-0.1.0-kTg8vxOeBwCS6RxeI2quMQ7PCnCSWWB3Q-NF-JOktWrN",
         },
         .supermd = .{
-            .url = "git+https://github.com/kristoff-it/supermd#cbca93e22ca8c92a8c570b649a38f57242e00635",
-            .hash = "supermd-0.1.0-3Mco3BecWABhO5BJzBZrz9lf8SeoeLpz4wQkFmJqcN7d",
+            .url = "git+https://github.com/kristoff-it/supermd#70e34739939e927dcef97288b57d30b24d221497",
+            .hash = "supermd-0.1.0-3Mco3GGbWACu_iiyO6xjVV1ViSYFACf2f_TIwjjJmEw9",
         },
         .translate_c = .{
             .url = "git+https://codeberg.org/kristoff/translate-c?ref=0.17.x#c01b34d1e57010019d77ffef1dbc704af870a2eb",

src/Variant.zig

@@ -105,12 +105,22 @@ pub const Section = struct {
     content_sub_path: Path,
     parent_section: u32, // index into sections, 0 = no parent section
     index: u32, // index into pages
-    pages: std.ArrayListUnmanaged(u32) = .empty, // indices into pages
+    pages: std.ArrayList(u32) = .empty, // indices into pages
+    pages_by_author: std.StringHashMapUnmanaged([]const u32) = .empty, // indices into pages
+    pages_by_tag: std.StringHashMapUnmanaged([]const u32) = .empty, // indices into pages
 
     pub fn deinit(s: *const Section, gpa: Allocator) void {
+        var p = s.pages;
+        p.deinit(gpa);
+        {
+            var it = s.pages_by_author.iterator();
+            while (it.next()) |entry| gpa.free(entry.value_ptr.*);
+            @constCast(s).pages_by_author.deinit(gpa);
+        }
         {
-            var p = s.pages;
-            p.deinit(gpa);
+            var it = s.pages_by_tag.iterator();
+            while (it.next()) |entry| gpa.free(entry.value_ptr.*);
+            @constCast(s).pages_by_tag.deinit(gpa);
         }
     }
 
@@ -129,8 +139,10 @@ pub const Section = struct {
         s.active = index._parse.active;
     }
 
-    pub fn sortPages(
+    pub fn indexAndSortPages(
         s: *Section,
+        gpa: Allocator,
+        arena: Allocator,
         v: *Variant,
         pages: []Page,
     ) void {
@@ -167,7 +179,39 @@ pub const Section = struct {
         };
 
         const ctx: Ctx = .{ .pages = pages, .v = v };
-        std.sort.insertion(u32, s.pages.items, ctx, Ctx.lessThan);
+        std.sort.pdq(u32, s.pages.items, ctx, Ctx.lessThan);
+
+        var author_temp: std.StringArrayHashMapUnmanaged(std.ArrayList(u32)) = .empty;
+        var tag_temp: std.StringArrayHashMapUnmanaged(std.ArrayList(u32)) = .empty;
+        for (s.pages.items) |idx| {
+            const p = pages[idx];
+            if (!p._parse.active) continue;
+
+            // TODO: report errors when a page has the same author listed twice
+            for (p.authors) |key| {
+                const gop = author_temp.getOrPut(arena, key) catch fatal.oom();
+                if (!gop.found_existing) gop.value_ptr.* = .empty;
+                gop.value_ptr.append(gpa, idx) catch fatal.oom();
+            }
+
+            // TODO: report errors when a page has the same tag listed twice
+            for (p.tags) |key| {
+                const gop = tag_temp.getOrPut(arena, key) catch fatal.oom();
+                if (!gop.found_existing) gop.value_ptr.* = .empty;
+                gop.value_ptr.append(gpa, idx) catch fatal.oom();
+            }
+        }
+
+        s.pages_by_author.ensureTotalCapacity(gpa, @intCast(author_temp.count())) catch fatal.oom();
+        s.pages_by_tag.ensureTotalCapacity(gpa, @intCast(tag_temp.count())) catch fatal.oom();
+
+        for (author_temp.keys(), author_temp.values()) |key, *val| {
+            s.pages_by_author.putAssumeCapacityNoClobber(key, val.toOwnedSlice(gpa) catch fatal.oom());
+        }
+
+        for (tag_temp.keys(), tag_temp.values()) |key, *val| {
+            s.pages_by_tag.putAssumeCapacityNoClobber(key, val.toOwnedSlice(gpa) catch fatal.oom());
+        }
     }
 };
 

src/context/DateTime.zig

@@ -12,7 +12,7 @@ const Value = context.Value;
 const String = context.String;
 const Bool = context.Bool;
 
-const epoch = zeit.instant(.{ .unix_timestamp = 0 }, &zeit.utc);
+pub const epoch = zeit.instant(.{ .unix_timestamp = 0 }, &zeit.utc);
 
 _raw: ?Raw = null,
 _loc: ?ziggy.Tokenizer.Token.Loc = null,

src/context/Iterator.zig

@@ -1,9 +1,11 @@
 const Iterator = @This();
 
 const std = @import("std");
+const assert = std.debug.assert;
 const ziggy = @import("ziggy");
 const superhtml = @import("superhtml");
 const scripty = @import("scripty");
+const zeit = @import("zeit");
 const context = @import("../context.zig");
 const doctypes = @import("doctypes.zig");
 const Signature = doctypes.Signature;
@@ -25,7 +27,8 @@ _superhtml_context: superhtml.utils.IteratorContext(Value) = .{},
 _impl: Impl,
 
 pub const Impl = union(enum) {
-    value_it: SliceIterator(Value),
+    slice_it: SliceIterator(Value),
+    leaves_it: LeavesIterator,
 
     pub fn len(impl: Impl) usize {
         switch (impl) {
@@ -37,6 +40,7 @@ pub const Impl = union(enum) {
 pub fn init(gpa: Allocator, impl: Impl) !*Iterator {
     const res = try gpa.create(Iterator);
     res.* = .{ ._impl = impl, .len = impl.len() };
+    res.last = 0 == res.len;
     return res;
 }
 
@@ -45,21 +49,24 @@ pub fn deinit(iter: *const Iterator, gpa: Allocator) void {
 }
 
 pub fn next(iter: *Iterator, gpa: Allocator) !bool {
+    if (iter.last) return false;
+
     switch (iter._impl) {
         inline else => |*v| {
-            const item = try v.next(gpa);
-            iter.it = try Value.from(gpa, item orelse return false);
-            iter.idx += 1;
-            iter.first = iter.idx == 1;
-            iter.last = iter.idx == iter.len;
-            return true;
+            const item = try v.next(iter.idx, gpa);
+            iter.it = try Value.from(gpa, item);
         },
     }
+
+    iter.idx += 1;
+    iter.first = iter.idx == 1;
+    iter.last = iter.idx >= iter.len;
+    return true;
 }
 
 pub fn fromArray(gpa: Allocator, arr: Array) !*Iterator {
     return init(gpa, .{
-        .value_it = .{ .items = arr._items },
+        .slice_it = .{ .items = arr._items },
     });
 }
 
@@ -82,6 +89,7 @@ pub const Fields = struct {
         \\True on the last iteration loop.
     ;
 };
+
 pub const Builtins = struct {
     pub const up = struct {
         pub const signature: Signature = .{ .ret = .Iterator };
@@ -107,18 +115,71 @@ pub const Builtins = struct {
 
 fn SliceIterator(comptime Element: type) type {
     return struct {
-        idx: usize = 0,
         items: []const Element,
 
         pub fn len(self: @This()) usize {
             return self.items.len;
         }
 
-        pub fn next(self: *@This(), gpa: Allocator) !?Element {
+        pub fn next(self: *@This(), idx: usize, gpa: Allocator) !Element {
             _ = gpa;
-            if (self.idx == self.items.len) return null;
-            defer self.idx += 1;
-            return self.items[self.idx];
+            return self.items[idx];
         }
     };
 }
+
+pub const LeavesIterator = struct {
+    limit: u32,
+    sections: []Section,
+    pages: []Page,
+
+    pub const Section = struct {
+        idx: u32 = 0, // cursor into `page_indexes`
+        page_indexes: []const u32, // index into pages
+    };
+
+    pub fn init(limit: u32, sections: []Section, pages: []Page) LeavesIterator {
+        return .{
+            .limit = limit,
+            .sections = sections,
+            .pages = pages,
+        };
+    }
+
+    pub fn len(lit: *const LeavesIterator) usize {
+        return lit.limit;
+    }
+
+    pub fn next(lit: *LeavesIterator, idx: usize, gpa: Allocator) !*context.Page {
+        assert(idx < lit.limit);
+        _ = gpa;
+
+        var next_page_date = context.DateTime.epoch;
+        var next_page: *context.Page = undefined;
+        var next_section_idx: usize = undefined;
+
+        for (lit.sections, 0..) |*s, section_idx| {
+            if (s.idx == s.page_indexes.len) continue;
+
+            while (true) {
+                const page_idx = s.page_indexes[s.idx];
+                const page = &lit.pages[page_idx];
+                if (!page._parse.active) {
+                    s.idx += 1;
+                    continue;
+                }
+
+                if (page.date._inst.timestamp >= next_page_date.timestamp) {
+                    next_page_date = page.date._inst;
+                    next_page = page;
+                    next_section_idx = section_idx;
+                }
+
+                break;
+            }
+        }
+
+        lit.sections[next_section_idx].idx += 1;
+        return next_page;
+    }
+};