god knows anymore

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 = .{
+                // .static_routes = std.StringHashMap(*Node).init(allocator),
-                //     .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.deinit(self.allocator);
+            self.root_node.deinit(self.arena.allocator());
-            // self.root_node.children.deinit();
+            self.arena.deinit();
-            // self.root_node.placeholder_children.deinit();
+            // self.static_routes.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});
+            std.debug.print("\npath {s}\n", .{path});
-            var is_static_route = true;
+            // 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});
+                                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
+                                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| {
+                std.debug.print("found node\n", .{});
-                    var rest_sections = mem.splitScalar(u8, sections.rest(), '/');
+                // if (node.children.count() == 0) {
-                    while (rest_sections.peek()) |_| _ = rest_sections.next();
+                // std.debug.print("node has no children\n", .{});
-                    const last_section = rest_sections.next().?;
+                if (node.parent) |_| {
-                    parent.wildcard_child_node = null;
+                    std.debug.print("removing self from parent\n", .{});
-                    parent.placeholder_children.clearAndFree();
+                    var rest_sections = mem.splitScalar(u8, path, '/');
-                    _ = parent.children.remove(last_section); // TODO assert this is true
+                    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 {
+            pub fn deinit(self: *Node, allocator: mem.Allocator, section: ?[]const u8) void {
-                for (self.placeholder_children.items) |child| child.deinit(allocator);
+                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 {}