this ain't it either, chief

src/main.zig

@@ -4,158 +4,197 @@ const net = std.net;
 const http = std.http;
 const heap = std.heap;
 
+const App = Listener(Router);
+
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
 
-    const router = BasicRouter.init(allocator);
+    var router = Router.init(allocator, &handle, &handleError);
     defer router.deinit();
 
+    try router.addRoute("/", &handle);
+
     const address = try net.Address.parseIp("0.0.0.0", 8080);
-    var listener = Listener.init(address, allocator, &handle);
+    var listener = App.init(.{
+        .address = address,
+        .allocator = allocator,
+        .context = router,
+        .handler = router.handle,
+    });
     defer listener.deinit();
     try listener.listen();
 }
 
-pub fn handle(event: *Listener.Event) anyerror!void {
+pub fn handle(_: *Router, event: *App.Event) anyerror!void {
     try event.res.body.appendSlice("hello there");
 }
 
-pub const Listener = struct {
-    address: net.Address,
-    arena: heap.ArenaAllocator,
-    handlerFn: *const fn (event: *Event) anyerror!void,
+pub fn handleError(_: Router, event: *App.Event) anyerror!void {
+    try event.res.body.appendSlice("ahoy, an error occurred");
+}
 
-    pub fn init(address: net.Address, allocator: mem.Allocator, handler: *const fn (event: *Event) anyerror!void) Listener {
-        return .{
-            .address = address,
-            .arena = heap.ArenaAllocator.init(allocator),
-            .handlerFn = handler,
-        };
-    }
-
-    pub fn deinit(self: *Listener) void {
-        self.arena.deinit();
-    }
-
-    pub fn listen(self: *Listener) !void {
-        var tcp = try self.address.listen(.{});
-        defer tcp.deinit();
-        std.debug.print("listening at: {any}\n", .{self.address});
-
-        while (true) {
-            const read_buf = try self.arena.allocator().alloc(u8, 1024 * 32);
-            const connection = try tcp.accept();
-            var server = http.Server.init(connection, read_buf);
-            try self.handle(&server);
-            _ = self.arena.reset(.retain_capacity);
-        }
-    }
-
-    fn handle(self: *Listener, server: *http.Server) !void {
-        handler: while (true) {
-            var req = server.receiveHead() catch |e| if (e == error.HttpConnectionClosing) break :handler else return e;
-
-            var event = Event{
-                .req = .{
-                    .uri = try std.Uri.parseWithoutScheme(req.head.target),
-                    .headers = std.ArrayList(*const http.Header).init(self.arena.allocator()),
-                },
-                .res = .{
-                    .status = .ok,
-                    .headers = std.StringHashMap(*http.Header).init(self.arena.allocator()),
-                    .body = std.ArrayList(u8).init(self.arena.allocator()),
-                },
-            };
-
-            var header_it = req.iterateHeaders();
-            while (header_it.next()) |header| try event.req.headers.append(&header);
-
-            try self.handlerFn(&event);
-
-            try self.respondFromEvent(&event, &req);
-        }
-    }
-
-    fn respondFromEvent(self: *Listener, event: *Event, req: *http.Server.Request) !void {
-        const res_body = try event.res.body.toOwnedSlice();
-        const res_headers = try self.arena.allocator().alloc(http.Header, event.res.headers.count());
-        var i: usize = 0;
-        var header_it = event.res.headers.iterator();
-        while (header_it.next()) |header_ptr| : (i += 1) res_headers[i] = header_ptr.value_ptr.*.*;
-        try req.respond(res_body, .{
-            .status = event.res.status,
-            .extra_headers = res_headers,
-        });
-    }
-
-    pub const Event = struct {
-        req: Request,
-        res: Response,
-
-        pub const Request = struct {
-            uri: std.Uri,
-            // head: http.Server.Request.Head,
-            headers: std.ArrayList(*const http.Header),
-        };
-        pub const Response = struct {
-            status: http.Status,
-            headers: std.StringHashMap(*http.Header),
-            body: std.ArrayList(u8),
-        };
-    };
-};
-
-pub const BasicRouter = Router(Listener.Event);
-
-pub fn Router(comptime Context: type) type {
+pub fn Listener(comptime Context: type) type {
     return struct {
-        ctx: Context,
-        allocator: mem.Allocator,
+        address: net.Address,
+        arena: heap.ArenaAllocator,
+        ctx: *Context,
+        handlerFn: HandlerFn,
 
-        static_routes: std.StringHashMap(*Node),
+        pub const Options = struct {
+            address: net.Address,
+            allocator: mem.Allocator,
+            context: *Context,
+            handler: HandlerFn,
+        };
 
-        pub fn init(allocator: mem.Allocator, ctx: Context) Self {
+        pub fn init(options: Options) Listener {
             return .{
-                .ctx = ctx,
-                .allocator = allocator,
-                .static_routes = std.StringHashMap(*Node).init(allocator),
+                .address = options.address,
+                .arena = heap.ArenaAllocator.init(options.allocator),
+                .ctx = options.context,
+                .handlerFn = options.handler,
             };
         }
 
-        pub fn deinit(self: *Self) void {
-            self.static_routes.deinit();
+        pub fn deinit(self: *Listener) void {
+            self.arena.deinit();
         }
 
-        pub fn addRoute(self: *Self, path: []const u8, handler: HandlerFn) !void {
-            try self.addStaticRoute(path, handler);
+        pub fn listen(self: *Listener) !void {
+            var tcp = try self.address.listen(.{});
+            defer tcp.deinit();
+            std.debug.print("listening at: {any}\n", .{self.address});
+
+            while (true) {
+                const read_buf = try self.arena.allocator().alloc(u8, 1024 * 32);
+                const connection = try tcp.accept();
+                var server = http.Server.init(connection, read_buf);
+                try self.handle(&server);
+                _ = self.arena.reset(.retain_capacity);
+            }
         }
 
-        fn addStaticRoute(self: *Self, path: []const u8, handler: HandlerFn) !void {
-            try self.static_routes.put(path, .{
-                .type = .normal,
-                .max_depth = 1,
-                .children = std.StringHashMap(*Node).init(self.allocator),
-                .handler = handler,
-                .placeholder_children = std.ArrayList(*Node).init(self.allocator),
+        fn handle(self: *Listener, server: *http.Server) !void {
+            handler: while (true) {
+                var req = server.receiveHead() catch |e| if (e == error.HttpConnectionClosing) break :handler else return e;
+
+                var event = Event{
+                    .req = .{
+                        .uri = try std.Uri.parseWithoutScheme(req.head.target),
+                        .headers = std.ArrayList(*const http.Header).init(self.arena.allocator()),
+                    },
+                    .res = .{
+                        .status = .ok,
+                        .headers = std.StringHashMap(*http.Header).init(self.arena.allocator()),
+                        .body = std.ArrayList(u8).init(self.arena.allocator()),
+                    },
+                };
+
+                var header_it = req.iterateHeaders();
+                while (header_it.next()) |header| try event.req.headers.append(&header);
+
+                try self.handlerFn(self.ctx, &event);
+
+                try self.respondFromEvent(&event, &req);
+            }
+        }
+
+        fn respondFromEvent(self: *Listener, event: *Event, req: *http.Server.Request) !void {
+            const res_body = try event.res.body.toOwnedSlice();
+            const res_headers = try self.arena.allocator().alloc(http.Header, event.res.headers.count());
+            var i: usize = 0;
+            var header_it = event.res.headers.iterator();
+            while (header_it.next()) |header_ptr| : (i += 1) res_headers[i] = header_ptr.value_ptr.*.*;
+            try req.respond(res_body, .{
+                .status = event.res.status,
+                .extra_headers = res_headers,
             });
         }
 
-        pub const Node = struct {
-            type: Type,
-            max_depth: usize, // TODO: what is best here
-            parent: ?*Node = null,
-            children: std.StringHashMap(*Node),
-            handler: HandlerFn,
-            wildcard_child_node: ?*Node = null,
-            placeholder_children: std.ArrayList(*Node),
+        pub const Event = struct {
+            req: Request,
+            res: Response,
 
-            pub const Type = enum { normal, wildcard, placeholder };
+            pub const Request = struct {
+                uri: std.Uri,
+                // head: http.Server.Request.Head,
+                headers: std.ArrayList(*const http.Header),
+            };
+            pub const Response = struct {
+                status: http.Status,
+                headers: std.StringHashMap(*http.Header),
+                body: std.ArrayList(u8),
+            };
         };
 
-        pub const HandlerFn = *const fn (ctx: *Context) anyerror!void;
-
-        const Self = @This();
+        pub const HandlerFn = *const fn (ctx: *Context, event: *Event) anyerror!void;
     };
 }
+
+pub const Router = struct {
+    allocator: mem.Allocator,
+
+    root_node: Node,
+    static_routes: std.StringHashMap(*Node),
+
+    error_handler: HandlerFn,
+
+    pub fn init(allocator: mem.Allocator, root_handler: HandlerFn, error_handler: HandlerFn) Router {
+        return .{
+            .allocator = allocator,
+            .root_node = .{
+                .type = .normal,
+                .max_depth = 64,
+                .children = std.StringHashMap(*Node).init(allocator),
+                .handler = root_handler,
+                .placeholder_children = std.ArrayList(*Node).init(allocator),
+            },
+            .static_routes = std.StringHashMap(*Node).init(allocator),
+            .error_handler = error_handler,
+        };
+    }
+
+    pub fn deinit(self: *Router) void {
+        self.static_routes.deinit();
+    }
+
+    pub fn handle(self: *Router, event: *Listener.Event) anyerror!void {
+        try self.route(event.req.uri.path)(self, event);
+    }
+
+    pub fn addRoute(self: *Router, path: []const u8, handler: HandlerFn) !void {
+        try self.addStaticRoute(path, handler);
+    }
+
+    fn addStaticRoute(self: *Router, path: []const u8, handler: HandlerFn) !void {
+        try self.static_routes.put(path, .{
+            .type = .normal,
+            .max_depth = 1,
+            .children = std.StringHashMap(*Node).init(self.allocator),
+            .handler = handler,
+            .placeholder_children = std.ArrayList(*Node).init(self.allocator),
+        });
+    }
+
+    pub fn route(self: *Router, path: []const u8) HandlerFn {
+        if (self.static_routes.get(path)) |rt| return rt.handler;
+        if (self.root_node.wildcard_child_node) |node| return node.handler;
+        return self.error_handler;
+    }
+
+    pub const Node = struct {
+        type: Type,
+        max_depth: usize, // TODO: what is best here
+        parent: ?*Node = null,
+        children: std.StringHashMap(*Node),
+        handler: HandlerFn,
+        wildcard_child_node: ?*Node = null,
+        placeholder_children: std.ArrayList(*Node),
+
+        pub const Type = enum { normal, wildcard, placeholder };
+    };
+
+    pub const HandlerFn = *const fn (self: *Router, event: *App.Event) anyerror!void;
+};