better(ish)

src/main.zig

@@ -4,197 +4,188 @@ 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();
 
-    var router = Router.init(allocator, &handle, &handleError);
+    // var router = Router.init(allocator, &handle, &handleError);
-    defer router.deinit();
+    // defer router.deinit();
 
-    try router.addRoute("/", &handle);
+    // try router.addRoute("/", &handle);
 
     const address = try net.Address.parseIp("0.0.0.0", 8080);
-    var listener = App.init(.{
+    var listener = Listener.init(.{
         .address = address,
         .allocator = allocator,
-        .context = router,
+        // .handler = router.handle,
-        .handler = router.handle,
+        .handler = &handle,
     });
     defer listener.deinit();
     try listener.listen();
 }
 
-pub fn handle(_: *Router, event: *App.Event) anyerror!void {
+pub fn handle(event: *Listener.Event) anyerror!void {
     try event.res.body.appendSlice("hello there");
 }
 
-pub fn handleError(_: Router, event: *App.Event) anyerror!void {
+pub fn handleError(event: *Listener.Event) anyerror!void {
     try event.res.body.appendSlice("ahoy, an error occurred");
 }
 
-pub fn Listener(comptime Context: type) type {
+pub const Listener = struct {
-    return struct {
+    address: net.Address,
+    arena: heap.ArenaAllocator,
+    handlerFn: HandlerFn,
+
+    pub const Options = struct {
         address: net.Address,
-        arena: heap.ArenaAllocator,
+        allocator: mem.Allocator,
-        ctx: *Context,
+        handler: HandlerFn,
-        handlerFn: HandlerFn,
-
-        pub const Options = struct {
-            address: net.Address,
-            allocator: mem.Allocator,
-            context: *Context,
-            handler: HandlerFn,
-        };
-
-        pub fn init(options: Options) Listener {
-            return .{
-                .address = options.address,
-                .arena = heap.ArenaAllocator.init(options.allocator),
-                .ctx = options.context,
-                .handlerFn = options.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(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 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 HandlerFn = *const fn (ctx: *Context, event: *Event) anyerror!void;
     };
-}
 
-pub const Router = struct {
+    pub fn init(options: Options) Listener {
-    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,
+            .address = options.address,
-            .root_node = .{
+            .arena = heap.ArenaAllocator.init(options.allocator),
-                .type = .normal,
+            .handlerFn = options.handler,
-                .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 {
+    pub fn deinit(self: *Listener) void {
-        self.static_routes.deinit();
+        self.arena.deinit();
     }
 
-    pub fn handle(self: *Router, event: *Listener.Event) anyerror!void {
+    pub fn listen(self: *Listener) !void {
-        try self.route(event.req.uri.path)(self, event);
+        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);
+        }
     }
 
-    pub fn addRoute(self: *Router, path: []const u8, handler: HandlerFn) !void {
+    fn handle(self: *Listener, server: *http.Server) !void {
-        try self.addStaticRoute(path, handler);
+        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 addStaticRoute(self: *Router, path: []const u8, handler: HandlerFn) !void {
+    fn respondFromEvent(self: *Listener, event: *Event, req: *http.Server.Request) !void {
-        try self.static_routes.put(path, .{
+        const res_body = try event.res.body.toOwnedSlice();
-            .type = .normal,
+        const res_headers = try self.arena.allocator().alloc(http.Header, event.res.headers.count());
-            .max_depth = 1,
+        var i: usize = 0;
-            .children = std.StringHashMap(*Node).init(self.allocator),
+        var header_it = event.res.headers.iterator();
-            .handler = handler,
+        while (header_it.next()) |header_ptr| : (i += 1) res_headers[i] = header_ptr.value_ptr.*.*;
-            .placeholder_children = std.ArrayList(*Node).init(self.allocator),
+        try req.respond(res_body, .{
+            .status = event.res.status,
+            .extra_headers = res_headers,
         });
     }
 
-    pub fn route(self: *Router, path: []const u8) HandlerFn {
+    pub const Event = struct {
-        if (self.static_routes.get(path)) |rt| return rt.handler;
+        req: Request,
-        if (self.root_node.wildcard_child_node) |node| return node.handler;
+        res: Response,
-        return self.error_handler;
-    }
 
-    pub const Node = struct {
+        pub const Request = struct {
-        type: Type,
+            uri: std.Uri,
-        max_depth: usize, // TODO: what is best here
+            // head: http.Server.Request.Head,
-        parent: ?*Node = null,
+            headers: std.ArrayList(*const http.Header),
-        children: std.StringHashMap(*Node),
+        };
-        handler: HandlerFn,
+        pub const Response = struct {
-        wildcard_child_node: ?*Node = null,
+            status: http.Status,
-        placeholder_children: std.ArrayList(*Node),
+            headers: std.StringHashMap(*http.Header),
-
+            body: std.ArrayList(u8),
-        pub const Type = enum { normal, wildcard, placeholder };
+        };
     };
 
-    pub const HandlerFn = *const fn (self: *Router, event: *App.Event) anyerror!void;
+    pub const HandlerFn = *const fn (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 };
+        };
+    };
 };