@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/zig/tests/word-wrap-editing_test.zig

@@ -0,0 +1,498 @@
+const std = @import("std");
+const edit_buffer = @import("../edit-buffer.zig");
+const text_buffer_view = @import("../text-buffer-view.zig");
+const gp = @import("../grapheme.zig");
+const link = @import("../link.zig");
+
+const EditBuffer = edit_buffer.EditBuffer;
+const TextBufferView = text_buffer_view.TextBufferView;
+
+test "Word wrap - editing around wrap boundary creates correct wrap" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good");
+
+    const vlines1 = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines1.len);
+
+    try eb.setCursor(0, 13);
+    try eb.insertText(" friend");
+
+    const vlines2 = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines2.len);
+
+    try std.testing.expectEqual(@as(u32, 14), vlines2[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines2[1].width_cols);
+}
+
+test "Word wrap - backspace and retype near boundary" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good friend");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try eb.setCursor(0, 20);
+    var i: usize = 0;
+    while (i < 7) : (i += 1) {
+        try eb.backspace();
+    }
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText(" friend");
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines[1].width_cols);
+}
+
+test "Word wrap - type character by character near boundary" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good ");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.setCursor(0, 14);
+    try eb.insertText("f");
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("r");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("i");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("e");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("n");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try eb.insertText("d");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try eb.insertText(" ");
+    vlines = view.getVirtualLines();
+
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 7), vlines[1].width_cols);
+}
+
+test "Word wrap - insert word in middle causes rewrap" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(20);
+
+    try eb.setText("hello friend");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.setCursor(0, 6);
+    try eb.insertText("my good ");
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+}
+
+test "Word wrap - delete word causes rewrap" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good friend buddy");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expect(vlines.len >= 2);
+
+    try eb.setCursor(0, 6);
+    var i: usize = 0;
+    while (i < 8) : (i += 1) {
+        try eb.deleteForward();
+    }
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+}
+
+test "Word wrap - rapid edits maintain correct wrapping" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my ");
+    try eb.setCursor(0, 9);
+    try eb.insertText("g");
+    try eb.insertText("o");
+    try eb.insertText("o");
+    try eb.insertText("d");
+    try eb.insertText(" ");
+    try eb.insertText("f");
+    try eb.insertText("r");
+    try eb.insertText("i");
+    try eb.insertText("e");
+    try eb.insertText("n");
+    try eb.insertText("d");
+
+    const vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines[1].width_cols);
+}
+
+test "Word wrap - fragmented at exact word boundary" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello ");
+    try eb.setCursor(0, 6);
+    try eb.insertText("my ");
+    try eb.insertText("good ");
+    try eb.insertText("friend");
+
+    const vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines[1].width_cols);
+}
+
+test "Word wrap - stale rollback state after newline with EditBuffer inserts" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(3);
+
+    try eb.setText("a\n好");
+
+    try eb.setCursor(0, 1);
+    try eb.insertText(" b");
+
+    try eb.setCursor(1, 2);
+    try eb.insertText("界");
+
+    var plain_text: [32]u8 = undefined;
+    const plain_text_len = view.getPlainTextIntoBuffer(&plain_text);
+    try std.testing.expectEqualStrings("a b\n好界", plain_text[0..plain_text_len]);
+
+    const vlines = view.getVirtualLines();
+
+    try std.testing.expectEqual(@as(usize, 3), vlines.len);
+    try std.testing.expectEqual(@as(u32, 3), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 2), vlines[1].width_cols);
+    try std.testing.expectEqual(@as(u32, 2), vlines[2].width_cols);
+    try std.testing.expectEqual(@as(u32, 0), vlines[0].source_line);
+    try std.testing.expectEqual(@as(u32, 1), vlines[1].source_line);
+    try std.testing.expectEqual(@as(u32, 1), vlines[2].source_line);
+}
+
+test "Word wrap - chunk boundary at start of word" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good ");
+    try eb.setCursor(0, 14);
+
+    try eb.insertText("f");
+
+    try eb.backspace();
+    try eb.insertText("friend");
+
+    const vlines = view.getVirtualLines();
+
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines[1].width_cols);
+}
+
+test "Word wrap - multiple edits create complex fragmentation" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(20);
+
+    try eb.setText("hello ");
+    try eb.setCursor(0, 6);
+    try eb.insertText("w");
+    try eb.backspace();
+    try eb.insertText("m");
+    try eb.insertText("y");
+    try eb.insertText(" ");
+    try eb.insertText("g");
+    try eb.insertText("o");
+    try eb.backspace();
+    try eb.insertText("o");
+    try eb.insertText("o");
+    try eb.insertText("d");
+    try eb.insertText(" ");
+    try eb.insertText("x");
+    try eb.backspace();
+    try eb.insertText("f");
+    try eb.insertText("r");
+    try eb.insertText("iend");
+
+    const vlines = view.getVirtualLines();
+
+    var buffer: [100]u8 = undefined;
+    const len = view.getPlainTextIntoBuffer(&buffer);
+    try std.testing.expectEqualStrings("hello my good friend", buffer[0..len]);
+
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+}
+
+test "Word wrap - insert at wrap boundary with existing wrap" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(15);
+
+    try eb.setText("hello world test");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expect(vlines.len >= 2);
+
+    try eb.setCursor(0, 11);
+    try eb.insertText("s");
+
+    vlines = view.getVirtualLines();
+
+    try std.testing.expect(vlines.len >= 2);
+
+    for (vlines) |vline| {
+        try std.testing.expect(vline.width_cols <= 15);
+    }
+}
+
+test "Word wrap - word at exact wrap width" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(20);
+
+    try eb.setText("12345678901234567890");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.setCursor(0, 20);
+    try eb.insertText(" word");
+
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+    try std.testing.expectEqual(@as(u32, 20), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 5), vlines[1].width_cols);
+}
+
+test "Word wrap - debug virtual line contents" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good ");
+    try eb.setCursor(0, 14);
+    try eb.insertText("f");
+    try eb.backspace();
+    try eb.insertText("friend");
+
+    const vlines = view.getVirtualLines();
+
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+}
+
+test "Word wrap - incremental character edits near boundary" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var eb = try EditBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer eb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, eb.getTextBuffer());
+    defer view.deinit();
+
+    view.setWrapMode(.word);
+    view.setWrapWidth(18);
+
+    try eb.setText("hello my good ");
+
+    var vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.setCursor(0, 14);
+    try eb.insertText("f");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("r");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("i");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("e");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 1), vlines.len);
+
+    try eb.insertText("n");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try eb.insertText("d");
+    vlines = view.getVirtualLines();
+    try std.testing.expectEqual(@as(usize, 2), vlines.len);
+
+    try std.testing.expectEqual(@as(u32, 14), vlines[0].width_cols);
+    try std.testing.expectEqual(@as(u32, 6), vlines[1].width_cols);
+}

