summaryrefslogtreecommitdiff
path: root/src/mini.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
committerGabriel Schneider <[email protected]>2026-10-30 17:35:06 -0300
commit6d8da8721141284cf33bb901168b26135893eb86 (patch)
tree791d63401d4e85fbca1d597a8ce0326e70efd545 /src/mini.zig
parentefd43a3a2cf03bb741366331158b368abf9ac583 (diff)
parentbf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff)
downloadpardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz
pardes-6d8da8721141284cf33bb901168b26135893eb86.zip
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/mini.zig')
-rw-r--r--src/mini.zig331
1 files changed, 331 insertions, 0 deletions
diff --git a/src/mini.zig b/src/mini.zig
new file mode 100644
index 00000000..9f7d865d
--- /dev/null
+++ b/src/mini.zig
@@ -0,0 +1,331 @@
+//! The Mini minimap: a file drawn four rows to a cell in braille dots.
+const panes = @import("panes.zig");
+const std = @import("std");
+const pardes = @import("pardes.zig");
+const exec = @import("exec.zig");
+const config = @import("config.zig");
+const Pardes = pardes.Pardes;
+const modal = @import("modal.zig");
+const filesystem = @import("fs.zig");
+const syntax = @import("syntax.zig");
+const File = panes.File;
+const Output = panes.Output;
+
+pub const max_input_bytes = 4 * 1024 * 1024;
+pub const max_output_bytes = 4 * 1024 * 1024;
+
+pub const State = struct {
+ source: []u8,
+ colors: []u8,
+
+ pub fn deinit(state: *State, gpa: std.mem.Allocator) void {
+ gpa.free(state.source);
+ gpa.free(state.colors);
+ state.* = undefined;
+ }
+};
+
+pub const Result = struct {
+ content: []u8,
+ colors: []u8,
+
+ pub fn deinit(result: Result, gpa: std.mem.Allocator) void {
+ gpa.free(result.content);
+ gpa.free(result.colors);
+ }
+};
+
+const Row = struct {
+ text: []const u8 = "",
+ base: usize = 0,
+ at: usize = 0,
+ left: usize = 0,
+ ink: bool = false,
+ color: u8 = 0,
+
+ fn dot(row: *Row, styles: []const u8) ?u8 {
+ if (row.left == 0) {
+ if (row.at == row.text.len) return null;
+ const end = modal.nextGrapheme(row.text, row.at);
+ const grapheme = row.text[row.at..end];
+ row.left = File.graphemeDisplayWidth(grapheme);
+ // unreachable below: `generate` refuses a source that is no UTF-8
+ const n = std.unicode.utf8ByteSequenceLength(grapheme[0]) catch unreachable;
+ const cp = std.unicode.utf8Decode(grapheme[0..n]) catch unreachable;
+ row.ink = !modal.isUnicodeWhitespace(cp) or grapheme.len != n;
+ row.color = if (styles.len == 0) 0 else styles[row.base + row.at];
+ row.at = end;
+ }
+ row.left -= 1;
+ return if (row.ink) row.color else null;
+ }
+};
+
+fn render(output: ?Result, source: []const u8, styles: []const u8) !usize {
+ if (source.len == 0) return 0;
+ const end = source.len - @intFromBool(source[source.len - 1] == '\n');
+ var lines = std.mem.splitScalar(u8, source[0..end], '\n');
+ var offset: usize = 0;
+ while (lines.peek() != null) {
+ var rows: [4]Row = @splat(.{});
+ for (&rows) |*row| {
+ const line = lines.next() orelse break;
+ row.text = std.mem.trimEnd(u8, line, "\r");
+ row.base = @intFromPtr(line.ptr) - @intFromPtr(source.ptr);
+ }
+ var spaces: usize = 0;
+ while (true) {
+ var more = false;
+ for (rows) |row| more = more or row.at < row.text.len or row.left > 0;
+ if (!more) break;
+ const bits = [4][2]u3{ .{ 0, 3 }, .{ 1, 4 }, .{ 2, 5 }, .{ 6, 7 } };
+ var mask: u8 = 0;
+ var counts: [5]u8 = @splat(0);
+ for (&rows, 0..) |*row, y| {
+ for (0..2) |x| {
+ if (row.dot(styles)) |color| {
+ mask |= @as(u8, 1) << bits[y][x];
+ counts[color] += 1;
+ }
+ }
+ }
+ if (mask == 0) {
+ spaces += 1;
+ continue;
+ }
+ if (spaces + 3 > max_output_bytes - offset) return error.MiniTooLarge;
+ var color: u8 = 0;
+ var most: u8 = 0;
+ for (counts[1..], 1..) |count, i| {
+ if (count > most) {
+ color = @intCast(i);
+ most = count;
+ }
+ }
+ if (output) |out| {
+ @memset(out.content[offset..][0..spaces], ' ');
+ @memset(out.colors[offset..][0..spaces], 0);
+ // unreachable: U+2800 plus a u8 mask is a braille codepoint, always three bytes
+ _ = std.unicode.utf8Encode(@as(u21, 0x2800) + mask, out.content[offset + spaces ..][0..3]) catch unreachable;
+ @memset(out.colors[offset + spaces ..][0..3], color);
+ }
+ offset += spaces + 3;
+ spaces = 0;
+ }
+ if (offset == max_output_bytes) return error.MiniTooLarge;
+ if (output) |out| {
+ out.content[offset] = '\n';
+ out.colors[offset] = 0;
+ }
+ offset += 1;
+ }
+ return offset;
+}
+
+pub fn generate(gpa: std.mem.Allocator, source: []const u8, styles: []const u8) !Result {
+ if (source.len > max_input_bytes) return error.MiniTooLarge;
+ if (!std.unicode.utf8ValidateSlice(source)) return error.InvalidUtf8;
+ if (styles.len != 0 and styles.len != source.len) return error.InvalidMiniColors;
+ for (styles) |color| if (color > @backingInt(syntax.Syn.comment)) return error.InvalidMiniColors;
+ const len = try render(null, source, styles);
+ const content = try gpa.alloc(u8, len);
+ errdefer gpa.free(content);
+ const colors = try gpa.alloc(u8, len);
+ errdefer gpa.free(colors);
+ const result: Result = .{ .content = content, .colors = colors };
+ const written = try render(result, source, styles);
+ std.debug.assert(written == len);
+ return result;
+}
+
+pub fn open(p: *Pardes, id: usize, argument: []const u8) !void {
+ const caller = p.panes[id] orelse return error.MissingPane;
+ const word = std.mem.trim(u8, argument, " \t\r\n");
+ if (word.len == 0) return error.MissingPath;
+ var path_buf: [4096]u8 = undefined;
+ const target = filesystem.resolve(p, word, Pardes.paneDir(caller), &path_buf) orelse return error.FileNotFound;
+ if (target.dir) return error.NotAFile;
+ const source = try p.gpa.dupe(u8, target.path);
+ errdefer p.gpa.free(source);
+ const input = try filesystem.readLimit(p, source, max_input_bytes);
+ defer p.gpa.free(input);
+ const styles = try syntax.highlightFileRange(p.tree_sitter_gpa, source, input, 0, input.len);
+ defer p.tree_sitter_gpa.free(styles);
+ const result = try generate(p.gpa, input, styles);
+ errdefer result.deinit(p.gpa);
+ for (p.panes, 0..) |slot, i| {
+ const pane = slot orelse continue;
+ const file = if (pane.file) |*f| f else continue;
+ const old = file.mini orelse continue;
+ if (!std.mem.eql(u8, old.source, source)) continue;
+ if (std.mem.eql(u8, file.content, result.content) and std.mem.eql(u8, old.colors, result.colors)) {
+ p.gpa.free(source);
+ result.deinit(p.gpa);
+ } else {
+ File.setContent(p, file, result.content);
+ file.mini = .{ .source = source, .colors = result.colors };
+ file.syntax_dirty = false;
+ Output.resetBody(p, pane);
+ }
+ p.active = i;
+ return;
+ }
+ const free = p.freeSlot() orelse return error.NoPaneSlots;
+ const dir = std.fs.path.dirname(source) orelse "/";
+ const path = try std.fmt.allocPrint(p.gpa, "{s}/Mini {s}", .{ std.mem.trimEnd(u8, dir, "/"), std.fs.path.basename(source) });
+ errdefer p.gpa.free(path);
+ const history = try File.History.create(p.gpa);
+ errdefer p.gpa.destroy(history);
+ const pane = try p.newDocPane(free);
+ pane.file = .{
+ .path = path,
+ .content = result.content,
+ .output = .{ .from = .{ .cmd = .Mini } },
+ .mini = .{ .source = source, .colors = result.colors },
+ .history = history,
+ .syntax_dirty = false,
+ };
+ pane.body.cur_pinned = true;
+ exec.placeNew(p, id, id, free, .doc);
+ p.active = free;
+}
+
+test "Mini maps every braille dot and partial line group" {
+ const gpa = std.testing.allocator;
+ const bits = [4][2]u3{ .{ 0, 3 }, .{ 1, 4 }, .{ 2, 5 }, .{ 6, 7 } };
+ for (0..256) |mask| {
+ var source: [12]u8 = undefined;
+ for (0..4) |row| {
+ for (0..2) |col| source[row * 3 + col] = if (mask & (@as(usize, 1) << bits[row][col]) != 0) 'x' else ' ';
+ source[row * 3 + 2] = '\n';
+ }
+ const result = try generate(gpa, &source, "");
+ defer result.deinit(gpa);
+ var expected: [4]u8 = undefined;
+ const len: usize = if (mask == 0) 0 else try std.unicode.utf8Encode(@as(u21, 0x2800) + @as(u21, @intCast(mask)), &expected);
+ expected[len] = '\n';
+ try std.testing.expectEqualStrings(expected[0 .. len + 1], result.content);
+ try std.testing.expectEqual(result.content.len, result.colors.len);
+ for (result.colors) |color| try std.testing.expectEqual(@as(u8, 0), color);
+ }
+ for ([_]struct { source: []const u8, expected: []const u8 }{
+ .{ .source = "", .expected = "" },
+ .{ .source = "x", .expected = "⠁\n" },
+ .{ .source = "xx\n", .expected = "⠉\n" },
+ .{ .source = "x \n", .expected = "⠁\n" },
+ .{ .source = "\n\n\n\nx", .expected = "\n⠁\n" },
+ .{ .source = "x\r\nx\r\n", .expected = "⠃\n" },
+ }) |case| {
+ const result = try generate(gpa, case.source, "");
+ defer result.deinit(gpa);
+ try std.testing.expectEqualStrings(case.expected, result.content);
+ }
+}
+
+test "Mini uses display cells for tabs combining text and wide characters" {
+ const gpa = std.testing.allocator;
+ for ([_]struct { source: []const u8, expected: []const u8 }{
+ .{ .source = "e\u{301}界\n", .expected = "⠉⠁\n" },
+ .{ .source = " x\n", .expected = " ⠁\n" },
+ .{ .source = "\u{a0}x\n", .expected = "⠈\n" },
+ }) |case| {
+ const result = try generate(gpa, case.source, "");
+ defer result.deinit(gpa);
+ try std.testing.expectEqualStrings(case.expected, result.content);
+ }
+ const tabs = try generate(gpa, "\tx\n", "");
+ defer tabs.deinit(gpa);
+ const spaces = config.tab_now / 2;
+ for (tabs.content[0..spaces]) |byte| try std.testing.expectEqual(@as(u8, ' '), byte);
+ try std.testing.expectEqualStrings(if (config.tab_now % 2 == 0) "⠁\n" else "⠈\n", tabs.content[spaces..]);
+}
+
+test "Mini chooses highlighted dots over plain ink with stable color ties" {
+ const gpa = std.testing.allocator;
+ const source = "xx\nxx\nxx\nxx\n";
+ var styles: [source.len]u8 = @splat(0);
+ styles[0] = @backingInt(syntax.Syn.keyword);
+ const rare = try generate(gpa, source, &styles);
+ defer rare.deinit(gpa);
+ try std.testing.expectEqualStrings("⣿\n", rare.content);
+ try std.testing.expectEqualSlices(u8, &.{ 1, 1, 1, 0 }, rare.colors);
+ styles[0] = @backingInt(syntax.Syn.string);
+ styles[1] = @backingInt(syntax.Syn.number);
+ const tied = try generate(gpa, source, &styles);
+ defer tied.deinit(gpa);
+ try std.testing.expectEqualSlices(u8, &.{ 2, 2, 2, 0 }, tied.colors);
+ styles[3] = @backingInt(syntax.Syn.number);
+ const majority = try generate(gpa, source, &styles);
+ defer majority.deinit(gpa);
+ try std.testing.expectEqualSlices(u8, &.{ 3, 3, 3, 0 }, majority.colors);
+}
+
+test "Mini generation bounds and allocation failures leave no partial result" {
+ const Case = struct {
+ fn run(gpa: std.mem.Allocator) !void {
+ const result = try generate(gpa, "alpha\nbeta\ngamma\ndelta\nepsilon\n", "");
+ defer result.deinit(gpa);
+ }
+ };
+ try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{});
+ try std.testing.expectError(error.InvalidMiniColors, generate(std.testing.allocator, "x", &.{5}));
+ try std.testing.expectError(error.InvalidMiniColors, generate(std.testing.allocator, "xx", &.{0}));
+ var allocator = std.testing.FailingAllocator.init(std.testing.allocator, .{ .fail_index = 0 });
+ const source = try std.testing.allocator.alloc(u8, max_input_bytes + 1);
+ defer std.testing.allocator.free(source);
+ try std.testing.expectError(error.MiniTooLarge, generate(allocator.allocator(), source, ""));
+ for (source[0..max_input_bytes], 0..) |*byte, i| byte.* = if (i % 2 == 0) 'x' else ' ';
+ try std.testing.expectError(error.MiniTooLarge, generate(allocator.allocator(), source[0..max_input_bytes], ""));
+ try std.testing.expect(!allocator.has_induced_failure);
+}
+
+test "Mini publishes only complete snapshots and content replacement drops metadata" {
+ const Case = struct {
+ fn run(gpa: std.mem.Allocator, path: []const u8) !void {
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ const source = try p.setTestFile("untouched\n");
+ const free = p.freeSlot();
+ open(p, 0, path) catch |err| {
+ try std.testing.expectEqual(@as(usize, 0), p.active);
+ try std.testing.expectEqual(free, p.freeSlot());
+ try std.testing.expectEqual(source, p.panes[0].?);
+ try std.testing.expectEqualStrings("untouched\n", source.file.?.content);
+ return err;
+ };
+ const file = &p.panes[p.active].?.file.?;
+ try std.testing.expectEqualStrings("⠉\n", file.content);
+ try std.testing.expectEqualStrings(path, file.mini.?.source);
+ const replacement = try gpa.dupe(u8, "plain\n");
+ File.setContent(p, file, replacement);
+ try std.testing.expect(file.mini == null);
+ try std.testing.expectEqualStrings("plain\n", file.content);
+ }
+ };
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "mini.txt", .data = "xx\n" });
+ var dir_buf: [4096]u8 = undefined;
+ const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+ var path_buf: [4096]u8 = undefined;
+ const path = try std.fmt.bufPrint(&path_buf, "{s}/mini.txt", .{dir});
+ // Growth that never resizes in place: whether a resize fits where it is
+ // depends on the heap's layout, and with it how many allocations a run
+ // makes, which checkAllAllocationFailures needs to be the same each run.
+ const NoResize = struct {
+ fn resize(_: *anyopaque, _: []u8, _: std.mem.Alignment, _: usize, _: usize) bool {
+ return false;
+ }
+ fn remap(_: *anyopaque, _: []u8, _: std.mem.Alignment, _: usize, _: usize) ?[*]u8 {
+ return null;
+ }
+ };
+ const testing_vtable = std.testing.allocator.vtable;
+ const no_resize_vtable: std.mem.Allocator.VTable = .{ .alloc = testing_vtable.alloc, .resize = NoResize.resize, .remap = NoResize.remap, .free = testing_vtable.free };
+ const backing: std.mem.Allocator = .{ .ptr = std.testing.allocator.ptr, .vtable = &no_resize_vtable };
+ try std.testing.checkAllAllocationFailures(backing, Case.run, .{path});
+}
+
+test "Mini refuses a file that is no UTF-8, before its decoding could panic" {
+ try std.testing.expectError(error.InvalidUtf8, generate(std.testing.allocator, "ok \xff\xfe bad\n\xc3", ""));
+}