diff options
Diffstat (limited to 'src/Tables.zig')
| -rw-r--r-- | src/Tables.zig | 1171 |
1 files changed, 1171 insertions, 0 deletions
diff --git a/src/Tables.zig b/src/Tables.zig new file mode 100644 index 00000000..2e65a716 --- /dev/null +++ b/src/Tables.zig @@ -0,0 +1,1171 @@ +//! A markdown file's pipe tables (GFM), laid out in their own rows. Every +//! byte of a table stays in its row as the text it is: B1, B2, B3 and the +//! chords work on it as on any text, and nothing is drawn over it. What +//! changes is the width some bytes take. A cell narrower than its column +//! is given the cells it lacks as virtual width, a *pad*, before one of its +//! bytes (the `|` that ends it, or for a right-aligned column the first +//! byte after the `|` that starts it), so every row's `|` of a column falls +//! on the same screen column whatever the source spacing. A pad is to the +//! byte it stands before what a tab's extra cells are to the tab: drawn as +//! blanks, every one of them maps back to that byte (a click there puts +//! the caret before it), and the caret before that byte is drawn after the +//! pad, against its glyph. +//! +//! The pads are the only mapping. File.zig's pane-aware column functions +//! (`displayOffset`, `displayEndOffset`, `byteAtRowDisplay`) and the row +//! walks that draw a body (`fillBody`, `recolorSyntax`) add them, so the +//! caret, every selection, a click and a Look map between a cell's x and +//! its byte as they map a tab's. The look itself (`paint`: the `|` as rules, +//! the delimiter row as one, the header bold) restyles cells that are +//! there; it moves nothing. +//! +//! Which lines are tables is found by lines, as tree-sitter-markdown's +//! scanner finds a `pipe_table` (its PIPE_TABLE_START: a header row's cells +//! counted by its pipes, a delimiter row of `:?-+:?` cells, the same count), +//! once per revision of the text, over the whole text: the highlighter +//! parses only the lines around the view, which start mid-table as soon as +//! a long one is scrolled, and fenced code is known only from the top. The +//! grammar is the oracle in a test ("tables are the pipe_tables tree-sitter +//! finds"). +const std = @import("std"); +const panes = @import("panes.zig"); +const pardes = @import("pardes.zig"); +const colors = @import("colors.zig"); +const modal = @import("modal.zig"); +const Surface = @import("surface.zig").Surface; +const Cell = @import("surface.zig").Cell; +const Color = @import("surface.zig").Color; +const Pardes = pardes.Pardes; +const Pane = panes.Pane; +const File = panes.File; + +const Tables = @This(); + +pub const Align = enum(u2) { left, right, center }; + +pub const Table = struct { + /// The header row's line; the delimiter row is the next. + first: u32, + /// One past the last row's line. + end: u32, + /// Where its columns' widths and alignments start in `widths`/`aligns`. + col0: u32, + /// Columns: the most cells any row ends with a `|`. + cols: u16, + /// The widest indentation before a leading `|`, in cells. + lead: u16, + /// The widest row laid out, in cells: a table wider than a wrapping + /// pane is shown as its source (`File.rowPads`). + width: u32, +}; + +/// `cells` of virtual width before the byte at `at` of its line. +pub const Pad = struct { at: u32, cells: u16 }; + +/// Columns past this many are not aligned (their pipes take no pad). +pub const max_cols = 64; +/// A centred column pads both sides of a cell, and a leading `|` its indent. +pub const max_pads = 2 * max_cols + 1; + +/// The text these tables are of: its revision, where it is, how long, and +/// how many lines. +revision: ?u32 = null, +content: usize = 0, +len: usize = 0, +lines: usize = 0, +list: std.ArrayList(Table) = .empty, +widths: std.ArrayList(u16) = .empty, +aligns: std.ArrayList(Align) = .empty, +/// The fenced code blocks, opener and closer lines (an unclosed one closes +/// past the end): no table is in one, and an edit to one of these lines +/// changes what every line after it is, so it finds them all again. +fences: std.ArrayList([2]u32) = .empty, +/// Columns in `widths` that no table points at any more (an edit's tables +/// are added at the end); past a bound, everything is found again. +garbage: usize = 0, +/// How many times the whole text was read (for the numbers and the tests). +scans: u32 = 0, +/// Where a reading of the whole text goes on from, until it reaches the +/// end: it is read a frame's budget at a time from the top (`frame_ns`), as +/// Places finds, so opening a big file never holds a frame; rows past it +/// are shown as their source until it gets there. +pending: ?Resume = null, + +/// A scan's place: the next line's byte and number, the fence it is in, +/// and whether the line before ended a block. +const Resume = struct { at: usize, n: u32, fence: ?Fence, prev_blank: bool }; + +/// What one frame spends reading a big text from the top. +pub const frame_ns: u64 = 4 * std.time.ns_per_ms; + +pub fn deinit(t: *Tables, gpa: std.mem.Allocator) void { + t.list.deinit(gpa); + t.widths.deinit(gpa); + t.aligns.deinit(gpa); + t.fences.deinit(gpa); + t.* = .{}; +} + +/// Whether these tables are of `f`'s text as it is now. +pub fn current(t: *const Tables, f: *const File.State) bool { + return t.revision == f.revision and t.content == @intFromPtr(f.content.ptr) and t.len == f.content.len; +} + +/// The table `line` is a row of, if any. +pub fn find(t: *const Tables, line: usize) ?*const Table { + const items = t.list.items; + var lo: usize = 0; + var hi: usize = items.len; + while (lo < hi) { + const mid = (lo + hi) / 2; + if (items[mid].end <= line) lo = mid + 1 else hi = mid; + } + if (lo < items.len and items[lo].first <= line) return &items[lo]; + return null; +} + +/// Find the tables of `f`'s text again unless they are of it already. Only +/// a markdown file has any; on no memory there are none (the text is shown +/// as it is). After one edit (File.State.splice) the tables it did not +/// touch shift and only the block around it is read again (`reflow`): a +/// keystroke costs its table, not the file. +pub fn ensure(t: *Tables, gpa: std.mem.Allocator, f: *File.State) void { + if (t.current(f)) { + if (t.pending != null) t.go(gpa, f.content, frame_ns); + return; + } + defer { + t.revision = f.revision; + t.content = @intFromPtr(f.content.ptr); + t.len = f.content.len; + } + if (f.output != null or f.mini != null or !isMarkdown(f.path)) { + t.list.clearRetainingCapacity(); + t.pending = null; + return; + } + const starts = File.lineIndex(gpa, f) catch { + t.list.clearRetainingCapacity(); + t.pending = null; + return; + }; + const one_edit = t.revision != null and t.revision.? +% 1 == f.revision and + f.splice.revision == f.revision and f.splice.old_len == t.len; + if (one_edit and t.garbage <= 4 * t.widths.items.len + 1024) { + if (t.pending) |r| { + // An edit past where the reading has got to changes nothing it + // read: it goes on. + if (lineHolding(starts, f.splice.head) >= r.n) { + t.lines = starts.len; + t.go(gpa, f.content, frame_ns); + return; + } + } else if (t.reflow(gpa, f)) |_| return else |_| {} + } + t.begin(starts.len); + t.go(gpa, f.content, frame_ns); +} + +/// Whether a reading of the text is still under way (Pardes.nextWake). +pub fn busy(t: *const Tables) bool { + return t.pending != null; +} + +/// Start reading the whole text again, from the top. +fn begin(t: *Tables, lines: usize) void { + t.list.clearRetainingCapacity(); + t.widths.clearRetainingCapacity(); + t.aligns.clearRetainingCapacity(); + t.fences.clearRetainingCapacity(); + t.garbage = 0; + t.scans +%= 1; + t.lines = lines; + t.pending = .{ .at = 0, .n = 0, .fence = null, .prev_blank = true }; +} + +/// Read on for about `budget_ns` (0: to the end). On no memory there are +/// no tables (the text is shown as it is). +fn go(t: *Tables, gpa: std.mem.Allocator, content: []const u8, budget_ns: u64) void { + var at = t.pending orelse return; + const done = t.scanFrom(gpa, content, &at, std.math.maxInt(u32), true, budget_ns) catch { + t.list.clearRetainingCapacity(); + t.pending = null; + return; + }; + t.pending = if (done) null else at; +} + +/// Line `n` of a text whose line index is `starts`. +fn lineOf(content: []const u8, starts: []const usize, n: usize) Line { + const start = starts[n]; + const end = if (n + 1 < starts.len) starts[n + 1] - 1 else content.len; + const text = content[start..end]; + return .{ .text = if (text.len > 0 and text[text.len - 1] == '\r') text[0 .. text.len - 1] else text, .start = start, .n = @intCast(n) }; +} + +/// The line byte `at` is on. +fn lineHolding(starts: []const usize, at: usize) usize { + var lo: usize = 0; + var hi: usize = starts.len; + while (lo < hi) { + const mid = (lo + hi) / 2; + if (starts[mid] <= at) lo = mid + 1 else hi = mid; + } + return lo -| 1; +} + +/// The tables after one edit: those it did not touch kept (shifted by the +/// lines it added), the block around it read again. error.Whole when the +/// edit could change what a line far from it is (a fence line in it), or +/// the block is unbounded. +fn reflow(t: *Tables, gpa: std.mem.Allocator, f: *File.State) !void { + const content = f.content; + const starts = try File.lineIndex(gpa, f); + const sp = f.splice; + const delta: i64 = @as(i64, @intCast(starts.len)) - @as(i64, @intCast(t.lines)); + // The edited lines: [a, b] now, [a, b_old] before it. + const a = lineHolding(starts, sp.head); + const b = lineHolding(starts, content.len - sp.tail); + const b_old_i = @as(i64, @intCast(b)) - delta; + if (b_old_i < @as(i64, @intCast(a))) return error.Whole; + const b_old: usize = @intCast(b_old_i); + for (a..b + 1) |n| if (fenceOf(lineOf(content, starts, n).text) != null) return error.Whole; + var inside = false; + for (t.fences.items) |fence| { + if ((fence[0] >= a and fence[0] <= b_old) or (fence[1] >= a and fence[1] <= b_old)) return error.Whole; + if (fence[0] < a and fence[1] > b_old) inside = true; + } + const shift = struct { + fn by(n: u32, d: i64) u32 { + return @intCast(@as(i64, n) + d); + } + }.by; + for (t.fences.items) |*fence| { + if (fence[0] > b_old) fence[0] = shift(fence[0], delta); + if (fence[1] > b_old and fence[1] != std.math.maxInt(u32)) fence[1] = shift(fence[1], delta); + } + // The old tables the edit touched or is next to: [lo_i, hi_i). + const items = t.list.items; + var lo_i: usize = 0; + while (lo_i < items.len and items[lo_i].end < a) lo_i += 1; + var hi_i = lo_i; + while (hi_i < items.len and items[hi_i].first <= b_old + 1) hi_i += 1; + for (items[hi_i..]) |*table| { + table.first = shift(table.first, delta); + table.end = shift(table.end, delta); + } + // Inside fenced code, no table changes. + if (inside) { + t.lines = starts.len; + return; + } + // The block: from the blank line before it to the one after, the old + // tables it touched taken in, never into a neighbouring table. + var r0 = a; + var r1 = b; + if (lo_i < hi_i) { + // Old lines: those past the edit moved by what it added. + const head: usize = items[lo_i].first; + const last: usize = items[hi_i - 1].end - 1; + r0 = @min(r0, if (head > b_old) @as(usize, shift(@intCast(head), delta)) else head); + r1 = @max(r1, if (last > b_old) @as(usize, shift(@intCast(last), delta)) else last); + } + const floor: usize = if (lo_i > 0) items[lo_i - 1].end else 0; + const ceiling: usize = if (hi_i < items.len) items[hi_i].first else starts.len; + var steps: usize = 0; + while (r0 > floor and !blank(lineOf(content, starts, r0 - 1).text)) : (steps += 1) { + if (steps > 512 or fenceOf(lineOf(content, starts, r0 - 1).text) != null) break; + r0 -= 1; + } + steps = 0; + while (r1 + 1 < ceiling and !blank(lineOf(content, starts, r1 + 1).text)) : (steps += 1) { + if (steps > 512) return error.Whole; + if (fenceOf(lineOf(content, starts, r1 + 1).text) != null) break; + r1 += 1; + } + for (items[lo_i..hi_i]) |table| t.garbage += table.cols; + // Its tables, found as the whole text's are, then put in the old ones' place. + const before = t.list.items.len; + const prev = if (r0 == 0) "" else lineOf(content, starts, r0 - 1).text; + const prev_blank = r0 == 0 or blank(prev) or closesAny(prev) or std.mem.startsWith(u8, prev[@min(indentOf(prev), prev.len)..], "#"); + const head = lineOf(content, starts, r0); + var at: Resume = .{ .at = head.start, .n = head.n, .fence = null, .prev_blank = prev_blank }; + _ = try t.scanFrom(gpa, content, &at, @intCast(r1), false, 0); + const fresh = try gpa.dupe(Table, t.list.items[before..]); + defer gpa.free(fresh); + t.list.shrinkRetainingCapacity(before); + try t.list.replaceRange(gpa, lo_i, hi_i - lo_i, fresh); + t.lines = starts.len; +} + +/// Whether a line closes some fence (any fence line does, to the block +/// after it: a header may follow it). +fn closesAny(text: []const u8) bool { + return fenceOf(text) != null; +} + +pub fn isMarkdown(path: []const u8) bool { + return std.ascii.endsWithIgnoreCase(path, ".md") or std.ascii.endsWithIgnoreCase(path, ".markdown"); +} + +/// One line of the text: its bytes and its number. +const Line = struct { text: []const u8, start: usize, n: u32 }; + +fn lineAt(content: []const u8, start: usize, n: u32) ?Line { + if (start > content.len) return null; + const end = std.mem.indexOfScalarPos(u8, content, start, '\n') orelse content.len; + const text = content[start..end]; + return .{ .text = if (text.len > 0 and text[text.len - 1] == '\r') text[0 .. text.len - 1] else text, .start = start, .n = n }; +} + +fn nextLine(content: []const u8, l: Line) ?Line { + const nl = std.mem.indexOfScalarPos(u8, content, l.start, '\n') orelse return null; + return lineAt(content, nl + 1, l.n + 1); +} + +fn indentOf(text: []const u8) usize { + var i: usize = 0; + while (i < text.len and (text[i] == ' ' or text[i] == '\t')) i += 1; + return i; +} + +fn blank(text: []const u8) bool { + return indentOf(text) == text.len; +} + +/// A fence's opener (```` ``` ```` or `~~~`, three or more, up to three +/// spaces in): its character and length. +const Fence = struct { ch: u8, len: usize }; + +fn fenceOf(text: []const u8) ?Fence { + const in = indentOf(text); + if (in > 3 or in >= text.len) return null; + const ch = text[in]; + if (ch != '`' and ch != '~') return null; + var n: usize = 0; + while (in + n < text.len and text[in + n] == ch) n += 1; + if (n < 3) return null; + // A backtick fence's info string has no backtick (CommonMark 4.5). + if (ch == '`' and std.mem.indexOfScalar(u8, text[in + n ..], '`') != null) return null; + return .{ .ch = ch, .len = n }; +} + +fn closes(text: []const u8, open: Fence) bool { + const f = fenceOf(text) orelse return false; + return f.ch == open.ch and f.len >= open.len and blank(text[indentOf(text) + f.len ..]); +} + +/// A line that ends a table's rows by starting a block of its own (what +/// the grammar's paragraph_interrupt_symbols are): a heading, a fence, a +/// quote, a list item, a thematic break, HTML. +fn interrupts(text: []const u8) bool { + const in = indentOf(text); + if (in > 3 or in >= text.len) return false; + const rest = text[in..]; + if (fenceOf(text) != null) return true; + switch (rest[0]) { + '#', '>', '<' => return true, + '-', '*', '+' => { + if (rest.len == 1 or rest[1] == ' ' or rest[1] == '\t') return true; + // A thematic break: three or more of one of -*_ and spaces. + var n: usize = 0; + for (rest) |b| { + if (b == rest[0]) n += 1 else if (b != ' ' and b != '\t') return false; + } + return n >= 3; + }, + '0'...'9' => { + var i: usize = 0; + while (i < rest.len and i < 9 and std.ascii.isDigit(rest[i])) i += 1; + return i < rest.len and (rest[i] == '.' or rest[i] == ')') and (i + 1 == rest.len or rest[i + 1] == ' '); + }, + else => return false, + } +} + +/// A row's unescaped pipes, in order, and whether the row starts with one +/// (after its indentation) and ends with one (before trailing blanks). +const Pipes = struct { + at: [max_cols + 2]u32 = undefined, + n: usize = 0, + /// Pipes past `at`'s room: counted, not kept. + more: usize = 0, + leading: bool = false, + trailing: bool = false, + + fn of(text: []const u8) Pipes { + var p: Pipes = .{}; + const in = indentOf(text); + p.leading = in < text.len and text[in] == '|'; + var last_ink: usize = text.len; + var i: usize = 0; + while (i < text.len) : (i += 1) { + const b = text[i]; + if (b == '\\' and i + 1 < text.len and std.ascii.isPrint(text[i + 1]) and !std.ascii.isAlphanumeric(text[i + 1]) and text[i + 1] != ' ') { + last_ink = i + 1; + i += 1; + continue; + } + if (b == '|') { + if (p.n < p.at.len) { + p.at[p.n] = @intCast(i); + p.n += 1; + } else p.more += 1; + } + if (b != ' ' and b != '\t') last_ink = i; + } + p.trailing = p.n > 0 and last_ink == p.at[p.n - 1] and p.more == 0; + return p; + } + + /// The cells the grammar counts: the pipes after a leading one, plus + /// the last cell when no pipe ends the row. + fn cells(p: *const Pipes) usize { + const pipes = p.n + p.more - @intFromBool(p.leading); + return pipes + @intFromBool(!p.trailing); + } + + /// The pipe that ends cell `k` (the pipes after a leading one). + fn end(p: *const Pipes, k: usize) ?usize { + const i = k + @intFromBool(p.leading); + return if (i < p.n) p.at[i] else null; + } + + /// Where cell `k` starts: after the pipe before it, or after the + /// indentation when it is the first and no pipe leads. + fn start(p: *const Pipes, k: usize) usize { + if (k == 0 and !p.leading) return 0; + return p.at[k - @intFromBool(!p.leading)] + 1; + } +}; + +/// A delimiter row's cells (`:?-+:?` between pipes), or null if `text` is +/// none: as the scanner reads one after a header. +fn delimiterCells(text: []const u8, out: *[max_cols]Align) ?usize { + var i = indentOf(text); + if (i > 3) return null; + var cells: usize = 0; + var pipes: usize = 0; + if (i < text.len and text[i] == '|') { + i += 1; + pipes += 1; + } + while (true) { + while (i < text.len and (text[i] == ' ' or text[i] == '\t')) i += 1; + if (i >= text.len) break; + if (text[i] == '|') { + // An empty cell (`||`): the scanner counts it, aligned as none. + if (cells < max_cols) out[cells] = .left; + cells += 1; + pipes += 1; + i += 1; + continue; + } + var left = false; + if (text[i] == ':') { + left = true; + i += 1; + if (i >= text.len or text[i] != '-') return null; + } + var dashes: usize = 0; + while (i < text.len and text[i] == '-') : (i += 1) dashes += 1; + if (dashes == 0) return null; + var right = false; + if (i < text.len and text[i] == ':') { + right = true; + i += 1; + } + if (cells < max_cols) out[cells] = if (left and right) .center else if (right) .right else .left; + cells += 1; + while (i < text.len and (text[i] == ' ' or text[i] == '\t')) i += 1; + if (i >= text.len) break; + if (text[i] != '|') return null; + pipes += 1; + i += 1; + } + if (pipes == 0) return null; + return cells; +} + +/// The display width of a cell's bytes; ASCII is a cell a byte. +fn widthOf(text: []const u8) usize { + for (text) |b| if (b < 0x20 or b >= 0x7f) return File.displayWidth(text); + return text.len; +} + +/// Find the tables of `content`, in place of the ones there were. +pub fn scan(t: *Tables, gpa: std.mem.Allocator, content: []const u8) !void { + t.list.clearRetainingCapacity(); + t.widths.clearRetainingCapacity(); + t.aligns.clearRetainingCapacity(); + t.begin(std.mem.count(u8, content, "\n") + 1); + var at = t.pending.?; + _ = try t.scanFrom(gpa, content, &at, std.math.maxInt(u32), true, 0); + t.pending = null; +} + +/// Find the tables whose header is on a line from `at` to `stop`, +/// appending them; with `fences`, keep the fences. With a budget, stop +/// when it is spent, `at` where to go on from. Whether it reached the end +/// (or `stop`). +fn scanFrom(t: *Tables, gpa: std.mem.Allocator, content: []const u8, at: *Resume, stop: u32, fences: bool, budget_ns: u64) !bool { + var fence = at.fence; + var prev_blank = at.prev_blank; + var line = lineAt(content, at.at, at.n); + const t0 = if (budget_ns > 0) panes.Places.nowNs() else 0; + var lines: usize = 0; + while (line) |l| : (lines += 1) { + if (l.n > stop) break; + if (budget_ns > 0 and lines % 256 == 255 and panes.Places.nowNs() -| t0 > budget_ns) { + at.* = .{ .at = l.start, .n = l.n, .fence = fence, .prev_blank = prev_blank }; + return false; + } + const following = nextLine(content, l); + if (fence) |open| { + if (closes(l.text, open)) { + fence = null; + if (fences) t.fences.items[t.fences.items.len - 1][1] = l.n; + } + prev_blank = fence == null; + line = following; + continue; + } + if (fenceOf(l.text)) |open| { + fence = open; + if (fences) try t.fences.append(gpa, .{ l.n, std.math.maxInt(u32) }); + prev_blank = false; + line = following; + continue; + } + const is_blank = blank(l.text); + var aligns: [max_cols]Align = undefined; + // A header starts a block: after a blank line, a heading or a fence + // (the grammar tries PIPE_TABLE_START where a paragraph could start). + if (!is_blank and prev_blank and indentOf(l.text) <= 3 and std.mem.indexOfScalar(u8, l.text, '|') != null) { + if (following) |delimiter| if (delimiterCells(delimiter.text, &aligns)) |count| { + const header = Pipes.of(l.text); + // A header's one pipe may not be its leading one alone, + // unless one ends it too (`| a |`, not `| a`). + const lone = header.n + header.more == @intFromBool(header.leading) and !(header.leading and header.trailing); + if (!lone and header.cells() == count) { + const last = try t.add(gpa, content, l, delimiter, aligns[0..@min(count, max_cols)]); + line = nextLine(content, last); + prev_blank = false; + continue; + } + }; + } + // A heading line ends a block too: a header may follow it. + prev_blank = is_blank or std.mem.startsWith(u8, l.text[@min(indentOf(l.text), l.text.len)..], "#"); + line = following; + } + return true; +} + +/// Take the table whose header is `header`: its rows, its columns' widths +/// and its width. Returns its last row's line. +fn add(t: *Tables, gpa: std.mem.Allocator, content: []const u8, header: Line, delimiter: Line, aligns: []const Align) !Line { + var last = delimiter; + while (nextLine(content, last)) |row| { + if (blank(row.text) or interrupts(row.text)) break; + last = row; + } + const col0: u32 = @intCast(t.widths.items.len); + var table: Table = .{ .first = header.n, .end = last.n + 1, .col0 = col0, .cols = 0, .lead = 0, .width = 0 }; + // Widths: each column's widest cell, the cell's bytes up to the pipe + // that ends it; a row's last cell with no pipe after it aligns nothing. + var row: ?Line = header; + while (row) |r| : (row = if (r.n == last.n) null else nextLine(content, r)) { + const pipes = Pipes.of(r.text); + if (pipes.leading) table.lead = @max(table.lead, @as(u16, @intCast(@min(widthOf(r.text[0..pipes.at[0]]), std.math.maxInt(u16))))); + var k: usize = 0; + while (k < max_cols) : (k += 1) { + const stop = pipes.end(k) orelse break; + const w: u16 = @intCast(@min(widthOf(r.text[pipes.start(k)..stop]), std.math.maxInt(u16))); + if (k >= table.cols) { + try t.widths.append(gpa, w); + try t.aligns.append(gpa, if (k < aligns.len) aligns[k] else .left); + table.cols += 1; + } else t.widths.items[col0 + k] = @max(t.widths.items[col0 + k], w); + } + } + // The width: each row laid out, its source width and its pads. + row = header; + var buf: [max_pads]Pad = undefined; + while (row) |r| : (row = if (r.n == last.n) null else nextLine(content, r)) { + var width = widthOf(r.text); + for (t.padsOf(&table, r.n, r.text, &buf)) |pad| width += pad.cells; + table.width = @max(table.width, @as(u32, @intCast(@min(width, std.math.maxInt(u32))))); + } + try t.list.append(gpa, table); + return last; +} + +/// The pads of one of `table`'s rows, by byte, in order. No pad is ever at +/// byte 0: a row is drawn from its first byte, so there is no cell before +/// it to give. +pub fn padsOf(t: *const Tables, table: *const Table, line: usize, text: []const u8, out: *[max_pads]Pad) []Pad { + const pipes = Pipes.of(text); + var n: usize = 0; + if (pipes.leading and pipes.at[0] > 0) { + const w = widthOf(text[0..pipes.at[0]]); + if (w < table.lead) { + out[n] = .{ .at = pipes.at[0], .cells = @intCast(table.lead - w) }; + n += 1; + } + } + var k: usize = 0; + while (k < table.cols) : (k += 1) { + const stop = pipes.end(k) orelse break; + const from = pipes.start(k); + const w = widthOf(text[from..stop]); + const want = t.widths.items[table.col0 + k]; + if (w >= want) continue; + const missing: u16 = @intCast(want - w); + // The first cell with no leading pipe starts at byte 0: it pads at + // its end, whatever its alignment. + const how: Align = if (from == 0) .left else t.aligns.items[table.col0 + k]; + // The delimiter row's cells keep their colons at their edges: the + // rule is drawn long between them (a pad before a closing `:`). + if (line == table.first + 1) { + var last = stop; + while (last > from and (text[last - 1] == ' ' or text[last - 1] == '\t')) last -= 1; + const at = if (last > from and text[last - 1] == ':') last - 1 else stop; + if (at == 0) continue; + out[n] = .{ .at = @intCast(at), .cells = missing }; + n += 1; + continue; + } + const before: u16 = switch (how) { + .left => 0, + .right => missing, + .center => missing / 2, + }; + // An empty cell's start is its pipe: one pad there. + if (before > 0 and from < stop) { + out[n] = .{ .at = @intCast(from), .cells = before }; + n += 1; + } + const after = if (from < stop) missing - before else missing; + if (after > 0) { + out[n] = .{ .at = @intCast(stop), .cells = after }; + n += 1; + } + } + return out[0..n]; +} + +/// The cells of virtual width between byte `from` (excluded: its pad is +/// before the row's first shown byte) and byte `to` (included: its pad is +/// before its glyph), negative when `to` is before `from`. +pub fn between(pads: []const Pad, from: usize, to: usize) i32 { + const lo = @min(from, to); + const hi = @max(from, to); + var sum: i32 = 0; + for (pads) |pad| { + if (pad.at > hi) break; + if (pad.at > lo) sum += pad.cells; + } + return if (to >= from) sum else -sum; +} + +/// The byte at display column `col` of a row shown from byte `from`, its +/// pads counted: a pad's cells are its byte's, as a tab's are the tab's. +/// Past the end, a virtual column a cell (File.rawAtDisplay). +pub fn byteAt(text: []const u8, pads: []const Pad, from_raw: usize, col: usize) usize { + if (from_raw >= text.len) return from_raw +| col; + var at = modal.graphemeStart(text, from_raw); + var k: usize = 0; + while (k < pads.len and pads[k].at <= at) k += 1; + var used: usize = 0; + while (at < text.len) { + if (k < pads.len and pads[k].at == at) { + used += pads[k].cells; + k += 1; + if (col < used) return at; + } + const end = modal.nextGrapheme(text, at); + used += File.graphemeDisplayWidth(text[at..end]); + if (col < used) return at; + at = end; + } + return text.len + (col - used); +} + +/// What a table's `|` and its delimiter row are drawn as: light box-drawing +/// rules, each one cell, as the glyph of the byte that is there. +const rule_v = "\u{2502}"; +const rule_h = "\u{2500}"; +const rule_cross = "\u{253c}"; +const rule_left = "\u{251c}"; +const rule_right = "\u{2524}"; + +fn glyph(cell: *Cell, g: []const u8) void { + cell.default = false; + @memcpy(cell.text[0..g.len], g); + cell.len = @intCast(g.len); +} + +/// A pane's table rows drawn as tables: every unescaped `|` a rule, the +/// delimiter row one rule across (its dashes, its blanks and its pads, its +/// `:` kept in the rule's colour, since they say the alignment), the header +/// row bold on the tag's ground, as compact context rows are. Only glyphs +/// and colours change, on the cells the row has: where each byte is and how +/// wide is fillBody's, so nothing is drawn over anything, B1 on a rule is +/// B1 on its `|`, and a selection's tint lies over the rules as over text. +pub fn paint(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16) void { + const f = if (pane.file) |*file| file else return; + if (f.tables.list.items.len == 0) return; + const th = p.theme(); + const tint = p.settings.colors; + const rule_fg: Color = .{ .rgb = th.border orelse th.lineno }; + const head_bg: Color = .{ .rgb = th.tag_bg }; + const prefix: usize = File.gutterWidth(pane); + const body_y = p.bodyTop(pane, r); + var vr: u16 = 0; + while (vr < body_h) : (vr += 1) { + const w = pane.wrapAt(vr); + const table = File.rowTable(pane, w.line) orelse continue; + const text = File.sourceLine(pane, w.line); + var buf: [max_pads]Pad = undefined; + const pads = f.tables.padsOf(table, @intCast(w.line), text, &buf); + const pipes = Pipes.of(text); + const delimiter = w.line == table.first + 1; + const header = w.line == table.first; + const y = body_y + vr; + // The row's walk, as fillBody lays it out from its first shown byte. + var at = modal.graphemeStart(text, @min(@as(usize, @intCast(@max(0, w.at))), text.len)); + var col: usize = prefix + @as(usize, @intCast(w.pad)); + var k: usize = 0; + while (k < pads.len and pads[k].at <= at) k += 1; + var q: usize = 0; + while (q < pipes.n and pipes.at[q] < at) q += 1; + while (at < text.len and col < tw) { + if (k < pads.len and pads[k].at == at) { + for (0..pads[k].cells) |i| { + if (col + i >= tw) break; + const cell = s.at(tx + @as(u16, @intCast(col + i)), y); + if (delimiter) { + glyph(cell, rule_h); + if (tint) cell.style.fg = rule_fg; + } + if (header and tint) cell.style.bg = head_bg; + } + col += pads[k].cells; + k += 1; + if (col >= tw) break; + } + const end = modal.nextGrapheme(text, at); + const cells = File.graphemeDisplayWidth(text[at..end]); + const cell = s.at(tx + @as(u16, @intCast(col)), y); + const pipe = q < pipes.n and pipes.at[q] == at; + if (pipe) { + q += 1; + glyph(cell, if (!delimiter) + rule_v + else if (q == 1 and pipes.leading) + rule_left + else if (q == pipes.n and pipes.trailing) + rule_right + else + rule_cross); + if (tint) cell.style.fg = rule_fg; + cell.style.bold = false; + } else if (delimiter) { + if (text[at] == '-' or text[at] == ' ') glyph(cell, rule_h); + if (tint) cell.style.fg = rule_fg; + } else if (header) { + cell.default = false; + cell.style.bold = true; + } + if (header and tint) for (0..cells) |i| { + if (col + i < tw) s.at(tx + @as(u16, @intCast(col + i)), y).style.bg = head_bg; + }; + col += cells; + at = end; + } + } +} + +// ---- tests ---- + +const testing = std.testing; +const config = @import("config.zig"); +const Key = pardes.Key; + +const sample = + "# Fruit\n" ++ + "\n" ++ + "| name | qty | note |\n" ++ + "|:-----|----:|:----:|\n" ++ + "| apple | 3 | red |\n" ++ + "| kiwi | 12 | small and fuzzy |\n" ++ + "| fig || |\n" ++ + "\n" ++ + "after\n"; + +/// A pane on `content` as a markdown file, drawn once. +fn testPane(p: *Pardes, content: []const u8, frame: std.mem.Allocator) !*Pane { + const pane = try p.setTestFile(content); + p.gpa.free(pane.file.?.path); + pane.file.?.path = try p.gpa.dupe(u8, "/notes.md"); + _ = try p.render(frame); + return pane; +} + +test "tables: a pipe table's columns, alignments and pads, by line" { + var t: Tables = .{}; + defer t.deinit(testing.allocator); + try t.scan(testing.allocator, sample); + try testing.expectEqual(@as(usize, 1), t.list.items.len); + const table = t.list.items[0]; + try testing.expectEqual(@as(u32, 2), table.first); + try testing.expectEqual(@as(u32, 7), table.end); + try testing.expectEqualSlices(u16, &.{ 7, 5, 17 }, t.widths.items); + try testing.expectEqualSlices(Align, &.{ .left, .right, .center }, t.aligns.items); + // `| fig || |`: the first cell short by 2 (left: before its `|`), the + // empty second by 5 (one pad at its pipe), the third by 16 (centred). + var buf: [max_pads]Pad = undefined; + const fig = "| fig || |"; + try testing.expectEqualSlices(Pad, &.{ + .{ .at = 6, .cells = 2 }, .{ .at = 7, .cells = 5 }, .{ .at = 8, .cells = 8 }, .{ .at = 9, .cells = 8 }, + }, t.padsOf(&table, 6, fig, &buf)); + // `| apple | 3 | red |`: right-aligned 3 pads before its first byte. + try testing.expectEqualSlices(Pad, &.{ + .{ .at = 9, .cells = 2 }, .{ .at = 13, .cells = 6 }, .{ .at = 18, .cells = 6 }, + }, t.padsOf(&table, 4, "| apple | 3 | red |", &buf)); + // Every row laid out is one width: the table's. + try testing.expectEqual(@as(u32, 1 + 7 + 1 + 5 + 1 + 17 + 1), table.width); + // Not tables: a fence's rows, counts that differ, a delimiter alone. + for ([_][]const u8{ + "```\n| a | b |\n|---|---|\n```\n", + "| a | b |\n|---|\n", + "|---|---|\n", + "| a\n|---\n", + }) |text| { + try t.scan(testing.allocator, text); + try testing.expectEqual(@as(usize, 0), t.list.items.len); + } +} + +test "tables: every byte's cell maps back to it, and every pad cell to the byte after it" { + var t: Tables = .{}; + defer t.deinit(testing.allocator); + try t.scan(testing.allocator, sample); + const table = &t.list.items[0]; + var lines = std.mem.splitScalar(u8, sample, '\n'); + var n: usize = 0; + while (lines.next()) |text| : (n += 1) { + if (n < table.first or n >= table.end) continue; + var buf: [max_pads]Pad = undefined; + const pads = t.padsOf(table, n, text, &buf); + var col: usize = 0; + for (text, 0..) |_, b| { + // The pad before b: each of its cells is b's. + const start = File.displayWidth(text[0..b]) + @as(usize, @intCast(between(pads, 0, b))); + while (col < start) : (col += 1) try testing.expectEqual(b, byteAt(text, pads, 0, col)); + try testing.expectEqual(b, byteAt(text, pads, 0, col)); + col += 1; + } + // Past the end, a virtual column a cell. + try testing.expectEqual(text.len + 2, byteAt(text, pads, 0, col + 2)); + // From a scrolled start, the pads before it are not counted. + try testing.expectEqual(@as(usize, 2), byteAt(text, pads, 2, 0)); + } +} + +test "tables: a markdown table is drawn aligned, its bytes in order, the caret and a click on each byte's cell" { + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try testPane(p, sample, frame.allocator()); + const r = p.rects[0]; + const text_x = r.x + config.GUTTER + File.gutterWidth(pane); + const body_y = p.bodyTop(pane, r); + // The k-th pipe of every row on one screen column. + var pipe_x: [4]?u16 = @splat(null); + for (2..7) |line| { + const text = File.sourceLine(pane, @intCast(line)); + var k: usize = 0; + for (text, 0..) |b, i| { + const x = text_x + @as(u16, @intCast(File.displayOffset(pane, @intCast(line), 0, @intCast(i)))); + const cell = p.surface.at(x, body_y + @as(u16, @intCast(line))); + if (b == '|') { + if (pipe_x[k]) |want| try testing.expectEqual(want, x) else pipe_x[k] = x; + try testing.expect(!std.mem.eql(u8, cell.grapheme(), " ")); + k += 1; + } else if (line != 3) try testing.expectEqualStrings(text[i .. i + 1], cell.grapheme()); + } + } + try testing.expectEqual(@as(u16, 1 + 7 + 1 + 5 + 1 + 17), pipe_x[3].? - text_x); + // The look: each `|` a rule; the delimiter row one rule across, its + // `:` kept; the header bold. The bytes under them are the source's. + const rule_y = body_y + 3; + var x = text_x; + while (x <= pipe_x[3].?) : (x += 1) { + const g = p.surface.at(x, rule_y).grapheme(); + try testing.expect(std.mem.eql(u8, g, rule_h) or std.mem.eql(u8, g, rule_cross) or + std.mem.eql(u8, g, rule_left) or std.mem.eql(u8, g, rule_right) or std.mem.eql(u8, g, ":")); + } + try testing.expectEqualStrings(rule_left, p.surface.at(pipe_x[0].?, rule_y).grapheme()); + try testing.expectEqualStrings(rule_cross, p.surface.at(pipe_x[1].?, rule_y).grapheme()); + try testing.expectEqualStrings(rule_right, p.surface.at(pipe_x[3].?, rule_y).grapheme()); + try testing.expectEqualStrings(rule_v, p.surface.at(pipe_x[2].?, body_y + 4).grapheme()); + try testing.expect(p.surface.at(text_x + 2, body_y + 2).style.bold); + try testing.expect(!p.surface.at(text_x + 2, body_y + 4).style.bold); + try testing.expectEqualStrings("| name | qty | note |", File.sourceLine(pane, 2)); + // B1 on any cell of `| fig || |`: the caret on the byte the cell is + // (a pad's cells are the byte after them), drawn where that byte is. + const fig: i32 = 6; + const text = File.sourceLine(pane, fig); + const y = body_y + 6; + var col: u16 = 0; + while (col < pipe_x[3].? - text_x + 1) : (col += 1) { + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = text_x + col, .row = y } }); + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = text_x + col, .row = y } }); + const want = File.byteAtRowDisplay(pane, fig, 0, col); + try testing.expectEqual(fig, pane.body.cur_row); + try testing.expectEqual(want, pane.body.cur_col); + try testing.expect(want < text.len); + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + const caret = p.surface.cursor orelse return error.NoCaret; + try testing.expectEqual(text_x + @as(u16, @intCast(File.displayOffset(pane, fig, 0, want))), caret.x); + // The caret is on the cell clicked, or on the glyph after its pad. + try testing.expect(caret.x >= text_x + col); + } + // A pad cell: the empty second cell's five, all the `|` after them. + const empty_x = pipe_x[1].? - text_x + 1; + for (0..5) |i| try testing.expectEqual(@as(i32, 7), File.byteAtRowDisplay(pane, fig, 0, @intCast(empty_x + i))); +} + +test "tables: typing in a cell re-aligns the table live, and j/k keep the column shown" { + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try testPane(p, sample, frame.allocator()); + // On `3` in the apple row: insert before it. + pane.body.cur_row = 4; + pane.body.cur_col = 10; + p.update(.{ .key = .{ .cp = 'i', .text = "i" } }); + for ("123456789") |c| p.update(.{ .key = .{ .cp = c, .text = &.{c} } }); + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + try testing.expectEqualStrings("| apple | 1234567893 | red |", File.sourceLine(pane, 4)); + // The qty column is now 12 wide in every row. + for (2..7) |line| { + const text = File.sourceLine(pane, @intCast(line)); + var k: usize = 0; + for (text, 0..) |b, i| { + if (b != '|') continue; + k += 1; + if (k == 3) try testing.expectEqual(@as(i32, 1 + 7 + 1 + 12), File.displayOffset(pane, @intCast(line), 0, @intCast(i))); + } + } + // k from the kiwi row's `and` keeps its screen column: the apple + // row's centred `red` under it. + p.update(.{ .key = .{ .cp = Key.escape } }); + pane.body.cur_row = 5; + pane.body.cur_col = @intCast(std.mem.indexOf(u8, File.sourceLine(pane, 5), "and").?); + pane.body.vsel.active = false; + pane.body.sticky_col = -1; + const shown = File.displayOffset(pane, 5, 0, pane.body.cur_col); + p.update(.{ .key = .{ .cp = 'k', .text = "k" } }); + try testing.expectEqual(@as(i32, 4), pane.body.cur_row); + try testing.expectEqual(shown, File.displayOffset(pane, 4, 0, pane.body.cur_col)); +} + +test "tables: an edit's tables, shifted and found again around it, are the whole text's" { + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try testPane(p, sample ++ "\n```\n| a | b |\n|---|---|\n```\n\n" ++ sample ++ "para\n| x | y |\n|---|--|\n| 1 | 2 |\n", frame.allocator()); + const f = &pane.file.?; + var whole: Tables = .{}; + defer whole.deinit(testing.allocator); + var prng: std.Random.DefaultPrng = .init(11); + const random = prng.random(); + const alphabet = "|||--: \n\nab`"; + var reflowed: usize = 0; + for (0..1500) |round| { + const old = f.content; + const at = random.uintAtMost(usize, old.len); + const cut = if (random.boolean()) @min(old.len - at, random.uintAtMost(usize, 3)) else 0; + const grow = random.uintAtMost(usize, 2); + const new = try p.gpa.alloc(u8, old.len - cut + grow); + @memcpy(new[0..at], old[0..at]); + for (new[at..][0..grow]) |*c| c.* = alphabet[random.uintLessThan(usize, alphabet.len)]; + @memcpy(new[at + grow ..], old[at + cut ..]); + const scans = f.tables.scans; + File.setContent(p, f, new); + f.tables.ensure(p.gpa, f); + if (f.tables.scans == scans) reflowed += 1; + try whole.scan(testing.allocator, f.content); + testing.expectEqual(whole.list.items.len, f.tables.list.items.len) catch |e| { + std.debug.print("round {d}\n{s}\n", .{ round, f.content }); + return e; + }; + for (whole.list.items, f.tables.list.items) |w, mine| { + try testing.expectEqual(w.first, mine.first); + try testing.expectEqual(w.end, mine.end); + try testing.expectEqual(w.cols, mine.cols); + try testing.expectEqual(w.lead, mine.lead); + try testing.expectEqual(w.width, mine.width); + try testing.expectEqualSlices(u16, whole.widths.items[w.col0..][0..w.cols], f.tables.widths.items[mine.col0..][0..mine.cols]); + try testing.expectEqualSlices(Align, whole.aligns.items[w.col0..][0..w.cols], f.tables.aligns.items[mine.col0..][0..mine.cols]); + } + try testing.expectEqual(whole.lines, f.tables.lines); + } + // Most edits took the short way. + try testing.expect(reflowed > 1000); +} + +test "tables: a big text's tables are read a frame's budget at a time from the top, edits on the way kept" { + var big: std.ArrayList(u8) = .empty; + defer big.deinit(testing.allocator); + for (0..1500) |i| try big.print(testing.allocator, "## {d}\n\n| a | b {d} |\n|---|--:|\n| one | two |\n| three | {d} |\n\n", .{ i, i, i * 7 }); + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try testPane(p, big.items, frame.allocator()); + const f = &pane.file.?; + // One frame did not read it all, and asks for the next. + try testing.expect(f.tables.busy()); + try testing.expect(p.nextWake() != null); + // The top's tables are found already: the view is right at once. + try testing.expect(File.rowTable(pane, 2) != null); + const reached = f.tables.pending.?.n; + // An edit past where it got to: it goes on; one before it: from the top. + var edits: usize = 0; + var frames: usize = 0; + while (f.tables.busy()) : (frames += 1) { + if (edits < 2) { + const at = if (edits == 0) f.content.len - 3 else 10; + const new = try std.mem.concat(p.gpa, u8, &.{ f.content[0..at], "x", f.content[at..] }); + File.setContent(p, f, new); + edits += 1; + } + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + try testing.expect(frames < 10_000); + } + try testing.expect(reached < File.nlines(p.gpa, f)); + var whole: Tables = .{}; + defer whole.deinit(testing.allocator); + try whole.scan(testing.allocator, f.content); + try testing.expectEqual(whole.list.items.len, f.tables.list.items.len); + for (whole.list.items, f.tables.list.items) |w, mine| { + try testing.expectEqual(w.first, mine.first); + try testing.expectEqual(w.end, mine.end); + try testing.expectEqual(w.width, mine.width); + } +} + +test "tables: a table wider than a wrapping pane is shown as its source, laid out again with Wrap off" { + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 34, .rows = 24 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try testPane(p, sample, frame.allocator()); + try testing.expect(pane.body_wrapped); + try testing.expect(File.wrapWidth(pane, true) < 34); + try testing.expect(File.rowTable(pane, 2) == null); + // Source: a pipe is a pipe, at its source column. + try testing.expectEqual(@as(i32, 7), File.displayOffset(pane, 5, 0, 7)); + try testing.expect(p.executeBuiltinLine(0, "Wrap off")); + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + try testing.expect(!pane.body_wrapped); + try testing.expect(File.rowTable(pane, 2) != null); +} + +test "zz tables timings on a big markdown file (TABLES_TIMES=<path>)" { + const path_z = std.c.getenv("TABLES_TIMES") orelse return error.SkipZigTest; + const path = std.mem.span(path_z); + const io = testing.io; + const bytes = try std.Io.Dir.cwd().readFileAlloc(io, path, testing.allocator, .limited(16 << 20)); + defer testing.allocator.free(bytes); + const now = panes.Places.nowNs; + var report: std.ArrayList(u8) = .empty; + defer report.deinit(testing.allocator); + { + var t: Tables = .{}; + defer t.deinit(testing.allocator); + var worst: u64 = 0; + var sum: u64 = 0; + for (0..5) |_| { + const t0 = now(); + try t.scan(testing.allocator, bytes); + const d = now() - t0; + sum += d; + worst = @max(worst, d); + } + try report.print(testing.allocator, "scan of {d} bytes: {d} tables, mean {d} us, worst {d} us\n", .{ bytes.len, t.list.items.len, sum / 5 / 1000, worst / 1000 }); + } + // The same text as markdown and as plain text: what the tables cost a + // frame and an edit. + for ([_][]const u8{ "/stress.md", "/stress.txt" }) |name| { + const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 50 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(testing.allocator); + defer frame.deinit(); + const pane = try p.setTestFile(bytes); + p.gpa.free(pane.file.?.path); + pane.file.?.path = try p.gpa.dupe(u8, name); + { + var t0 = now(); + _ = try p.render(frame.allocator()); + const first = now() - t0; + var frames: usize = 1; + var worst: u64 = first; + t0 = now(); + while (pane.file.?.tables.busy()) : (frames += 1) { + const t1 = now(); + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + worst = @max(worst, now() - t1); + } + try report.print(testing.allocator, "{s}: the first frame {d} us; the tables read in {d} frames, the worst {d} us\n", .{ name, first / 1000, frames, worst / 1000 }); + } + // Into the middle of a table half way down. + var line: usize = File.nlines(p.gpa, &pane.file.?) / 2; + while (!std.mem.startsWith(u8, File.sourceLine(pane, @intCast(line)), "| ") or + std.mem.indexOf(u8, File.sourceLine(pane, @intCast(line)), "col") != null) line += 1; + pane.body.cur_row = @intCast(line + 2); + pane.body.cur_col = 2; + pane.ensureCursorVisible(); + _ = frame.reset(.retain_capacity); + _ = try p.render(frame.allocator()); + const Clock = struct { + fn step(pp: *Pardes, fr: *std.heap.ArenaAllocator, ev: pardes.Event) !u64 { + const t0 = panes.Places.nowNs(); + pp.update(ev); + _ = fr.reset(.retain_capacity); + _ = try pp.render(fr.allocator()); + return panes.Places.nowNs() - t0; + } + }; + var sum: u64 = 0; + var worst: u64 = 0; + for (0..10) |_| { + const d = try Clock.step(p, &frame, .{ .key = .{ .cp = 'j', .text = "j" } }); + sum += d; + worst = @max(worst, d); + } + try report.print(testing.allocator, "{s}: j and its frame: mean {d} us, worst {d} us\n", .{ name, sum / 10 / 1000, worst / 1000 }); + _ = try Clock.step(p, &frame, .{ .key = .{ .cp = 'i', .text = "i" } }); + sum = 0; + worst = 0; + for (0..10) |_| { + const d = try Clock.step(p, &frame, .{ .key = .{ .cp = 'x', .text = "x" } }); + sum += d; + worst = @max(worst, d); + } + try report.print(testing.allocator, "{s}: a letter typed in a cell and its frame: mean {d} us, worst {d} us\n", .{ name, sum / 10 / 1000, worst / 1000 }); + } + std.debug.print("\n{s}", .{report.items}); +} |
