chor: upgrade to latest zig; remove zg dependency

src/testing.zig

@@ -116,6 +116,41 @@ pub fn expectContainerScreen(size: Point, container: *Container(event.SystemEven
     try expectEqualCells(.{}, renderer.size, expected, renderer.screen);
 }
 
+/// Taken from: https://codeberg.org/atman/zg/src/branch/master/src/DisplayWidth.zig
+/// Owned by https://codeberg.org/atman licensed under MIT all credits for this function go to him
+fn center(allocator: Allocator, str: []const u8, total_width: usize, pad: []const u8) ![]u8 {
+    if (str.len > total_width) return error.StrTooLong;
+    if (str.len == total_width) return try allocator.dupe(u8, str);
+
+    if (pad.len > total_width or str.len + pad.len > total_width) return error.PadTooLong;
+
+    const margin_width = @divFloor((total_width - str.len), 2);
+    if (pad.len > margin_width) return error.PadTooLong;
+
+    const extra_pad: usize = if (total_width % 2 != str.len % 2) 1 else 0;
+    const pads = @divFloor(margin_width, pad.len) * 2 + extra_pad;
+
+    var result = try allocator.alloc(u8, pads * pad.len + str.len);
+    var bytes_index: usize = 0;
+    var pads_index: usize = 0;
+
+    while (pads_index < pads / 2) : (pads_index += 1) {
+        @memcpy(result[bytes_index..][0..pad.len], pad);
+        bytes_index += pad.len;
+    }
+
+    @memcpy(result[bytes_index..][0..str.len], str);
+    bytes_index += str.len;
+
+    pads_index = 0;
+    while (pads_index < pads / 2 + extra_pad) : (pads_index += 1) {
+        @memcpy(result[bytes_index..][0..pad.len], pad);
+        bytes_index += pad.len;
+    }
+
+    return result;
+}
+
 /// This function is intended to be used only in tests. Test if the two
 /// provided cell arrays are identical. Usually the `Cell` slices are
 /// the contents of a given screen from the `zterm.testing.Renderer`. See
@@ -127,28 +162,21 @@ pub fn expectEqualCells(origin: Point, size: Point, expected: []const Cell, actu
     try testing.expectEqual(expected.len, @as(usize, size.y) * @as(usize, size.x));
 
     var expected_cps = try std.ArrayList(Cell).initCapacity(allocator, size.x);
-    defer expected_cps.deinit();
+    defer expected_cps.deinit(allocator);
 
     var actual_cps = try std.ArrayList(Cell).initCapacity(allocator, size.x);
-    defer actual_cps.deinit();
+    defer actual_cps.deinit(allocator);
 
     var output = try std.ArrayList(u8).initCapacity(allocator, expected_cps.capacity * actual_cps.capacity + 5 * size.y);
-    defer output.deinit();
+    defer output.deinit(allocator);
 
-    var buffer = std.io.bufferedWriter(output.writer());
-    defer buffer.flush() catch {};
-
-    const writer = buffer.writer();
+    const writer = output.writer(allocator);
     var differ = false;
 
-    const dwd = try DisplayWidth.DisplayWidthData.init(allocator);
-    defer dwd.deinit();
-    const dw: DisplayWidth = .{ .data = &dwd };
-
-    const expected_centered = try dw.center(allocator, "Expected Screen", size.x, " ");
+    const expected_centered = try center(allocator, "Expected Screen", size.x, " ");
     defer allocator.free(expected_centered);
 
-    const actual_centered = try dw.center(allocator, "Actual Screen", size.x, " ");
+    const actual_centered = try center(allocator, "Actual Screen", size.x, " ");
     defer allocator.free(actual_centered);
 
     try writer.print("Screens are not equivalent.\n{s} ┆ {s}\n", .{ expected_centered, actual_centered });
@@ -164,8 +192,8 @@ pub fn expectEqualCells(origin: Point, size: Point, expected: []const Cell, actu
 
             if (!expected_cell.eql(actual_cell)) differ = true;
 
-            try expected_cps.append(expected_cell);
-            try actual_cps.append(actual_cell);
+            try expected_cps.append(allocator, expected_cell);
+            try actual_cps.append(allocator, actual_cell);
         }
 
         // write screens both formatted to buffer
@@ -178,13 +206,14 @@ pub fn expectEqualCells(origin: Point, size: Point, expected: []const Cell, actu
     if (!differ) return;
 
     // test failed
-    try buffer.flush();
-
     debug.lockStdErr();
     defer debug.unlockStdErr();
 
-    const std_writer = std.io.getStdErr().writer();
-    try std_writer.writeAll(output.items);
+    var stdout_buffer: [1024]u8 = undefined;
+    var stdout = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout_writer = &stdout.interface;
+    try stdout_writer.writeAll(output.items);
+    try stdout_writer.flush();
     return error.TestExpectEqualCells;
 }
 
@@ -195,5 +224,4 @@ const Allocator = std.mem.Allocator;
 const event = @import("event.zig");
 const Container = @import("container.zig").Container;
 const Cell = @import("cell.zig");
-const DisplayWidth = @import("DisplayWidth");
 const Point = @import("point.zig").Point;