From c0511cebe0488bb2dacee0c3d590551bdda46313 Mon Sep 17 00:00:00 2001 From: Jeeves Date: Tue, 26 Mar 2024 16:07:16 -0600 Subject: [PATCH] god knows anymore --- src/main.zig | 125 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 81 insertions(+), 44 deletions(-) diff --git a/src/main.zig b/src/main.zig index 4a90fde..a951667 100644 --- a/src/main.zig +++ b/src/main.zig @@ -138,32 +138,28 @@ pub const Listener = struct { /// Some code taken from [unjs/radix3](https://github.com/unjs/radix3) pub const Router = struct { allocator: mem.Allocator, + arena: heap.ArenaAllocator, root_node: *Node, - static_routes: std.StringHashMap(*Node), + // static_routes: std.StringHashMap(*Node), pub fn init(allocator: mem.Allocator, root_handler: HandlerFn) Router { - var node = Node.init(allocator) catch @panic("OOM"); + var arena = heap.ArenaAllocator.init(allocator); + var node = Node.init(arena.allocator()) catch @panic("OOM"); node.handler = root_handler; + // std.debug.print("init router with root_node {any}\n", .{node}); return .{ .allocator = allocator, + .arena = arena, .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), + // .static_routes = std.StringHashMap(*Node).init(allocator), }; } pub fn deinit(self: *Router) void { - self.root_node.deinit(self.allocator); - // self.root_node.children.deinit(); - // self.root_node.placeholder_children.deinit(); - self.static_routes.deinit(); + self.root_node.deinit(self.arena.allocator()); + self.arena.deinit(); + // self.static_routes.deinit(); } pub fn handle(self: *Router, event: *Listener.Event) !void { @@ -173,17 +169,21 @@ pub const Listener = struct { /// Insert a route if the path is not already present, otherwise overwrite preexisting HandlerFn. pub fn putRoute(self: *Router, path: []const u8, handler: HandlerFn) !void { - // std.debug.print("\npath {s}\n", .{path}); - var is_static_route = true; + std.debug.print("\npath {s}\n", .{path}); + // var is_static_route = true; var sections = mem.splitScalar(u8, path, '/'); + if (sections.peek()) |sec| if (sec.len == 0) { + _ = sections.next(); + }; var node = self.root_node; var unnamed_placeholder_ctr: usize = 0; var matched_nodes = std.ArrayList(*Node).init(self.allocator); defer matched_nodes.deinit(); try matched_nodes.append(node); while (sections.next()) |section| { - // std.debug.print("adding section {s}\n", .{section}); + std.debug.print("adding section {s}\n", .{section}); if (node.children.get(section)) |child| { + std.debug.print("into child\n", .{}); node = child; } else { var child_node = try Node.init(self.allocator); @@ -194,29 +194,32 @@ pub const Listener = struct { else .normal; child_node.parent = node; + // child_node.handler = handler; try node.children.put(section, child_node); switch (child_node.type) { .normal => {}, .wildcard => { - // std.debug.print("is wildcard\n", .{}); + std.debug.print("is wildcard\n", .{}); node.wildcard_child_node = child_node; child_node.param_name = if (section.len > 3) section[3..] else "_"; - is_static_route = false; + // is_static_route = false; }, .placeholder => { - // std.debug.print("is placeholder\n", .{}); + std.debug.print("is placeholder\n", .{}); child_node.param_name = if (mem.eql(u8, section, "*")) blk: { - // std.debug.print("is unnamed placeholder #{d}\n", .{unnamed_placeholder_ctr}); - const s = try std.fmt.allocPrint(self.allocator, "_{d}", .{unnamed_placeholder_ctr}); // TODO: this will leak + std.debug.print("is unnamed placeholder #{d}\n", .{unnamed_placeholder_ctr}); + const s = try std.fmt.allocPrint(self.arena.allocator(), "_{d}", .{unnamed_placeholder_ctr}); // TODO: this will leak unnamed_placeholder_ctr += 1; break :blk s; - } else section[1..]; + } else try self.arena.allocator().dupe(u8, section[1..]); try node.placeholder_children.append(child_node); - is_static_route = false; + // is_static_route = false; }, } + // std.debug.print("added child node: {any}\n", .{child_node}); + try matched_nodes.append(child_node); node = child_node; } @@ -226,12 +229,13 @@ pub const Listener = struct { // if (is_static_route) std.debug.print("was static route\n", .{}); - if (is_static_route) try self.static_routes.put(path, node); + // if (is_static_route) try self.static_routes.put(path, node); } /// Get the HandlerFn associated with path, otherwise get root_handler. pub fn getRoute(self: *Router, path: []const u8) !*Node { - if (self.static_routes.get(path)) |rt| return rt; + // if (self.static_routes.get(path)) |rt| return rt; + std.debug.print("\nget path {s}\n", .{path}); var params = std.StringHashMap([]const u8).init(self.allocator); defer params.deinit(); @@ -242,8 +246,13 @@ pub const Listener = struct { var remaining = mem.count(u8, path, "/") + 1; var sections = mem.splitScalar(u8, path, '/'); + if (sections.peek()) |sec| if (sec.len == 0) { + _ = sections.next(); + }; while (sections.next()) |section| : (remaining -= 1) { + std.debug.print("finding section: {s}\n", .{section}); if (node.wildcard_child_node) |wildcard_child_node| { + std.debug.print("section has wildcard\n", .{}); wildcard_node = wildcard_child_node; wildcard_param = sections.rest(); } @@ -251,7 +260,7 @@ pub const Listener = struct { const next_node = node.children.get(section); if (next_node) |child| { node = child; - // std.debug.print("found section {s} child_node {any}\n", .{ section, child.type }); + std.debug.print("found section {s} child_node {any}\n", .{ section, child.type }); } else { var child_node: ?*Node = null; if (node.placeholder_children.items.len > 1) { @@ -273,7 +282,7 @@ pub const Listener = struct { } } - // std.debug.print("ended up with node {any}\n", .{node.type}); + std.debug.print("ended up with node {any}\nhas wildcard_node: {any}\nis root_node: {any}\n", .{ node.type, wildcard_node != null, node == self.root_node }); if (wildcard_node) |wildcard| { node = wildcard; @@ -286,25 +295,36 @@ pub const Listener = 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; + // _ = self.static_routes.remove(path); + std.debug.print("\nremoving path {s}\n", .{path}); var opt_node: ?*Node = self.root_node; var sections = mem.splitScalar(u8, path, '/'); + if (sections.peek()) |sec| if (sec.len == 0) { + _ = sections.next(); + }; while (sections.next()) |section| { // TODO: reorder to be safe + std.debug.print("section: {s}\n", .{section}); 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 - }; + std.debug.print("found node\n", .{}); + // if (node.children.count() == 0) { + // std.debug.print("node has no children\n", .{}); + if (node.parent) |_| { + std.debug.print("removing self from parent\n", .{}); + var rest_sections = mem.splitScalar(u8, path, '/'); + var last_section: []const u8 = undefined; + while (rest_sections.peek()) |_| last_section = rest_sections.next().?; + // parent.wildcard_child_node = null; + // parent.placeholder_children.clearAndFree(); + // _ = parent.children.remove(last_section); // TODO assert this is true + node.deinit(self.allocator, last_section); + } else node.deinit(self.allocator, null); + // } // else node.deinit(self.allocator); return true; } return false; @@ -322,17 +342,23 @@ pub const Listener = struct { pub const Type = enum { normal, wildcard, placeholder }; + /// Expects handler to be set later. Will cause problems otherwise! pub fn init(allocator: mem.Allocator) !*Node { var self = try allocator.create(Node); self.type = .normal; self.max_depth = 256; self.children = std.StringHashMap(*Node).init(allocator); self.placeholder_children = std.ArrayList(*Node).init(allocator); + self.parent = null; + self.param_name = null; + self.wildcard_child_node = null; return self; } - pub fn deinit(self: *Node, allocator: mem.Allocator) void { - for (self.placeholder_children.items) |child| child.deinit(allocator); + pub fn deinit(self: *Node, allocator: mem.Allocator, section: ?[]const u8) void { + std.debug.print("deiniting node with {d} children.. and {d} placeholder_children\n", .{ self.children.count(), self.placeholder_children.items.len }); + if (section) |sec| if (self.parent) |parent| parent.children.remove(sec); + for (self.placeholder_children.items) |child| std.debug.print("child {any}\n", .{child}); // child.deinit(allocator); self.placeholder_children.deinit(); var child_it = self.children.valueIterator(); while (child_it.next()) |child| child.*.deinit(allocator); @@ -347,24 +373,35 @@ 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("/foo/foobar", &tummyCandler); try router.putRoute("/bar", &hummyDandler); - try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/")).handler); + try std.testing.expectEqual(&dummyHandler, (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(&tummyCandler, (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); + try std.testing.expectEqual(&dummyHandler, (try router.getRoute("/")).handler); + + try router.putRoute("/foo", &hummyDandler); + try router.putRoute("/foo/**", &tummyCandler); + try router.putRoute("/bar/*", &tummyCandler); + + try std.testing.expectEqual(&hummyDandler, (try router.getRoute("/foo")).handler); + try std.testing.expectEqual(&tummyCandler, (try router.getRoute("/foo/bar")).handler); + try std.testing.expectEqual(&tummyCandler, (try router.getRoute("/foo/bar/foo")).handler); + try std.testing.expectEqual(&tummyCandler, (try router.getRoute("/foo/foof")).handler); + + try std.testing.expect(router.removeRoute("/bar/*")); } fn dummyHandler(_: *Listener.Event) anyerror!void {} fn hummyDandler(_: *Listener.Event) anyerror!void {} +fn tummyCandler(_: *Listener.Event) anyerror!void {}