usecomputer 0.1.2 → 0.1.3

package/zig/src/table.zig

@@ -0,0 +1,170 @@
+/// Aligned table renderer for CLI output.
+/// Renders rows of string columns with padding to align them visually.
+const std = @import("std");
+
+pub const Alignment = enum { left, right };
+
+pub const Column = struct {
+    header: []const u8,
+    alignment: Alignment = .left,
+};
+
+/// Render rows into aligned, space-separated lines.
+/// Each row is a slice of cell strings matching the columns in order.
+/// Returns a slice of lines allocated with the given allocator.
+pub fn render(
+    allocator: std.mem.Allocator,
+    columns: []const Column,
+    rows: []const []const []const u8,
+) ![]const []const u8 {
+    if (columns.len == 0 or rows.len == 0) return &.{};
+
+    // Compute max width per column (header vs data)
+    const widths = try allocator.alloc(usize, columns.len);
+    defer allocator.free(widths);
+
+    for (columns, 0..) |col, i| {
+        widths[i] = col.header.len;
+    }
+    for (rows) |row| {
+        for (row, 0..) |cell, i| {
+            if (i < widths.len and cell.len > widths[i]) {
+                widths[i] = cell.len;
+            }
+        }
+    }
+
+    var lines = std.ArrayListUnmanaged([]const u8).empty;
+    errdefer {
+        for (lines.items) |line| allocator.free(line);
+        lines.deinit(allocator);
+    }
+
+    // Header line
+    const header_line = try formatRow(allocator, columns, &.{}, widths, true);
+    try lines.append(allocator, header_line);
+
+    // Data lines
+    for (rows) |row| {
+        const line = try formatRow(allocator, columns, row, widths, false);
+        try lines.append(allocator, line);
+    }
+
+    return lines.toOwnedSlice(allocator);
+}
+
+fn formatRow(
+    allocator: std.mem.Allocator,
+    columns: []const Column,
+    cells: []const []const u8,
+    widths: []const usize,
+    is_header: bool,
+) ![]const u8 {
+    var buf = std.ArrayListUnmanaged(u8).empty;
+    errdefer buf.deinit(allocator);
+
+    for (columns, 0..) |col, i| {
+        if (i > 0) try buf.appendSlice(allocator, "  ");
+
+        const text = if (is_header) col.header else if (i < cells.len) cells[i] else "";
+        const w = widths[i];
+        const pad = if (w > text.len) w - text.len else 0;
+
+        if (col.alignment == .right and !is_header) {
+            try buf.appendNTimes(allocator, ' ', pad);
+            try buf.appendSlice(allocator, text);
+        } else {
+            try buf.appendSlice(allocator, text);
+            // Don't pad the last column
+            if (i < columns.len - 1) {
+                try buf.appendNTimes(allocator, ' ', pad);
+            }
+        }
+    }
+
+    return buf.toOwnedSlice(allocator);
+}
+
+// ─── Tests ───
+
+test "renders aligned columns with headers" {
+    const allocator = std.testing.allocator;
+    const columns = &[_]Column{
+        .{ .header = "desktop" },
+        .{ .header = "primary" },
+        .{ .header = "size", .alignment = .right },
+        .{ .header = "name" },
+    };
+    const rows = &[_][]const []const u8{
+        &.{ "#0", "yes", "1720x1440", "Display 1" },
+        &.{ "#1", "no", "800x600", "External" },
+    };
+
+    const lines = try render(allocator, columns, rows);
+    defer {
+        for (lines) |line| allocator.free(line);
+        allocator.free(lines);
+    }
+
+    try std.testing.expectEqual(3, lines.len);
+    try std.testing.expectEqualStrings("desktop  primary  size       name", lines[0]);
+    try std.testing.expectEqualStrings("#0       yes      1720x1440  Display 1", lines[1]);
+    try std.testing.expectEqualStrings("#1       no         800x600  External", lines[2]);
+}
+
+test "renders right-aligned numeric columns" {
+    const allocator = std.testing.allocator;
+    const columns = &[_]Column{
+        .{ .header = "id", .alignment = .right },
+        .{ .header = "app" },
+        .{ .header = "size", .alignment = .right },
+        .{ .header = "title" },
+    };
+    const rows = &[_][]const []const u8{
+        &.{ "42", "Zed", "1720x1440", "main.zig" },
+        &.{ "1337", "Safari", "800x600", "Google" },
+    };
+
+    const lines = try render(allocator, columns, rows);
+    defer {
+        for (lines) |line| allocator.free(line);
+        allocator.free(lines);
+    }
+
+    try std.testing.expectEqual(3, lines.len);
+    try std.testing.expectEqualStrings("id    app     size       title", lines[0]);
+    try std.testing.expectEqualStrings("  42  Zed     1720x1440  main.zig", lines[1]);
+    try std.testing.expectEqualStrings("1337  Safari    800x600  Google", lines[2]);
+}
+
+test "empty rows returns empty" {
+    const allocator = std.testing.allocator;
+    const columns = &[_]Column{
+        .{ .header = "a" },
+    };
+    const empty: []const []const []const u8 = &.{};
+    const lines = try render(allocator, columns, empty);
+    try std.testing.expectEqual(0, lines.len);
+}
+
+test "single column no trailing spaces" {
+    const allocator = std.testing.allocator;
+    const columns = &[_]Column{
+        .{ .header = "name" },
+    };
+    const rows = &[_][]const []const u8{
+        &.{"hello"},
+        &.{"hi"},
+    };
+
+    const lines = try render(allocator, columns, rows);
+    defer {
+        for (lines) |line| allocator.free(line);
+        allocator.free(lines);
+    }
+
+    try std.testing.expectEqual(3, lines.len);
+    try std.testing.expectEqualStrings("name", lines[0]);
+    try std.testing.expectEqualStrings("hello", lines[1]);
+    try std.testing.expectEqualStrings("hi", lines[2]);
+}

