@fairyhunter13/opentui-core 0.1.113 → 0.1.114

package/src/zig/tests/rope-nested_test.zig

@@ -0,0 +1,712 @@
+const std = @import("std");
+const rope_mod = @import("../rope.zig");
+
+// NOTE: This is not strictly necessary to be supported as it is not used this way in the codebase.
+// It can be removed if the rope needs to change in a way that would break this behavior.
+
+const Chunk = struct {
+    data: []const u8,
+    width: u32,
+
+    pub const Metrics = struct {
+        total_width: u32 = 0,
+        total_bytes: u32 = 0,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_width += other.total_width;
+            self.total_bytes += other.total_bytes;
+        }
+    };
+
+    pub fn measure(self: *const Chunk) Metrics {
+        return .{
+            .total_width = self.width,
+            .total_bytes = @intCast(self.data.len),
+        };
+    }
+
+    pub fn empty() Chunk {
+        return .{ .data = "", .width = 0 };
+    }
+
+    pub fn is_empty(self: *const Chunk) bool {
+        return self.data.len == 0;
+    }
+};
+
+// Static empty chunk rope node for Line.empty()
+const empty_chunk_leaf_node = rope_mod.Rope(Chunk).Node{
+    .leaf = .{
+        .data = Chunk.empty(),
+    },
+};
+
+// Line type containing a rope of chunks
+const Line = struct {
+    chunks: rope_mod.Rope(Chunk),
+    line_id: u32,
+
+    pub const Metrics = struct {
+        total_width: u32 = 0,
+        total_lines: u32 = 1,
+
+        pub fn add(self: *Metrics, other: Metrics) void {
+            self.total_width += other.total_width;
+            self.total_lines += other.total_lines;
+        }
+    };
+
+    pub fn measure(self: *const Line) Metrics {
+        const chunk_metrics = self.chunks.root.metrics();
+        return .{
+            .total_width = chunk_metrics.custom.total_width,
+            .total_lines = 1,
+        };
+    }
+
+    pub fn empty() Line {
+        // Use static empty chunk rope - safe because it's immutable
+        const ChunkRope = rope_mod.Rope(Chunk);
+        return .{
+            .chunks = .{
+                .root = &empty_chunk_leaf_node,
+                .allocator = undefined, // Never used for empty
+                .empty_leaf = &empty_chunk_leaf_node,
+                .marker_cache = ChunkRope.MarkerCache.init(undefined),
+            },
+            .line_id = 0,
+        };
+    }
+
+    pub fn is_empty(self: *const Line) bool {
+        return self.line_id == 0 and self.chunks.count() == 1;
+    }
+};
+
+test "Nested Rope - create line with chunks" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks = [_]Chunk{
+        .{ .data = "Hello ", .width = 6 },
+        .{ .data = "World", .width = 5 },
+    };
+
+    const chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
+
+    const line = Line{
+        .chunks = chunk_rope,
+        .line_id = 1,
+    };
+
+    try std.testing.expectEqual(@as(u32, 2), line.chunks.count());
+    try std.testing.expectEqualStrings("Hello ", line.chunks.get(0).?.data);
+    try std.testing.expectEqualStrings("World", line.chunks.get(1).?.data);
+
+    const metrics = line.measure();
+    try std.testing.expectEqual(@as(u32, 11), metrics.total_width); // 6 + 5
+}
+
+test "Nested Rope - rope of lines with chunks" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{
+        .{ .data = "Line ", .width = 5 },
+        .{ .data = "One", .width = 3 },
+    };
+    const line1 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
+        .line_id = 1,
+    };
+
+    const chunks2 = [_]Chunk{
+        .{ .data = "Line ", .width = 5 },
+        .{ .data = "Two", .width = 3 },
+    };
+    const line2 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
+        .line_id = 2,
+    };
+
+    const lines = [_]Line{ line1, line2 };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
+
+    // Access nested data
+    const first_line = line_rope.get(0).?;
+    try std.testing.expectEqual(@as(u32, 1), first_line.line_id);
+    try std.testing.expectEqual(@as(u32, 2), first_line.chunks.count());
+    try std.testing.expectEqualStrings("Line ", first_line.chunks.get(0).?.data);
+
+    const second_line = line_rope.get(1).?;
+    try std.testing.expectEqual(@as(u32, 2), second_line.line_id);
+    try std.testing.expectEqualStrings("Two", second_line.chunks.get(1).?.data);
+}
+
+test "Nested Rope - insert chunk into line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks = [_]Chunk{
+        .{ .data = "Hello ", .width = 6 },
+        .{ .data = "World", .width = 5 },
+    };
+    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
+
+    try chunk_rope.insert(1, .{ .data = "Beautiful ", .width = 10 });
+
+    try std.testing.expectEqual(@as(u32, 3), chunk_rope.count());
+    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
+    try std.testing.expectEqualStrings("Beautiful ", chunk_rope.get(1).?.data);
+    try std.testing.expectEqualStrings("World", chunk_rope.get(2).?.data);
+
+    const metrics = chunk_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 21), metrics.custom.total_width); // 6 + 10 + 5
+}
+
+test "Nested Rope - delete chunk from line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks = [_]Chunk{
+        .{ .data = "A ", .width = 2 },
+        .{ .data = "B ", .width = 2 },
+        .{ .data = "C", .width = 1 },
+    };
+    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks);
+
+    try chunk_rope.delete(1);
+
+    try std.testing.expectEqual(@as(u32, 2), chunk_rope.count());
+    try std.testing.expectEqualStrings("A ", chunk_rope.get(0).?.data);
+    try std.testing.expectEqualStrings("C", chunk_rope.get(1).?.data);
+
+    const metrics = chunk_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 3), metrics.custom.total_width); // 2 + 1
+}
+
+test "Nested Rope - walk through lines and chunks" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{.{ .data = "Line1", .width = 5 }};
+    const chunks2 = [_]Chunk{.{ .data = "Line2", .width = 5 }};
+    const chunks3 = [_]Chunk{.{ .data = "Line3", .width = 5 }};
+
+    const lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
+    };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    const LineContext = struct {
+        total_lines: u32 = 0,
+        total_width: u32 = 0,
+
+        fn walker(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
+            _ = index;
+            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
+            self.total_lines += 1;
+
+            const metrics = line.chunks.root.metrics();
+            self.total_width += metrics.custom.total_width;
+            return .{};
+        }
+    };
+
+    var ctx = LineContext{};
+    try line_rope.walk(&ctx, LineContext.walker);
+
+    try std.testing.expectEqual(@as(u32, 3), ctx.total_lines);
+    try std.testing.expectEqual(@as(u32, 15), ctx.total_width); // 5 + 5 + 5
+}
+
+test "Nested Rope - complex line and chunk operations" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{
+        .{ .data = "First ", .width = 6 },
+        .{ .data = "line", .width = 4 },
+    };
+    const line1 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
+        .line_id = 1,
+    };
+
+    var line_rope = try rope_mod.Rope(Line).from_item(allocator, line1);
+
+    const chunks2 = [_]Chunk{.{ .data = "Second line", .width = 11 }};
+    const line2 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
+        .line_id = 2,
+    };
+    try line_rope.append(line2);
+
+    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
+
+    // Access specific chunk in specific line
+    const first_line = line_rope.get(0).?;
+    try std.testing.expectEqual(@as(u32, 2), first_line.chunks.count());
+    try std.testing.expectEqualStrings("First ", first_line.chunks.get(0).?.data);
+
+    const metrics = line_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 2), metrics.count);
+}
+
+test "Nested Rope - metrics propagate through all levels" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{
+        .{ .data = "abc", .width = 3 },
+        .{ .data = "def", .width = 3 },
+    };
+    const chunks2 = [_]Chunk{
+        .{ .data = "12345", .width = 5 },
+    };
+    const chunks3 = [_]Chunk{
+        .{ .data = "x", .width = 1 },
+        .{ .data = "y", .width = 1 },
+        .{ .data = "z", .width = 1 },
+    };
+
+    const lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
+    };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    const line_metrics = line_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 3), line_metrics.count);
+
+    const line1 = line_rope.get(0).?;
+    const line1_metrics = line1.measure();
+    try std.testing.expectEqual(@as(u32, 6), line1_metrics.total_width); // 3 + 3
+
+    const line2 = line_rope.get(1).?;
+    const line2_metrics = line2.measure();
+    try std.testing.expectEqual(@as(u32, 5), line2_metrics.total_width);
+
+    const line3 = line_rope.get(2).?;
+    const line3_metrics = line3.measure();
+    try std.testing.expectEqual(@as(u32, 3), line3_metrics.total_width); // 1 + 1 + 1
+}
+
+test "Nested Rope - simulate text buffer edit: insert within line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const initial_chunks = [_]Chunk{
+        .{ .data = "Hello ", .width = 6 },
+        .{ .data = "World", .width = 5 },
+    };
+    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
+
+    try chunk_rope.insert(1, .{ .data = "Beautiful ", .width = 10 });
+
+    try std.testing.expectEqual(@as(u32, 3), chunk_rope.count());
+
+    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
+    try std.testing.expectEqualStrings("Beautiful ", chunk_rope.get(1).?.data);
+    try std.testing.expectEqualStrings("World", chunk_rope.get(2).?.data);
+
+    const metrics = chunk_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 21), metrics.custom.total_width);
+}
+
+test "Nested Rope - simulate text buffer edit: delete within line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const initial_chunks = [_]Chunk{
+        .{ .data = "Hello ", .width = 6 },
+        .{ .data = "Beautiful ", .width = 10 },
+        .{ .data = "World", .width = 5 },
+    };
+    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
+
+    try chunk_rope.delete(1);
+
+    try std.testing.expectEqual(@as(u32, 2), chunk_rope.count());
+    try std.testing.expectEqualStrings("Hello ", chunk_rope.get(0).?.data);
+    try std.testing.expectEqualStrings("World", chunk_rope.get(1).?.data);
+
+    const metrics = chunk_rope.root.metrics();
+    try std.testing.expectEqual(@as(u32, 11), metrics.custom.total_width);
+}
+
+test "Nested Rope - insert line into document" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{.{ .data = "Line 1", .width = 6 }};
+    const chunks3 = [_]Chunk{.{ .data = "Line 3", .width = 6 }};
+
+    const initial_lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
+    };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &initial_lines);
+
+    const chunks2 = [_]Chunk{.{ .data = "Line 2", .width = 6 }};
+    const line2 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
+        .line_id = 2,
+    };
+    try line_rope.insert(1, line2);
+
+    try std.testing.expectEqual(@as(u32, 3), line_rope.count());
+    try std.testing.expectEqual(@as(u32, 1), line_rope.get(0).?.line_id);
+    try std.testing.expectEqual(@as(u32, 2), line_rope.get(1).?.line_id);
+    try std.testing.expectEqual(@as(u32, 3), line_rope.get(2).?.line_id);
+}
+
+test "Nested Rope - delete line from document" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{.{ .data = "Line 1", .width = 6 }};
+    const chunks2 = [_]Chunk{.{ .data = "Line 2", .width = 6 }};
+    const chunks3 = [_]Chunk{.{ .data = "Line 3", .width = 6 }};
+
+    const lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks3), .line_id = 3 },
+    };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    try line_rope.delete(1);
+
+    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
+    try std.testing.expectEqual(@as(u32, 1), line_rope.get(0).?.line_id);
+    try std.testing.expectEqual(@as(u32, 3), line_rope.get(1).?.line_id);
+}
+
+test "Nested Rope - modify chunks within a specific line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const initial_chunks = [_]Chunk{
+        .{ .data = "Hello", .width = 5 },
+    };
+    var chunk_rope = try rope_mod.Rope(Chunk).from_slice(allocator, &initial_chunks);
+
+    try chunk_rope.insert(1, .{ .data = " World", .width = 6 });
+
+    const line = Line{
+        .chunks = chunk_rope,
+        .line_id = 1,
+    };
+
+    const lines = [_]Line{line};
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    const retrieved_line = line_rope.get(0).?;
+    try std.testing.expectEqual(@as(u32, 2), retrieved_line.chunks.count());
+    try std.testing.expectEqualStrings("Hello", retrieved_line.chunks.get(0).?.data);
+    try std.testing.expectEqualStrings(" World", retrieved_line.chunks.get(1).?.data);
+
+    const line_metrics = retrieved_line.measure();
+    try std.testing.expectEqual(@as(u32, 11), line_metrics.total_width);
+}
+
+test "Nested Rope - walk all chunks in all lines" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{
+        .{ .data = "A", .width = 1 },
+        .{ .data = "B", .width = 1 },
+    };
+    const chunks2 = [_]Chunk{
+        .{ .data = "C", .width = 1 },
+        .{ .data = "D", .width = 1 },
+        .{ .data = "E", .width = 1 },
+    };
+
+    const lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
+    };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    var total_chunks: u32 = 0;
+    var total_bytes: u32 = 0;
+
+    const LineWalker = struct {
+        fn walk(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
+            _ = index;
+            const counters = @as(*[2]u32, @ptrCast(@alignCast(ctx)));
+
+            // Count chunks in this line
+            const ChunkWalker = struct {
+                fn walk(chunk_ctx: *anyopaque, chunk: *const Chunk, chunk_idx: u32) rope_mod.Rope(Chunk).Node.WalkerResult {
+                    _ = chunk_idx;
+                    const chunk_counters = @as(*[2]u32, @ptrCast(@alignCast(chunk_ctx)));
+                    chunk_counters[0] += 1; // total_chunks
+                    chunk_counters[1] += @intCast(chunk.data.len); // total_bytes
+                    return .{};
+                }
+            };
+
+            line.chunks.walk(counters, ChunkWalker.walk) catch {};
+            return .{};
+        }
+    };
+
+    var counters = [2]u32{ total_chunks, total_bytes };
+    try line_rope.walk(&counters, LineWalker.walk);
+    total_chunks = counters[0];
+    total_bytes = counters[1];
+
+    try std.testing.expectEqual(@as(u32, 5), total_chunks); // 2 + 3
+    try std.testing.expectEqual(@as(u32, 5), total_bytes); // All single char chunks
+}
+
+test "Nested Rope - simulate full text buffer workflow" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const chunks1 = [_]Chunk{
+        .{ .data = "Hello ", .width = 6 },
+        .{ .data = "World", .width = 5 },
+    };
+    const line1 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1),
+        .line_id = 1,
+    };
+
+    var document = try rope_mod.Rope(Line).from_item(allocator, line1);
+
+    const chunks2 = [_]Chunk{.{ .data = "Goodbye", .width = 7 }};
+    const line2 = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2),
+        .line_id = 2,
+    };
+    try document.append(line2);
+
+    try std.testing.expectEqual(@as(u32, 2), document.count());
+
+    const retrieved_line1 = document.get(0).?;
+    try std.testing.expectEqual(@as(u32, 2), retrieved_line1.chunks.count());
+
+    const retrieved_line2 = document.get(1).?;
+    try std.testing.expectEqual(@as(u32, 1), retrieved_line2.chunks.count());
+
+    var modified_chunks = retrieved_line1.chunks;
+    try modified_chunks.insert(1, .{ .data = "Beautiful ", .width = 10 });
+
+    const modified_line = Line{
+        .chunks = modified_chunks,
+        .line_id = 1,
+    };
+
+    // Note: In a real text buffer, you'd replace the line in the document
+    // For now, just verify the modified line has the new chunk
+    try std.testing.expectEqual(@as(u32, 3), modified_line.chunks.count());
+    try std.testing.expectEqualStrings("Beautiful ", modified_line.chunks.get(1).?.data);
+}
+
+test "Nested Rope - empty lines with no chunks" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const empty_chunks: []const Chunk = &[_]Chunk{};
+    const empty_line = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, empty_chunks),
+        .line_id = 1,
+    };
+
+    const chunks = [_]Chunk{.{ .data = "Content", .width = 7 }};
+    const content_line = Line{
+        .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks),
+        .line_id = 2,
+    };
+
+    const lines = [_]Line{ empty_line, content_line };
+    var line_rope = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    try std.testing.expectEqual(@as(u32, 2), line_rope.count());
+
+    const empty = line_rope.get(0).?;
+    try std.testing.expectEqual(@as(u32, 0), empty.chunks.count());
+
+    const content = line_rope.get(1).?;
+    try std.testing.expectEqual(@as(u32, 1), content.chunks.count());
+    try std.testing.expectEqualStrings("Content", content.chunks.get(0).?.data);
+}
+
+test "Nested Rope - large document with many lines and chunks" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var lines_array: [20]Line = undefined;
+    for (&lines_array, 0..) |*line, line_idx| {
+        var chunks_array: [3]Chunk = undefined;
+        for (&chunks_array, 0..) |*chunk, chunk_idx| {
+            chunk.* = .{
+                .data = "X",
+                .width = 1,
+            };
+            _ = chunk_idx;
+        }
+        line.* = Line{
+            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks_array),
+            .line_id = @intCast(line_idx),
+        };
+    }
+
+    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
+
+    try std.testing.expectEqual(@as(u32, 20), document.count());
+
+    const line_5 = document.get(5).?;
+    try std.testing.expectEqual(@as(u32, 5), line_5.line_id);
+    try std.testing.expectEqual(@as(u32, 3), line_5.chunks.count());
+
+    const line_15 = document.get(15).?;
+    try std.testing.expectEqual(@as(u32, 15), line_15.line_id);
+
+    try std.testing.expectEqualStrings("X", line_5.chunks.get(0).?.data);
+}
+
+test "Nested Rope - walk_from specific line" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var lines_array: [5]Line = undefined;
+    for (&lines_array, 0..) |*line, i| {
+        const chunks = [_]Chunk{.{ .data = "X", .width = 1 }};
+        line.* = Line{
+            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks),
+            .line_id = @intCast(i),
+        };
+    }
+    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
+
+    const Context = struct {
+        count: u32 = 0,
+        first_id: ?u32 = null,
+
+        fn walker(ctx: *anyopaque, line: *const Line, index: u32) rope_mod.Rope(Line).Node.WalkerResult {
+            _ = index;
+            const self = @as(*@This(), @ptrCast(@alignCast(ctx)));
+            if (self.first_id == null) {
+                self.first_id = line.line_id;
+            }
+            self.count += 1;
+            return .{};
+        }
+    };
+
+    var ctx = Context{};
+    try document.walk_from(3, &ctx, Context.walker);
+
+    // Should walk lines 3 and 4 (indices 3 and 4)
+    try std.testing.expectEqual(@as(u32, 2), ctx.count);
+    try std.testing.expectEqual(@as(u32, 3), ctx.first_id.?);
+}
+
+test "Nested Rope - metrics aggregate correctly through all levels" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // Line 1: 3 chunks, total width 10
+    const chunks1 = [_]Chunk{
+        .{ .data = "abc", .width = 3 },
+        .{ .data = "def", .width = 3 },
+        .{ .data = "ghij", .width = 4 },
+    };
+
+    // Line 2: 2 chunks, total width 15
+    const chunks2 = [_]Chunk{
+        .{ .data = "12345", .width = 5 },
+        .{ .data = "6789012345", .width = 10 },
+    };
+
+    const lines = [_]Line{
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks1), .line_id = 1 },
+        .{ .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks2), .line_id = 2 },
+    };
+    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines);
+
+    const line1 = document.get(0).?;
+    const chunk_metrics1 = line1.chunks.root.metrics();
+    try std.testing.expectEqual(@as(u32, 3), chunk_metrics1.count);
+    try std.testing.expectEqual(@as(u32, 10), chunk_metrics1.custom.total_width);
+    try std.testing.expectEqual(@as(u32, 10), chunk_metrics1.custom.total_bytes);
+
+    const line2 = document.get(1).?;
+    const chunk_metrics2 = line2.chunks.root.metrics();
+    try std.testing.expectEqual(@as(u32, 2), chunk_metrics2.count);
+    try std.testing.expectEqual(@as(u32, 15), chunk_metrics2.custom.total_width);
+    try std.testing.expectEqual(@as(u32, 15), chunk_metrics2.custom.total_bytes);
+
+    const line1_metrics = line1.measure();
+    try std.testing.expectEqual(@as(u32, 10), line1_metrics.total_width);
+
+    const doc_metrics = document.root.metrics();
+    try std.testing.expectEqual(@as(u32, 2), doc_metrics.count); // 2 lines
+}
+
+test "Nested Rope - O(log n) access to deeply nested data" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var lines_array: [100]Line = undefined;
+    for (&lines_array, 0..) |*line, line_idx| {
+        var chunks_array: [5]Chunk = undefined;
+        for (&chunks_array, 0..) |*chunk, chunk_idx| {
+            chunk.* = .{
+                .data = "c",
+                .width = 1,
+            };
+            _ = chunk_idx;
+        }
+        line.* = Line{
+            .chunks = try rope_mod.Rope(Chunk).from_slice(allocator, &chunks_array),
+            .line_id = @intCast(line_idx),
+        };
+    }
+
+    var document = try rope_mod.Rope(Line).from_slice(allocator, &lines_array);
+
+    // Access line 50, chunk 3 (deep in the tree)
+    // This tests O(log lines) + O(log chunks) access
+    const line_50 = document.get(50).?;
+    try std.testing.expectEqual(@as(u32, 50), line_50.line_id);
+
+    const chunk_3 = line_50.chunks.get(3).?;
+    try std.testing.expectEqualStrings("c", chunk_3.data);
+
+    const doc_depth = document.root.depth();
+    try std.testing.expect(doc_depth < 20); // log2(100) ≈ 7, with some buffer
+
+    const line_depth = line_50.chunks.root.depth();
+    try std.testing.expect(line_depth < 10); // log2(5) ≈ 3, with buffer
+}