jeeves/httz
1
0
Fork 0
Code Issues 2 Pull requests Projects Releases Packages Wiki Activity

god knows anymore

Browse source
This commit is contained in:
Jeeves 2024-03-26 16:07:16 -06:00
parent 6925d69bac
commit c0511cebe0
1 changed files with 81 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

125
src/main.zig
View file

@ -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 {}