package/bin.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { runCli } from './dist/cli.js'
-
-runCli()

package/src/cli-parsing.test.ts

@@ -1,61 +0,0 @@
-// Parser tests for goke CLI options and flags.
-
-import { describe, expect, test } from 'vitest'
-import { createCli } from './cli.js'
-
-describe('usecomputer cli parsing', () => {
-  test('parses click options with typed defaults', () => {
-    const cli = createCli()
-    const parsed = cli.parse(['node', 'usecomputer', 'click', '100,200', '--count', '2'], { run: false })
-    expect(parsed.args[0]).toBe('100,200')
-    expect(parsed.options.count).toBe(2)
-    expect(parsed.options.button).toBe('left')
-  })
-
-  test('parses screenshot options', () => {
-    const cli = createCli()
-    const parsed = cli.parse(['node', 'usecomputer', 'screenshot', './shot.png', '--display', '2', '--region', '0,0,120,80'], {
-      run: false,
-    })
-    expect(parsed.args[0]).toBe('./shot.png')
-    expect(parsed.options.display).toBe(2)
-    expect(parsed.options.region).toBe('0,0,120,80')
-  })
-
-  test('parses coord-map option for click and mouse move', () => {
-    const clickCli = createCli()
-    const clickParsed = clickCli.parse(['node', 'usecomputer', 'click', '-x', '100', '-y', '200', '--coord-map', '0,0,1600,900,1568,882'], {
-      run: false,
-    })
-
-    const moveCli = createCli()
-    const moveParsed = moveCli.parse(['node', 'usecomputer', 'mouse', 'move', '-x', '100', '-y', '200', '--coord-map', '0,0,1600,900,1568,882'], {
-      run: false,
-    })
-
-    expect(clickParsed.options.coordMap).toBe('0,0,1600,900,1568,882')
-    expect(moveParsed.options.coordMap).toBe('0,0,1600,900,1568,882')
-  })
-
-  test('parses debug-point options', () => {
-    const cli = createCli()
-    const parsed = cli.parse([
-      'node',
-      'usecomputer',
-      'debug-point',
-      '-x',
-      '210',
-      '-y',
-      '560',
-      '--coord-map',
-      '0,0,1720,1440,1568,1313',
-      '--output',
-      './tmp/debug-point.png',
-    ], { run: false })
-
-    expect(parsed.options.coordMap).toBe('0,0,1720,1440,1568,1313')
-    expect(parsed.options.output).toBe('./tmp/debug-point.png')
-    expect(parsed.options.x).toBe(210)
-    expect(parsed.options.y).toBe(560)
-  })
-})