From 6925d69bac48be1e57b83c21fdef34ae6b617cd8 Mon Sep 17 00:00:00 2001 From: Jeeves Date: Tue, 26 Mar 2024 11:23:48 -0600 Subject: [PATCH] basic test (failing) --- src/main.zig | 95 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 77 insertions(+), 18 deletions(-) diff --git a/src/main.zig b/src/main.zig index b94ec24..4a90fde 100644 --- a/src/main.zig +++ b/src/main.zig @@ -139,32 +139,36 @@ pub const Listener = struct { pub const Router = struct { allocator: mem.Allocator, - root_node: Node, + root_node: *Node, static_routes: std.StringHashMap(*Node), pub fn init(allocator: mem.Allocator, root_handler: HandlerFn) Router { + var node = Node.init(allocator) catch @panic("OOM"); + node.handler = root_handler; return .{ .allocator = allocator, - .root_node = .{ - .type = .normal, - .max_depth = 1024, - .children = std.StringHashMap(*Node).init(allocator), - .handler = root_handler, - .placeholder_children = std.ArrayList(*Node).init(allocator), - }, + .root_node = node, + // .root_node = .{ + // .type = .normal, + // .max_depth = 1024, + // .children = std.StringHashMap(*Node).init(allocator), + // .handler = root_handler, + // .placeholder_children = std.ArrayList(*Node).init(allocator), + // }, .static_routes = std.StringHashMap(*Node).init(allocator), }; } pub fn deinit(self: *Router) void { - self.root_node.children.deinit(); - self.root_node.placeholder_children.deinit(); + self.root_node.deinit(self.allocator); + // self.root_node.children.deinit(); + // self.root_node.placeholder_children.deinit(); self.static_routes.deinit(); } pub fn handle(self: *Router, event: *Listener.Event) !void { - const handlerFn = try self.getRoute(event.req.uri.path); - try handlerFn(event); + const route = try self.getRoute(event.req.uri.path); + try route.handler(event); } /// Insert a route if the path is not already present, otherwise overwrite preexisting HandlerFn. @@ -172,7 +176,7 @@ pub const Listener = struct { // std.debug.print("\npath {s}\n", .{path}); var is_static_route = true; var sections = mem.splitScalar(u8, path, '/'); - var node = &self.root_node; + var node = self.root_node; var unnamed_placeholder_ctr: usize = 0; var matched_nodes = std.ArrayList(*Node).init(self.allocator); defer matched_nodes.deinit(); @@ -226,14 +230,14 @@ pub const Listener = struct { } /// Get the HandlerFn associated with path, otherwise get root_handler. - pub fn getRoute(self: *Router, path: []const u8) !HandlerFn { - if (self.static_routes.get(path)) |rt| return rt.handler; + pub fn getRoute(self: *Router, path: []const u8) !*Node { + if (self.static_routes.get(path)) |rt| return rt; var params = std.StringHashMap([]const u8).init(self.allocator); defer params.deinit(); var params_found = false; var wildcard_node: ?*Node = null; - var node: *Node = &self.root_node; + var node: *Node = self.root_node; var wildcard_param: ?[]const u8 = null; var remaining = mem.count(u8, path, "/") + 1; @@ -277,10 +281,36 @@ pub const Listener = struct { params_found = true; } - return self.root_node.handler; + return node; } - const Node = struct { + /// If there is a route with a matching path, it is deleted from the router, and this function return true. Otherwise it returns false. + pub fn removeRoute(self: *Router, path: []const u8) bool { + if (self.static_routes.remove(path)) return true; + + var opt_node: ?*Node = self.root_node; + var sections = mem.splitScalar(u8, path, '/'); + while (sections.next()) |section| { + // TODO: reorder to be safe + opt_node = opt_node.?.children.get(section); + if (opt_node == null) return false; + } + // TODO: should this node.parent be an assert instead? + if (opt_node) |node| { + if (node.children.count() == 0) if (node.parent) |parent| { + var rest_sections = mem.splitScalar(u8, sections.rest(), '/'); + while (rest_sections.peek()) |_| _ = rest_sections.next(); + const last_section = rest_sections.next().?; + parent.wildcard_child_node = null; + parent.placeholder_children.clearAndFree(); + _ = parent.children.remove(last_section); // TODO assert this is true + }; + return true; + } + return false; + } + + pub const Node = struct { type: Type, max_depth: usize, // TODO: what is best here parent: ?*Node = null, @@ -302,10 +332,39 @@ pub const Listener = struct { } pub fn deinit(self: *Node, allocator: mem.Allocator) void { + for (self.placeholder_children.items) |child| child.deinit(allocator); self.placeholder_children.deinit(); + var child_it = self.children.valueIterator(); + while (child_it.next()) |child| child.*.deinit(allocator); self.children.deinit(); allocator.destroy(self); } }; }; }; + +test "Router" { + var router = Listener.Router.init(std.testing.allocator, &dummyHandler); + defer router.deinit(); + + try router.putRoute("/", &hummyDandler); + try router.putRoute("/foo", &hummyDandler); + try router.putRoute("/foo/bar", &hummyDandler); + try router.putRoute("/foo/foobar", &hummyDandler); + try router.putRoute("/bar", &hummyDandler); + + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/")).handler); + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/foo")).handler); + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/foo/bar")).handler); + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/foo/foobar")).handler); + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/bar")).handler); + + try std.testing.expect(router.removeRoute("/foo")); + + try std.testing.expectEqual(&dummyHandler, (try router.getRoute("/foo/bar")).handler); + try std.testing.expectEqual(&dummyHandler, (try router.getRoute("/foo")).handler); + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/")).handler); +} + +fn dummyHandler(_: *Listener.Event) anyerror!void {} +fn hummyDandler(_: *Listener.Event) anyerror!void {}