Adding test

zon-dev · Sep 15, 2024 · 2b605a8 · 2b605a8
1 parent 999a532
commit 2b605a8
Show file tree

Hide file tree

Showing 4 changed files with 94 additions and 22 deletions.
diff --git a/src/url.zig b/src/url.zig
@@ -9,26 +9,34 @@ const Values = @import("values.zig").Values;
 
 pub const URL = @This();
 
-allocator: std.mem.Allocator = std.heap.page_allocator,
+allocator: std.mem.Allocator,
+
 uri: Uri = undefined,
 scheme: ?[]const u8 = undefined,
 host: ?[]const u8 = undefined,
 path: []const u8 = "/",
 fragment: ?[]const u8 = undefined,
 query: ?[]const u8 = undefined,
 
-// querymap: ?StringHashMap(std.ArrayList([]const u8)) = StringHashMap(std.ArrayList([]const u8)).init(std.heap.page_allocator),
-values: ?std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(std.heap.page_allocator),
+// querymap: ?StringHashMap(std.ArrayList([]const u8))
+values: ?std.StringHashMap(std.ArrayList([]const u8)) = undefined,
 
 // https://developer.mozilla.org/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_URL
 
 pub fn init(self: URL) URL {
     return .{
         .allocator = self.allocator,
-        // .querymap = self.querymap,
+        .values = std.StringHashMap(std.ArrayList([]const u8)).init(self.allocator),
     };
 }
 
