//! Tree component: a collapsible, navigable tree of nodes with per-node //! styling, enumeration/indentation, a cursor column, and an optional help //! footer. Ported from charm's `bubbles/tree` (v2.2.x). //! //! Build a tree with the builder API, then hand it to a model: //! //! const root = try Tree.Node.new(gpa, "prj"); //! try root.child(gpa, "ayman"); //! const bash = try Tree.Node.new(gpa, "bash"); //! const tools = try Tree.Node.new(gpa, "tools"); //! try tools.child(gpa, "zsh"); //! try bash.childNode(gpa, tools); //! try root.childNode(gpa, bash); //! //! var tree: Tree = .{}; //! defer tree.deinit(); //! tree.gpa = gpa; //! tree.setRoot(root); //! tree.setSize(70, 13); //! //! A node created with [`Node.new`] renders its open/closed indicator; a //! leaf created via [`Node.child`] renders without one (mirrors bubbles' //! `Root` vs plain-string children). //! //! Skipped from bubbles for v1: light/dark style variants (`DefaultLightStyles` //! and a `DefaultStyles(isDark)`), per-node `StyleFunc` conditionals exposed //! directly on `Node` (styles are set globally on the model), the //! `EnumeratorStyleFunc`/`IndenterStyleFunc` per-node variants, and the //! full-help multi-column footer (the short footer is shown in both modes). //! Navigation, open/close, scroll-off, the cursor column, and rendering match //! bubbles' default dark tree. const std = @import("std"); const tea = @import("blacktea"); const matte = @import("matte"); const key = @import("key.zig"); const util = @import("util.zig"); const Help = @import("Help.zig"); const Viewport = @import("Viewport.zig"); const Allocator = std.mem.Allocator; const Writer = std.Io.Writer; const ArrayList = std.ArrayList; const Tree = @This(); /// Generates the branch character for a child at `index` among `count` /// siblings (e.g. "├──" / "└──"). const Enumerator = *const fn (count: usize, index: usize) []const u8; /// Generates the indentation connecting a child at `index` among `count` /// siblings to its descendants (e.g. "│ " / " "). const Indenter = *const fn (count: usize, index: usize) []const u8; pub fn defaultEnumerator(count: usize, index: usize) []const u8 { return if (count - 1 == index) "└──" else "├──"; } pub fn roundedEnumerator(count: usize, index: usize) []const u8 { return if (count - 1 == index) "╰──" else "├──"; } pub fn defaultIndenter(count: usize, index: usize) []const u8 { return if (count - 1 == index) " " else "│ "; } const Styles = struct { const style = matte.style; tree_style: matte.Style = .none, help_style: matte.Style = style.pad(.top, 1), selected_node_style: matte.Style = .none, node_style: matte.Style = .none, root_node_style: matte.Style = .none, parent_node_style: matte.Style = .none, cursor_style: matte.Style = .none, enumerator_style: matte.Style = .none, selected_enumerator_style: matte.Style = .none, indenter_style: matte.Style = .none, open_indicator_style: matte.Style = .none, pub const dark: Styles = .{ .node_style = style.fg(.rgb(0xB0, 0xB0, 0xB0)), .selected_node_style = style.fg(.ansi256(212)).bold(true), .root_node_style = style.fg(.rgb(0xEE, 0x6F, 0xF8)), .parent_node_style = style.fg(.ansi256(99)), .cursor_style = style.fg(.ansi256(212)).bold(true).pad(.right, 1), .enumerator_style = style.fg(.rgb(0x3C, 0x3C, 0x3C)), .selected_enumerator_style = style.fg(.rgb(0x3C, 0x3C, 0x3C)), .indenter_style = style.fg(.rgb(0x3C, 0x3C, 0x3C)), .open_indicator_style = style.fg(.rgb(0x5C, 0x5C, 0x5C)), }; }; pub const Node = struct { value: []const u8, /// True for container nodes (created via [`Node.new`]); such nodes render /// the open/closed indicator. Leaf nodes (created via [`Node.child`]) do /// not. is_branch: bool, hidden: bool = false, open: bool = false, /// Y offset in nodes within the flattened tree. Computed by the model. y_offset: i32 = 0, /// Y offset in rendered lines. Differs from `y_offset` for multi-line /// nodes. Computed by the model. line_offset: i32 = 0, children: ArrayList(*Node) = .empty, allocator: Allocator = undefined, /// Creates a branch node. The returned node is owned by the model once /// passed to `setRoot` and freed via `Tree.deinit`. pub fn new(allocator: Allocator, value: []const u8) Allocator.Error!*Node { const node = try allocator.create(Node); node.* = .{ .value = value, .is_branch = true, .open = true, .allocator = allocator, }; return node; } pub fn deinit(self: *Node) void { for (self.children.items) |c| c.deinit(); self.children.deinit(self.allocator); self.allocator.destroy(self); } /// Appends an existing node (subtree) as a child. pub fn childNode(self: *Node, allocator: Allocator, sub: *Node) Allocator.Error!void { try self.children.append(allocator, sub); } /// Appends a leaf node with the given text value (borrowed). pub fn child(self: *Node, allocator: Allocator, text: []const u8) Allocator.Error!void { const leaf = try allocator.create(Node); leaf.* = .{ .value = text, .is_branch = false, .open = false, .allocator = allocator, }; try self.children.append(allocator, leaf); } pub fn setOpen(self: *Node, open: bool) void { self.open = open; } pub fn setHidden(self: *Node, hidden: bool) void { self.hidden = hidden; } pub fn isOpen(self: *const Node) bool { return self.open; } pub fn isSelected(self: *const Node, tree_y_offset: i32) bool { return self.y_offset == tree_y_offset; } /// Number of nodes in this subtree (self included). Closed nodes count 1. pub fn size(self: *const Node) usize { if (!self.open) return 1; var n: usize = 1; for (self.children.items) |c| { if (c.hidden) continue; n += c.size(); } return n; } }; const KeyMap = struct { down: key.Binding = .{ .keys = &.{ .down, .j, .ctrl(.n) }, .help = .{ .key = "↓/j", .desc = "down" }, }, up: key.Binding = .{ .keys = &.{ .up, .k, .ctrl(.p) }, .help = .{ .key = "↑/k", .desc = "up" }, }, page_down: key.Binding = .{ .keys = &.{ .page_down, .space, .f }, .help = .{ .key = "f/pgdn", .desc = "page down" }, }, page_up: key.Binding = .{ .keys = &.{ .page_up, .b }, .help = .{ .key = "b/pgup", .desc = "page up" }, }, half_page_down: key.Binding = .{ .keys = &.{ .d, .ctrl(.d) }, .help = .{ .key = "d", .desc = "½ page down" }, }, half_page_up: key.Binding = .{ .keys = &.{ .u, .ctrl(.u) }, .help = .{ .key = "u", .desc = "½ page up" }, }, goto_top: key.Binding = .{ .keys = &.{ .g, .home }, .help = .{ .key = "g", .desc = "top" }, }, goto_bottom: key.Binding = .{ .keys = &.{ .G, .end }, .help = .{ .key = "G", .desc = "bottom" }, }, toggle: key.Binding = .{ .keys = &.{.enter}, .help = .{ .key = "⏎", .desc = "toggle" }, }, open: key.Binding = .{ .keys = &.{ .l, .right }, .help = .{ .key = "→/l", .desc = "open" }, }, close: key.Binding = .{ .keys = &.{ .h, .left }, .help = .{ .key = "←/h", .desc = "close" }, }, show_full_help: key.Binding = .{ .keys = &.{.rune('?')}, .help = .{ .key = "?", .desc = "more" }, }, close_full_help: key.Binding = .{ .keys = &.{.rune('?')}, .help = .{ .key = "?", .desc = "close help" }, }, }; /// Allocator used for rendering. The matcha program sets `model.gpa` before /// `update`/`view`; set it manually when driving the tree directly (tests). gpa: Allocator = undefined, key_map: KeyMap = .{}, help: Help = .{}, show_help: bool = true, scroll_off: i32 = 5, open_character: []const u8 = "▼", closed_character: []const u8 = "▶", cursor_character: []const u8 = "→", styles: Styles = .dark, enumerator: Enumerator = defaultEnumerator, indenter: Indenter = defaultIndenter, root: ?*Node = null, viewport: Viewport = .{}, width: u16 = 0, height: u16 = 0, /// Selected node offset (in nodes). y_offset: i32 = 0, model: tea.Model = .{ .vtable = &.{ .init = vtableInit, .update = vtableUpdate, .view = vtableView, } }, fn vtableInit(_: *tea.Model) ?tea.Cmd { return null; } fn vtableUpdate(m: *tea.Model, msg: tea.Msg) ?tea.Cmd { const self: *Tree = @fieldParentPtr("model", m); self.gpa = m.gpa; return self.update(msg); } fn vtableView(m: *tea.Model, w: *Writer) Writer.Error!tea.View { const self: *Tree = @fieldParentPtr("model", m); self.gpa = m.gpa; try self.view(w); return .{}; } /// Frees the entire owned tree (the nodes allocated by `setRoot`) and the /// viewport's content buffer. pub fn deinit(self: *Tree) void { if (self.root) |r| r.deinit(); self.root = null; self.viewport.deinit(self.gpa); } /// Takes ownership of `root` and re-renders. pub fn setRoot(self: *Tree, root: *Node) void { self.root = root; self.setYOffsets(); self.renderFull(); } pub fn nodeAtOffset(self: *const Tree, y_offset: i32) ?*Node { const r = self.root orelse return null; return findNode(r, y_offset); } pub fn nodeAtCurrentOffset(self: *const Tree) ?*Node { return self.nodeAtOffset(self.y_offset); } pub fn viewportYOffset(self: *const Tree) u16 { return self.viewport.yOffset(); } pub fn setSize(self: *Tree, w: u16, h: u16) void { self.width = w; self.height = h; self.viewport.setWidth(w); if (self.show_help) { const hv = self.helpHeight(); self.viewport.setHeight(h -| hv); } else { self.viewport.setHeight(h); } self.help.width = w; if (self.root != null) self.renderFull(); } pub fn setWidth(self: *Tree, w: u16) void { self.setSize(w, self.height); } pub fn setHeight(self: *Tree, h: u16) void { self.setSize(self.width, h); } pub fn setStyles(self: *Tree, s: Styles) void { self.styles = s; self.setYOffsets(); if (self.root != null) self.renderFull(); } pub fn setOpenCharacter(self: *Tree, c: []const u8) void { self.open_character = c; if (self.root != null) self.renderFull(); } pub fn setClosedCharacter(self: *Tree, c: []const u8) void { self.closed_character = c; if (self.root != null) self.renderFull(); } pub fn setCursorCharacter(self: *Tree, c: []const u8) void { self.cursor_character = c; if (self.root != null) self.renderFull(); } pub fn setScrollOff(self: *Tree, val: i32) void { self.scroll_off = val; } pub fn setShowHelp(self: *Tree, on: bool) void { self.show_help = on; self.setSize(self.width, self.height); } pub fn setEnumerator(self: *Tree, e: Enumerator) void { self.enumerator = e; if (self.root != null) self.renderFull(); } pub fn setIndenter(self: *Tree, i: Indenter) void { self.indenter = i; if (self.root != null) self.renderFull(); } pub fn down(self: *Tree) void { self.updateViewport(1); } pub fn up(self: *Tree) void { self.updateViewport(-1); } pub fn pageDown(self: *Tree) void { self.updateViewport(@intCast(@min(self.viewport.height, std.math.maxInt(i32)))); } pub fn pageUp(self: *Tree) void { self.updateViewport(-@as(i32, @intCast(@min(self.viewport.height, std.math.maxInt(i32))))); } pub fn halfPageDown(self: *Tree) void { self.updateViewport(@intCast(@min(self.viewport.height / 2, std.math.maxInt(i32)))); } pub fn halfPageUp(self: *Tree) void { self.updateViewport(-@as(i32, @intCast(@min(self.viewport.height / 2, std.math.maxInt(i32))))); } pub fn gotoTop(self: *Tree) void { self.updateViewport(-self.y_offset); } pub fn gotoBottom(self: *Tree) void { const r = self.root orelse return; self.updateViewport(@intCast(@min(r.size(), std.math.maxInt(i32)))); } pub fn toggleCurrentNode(self: *Tree) void { const r = self.root orelse return; const n = findNode(r, self.y_offset) orelse return; self.toggleNode(n, !n.isOpen()); } pub fn openCurrentNode(self: *Tree) void { const r = self.root orelse return; const n = findNode(r, self.y_offset) orelse return; self.toggleNode(n, true); } pub fn closeCurrentNode(self: *Tree) void { const r = self.root orelse return; const n = findNode(r, self.y_offset) orelse return; self.toggleNode(n, false); } fn toggleNode(self: *Tree, node: *Node, open: bool) void { node.setOpen(open); self.setYOffsets(); self.updateViewport(0); } /// Moves selection by `movement` nodes and re-renders, honoring `scroll_off`. fn updateViewport(self: *Tree, movement: i32) void { const r = self.root orelse return; const root_size: i32 = @intCast(@max(r.size(), 1)); self.y_offset = @max(@min(root_size - 1, self.y_offset + movement), 0); self.renderFull(); if (self.y_offset == 0 and movement == 0) return; const selected = findNode(r, self.y_offset) orelse return; const line_offset = selected.line_offset; const height: i32 = @intCast(self.viewport.height); const total: i32 = @intCast(self.viewport.lineCount()); const scrolloff = @min(self.scroll_off, @divTrunc(height, 2)); const min_top = @max(line_offset - scrolloff, 0); const min_bottom = @min(total - 1, line_offset + scrolloff); if (@as(i32, @intCast(self.viewport.yOffset())) > min_top) { self.viewport.setYOffset(@intCast(min_top)); } else if (@as(i32, @intCast(self.viewport.yOffset())) + height < min_bottom + 1) { self.viewport.setYOffset(@intCast(@max(min_bottom - height + 1, 0))); } } pub fn update(self: *Tree, msg: tea.Msg) ?tea.Cmd { switch (msg) { .key_press => |k| { if (self.key_map.down.matches(k)) self.down() else if (self.key_map.up.matches(k)) self.up() else if (self.key_map.page_down.matches(k)) self.pageDown() else if (self.key_map.page_up.matches(k)) self.pageUp() else if (self.key_map.half_page_down.matches(k)) self.halfPageDown() else if (self.key_map.half_page_up.matches(k)) self.halfPageUp() else if (self.key_map.goto_top.matches(k)) self.gotoTop() else if (self.key_map.goto_bottom.matches(k)) self.gotoBottom() else if (self.key_map.toggle.matches(k)) self.toggleCurrentNode() else if (self.key_map.open.matches(k)) self.openCurrentNode() else if (self.key_map.close.matches(k)) self.closeCurrentNode() else if (self.key_map.show_full_help.matches(k) or self.key_map.close_full_help.matches(k)) { self.help.show_all = !self.help.show_all; self.renderFull(); } }, else => {}, } return null; } fn cursorWidth(self: *const Tree) u16 { if (self.cursor_character.len == 0) return 0; return matte.measure.cellWidth(self.cursor_character) + self.styles.cursor_style.internal.padding.spacing.right; } fn treeWidth(self: *const Tree) u16 { return self.width -| self.cursorWidth(); } fn nodeStyle(self: *const Tree, node: *const Node) matte.Style { if (node.isSelected(self.y_offset)) return self.styles.selected_node_style; if (node.y_offset == 0) return self.styles.root_node_style; if (node.children.items.len > 0) return self.styles.parent_node_style; return self.styles.node_style; } fn helpHeight(self: *const Tree) u16 { var buf: [512]u8 = undefined; var w: Writer = .fixed(&buf); self.writeShortHelp(&w) catch {}; const text_h = matte.measure.lineCount(w.buffered()); return text_h +| self.styles.help_style.internal.padding.spacing.top; } fn setYOffsets(self: *Tree) void { const r = self.root orelse return; r.y_offset = 0; r.line_offset = 0; self.setYOffsetsRec(r); } fn setYOffsetsRec(self: *Tree, node: *const Node) void { if (!node.open) return; var above: i32 = 0; var lines_above: i32 = 0; for (node.children.items) |child| { child.y_offset = node.y_offset + above + 1; child.line_offset = node.line_offset + lines_above + 1; self.setYOffsetsRec(child); above += @intCast(@max(child.size(), 1)); lines_above += @intCast(@max(self.renderHeight(child), 1)); } } /// Rendered height (lines) of a single node's value. fn nodeHeight(self: *const Tree, node: *const Node) u16 { var buf: [2048]u8 = undefined; var w: Writer = .fixed(&buf); self.nodeStyle(node).render(&w, node.value) catch {}; return matte.measure.lineCount(w.buffered()); } /// Total rendered lines of the open subtree rooted at `node`. fn renderHeight(self: *const Tree, node: *const Node) u16 { var h = self.nodeHeight(node); if (node.open) { for (node.children.items) |c| h += self.renderHeight(c); } return h; } /// Builds the viewport content: the cursor column joined to the tree text. fn renderFull(self: *Tree) void { const r = self.root orelse return; const gpa = self.gpa; const tree_w = self.treeWidth(); var tree = ArrayList(u8).empty; defer tree.deinit(gpa); self.buildTree(&tree, r, tree_w) catch return; var cursor = ArrayList(u8).empty; defer cursor.deinit(gpa); self.buildCursor(&cursor, r) catch return; if (self.cursorWidth() == 0) { self.viewport.setContent(gpa, tree.items) catch return; } else { var joined = ArrayList(u8).empty; defer joined.deinit(gpa); const blocks = [_][]const u8{ cursor.items, tree.items }; const j = matte.join.horizontal(gpa, 0, &blocks) catch return; defer gpa.free(j); joined.appendSlice(gpa, j) catch return; self.viewport.setContent(gpa, joined.items) catch return; } } /// Builds the cursor strip (one line per tree line). Each line is the cursor /// character (for the selected node's line) or a space, styled with the cursor /// style (whose right padding yields the column width). fn buildCursor(self: *Tree, cursor: *ArrayList(u8), _: *const Node) Allocator.Error!void { const gpa = self.gpa; const r = self.root orelse return; const total_h = self.renderHeight(r); const sel_line = (findNode(r, self.y_offset) orelse r).line_offset; var buf: [64]u8 = undefined; var line: u16 = 0; while (line < total_h) : (line += 1) { if (line > 0) try cursor.append(gpa, '\n'); const cell: []const u8 = if (@as(i32, @intCast(line)) == sel_line) self.cursor_character else " "; var w: Writer = .fixed(&buf); self.styles.cursor_style.render(&w, cell) catch {}; try cursor.appendSlice(gpa, w.buffered()); } } /// Renders the whole tree (root row then each child, recursively) into `out`. fn buildTree(self: *Tree, out: *ArrayList(u8), node: *const Node, tree_w: u16) Allocator.Error!void { const gpa = self.gpa; // Root row: indicator + value, padded to the tree width. var row = ArrayList(u8).empty; defer row.deinit(gpa); try self.appendIndicator(&row, node); try appendStyled(&row, gpa, self.nodeStyle(node), node.value); try padToWidth(&row, gpa, tree_w); try appendStyled(out, gpa, self.styles.tree_style, row.items); try out.append(gpa, '\n'); try self.buildChildren(out, node, "", tree_w); } fn buildChildren(self: *Tree, out: *ArrayList(u8), node: *const Node, prefix: []const u8, tree_w: u16) Allocator.Error!void { if (!node.open) return; const children = node.children.items; const n = children.len; // Farthest-visible maximum enumeration prefix width among siblings. var max_len: u16 = 0; for (children, 0..) |_, i| { const seg = self.enumerator(n, i); max_len = @max(max_len, matte.measure.cellWidth(seg)); } for (children, 0..) |child, i| { if (child.hidden) continue; const enum_seg = self.enumerator(n, i); const indent_seg = self.indenter(n, i); var line = ArrayList(u8).empty; defer line.deinit(self.gpa); try line.appendSlice(self.gpa, prefix); // Pad to the sibling max so enumeration lines up (pad goes before the // enumerator, mirroring bubbles). const pad: u16 = max_len -| matte.measure.cellWidth(enum_seg); try padSpaces(&line, self.gpa, pad); try appendStyled(&line, self.gpa, self.styles.enumerator_style, enum_seg); try self.appendIndicator(&line, child); try appendStyled(&line, self.gpa, self.nodeStyle(child), child.value); try padToWidth(&line, self.gpa, tree_w); try out.appendSlice(self.gpa, line.items); try out.append(self.gpa, '\n'); // Recurse into the child with its indent appended to the prefix. var child_prefix = ArrayList(u8).empty; defer child_prefix.deinit(self.gpa); try child_prefix.appendSlice(self.gpa, prefix); try appendStyled(&child_prefix, self.gpa, self.styles.indenter_style, indent_seg); try self.buildChildren(out, child, child_prefix.items, tree_w); } } fn appendIndicator(self: *Tree, out: *ArrayList(u8), node: *const Node) Allocator.Error!void { if (!node.is_branch) return; const ch = if (node.open) self.open_character else self.closed_character; var buf: [64]u8 = undefined; var w: Writer = .fixed(&buf); self.styles.open_indicator_style.render(&w, ch) catch {}; try out.appendSlice(self.gpa, w.buffered()); try out.append(self.gpa, ' '); _ = &buf; } fn appendStyled(out: *ArrayList(u8), gpa: Allocator, s: matte.Style, text: []const u8) Allocator.Error!void { var buf: [4096]u8 = undefined; var w: Writer = .fixed(&buf); s.render(&w, text) catch {}; try out.appendSlice(gpa, w.buffered()); } fn padToWidth(out: *ArrayList(u8), gpa: Allocator, target: u16) Allocator.Error!void { const cur = matte.measure.cellWidth(out.items); if (target > cur) try padSpaces(out, gpa, target - cur); } fn padSpaces(out: *ArrayList(u8), gpa: Allocator, count: u16) Allocator.Error!void { var i: u16 = 0; while (i < count) : (i += 1) try out.append(gpa, ' '); } fn findNode(node: *const Node, target: i32) ?*Node { if (node.y_offset == target) return @constCast(node); if (!node.open) return null; for (node.children.items) |c| { if (findNode(c, target)) |found| return found; } return null; } pub fn view(self: *Tree, w: *Writer) Writer.Error!void { try self.viewport.view(w); if (self.show_help) { try w.writeByte('\n'); var i: u16 = 0; while (i < self.styles.help_style.internal.padding.spacing.top) : (i += 1) try w.writeByte('\n'); if (!self.help.show_all) { try self.writeShortHelp(w); } else { try self.writeFullHelp(w); } } } fn writeShortHelp(self: *const Tree, w: *Writer) Writer.Error!void { const bindings = [_]key.Binding{ self.key_map.down, self.key_map.up, self.key_map.toggle, self.key_map.show_full_help, }; try self.help.shortView(w, &bindings); } fn writeFullHelp(self: *const Tree, w: *Writer) Writer.Error!void { const g1 = [_]key.Binding{ self.key_map.down, self.key_map.up, self.key_map.open, self.key_map.close, self.key_map.toggle, }; const g2 = [_]key.Binding{ self.key_map.page_down, self.key_map.page_up, self.key_map.half_page_down, self.key_map.half_page_up, }; const g3 = [_]key.Binding{ self.key_map.goto_top, self.key_map.goto_bottom }; const groups = [_][]const key.Binding{ &g1, &g2, &g3 }; try self.help.fullView(w, &groups); } const testing = std.testing; fn testRoot(gpa: Allocator) !*Node { const root = try Node.new(gpa, "~/charm"); try root.child(gpa, "ayman"); const bash = try Node.new(gpa, "bash"); const tools = try Node.new(gpa, "tools"); try tools.child(gpa, "zsh"); try tools.child(gpa, "doom-emacs"); try bash.childNode(gpa, tools); try root.childNode(gpa, bash); const carlos = try Node.new(gpa, "carlos"); const emotes = try Node.new(gpa, "emotes"); try emotes.child(gpa, "chefkiss.png"); try emotes.child(gpa, "kekw.png"); try carlos.childNode(gpa, emotes); try root.childNode(gpa, carlos); try root.child(gpa, "maas"); return root; } fn treeText(tree: *Tree, buf: []u8) []const u8 { var w: Writer = .fixed(buf); tree.view(&w) catch {}; return w.buffered(); } test "tree node builds and sizes" { const gpa = testing.allocator; const root = try testRoot(gpa); defer root.deinit(); try testing.expectEqual(@as(usize, 11), root.size()); } test "tree renders matching bubbles default golden" { const gpa = testing.allocator; const root = try testRoot(gpa); var tree: Tree = .{}; defer tree.deinit(); tree.gpa = gpa; tree.setRoot(root); tree.setSize(70, 13); const expected = \\→ ▼ ~/charm \\ ├──ayman \\ ├──▼ bash \\ │ └──▼ tools \\ │ ├──zsh \\ │ └──doom-emacs \\ ├──▼ carlos \\ │ └──▼ emotes \\ │ ├──chefkiss.png \\ │ └──kekw.png \\ └──maas \\ \\↓/j down • ↑/k up • ⏎ toggle • ? more ; var buf: [4096]u8 = undefined; // Strip ANSI and trailing per-line padding to compare structure. var stripped = ArrayList(u8).empty; defer stripped.deinit(gpa); stripAnsi(&stripped, gpa, treeText(&tree, &buf)); const final = stripLineTrailing(gpa, stripped.items); defer gpa.free(final); try testing.expectEqualStrings(expected, final); } test "tree down past collapsed set keeps correct selection order" { const gpa = testing.allocator; const root = try testRoot(gpa); // Select "bash" (index 2) and collapse it via the real toggle path. var tree: Tree = .{}; defer tree.deinit(); tree.gpa = gpa; tree.setRoot(root); tree.setSize(70, 13); tree.y_offset = 2; tree.toggleCurrentNode(); // Collapsed "bash" should no longer expose zsh/doom-emacs, but must still // occupy a single selectable row. Walking down in preorder should then // land on "carlos", then descend into its subtree, then "maas". const expected = [_][]const u8{ "~/charm", "ayman", "bash", "carlos", "emotes", "chefkiss.png", "kekw.png", "maas", }; tree.y_offset = 0; for (expected, 0..) |expect, i| { const node = tree.nodeAtCurrentOffset(); try testing.expect(node != null); const got = if (node) |n| n.value else ""; try testing.expectEqualStrings(expect, got); if (i + 1 < expected.len) tree.down(); } // Bottom of the (collapsed) tree is reachable. tree.gotoBottom(); const b = tree.nodeAtCurrentOffset(); try testing.expectEqualStrings("maas", b.?.value); // Re-expand "bash" and confirm the hidden children come back in order. tree.y_offset = 2; tree.toggleCurrentNode(); tree.gotoBottom(); const last = tree.nodeAtCurrentOffset(); try testing.expectEqualStrings("maas", last.?.value); } fn stripAnsi(out: *ArrayList(u8), gpa: Allocator, s: []const u8) void { var i: usize = 0; while (i < s.len) { if (s[i] == 0x1b) { i += skipEscape(s, i); } else if (s[i] == '\n') { out.append(gpa, '\n') catch {}; i += 1; } else { out.append(gpa, s[i]) catch {}; i += 1; } } } /// Returns a copy of `s` with trailing whitespace removed from every line. /// Caller owns the returned slice. fn stripLineTrailing(gpa: Allocator, s: []const u8) []u8 { var new = ArrayList(u8).empty; defer new.deinit(gpa); var line_start: usize = 0; var i: usize = 0; while (i <= s.len) : (i += 1) { if (i == s.len or s[i] == '\n') { var j = i; while (j > line_start and s[j - 1] == ' ') j -= 1; new.appendSlice(gpa, s[line_start..j]) catch {}; if (i < s.len) new.append(gpa, '\n') catch {}; line_start = i + 1; } } return new.toOwnedSlice(gpa) catch return gpa.dupe(u8, "") catch &[_]u8{}; } fn skipEscape(s: []const u8, index: usize) usize { var j = index + 1; if (j < s.len and s[j] == '[') { j += 1; while (j < s.len and (s[j] < 0x40 or s[j] > 0x7e)) j += 1; return if (j < s.len) j + 1 - index else s.len - index; } return 2; }