feat: Added table viewer.

src/tabula.zig

@@ -0,0 +1,314 @@
+const std = @import("std");
+
+const hor = "─";
+const tl = "┌";
+const tm = "┬";
+const tr = "┐";
+const sep = "│";
+const ml = "├";
+const mm = "┼";
+const mr = "┤";
+const bl = "└";
+const bm = "┴";
+const br = "┘";
+
+// Print a list of structs as a table to opts.out.
+pub fn structs(
+    comptime T: type,
+    items: []T,
+    opts: struct {
+        out: *std.Io.Writer, // TODO: Default stdout.
+        fields: std.EnumSet(std.meta.FieldEnum(T)) = .full,
+    },
+) !void {
+    const writer = opts.out;
+    const max_column_widths = determine_col_widths(T, items);
+
+    try header(T, opts.fields, &max_column_widths, opts.out);
+
+    // Print body
+    for (items) |item| {
+        _ = try writer.write(sep);
+
+        // TODO: Not the most efficient
+        const all_fields = @typeInfo(T).@"struct".fields;
+        inline for (all_fields) |field| {
+            var itr = opts.fields.iterator();
+            var i: usize = 0;
+            while (itr.next()) |c| : (i += 1) {
+                if (std.mem.eql(u8, @tagName(c), field.name)) {
+                    _ = try writer.write(" ");
+                    try write_aligned(writer, @field(item, field.name), max_column_widths[i], .left);
+                    try writer.print(" {s}", .{sep});
+
+                    break;
+                }
+            }
+        }
+
+        _ = try writer.write("\n");
+    }
+
+    // Print post-body
+    {
+        _ = try writer.write(bl);
+
+        var itr = opts.fields.iterator();
+        var i: usize = 0;
+        while (itr.next()) |_| : (i += 1) {
+            if (i > 0) {
+                _ = try writer.write(bm);
+            }
+
+            const padding = max_column_widths[i] + 2;
+            for (0..padding) |_| {
+                _ = try writer.write(hor);
+            }
+        }
+
+        _ = try writer.write(br);
+        _ = try writer.write("\n");
+    }
+}
+
+fn determine_col_widths(
+    T: type,
+    items: []T,
+) [@typeInfo(T).@"struct".fields.len]usize {
+    const all_fields = @typeInfo(T).@"struct".fields;
+
+    var max_column_widths: [all_fields.len]usize = @splat(0);
+    for (items) |item| {
+        inline for (all_fields, 0..) |field, i| {
+            // TODO: Get str len of item
+            const value_len = @field(item, field.name).len;
+            max_column_widths[i] = @max(
+                max_column_widths[i],
+                field.name.len,
+                value_len,
+            );
+        }
+    }
+
+    return max_column_widths;
+}
+
+// Print the header of a table
+fn header(
+    T: type,
+    fields: std.EnumSet(std.meta.FieldEnum(T)),
+    max_column_widths: []const usize,
+    writer: *std.Io.Writer,
+) !void {
+
+    // Print Pre-Header
+    {
+        _ = try writer.write(tl);
+
+        var itr = fields.iterator();
+        var i: usize = 0;
+        while (itr.next()) |_| : (i += 1) {
+            if (i > 0) {
+                _ = try writer.write(tm);
+            }
+            const padding = max_column_widths[i] + 2;
+            for (0..padding) |_| {
+                _ = try writer.write(hor);
+            }
+        }
+
+        _ = try writer.write(tr ++ "\n");
+    }
+
+    // Main Header
+    {
+        _ = try writer.write(sep);
+
+        var itr = fields.iterator();
+        var i: usize = 0;
+        while (itr.next()) |field| : (i += 1) {
+            _ = try writer.write(" ");
+            try write_aligned(
+                writer,
+                @tagName(field),
+                max_column_widths[i],
+                .center,
+            );
+            try writer.print(" {s}", .{sep});
+        }
+
+        try writer.print("\n", .{});
+    }
+
+    // Print post-header
+    {
+        _ = try writer.write(ml);
+
+        var itr = fields.iterator();
+        var i: usize = 0;
+        while (itr.next()) |_| : (i += 1) {
+            if (i > 0) {
+                _ = try writer.write(mm);
+            }
+            const padding = max_column_widths[i] + 2;
+            for (0..padding) |_| {
+                _ = try writer.write(hor);
+            }
+        }
+
+        _ = try writer.write(mr ++ "\n");
+    }
+}
+
+fn write_aligned(
+    writer: *std.Io.Writer,
+    data: []const u8,
+    max_width: usize,
+    alignment: Alignment,
+) !void {
+    const padding: [2]usize = switch (alignment) {
+        .left => .{ 0, max_width - data.len },
+        .right => .{ max_width - data.len, 0 },
+        .center => blk: {
+            // Faster to inline the divFloor?
+            const half = @divFloor(max_width - data.len, 2);
+            break :blk .{ half, max_width - data.len - half };
+        },
+    };
+
+    for (0..padding[0]) |_| {
+        _ = try writer.write(" ");
+    }
+
+    _ = try writer.write(data);
+
+    for (0..padding[1]) |_| {
+        _ = try writer.write(" ");
+    }
+}
+
+const Alignment = enum { left, center, right };
+
+test "can print a simple table" {
+    const gpa = std.testing.allocator;
+    const F = struct { foo: []const u8, bar: []const u8 };
+    // const table: Table(F) = .{ .rows = &.{.{ .foo = "bat", .bar = "baz" }} };
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const rows: [1]F = .{.{ .foo = "bat", .bar = "baz" }};
+    try structs(F, @constCast(&rows), .{ .out = &out.writer });
+
+    // try out.writer.print("{f}", .{table});
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬─────┐
+        \\│ foo │ bar │
+        \\├─────┼─────┤
+        \\│ bat │ baz │
+        \\└─────┴─────┘
+        \\
+    , got);
+}
+
+test "can print a table with varying header widths" {
+    const gpa = std.testing.allocator;
+    const F = struct { foo: []const u8, abart: []const u8 };
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const rows: [1]F = .{.{ .foo = "bat", .abart = "baz" }};
+    try structs(F, @constCast(&rows), .{ .out = &out.writer });
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬───────┐
+        \\│ foo │ abart │
+        \\├─────┼───────┤
+        \\│ bat │ baz   │
+        \\└─────┴───────┘
+        \\
+    , got);
+}
+
+test "can print a table with varying column widths" {
+    const gpa = std.testing.allocator;
+    const F = struct { foo: []const u8, bar: []const u8 };
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const rows: [1]F = .{.{ .foo = "bat", .bar = "bazzar" }};
+    try structs(F, @constCast(&rows), .{ .out = &out.writer });
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬────────┐
+        \\│ foo │  bar   │
+        \\├─────┼────────┤
+        \\│ bat │ bazzar │
+        \\└─────┴────────┘
+        \\
+    , got);
+}
+
+test "can print a multi row table with varying column widths" {
+    const gpa = std.testing.allocator;
+    const F = struct { foo: []const u8, bar: []const u8 };
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    const rows: []const F = &.{
+        .{ .foo = "baz", .bar = "quz" },
+        .{ .foo = "bat", .bar = "bazzar" },
+    };
+    try structs(F, @constCast(rows), .{ .out = &out.writer });
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┬────────┐
+        \\│ foo │  bar   │
+        \\├─────┼────────┤
+        \\│ baz │ quz    │
+        \\│ bat │ bazzar │
+        \\└─────┴────────┘
+        \\
+    , got);
+}
+
+test "can print a table with limited columns" {
+    const gpa = std.testing.allocator;
+    const F = struct { foo: []const u8, bar: []const u8 };
+    const rows: [1]F = .{.{ .foo = "bat", .bar = "baz" }};
+
+    var out: std.Io.Writer.Allocating = .init(gpa);
+    defer out.deinit();
+
+    try structs(F, @constCast(&rows), .{ .out = &out.writer, .fields = .initOne(.foo) });
+
+    const got = try out.toOwnedSlice();
+    defer gpa.free(got);
+
+    try std.testing.expectEqualStrings(
+        \\┌─────┐
+        \\│ foo │
+        \\├─────┤
+        \\│ bat │
+        \\└─────┘
+        \\
+    , got);
+}
+
+// TODO: test "returns a table" {}