terminal: remove all legacy encodeUtf8 functions, replace with formatter (ghostty-org#9392)

mitchellh · web-flow · commit a4d54dca1c50 · 2025-10-29T10:50:47.000-07:00
This removes all existing functionality that I know of that encodes a
terminal, screen, pagelist, or page as plaintext and unifies all logic
onto the formatter system.
diff --git a/src/terminal/PageList.zig b/src/terminal/PageList.zig
@@ -3216,50 +3216,6 @@ pub fn getCell(self: *const PageList, pt: point.Point) ?Cell {
     };
 }
 
-pub const EncodeUtf8Options = struct {
-    /// The start and end points of the dump, both inclusive. The x will
-    /// be ignored and the full row will always be dumped.
-    tl: Pin,
-    br: ?Pin = null,
-
-    /// If true, this will unwrap soft-wrapped lines. If false, this will
-    /// dump the screen as it is visually seen in a rendered window.
-    unwrap: bool = true,
-
-    /// See Page.EncodeUtf8Options.
-    cell_map: ?*Page.CellMap = null,
-};
-
-/// Encode the pagelist to utf8 to the given writer.
-///
-/// The writer should be buffered; this function does not attempt to
-/// efficiently write and often writes one byte at a time.
-///
-/// Note: this is tested using Screen.dumpString. This is a function that
-/// predates this and is a thin wrapper around it so the tests all live there.
-pub fn encodeUtf8(
-    self: *const PageList,
-    writer: *std.Io.Writer,
-    opts: EncodeUtf8Options,
-) anyerror!void {
-    // We don't currently use self at all. There is an argument that this
-    // function should live on Pin instead but there is some future we might
-    // need state on here so... letting it go.
-    _ = self;
-
-    var page_opts: Page.EncodeUtf8Options = .{
-        .unwrap = opts.unwrap,
-        .cell_map = opts.cell_map,
-    };
-    var iter = opts.tl.pageIterator(.right_down, opts.br);
-    while (iter.next()) |chunk| {
-        const page: *const Page = &chunk.node.data;
-        page_opts.start_y = chunk.start;
-        page_opts.end_y = chunk.end;
-        page_opts.preceding = try page.encodeUtf8(writer, page_opts);
-    }
-}
-
 /// Log a debug diagram of the page list to the provided writer.
 ///
 /// EXAMPLE:
@@ -3857,13 +3813,17 @@ pub fn getBottomRight(self: *const PageList, tag: point.Tag) ?Pin {
         },
 
         .viewport => viewport: {
-            const tl = self.getTopLeft(.viewport);
-            break :viewport tl.down(self.rows - 1).?;
+            var br = self.getTopLeft(.viewport);
+            br = br.down(self.rows - 1).?;
+            br.x = br.node.data.size.cols - 1;
+            break :viewport br;
         },
 
         .history => active: {
-            const tl = self.getTopLeft(.active);
-            break :active tl.up(1);
+            var br = self.getTopLeft(.active);
+            br = br.up(1) orelse return null;
+            br.x = br.node.data.size.cols - 1;
+            break :active br;
         },
     };
 }
