style(): rename alloc into gpa

4 files changed, 110 insertions, 110 deletions

diff --git a/src/dom/Element.zig b/src/dom/Element.zig
index 60f82e0..7fd2f2d 100644
--- a/src/dom/Element.zig
+++ b/src/dom/Element.zig
@@ -12,7 +12,7 @@ pub const Kind = enum {
 const Self = @This();
 
 kind: Kind,
-alloc: Allocator,
+gpa: Allocator,
 tag: ?[]const u8 = null,
 attributes: std.StringArrayHashMap([]const u8),
 class_list: std.BufSet,
@@ -21,33 +21,33 @@ literal: ?[]const u8 = null,
 
 /// Init a new Element with the given kind.
 /// The tag will never be escaped.
-pub fn init(alloc: Allocator, knd: Kind, tag: []const u8) Self {
+pub fn init(gpa: Allocator, knd: Kind, tag: []const u8) Self {
     return .{
         .kind = knd,
-        .alloc = alloc,
+        .gpa = gpa,
         .tag = tag,
-        .attributes = .init(alloc),
-        .class_list = .init(alloc),
+        .attributes = .init(gpa),
+        .class_list = .init(gpa),
     };
 }
 
 /// Init a new literal element.
 /// The literal content will never be escaped, see initLitEscaped if you want to escape it.
 /// The literal content must be free'd by the allocator (use Allocator.dupe if you want to use a const string).
-pub fn initLit(alloc: Allocator, literal: []const u8) Self {
+pub fn initLit(gpa: Allocator, literal: []const u8) Self {
     return .{
         .kind = .literal,
-        .alloc = alloc,
+        .gpa = gpa,
         .literal = literal,
-        .attributes = .init(alloc),
-        .class_list = .init(alloc),
+        .attributes = .init(gpa),
+        .class_list = .init(gpa),
     };
 }
 
 /// Init a new literal element that is escaped.
 /// The literal content will be escaped, see initLit if you don't want this behavior.
-pub fn initLitEscaped(alloc: Allocator, literal: []const u8) !Self {
-    return .initLit(alloc, try html.escape(alloc, literal));
+pub fn initLitEscaped(gpa: Allocator, literal: []const u8) !Self {
+    return .initLit(gpa, try html.escape(gpa, literal));
 }
 
 pub fn deinit(self: *Self) void {
@@ -57,75 +57,75 @@ pub fn deinit(self: *Self) void {
         var v = it;
         v.deinit();
     }
-    self.content.deinit(self.alloc);
-    if (self.literal) |it| self.alloc.free(it);
+    self.content.deinit(self.gpa);
+    if (self.literal) |it| self.gpa.free(it);
 }
 
-pub fn render(self: *Self, alloc: Allocator) ![]const u8 {
-    const attr = try self.renderAttribute(alloc);
-    defer if (attr) |it| alloc.free(it);
-    var acc = try std.ArrayList(u8).initCapacity(alloc, self.content.items.len + if (self.literal) |it| it.len else 0);
-    errdefer acc.deinit(alloc);
+pub fn render(self: *Self, gpa: Allocator) ![]const u8 {
+    const attr = try self.renderAttribute(gpa);
+    defer if (attr) |it| gpa.free(it);
+    var acc = try std.ArrayList(u8).initCapacity(gpa, self.content.items.len + if (self.literal) |it| it.len else 0);
+    errdefer acc.deinit(gpa);
     if (self.tag) |tag| {
-        try acc.append(alloc, '<');
-        try acc.appendSlice(alloc, tag);
-        if (attr) |it| try acc.appendSlice(alloc, it);
-        try acc.append(alloc, '>');
+        try acc.append(gpa, '<');
+        try acc.appendSlice(gpa, tag);
+        if (attr) |it| try acc.appendSlice(gpa, it);
+        try acc.append(gpa, '>');
     }
     switch (self.kind) {
-        .void => return acc.toOwnedSlice(alloc),
+        .void => return acc.toOwnedSlice(gpa),
         .content => {
             for (self.content.items) |it| {
                 var v = it;
-                const sub = try v.render(alloc);
-                defer alloc.free(sub);
-                try acc.appendSlice(alloc, sub);
+                const sub = try v.render(gpa);
+                defer gpa.free(sub);
+                try acc.appendSlice(gpa, sub);
             }
         },
-        .literal => try acc.appendSlice(alloc, self.literal.?),
+        .literal => try acc.appendSlice(gpa, self.literal.?),
     }
     if (self.tag) |tag| {
-        try acc.appendSlice(alloc, "</");
-        try acc.appendSlice(alloc, tag);
-        try acc.append(alloc, '>');
+        try acc.appendSlice(gpa, "</");
+        try acc.appendSlice(gpa, tag);
+        try acc.append(gpa, '>');
     }
-    return acc.toOwnedSlice(alloc);
+    return acc.toOwnedSlice(gpa);
 }
 
-fn renderAttribute(self: *Self, alloc: Allocator) !?[]const u8 {
-    const class = try self.renderClass(alloc);
-    defer if (class) |it| alloc.free(it);
+fn renderAttribute(self: *Self, gpa: Allocator) !?[]const u8 {
+    const class = try self.renderClass(gpa);
+    defer if (class) |it| gpa.free(it);
     if (class) |it| try self.setAttribute("class", it);
     var iter = self.attributes.iterator();
     if (iter.len == 0) return null;
-    var acc = try std.ArrayList(u8).initCapacity(alloc, iter.len);
-    errdefer acc.deinit(alloc);
-    try acc.append(alloc, ' ');
+    var acc = try std.ArrayList(u8).initCapacity(gpa, iter.len);
+    errdefer acc.deinit(gpa);
+    try acc.append(gpa, ' ');
     var i: usize = 0;
     while (iter.next()) |it| : (i += 1) {
-        try acc.appendSlice(alloc, it.key_ptr.*);
-        try acc.appendSlice(alloc, "=\"");
-        const escape = try html.escape(alloc, it.value_ptr.*);
-        defer alloc.free(escape);
-        try acc.appendSlice(alloc, escape);
-        try acc.append(alloc, '"');
-        if (i < iter.len - 1) try acc.append(alloc, ' ');
+        try acc.appendSlice(gpa, it.key_ptr.*);
+        try acc.appendSlice(gpa, "=\"");
+        const escape = try html.escape(gpa, it.value_ptr.*);
+        defer gpa.free(escape);
+        try acc.appendSlice(gpa, escape);
+        try acc.append(gpa, '"');
+        if (i < iter.len - 1) try acc.append(gpa, ' ');
     }
-    return try acc.toOwnedSlice(alloc);
+    return try acc.toOwnedSlice(gpa);
 }
 
-fn renderClass(self: *const Self, alloc: Allocator) !?[]const u8 {
+fn renderClass(self: *const Self, gpa: Allocator) !?[]const u8 {
     var iter = self.class_list.iterator();
     if (iter.len == 0) return null;
     const n = self.class_list.count();
-    var acc = try std.ArrayList(u8).initCapacity(alloc, n);
-    errdefer acc.deinit(alloc);
+    var acc = try std.ArrayList(u8).initCapacity(gpa, n);
+    errdefer acc.deinit(gpa);
     var i: usize = 0;
     while (iter.next()) |it| : (i += 1) {
-        try acc.appendSlice(alloc, it.*);
-        if (i < n - 1) try acc.append(alloc, ' ');
+        try acc.appendSlice(gpa, it.*);
+        if (i < n - 1) try acc.append(gpa, ' ');
     }
-    return try acc.toOwnedSlice(alloc);
+    return try acc.toOwnedSlice(gpa);
 }
 
 pub fn setAttribute(self: *Self, k: []const u8, v: []const u8) !void {
@@ -153,32 +153,32 @@ pub fn removeClass(self: *Self, v: []const u8) void {
 }
 
 pub fn appendContent(self: *Self, content: Self) !void {
-    return self.content.append(self.alloc, content);
+    return self.content.append(self.gpa, content);
 }
 
-pub fn initImg(alloc: Allocator, src: []const u8, alt: []const u8) !Self {
-    var el = init(alloc, .void, "img");
+pub fn initImg(gpa: Allocator, src: []const u8, alt: []const u8) !Self {
+    var el = init(gpa, .void, "img");
     try el.setAttribute("src", src);
     try el.setAttribute("alt", alt);
     return el;
 }
 
-pub fn initContent(alloc: Allocator, tag: []const u8, content: []Self) !Self {
-    var el = init(alloc, .content, tag);
+pub fn initContent(gpa: Allocator, tag: []const u8, content: []Self) !Self {
+    var el = init(gpa, .content, tag);
     for (content) |it| try el.appendContent(it);
     return el;
 }
 
 /// Init a paragraph tag with an automatically escaped content.
-pub fn initParagraph(alloc: Allocator, content: []const u8) !Self {
-    var el = init(alloc, .content, "p");
-    try el.appendContent(try initLitEscaped(alloc, content));
+pub fn initParagraph(gpa: Allocator, content: []const u8) !Self {
+    var el = init(gpa, .content, "p");
+    try el.appendContent(try initLitEscaped(gpa, content));
     return el;
 }
 
-fn doTest(alloc: Allocator, el: *Self, exp: []const u8) !void {
-    const got = try el.render(alloc);
-    defer alloc.free(got);
+fn doTest(gpa: Allocator, el: *Self, exp: []const u8) !void {
+    const got = try el.render(gpa);
+    defer gpa.free(got);
     std.testing.expect(eql(u8, got, exp)) catch |err| {
         std.debug.print("{s}\n", .{got});
         return err;
@@ -188,49 +188,49 @@ fn doTest(alloc: Allocator, el: *Self, exp: []const u8) !void {
 test "void element" {
     var arena = std.heap.DebugAllocator(.{}).init;
     defer _ = arena.deinit();
-    const alloc = arena.allocator();
+    const gpa = arena.allocator();
 
-    var br = init(alloc, .void, "br");
+    var br = init(gpa, .void, "br");
     defer br.deinit();
 
-    try doTest(alloc, &br, "<br>");
+    try doTest(gpa, &br, "<br>");
 
-    var img = init(alloc, .void, "img");
+    var img = init(gpa, .void, "img");
     defer img.deinit();
     try img.setAttribute("src", "foo");
     try img.setAttribute("alt", "bar");
 
-    try doTest(alloc, &img, "<img src=\"foo\" alt=\"bar\">");
+    try doTest(gpa, &img, "<img src=\"foo\" alt=\"bar\">");
 
-    var img2 = try initImg(alloc, "foo", "bar");
+    var img2 = try initImg(gpa, "foo", "bar");
     defer img2.deinit();
-    try doTest(alloc, &img2, "<img src=\"foo\" alt=\"bar\">");
+    try doTest(gpa, &img2, "<img src=\"foo\" alt=\"bar\">");
 }
 
 test "content element" {
     var arena = std.heap.DebugAllocator(.{}).init;
     defer _ = arena.deinit();
-    const alloc = arena.allocator();
+    const gpa = arena.allocator();
 
-    var p = init(alloc, .content, "p");
+    var p = init(gpa, .content, "p");
     defer p.deinit();
 
-    var content = initLit(alloc, try alloc.dupe(u8, "hello world"));
+    var content = initLit(gpa, try gpa.dupe(u8, "hello world"));
     try p.appendContent(content);
 
-    try doTest(alloc, &content, "hello world");
-    try doTest(alloc, &p, "<p>hello world</p>");
+    try doTest(gpa, &content, "hello world");
+    try doTest(gpa, &p, "<p>hello world</p>");
 
-    var p_managed = try initParagraph(alloc, "hello world");
+    var p_managed = try initParagraph(gpa, "hello world");
     defer p_managed.deinit();
 
-    try doTest(alloc, &p_managed, "<p>hello world</p>");
+    try doTest(gpa, &p_managed, "<p>hello world</p>");
 
-    var div = init(alloc, .content, "div");
+    var div = init(gpa, .content, "div");
     defer div.deinit();
     try div.appendClass("foo-bar");
-    try div.appendContent(try initParagraph(alloc, "hello world"));
-    try div.appendContent(try initImg(alloc, "example.org", "example"));
+    try div.appendContent(try initParagraph(gpa, "hello world"));
+    try div.appendContent(try initImg(gpa, "example.org", "example"));
 
-    try doTest(alloc, &div, "<div class=\"foo-bar\"><p>hello world</p><img src=\"example.org\" alt=\"example\"></div>");
+    try doTest(gpa, &div, "<div class=\"foo-bar\"><p>hello world</p><img src=\"example.org\" alt=\"example\"></div>");
 }
diff --git a/src/dom/html.zig b/src/dom/html.zig
index bf62fbb..4b39a3f 100644
--- a/src/dom/html.zig
+++ b/src/dom/html.zig
@@ -24,9 +24,9 @@ pub fn escape(gpa: std.mem.Allocator, v: []const u8) ![]const u8 {
     return acc.toOwnedSlice(gpa);
 }
 
-fn doTest(alloc: std.mem.Allocator, el: []const u8, exp: []const u8) !void {
-    const got = try escape(alloc, el);
-    defer alloc.free(got);
+fn doTest(gpa: std.mem.Allocator, el: []const u8, exp: []const u8) !void {
+    const got = try escape(gpa, el);
+    defer gpa.free(got);
     std.testing.expect(eql(u8, got, exp)) catch |err| {
         std.debug.print("{s}\n", .{got});
         return err;
@@ -36,12 +36,12 @@ fn doTest(alloc: std.mem.Allocator, el: []const u8, exp: []const u8) !void {
 test "escaping html" {
     var arena = std.heap.DebugAllocator(.{}).init;
     defer _ = arena.deinit();
-    const alloc = arena.allocator();
+    const gpa = arena.allocator();
 
-    try doTest(alloc, "hello world", "hello world");
-    try doTest(alloc, "hello&world", "hello&amp;world");
-    try doTest(alloc, "hello'world", "hello&#39;world");
-    try doTest(alloc, "hello<world", "hello&lt;world");
-    try doTest(alloc, "hello>world", "hello&gt;world");
-    try doTest(alloc, "hello\"world", "hello&#34;world");
+    try doTest(gpa, "hello world", "hello world");
+    try doTest(gpa, "hello&world", "hello&amp;world");
+    try doTest(gpa, "hello'world", "hello&#39;world");
+    try doTest(gpa, "hello<world", "hello&lt;world");
+    try doTest(gpa, "hello>world", "hello&gt;world");
+    try doTest(gpa, "hello\"world", "hello&#34;world");
 }
diff --git a/src/lexer/Lexed.zig b/src/lexer/Lexed.zig
index b7c3b2c..2ce6913 100644
--- a/src/lexer/Lexed.zig
+++ b/src/lexer/Lexed.zig
@@ -21,26 +21,26 @@ pub const Kind = enum {
     tag,
 };
 
-allocator: Allocator,
+gpa: Allocator,
 kind: Kind,
 content: std.ArrayList(u8),
 
 const Self = @This();
 
-pub fn init(alloc: Allocator, kind: Kind, content: std.ArrayList(u8)) Self {
+pub fn init(gpa: Allocator, kind: Kind, content: std.ArrayList(u8)) Self {
     return .{
-        .allocator = alloc,
+        .gpa = gpa,
         .kind = kind,
         .content = content,
     };
 }
 
 pub fn deinit(self: *Self) void {
-    self.content.deinit(self.allocator);
+    self.content.deinit(self.gpa);
 }
 
-pub fn clone(self: *const Self, alloc: Allocator) Allocator.Error!std.ArrayList(u8) {
-    return self.content.clone(alloc);
+pub fn clone(self: *const Self, gpa: Allocator) Allocator.Error!std.ArrayList(u8) {
+    return self.content.clone(gpa);
 }
 
 pub fn equals(self: *const Self, kind: Kind, content: []const u8) bool {
diff --git a/src/lexer/Lexer.zig b/src/lexer/Lexer.zig
index 2705347..2ccc065 100644
--- a/src/lexer/Lexer.zig
+++ b/src/lexer/Lexer.zig
@@ -18,9 +18,9 @@ pub fn init(content: []const u8) Error!Self {
     return .{ .iter = view.iterator() };
 }
 
-pub fn next(self: *Self, alloc: Allocator) Error!?Lexed {
-    var acc = try std.ArrayList(u8).initCapacity(alloc, 2);
-    errdefer acc.deinit(alloc);
+pub fn next(self: *Self, gpa: Allocator) Error!?Lexed {
+    var acc = try std.ArrayList(u8).initCapacity(gpa, 2);
+    errdefer acc.deinit(gpa);
 
     var current_kind: ?Lexed.Kind = null;
     while (self.iter.nextCodepointSlice()) |rune| {
@@ -35,7 +35,7 @@ pub fn next(self: *Self, alloc: Allocator) Error!?Lexed {
             const res = self.getCurrentKind(current_kind, rune, acc.items);
             current_kind = res.kind;
             override_if = res.override_if;
-            try acc.appendSlice(alloc, rune);
+            try acc.appendSlice(gpa, rune);
         }
         // conds here to avoid creating complex condition in while
         const next_rune = self.iter.peek(1);
@@ -57,10 +57,10 @@ pub fn next(self: *Self, alloc: Allocator) Error!?Lexed {
         }
     }
     const kind = current_kind orelse {
-        acc.deinit(alloc);
+        acc.deinit(gpa);
         return null;
     };
-    return .init(alloc, kind, acc);
+    return .init(gpa, kind, acc);
 }
 
 const kindRes = struct {
@@ -149,8 +149,8 @@ fn requiresSpace(k: Lexed.Kind) bool {
     };
 }
 
-fn doTest(alloc: Allocator, l: *Self, k: Lexed.Kind, v: []const u8) !void {
-    var first = (try l.next(alloc)).?;
+fn doTest(gpa: Allocator, l: *Self, k: Lexed.Kind, v: []const u8) !void {
+    var first = (try l.next(gpa)).?;
     defer first.deinit();
     std.testing.expect(first.equals(k, v)) catch |err| {
         std.debug.print("{}({s})\n", .{ first.kind, first.content.items });
@@ -178,14 +178,14 @@ test "lexer common" {
 
     var arena = std.heap.DebugAllocator(.{}).init;
     defer _ = arena.deinit();
-    const alloc = arena.allocator();
+    const gpa = arena.allocator();
 
     var l = try init("# hello world :)");
 
-    try doTest(alloc, &l, .title, "#");
-    try doTest(alloc, &l, .literal, "hello world ");
-    try doTest(alloc, &l, .ref, ":");
-    try doTest(alloc, &l, .link, ")");
+    try doTest(gpa, &l, .title, "#");
+    try doTest(gpa, &l, .literal, "hello world ");
+    try doTest(gpa, &l, .ref, ":");
+    try doTest(gpa, &l, .link, ")");
 
-    try expect(try l.next(alloc) == null);
+    try expect(try l.next(gpa) == null);
 }