+pub fn deinit(self: *URL) void {
+    if (self.values != null) {
+        self.values.?.deinit();
+    }
+    // self.allocator.destroy(self);
+}
+
 const SliceReader = struct {
     const Self = @This();
 
@@ -93,7 +101,9 @@ fn uriToUrl(self: *URL, uri: Uri) void {
 
     if (uri.query != null) {
         self.query = @constCast(uri.query.?.percent_encoded);
-        try parseQuery(&self.values.?, @constCast(uri.query.?.percent_encoded));
+        if (self.values != null) {
+            try parseQuery(&self.values.?, @constCast(uri.query.?.percent_encoded));
+        }
     }
     if (uri.fragment != null) {
         self.fragment = @constCast(uri.fragment.?.percent_encoded);
@@ -108,6 +118,8 @@ pub fn parseUri(self: *URL, text: []const u8) ParseError!*URL {
 }
 
 pub fn parseQuery(map: *std.StringHashMap(std.ArrayList([]const u8)), uri_query: []const u8) !void {
+    const allocator = std.heap.page_allocator;
+
     var queryitmes = std.mem.splitSequence(u8, uri_query, "&");
     while (true) {
         const pair = queryitmes.next();
@@ -131,7 +143,7 @@ pub fn parseQuery(map: *std.StringHashMap(std.ArrayList([]const u8)), uri_query:
         var al: std.ArrayList([]const u8) = undefined;
         const v = map.get(key.?);
         if (v == null) {
-            al = std.ArrayList([]const u8).init(std.heap.page_allocator);
+            al = std.ArrayList([]const u8).init(allocator);
             al.append(value.?) catch continue;
             map.put(key.?, al) catch continue;
             continue;

diff --git a/src/url_test.zig b/src/url_test.zig
@@ -7,9 +7,12 @@ const StringHashMap = @import("std").StringHashMap;
 const URL = @import("url.zig");
 
 test "parseUri 1" {
-    var url = URL.init(.{});
+    var url = URL.init(.{ .allocator = std.testing.allocator });
+
     const text = "http://example.com/path?query=1&query2=2";
     const result = url.parseUri(text) catch return;
+    // defer result.deinit();
+
     try testing.expectEqualStrings("http", result.scheme.?);
     try testing.expectEqualStrings(
         "example.com",
@@ -45,7 +48,7 @@ test "parseUri 1" {
 }
 test "parseUri 2" {
     const text = "foo://example.com:8042/over/there?name=ferret#nose";
-    var url = URL.init(.{});
+    var url = URL.init(.{ .allocator = std.testing.allocator });
     const result = url.parseUri(text) catch return;
     try testing.expectEqualStrings("foo", result.scheme.?);
     try testing.expectEqualStrings(
@@ -73,16 +76,19 @@ test "url target" {
 
 test "url parse" {
     const text = "/path?query=1&query2=2";
-    var url = URL.init(.{});
-    const result = url.parseUrl(text) catch return;
+
+    var url = URL.init(.{ .allocator = std.testing.allocator });
+    defer url.deinit();
+
+    const result = try url.parseUrl(text);
     try testing.expectEqualStrings("/path", result.path);
     try testing.expectEqualStrings("query=1&query2=2", result.query.?);
 }
 
 test "RFC example 1" {
     const text = "/over/there?name=ferret#nose";
-    var url = URL.init(.{});
-    const result = url.parseUrl(text) catch return;
+    var url = URL.init(.{ .allocator = std.testing.allocator });
+    const result = try url.parseUrl(text);
     try testing.expectEqualStrings("/over/there", result.path);
     try testing.expectEqualStrings("name=ferret", @constCast(result.query.?));
     try testing.expectEqualStrings("nose", result.fragment.?);

diff --git a/src/values.zig b/src/values.zig
@@ -1,7 +1,6 @@
-// const std = @import("std");
-// const StringArrayHashMap = std.StringArrayHashMap;
-// const ArrayList = std.ArrayList;
-// const allocator = std.heap.page_allocator;
+const std = @import("std");
+const StringArrayHashMap = std.StringArrayHashMap;
+const ArrayList = std.ArrayList;
 
 // pub fn has(list: ArrayList([]const u8), value: []const u8) bool {
 //     for (list.items) |item| {
@@ -11,3 +10,30 @@
 //     }
 //     return false;
 // }
+
+pub fn encode(allocator: std.mem.Allocator, values: std.StringHashMap(ArrayList([]const u8))) anyerror![]const u8 {
+    // name=Ava&friend=Jess&friend=Sarah&friend=Zoe
+    // var result: []const u8 = undefined;
+    var it = values.iterator();
+    while (it.next()) |entry| {
+
+        // if (result.len > 0) {
+        // }
+
+        // result = try std.mem.join(allocator, "&", result);
+
+        const key: []const u8 = entry.key_ptr.*;
+        const value: ArrayList([]const u8) = entry.value_ptr.*;
+
+        const keypair = try std.fmt.allocPrint(allocator, "{s}=", .{key});
+        defer allocator.free(keypair);
+
+        for (value.items) |item| {
+            const valuepair = try std.fmt.allocPrint(allocator, "{s}", .{item});
+            defer allocator.free(valuepair);
+        }
+        // result = keypair;
+    }
+
+    return "";
+}
diff --git a/src/values_test.zig b/src/values_test.zig
@@ -1,14 +1,18 @@
 const std = @import("std");
+const testing = std.testing;
+const allocator = testing.allocator;
+
 const URL = @import("url.zig");
+const Values = @import("values.zig");
 
 test "sample1" {
-    var values: std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(std.testing.allocator);
+    var values: std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(allocator);
     defer values.deinit();
-    var name = std.ArrayList([]const u8).init(std.testing.allocator);
+    var name = std.ArrayList([]const u8).init(allocator);
     defer name.deinit();
     try name.append("Ava");
 
-    var friend = std.ArrayList([]const u8).init(std.testing.allocator);
+    var friend = std.ArrayList([]const u8).init(allocator);
     defer friend.deinit();
     try friend.append("Jess");
     try friend.append("Sarah");
@@ -31,7 +35,7 @@ test "sample1" {
 
 test "sample2" {
     const text = "name=Ava&friend=Jess&friend=Sarah&friend=Zoe";
-    var values: std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(std.testing.allocator);
+    var values: std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(allocator);
     defer values.deinit();
     try URL.parseQuery(&values, text);
     try std.testing.expectEqualStrings("Ava", values.get("name").?.items[0]);
@@ -42,10 +46,11 @@ test "sample2" {
 
 test "sample3" {
     const text = "https://example.org/?a=1&a=2&b=&=3&&&&";
-    var url = URL.init(.{});
+    var url = URL.init(.{ .allocator = std.testing.allocator });
     const result = try url.parseUri(text);
 
-    const values = result.values.?;
+    var values = result.values.?;
+    defer values.deinit();
 
     const a1 = values.get("a").?.items[0];
     const a2 = values.get("a").?.items[1];
@@ -58,3 +63,26 @@ test "sample3" {
     try std.testing.expectEqual(1, v3.items.len);
     try std.testing.expectEqualStrings("3", v3.items[0]);
 }
+
+test "encode" {
+    var name = std.ArrayList([]const u8).init(allocator);
+    defer name.deinit();
+    try name.append("Ava");
+
+    var friend = std.ArrayList([]const u8).init(allocator);
+    defer friend.deinit();
+    try friend.append("Jess");
+    try friend.append("Sarah");
+    try friend.append("Zoe");
+
+    var values: std.StringHashMap(std.ArrayList([]const u8)) = std.StringHashMap(std.ArrayList([]const u8)).init(allocator);
+    defer values.deinit();
+
+    try values.put("name", name);
+    try values.put("friend", friend);
+    const url_values = try Values.encode(allocator, values);
+    defer allocator.free(url_values);
+    // const expected = "name=Ava&friend=Jess&friend=Sarah&friend=Zoe";
+    // std.debug.print("url_values: {s}\n", .{url_values});
+    // try testing.expectEqualStrings(expected, url_values);
+}