diff --git a/src/terminal/Screen.zig b/src/terminal/Screen.zig
@@ -2799,9 +2799,38 @@ pub fn promptPath(
 pub fn dumpString(
     self: *const Screen,
     writer: *std.Io.Writer,
-    opts: PageList.EncodeUtf8Options,
-) anyerror!void {
-    try self.pages.encodeUtf8(writer, opts);
+    opts: struct {
+        /// The start and end points of the dump, both inclusive. The x will
+        /// be ignored and the full row will always be dumped.
+        tl: Pin,
+        br: ?Pin = null,
+
+        /// If true, this will unwrap soft-wrapped lines. If false, this will
+        /// dump the screen as it is visually seen in a rendered window.
+        unwrap: bool = true,
+    },
+) std.Io.Writer.Error!void {
+    // Create a formatter and use that to emit our text.
+    var formatter: ScreenFormatter = .init(self, .{
+        .emit = .plain,
+        .unwrap = opts.unwrap,
+        .trim = false,
+    });
+
+    // Set up the selection based on the pins
+    const tl = opts.tl;
+    const br = opts.br orelse self.pages.getBottomRight(.screen).?;
+
+    formatter.content = .{
+        .selection = Selection.init(
+            tl,
+            br,
+            false, // not rectangle
+        ),
+    };
+
+    // Emit
+    try formatter.format(writer);
 }
 
 /// You should use dumpString, this is a restricted version mostly for
@@ -8916,81 +8945,3 @@ test "Screen: adjustCapacity cursor style exceeds style set capacity" {
     try testing.expect(s.cursor.style.default());
     try testing.expectEqual(style.default_id, s.cursor.style_id);
 }
-
-test "Screen UTF8 cell map with newlines" {
-    const testing = std.testing;
-    const alloc = testing.allocator;
-
-    var s = try Screen.init(alloc, 80, 24, 0);
-    defer s.deinit();
-    try s.testWriteString("A\n\nB\n\nC");
-
-    var cell_map = Page.CellMap.init(alloc);
-    defer cell_map.deinit();
-    var builder: std.Io.Writer.Allocating = .init(alloc);
-    defer builder.deinit();
-    try s.dumpString(&builder.writer, .{
-        .tl = s.pages.getTopLeft(.screen),
-        .br = s.pages.getBottomRight(.screen),
-        .cell_map = &cell_map,
-    });
-
-    try testing.expectEqual(7, builder.written().len);
-    try testing.expectEqualStrings("A\n\nB\n\nC", builder.written());
-    try testing.expectEqual(builder.written().len, cell_map.map.items.len);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 0,
-        .y = 0,
-    }, cell_map.map.items[0]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 1,
-        .y = 0,
-    }, cell_map.map.items[1]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 0,
-        .y = 1,
-    }, cell_map.map.items[2]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 0,
-        .y = 2,
-    }, cell_map.map.items[3]);
-}
-
-test "Screen UTF8 cell map with blank prefix" {
-    const testing = std.testing;
-    const alloc = testing.allocator;
-
-    var s = try Screen.init(alloc, 80, 24, 0);
-    defer s.deinit();
-    s.cursorAbsolute(2, 1);
-    try s.testWriteString("B");
-
-    var cell_map: Page.CellMap = .init(alloc);
-    defer cell_map.deinit();
-    var builder: std.Io.Writer.Allocating = .init(alloc);
-    defer builder.deinit();
-    try s.dumpString(&builder.writer, .{
-        .tl = s.pages.getTopLeft(.screen),
-        .br = s.pages.getBottomRight(.screen),
-        .cell_map = &cell_map,
-    });
-
-    try testing.expectEqualStrings("\n  B", builder.written());
-    try testing.expectEqual(builder.written().len, cell_map.map.items.len);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 0,
-        .y = 0,
-    }, cell_map.map.items[0]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 0,
-        .y = 1,
-    }, cell_map.map.items[1]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 1,
-        .y = 1,
-    }, cell_map.map.items[2]);
-    try testing.expectEqual(Page.CellMapEntry{
-        .x = 2,
-        .y = 1,
-    }, cell_map.map.items[3]);
-}
diff --git a/src/terminal/page.zig b/src/terminal/page.zig
@@ -1501,193 +1501,6 @@ pub const Page = struct {
         return self.grapheme_map.map(self.memory).capacity();
     }
 