package/src/zig/tests/wrap-cache-perf_test.zig

@@ -0,0 +1,113 @@
+const std = @import("std");
+const text_buffer = @import("../text-buffer.zig");
+const text_buffer_view = @import("../text-buffer-view.zig");
+const gp = @import("../grapheme.zig");
+const link = @import("../link.zig");
+
+const TextBuffer = text_buffer.UnifiedTextBuffer;
+const TextBufferView = text_buffer_view.UnifiedTextBufferView;
+
+test "word wrap complexity - width changes are O(n)" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    const size: usize = 100_000;
+
+    const text = try std.testing.allocator.alloc(u8, size);
+    defer std.testing.allocator.free(text);
+    @memset(text, 'x');
+
+    var tb = try TextBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer tb.deinit();
+    try tb.setText(text);
+
+    var view = try TextBufferView.init(std.testing.allocator, tb);
+    defer view.deinit();
+    view.setWrapMode(.word);
+
+    const widths = [_]u32{ 60, 70, 80, 90, 100 };
+
+    // Run multiple iterations and use median to reduce noise from CI variability
+    const iterations = 5;
+    var median_times: [widths.len]u64 = undefined;
+
+    for (widths, 0..) |width, width_idx| {
+        var iter_times: [iterations]u64 = undefined;
+
+        for (0..iterations) |iter| {
+            // Reset cache by setting a different width first
+            view.setWrapWidth(50);
+            _ = view.getVirtualLineCount();
+
+            view.setWrapWidth(width);
+            var timer = std.time.Timer.start() catch unreachable;
+            _ = view.getVirtualLineCount();
+            iter_times[iter] = timer.read();
+        }
+
+        // Sort and take median
+        std.mem.sort(u64, &iter_times, {}, std.sort.asc(u64));
+        median_times[width_idx] = iter_times[iterations / 2];
+    }
+
+    var min_time: u64 = std.math.maxInt(u64);
+    var max_time: u64 = 0;
+    for (median_times) |t| {
+        min_time = @min(min_time, t);
+        max_time = @max(max_time, t);
+    }
+
+    const ratio = @as(f64, @floatFromInt(max_time)) / @as(f64, @floatFromInt(min_time));
+
+    // All times should be roughly similar since text size is constant.
+    // Use a generous threshold (5x) to account for CI runner variability.
+    try std.testing.expect(ratio < 5.0);
+}
+
+test "word wrap - virtual line count correctness" {
+    const pool = gp.initGlobalPool(std.testing.allocator);
+    defer gp.deinitGlobalPool();
+    const link_pool = link.initGlobalLinkPool(std.testing.allocator);
+    defer link.deinitGlobalLinkPool();
+
+    var tb = try TextBuffer.init(std.testing.allocator, pool, link_pool, .wcwidth);
+    defer tb.deinit();
+
+    var view = try TextBufferView.init(std.testing.allocator, tb);
+    defer view.deinit();
+
+    const pattern = "var abc=123;function foo(){return bar+baz;}if(x>0){y=z*2;}else{y=0;}";
+    const size = 10_000;
+    var text = try std.testing.allocator.alloc(u8, size);
+    defer std.testing.allocator.free(text);
+
+    var i: usize = 0;
+    while (i < size) {
+        const remaining = size - i;
+        const copy_len = @min(pattern.len, remaining);
+        @memcpy(text[i .. i + copy_len], pattern[0..copy_len]);
+        i += copy_len;
+    }
+
+    try tb.setText(text);
+    view.setWrapMode(.word);
+
+    view.setWrapWidth(80);
+    const count_80 = view.getVirtualLineCount();
+
+    view.setWrapWidth(100);
+    const count_100 = view.getVirtualLineCount();
+
+    view.setWrapWidth(60);
+    const count_60 = view.getVirtualLineCount();
+
+    view.setWrapWidth(80);
+    const count_80_again = view.getVirtualLineCount();
+
+    try std.testing.expect(count_80 > 100);
+    try std.testing.expectEqual(count_80, count_80_again);
+    try std.testing.expect(count_100 < count_80);
+    try std.testing.expect(count_60 > count_80);
+}