-    /// Options for encoding the page as UTF-8.
-    pub const EncodeUtf8Options = struct {
-        /// The range of rows to encode. If end_y is null, then it will
-        /// encode to the end of the page.
-        start_y: size.CellCountInt = 0,
-        end_y: ?size.CellCountInt = null,
-
-        /// If true, this will unwrap soft-wrapped lines. If false, this will
-        /// dump the screen as it is visually seen in a rendered window.
-        unwrap: bool = true,
-
-        /// Preceding state from encoding the prior page. Used to preserve
-        /// blanks properly across multiple pages.
-        preceding: TrailingUtf8State = .{},
-
-        /// If non-null, this will be cleared and filled with the x/y
-        /// coordinates of each byte in the UTF-8 encoded output.
-        /// The index in the array is the byte offset in the output
-        /// where 0 is the cursor of the writer when the function is
-        /// called.
-        cell_map: ?*CellMap = null,
-
-        /// Trailing state for UTF-8 encoding.
-        pub const TrailingUtf8State = struct {
-            rows: usize = 0,
-            cells: usize = 0,
-        };
-    };
-
-    /// See cell_map
-    pub const CellMap = struct {
-        alloc: Allocator,
-        map: std.ArrayList(CellMapEntry),
-
-        pub fn init(alloc: Allocator) CellMap {
-            return .{
-                .alloc = alloc,
-                .map = .empty,
-            };
-        }
-
-        pub fn deinit(self: *CellMap) void {
-            self.map.deinit(self.alloc);
-        }
-    };
-
-    /// The x/y coordinate of a single cell in the cell map.
-    pub const CellMapEntry = struct {
-        y: size.CellCountInt,
-        x: size.CellCountInt,
-    };
-
-    /// Encode the page contents as UTF-8.
-    ///
-    /// If preceding is non-null, then it will be used to initialize our
-    /// blank rows/cells count so that we can accumulate blanks across
-    /// multiple pages.
-    ///
-    /// Note: Many tests for this function are done via Screen.dumpString
-    /// tests since that function is a thin wrapper around this one and
-    /// it makes it easier to test input contents.
-    pub fn encodeUtf8(
-        self: *const Page,
-        writer: *std.Io.Writer,
-        opts: EncodeUtf8Options,
-    ) anyerror!EncodeUtf8Options.TrailingUtf8State {
-        var blank_rows: usize = opts.preceding.rows;
-        var blank_cells: usize = opts.preceding.cells;
-
-        const start_y: size.CellCountInt = opts.start_y;
-        const end_y: size.CellCountInt = opts.end_y orelse self.size.rows;
-
-        // We can probably avoid this by doing the logic below in a different
-        // way. The reason this exists is so that when we end a non-blank
-        // line with a newline, we can correctly map the cell map over to
-        // the correct x value.
-        //
-        // For example "A\nB". The cell map for "\n" should be (1, 0).
-        // This is tested in Screen.zig so feel free to refactor this.
-        var last_x: size.CellCountInt = 0;
-
-        for (start_y..end_y) |y_usize| {
-            const y: size.CellCountInt = @intCast(y_usize);
-            const row: *Row = self.getRow(y);
-            const cells: []const Cell = self.getCells(row);
-
-            // If this row is blank, accumulate to avoid a bunch of extra
-            // work later. If it isn't blank, make sure we dump all our
-            // blanks.
-            if (!Cell.hasTextAny(cells)) {
-                blank_rows += 1;
-                continue;
-            }
-            for (1..blank_rows + 1) |i| {
-                try writer.writeByte('\n');
-
-                // This is tested in Screen.zig, i.e. one test is
-                // "cell map with newlines"
-                if (opts.cell_map) |cell_map| {
-                    try cell_map.map.append(cell_map.alloc, .{
-                        .x = last_x,
-                        .y = @intCast(y - blank_rows + i - 1),
-                    });
-                    last_x = 0;
-                }
-            }
-            blank_rows = 0;
-
-            // If we're not wrapped, we always add a newline so after
-            // the row is printed we can add a newline.
-            if (!row.wrap or !opts.unwrap) blank_rows += 1;
-
-            // If the row doesn't continue a wrap then we need to reset
-            // our blank cell count.
-            if (!row.wrap_continuation or !opts.unwrap) blank_cells = 0;
-
-            // Go through each cell and print it
-            for (cells, 0..) |*cell, x_usize| {
-                const x: size.CellCountInt = @intCast(x_usize);
-
-                // Skip spacers
-                switch (cell.wide) {
-                    .narrow, .wide => {},
-                    .spacer_head, .spacer_tail => continue,
-                }
-
-                // If we have a zero value, then we accumulate a counter. We
-                // only want to turn zero values into spaces if we have a non-zero
-                // char sometime later.
-                if (!cell.hasText()) {
-                    blank_cells += 1;
-                    continue;
-                }
-                if (blank_cells > 0) {
-                    try writer.splatByteAll(' ', blank_cells);
-                    if (opts.cell_map) |cell_map| {
-                        for (0..blank_cells) |i| try cell_map.map.append(cell_map.alloc, .{
-                            .x = @intCast(x - blank_cells + i),
-                            .y = y,
-                        });
-                    }
-
-                    blank_cells = 0;
-                }
-
-                switch (cell.content_tag) {
-                    .codepoint => {
-                        try writer.print("{u}", .{cell.content.codepoint});
-                        if (opts.cell_map) |cell_map| {
-                            last_x = x + 1;
-                            try cell_map.map.append(cell_map.alloc, .{
-                                .x = x,
-                                .y = y,
-                            });
-                        }
-                    },
-
-                    .codepoint_grapheme => {
-                        try writer.print("{u}", .{cell.content.codepoint});
-                        if (opts.cell_map) |cell_map| {
-                            last_x = x + 1;
-                            try cell_map.map.append(cell_map.alloc, .{
-                                .x = x,
-                                .y = y,
-                            });
-                        }
-
-                        for (self.lookupGrapheme(cell).?) |cp| {
-                            try writer.print("{u}", .{cp});
-                            if (opts.cell_map) |cell_map| try cell_map.map.append(cell_map.alloc, .{
-                                .x = x,
-                                .y = y,
-                            });
-                        }
-                    },
-
-                    // Unreachable since we do hasText() above
-                    .bg_color_palette,
-                    .bg_color_rgb,
-                    => unreachable,
-                }
-            }
-        }
-
-        return .{ .rows = blank_rows, .cells = blank_cells };
-    }
-
     /// Returns the bitset for the dirty bits on this page.
     ///
     /// The returned value is a DynamicBitSetUnmanaged but it is NOT
diff --git a/src/terminal/search.zig b/src/terminal/search.zig
