Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Keep textarea cursors and rendering inside the viewport (#37166)

Charlie Marshad6e48ddd35a
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_final_line_scrolls_to_visible_cursor_row.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_final_line_scrolls_to_visible_cursor_row.snap
new file mode 100644
index 0000000000..2e7df724b4
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_final_line_scrolls_to_visible_cursor_row.snap
@@ -0,0 +1,8 @@
+---
+source: tui/src/bottom_pane/textarea.rs
+expression: "format!(\"scroll: {}\\ncursor: {:?}\\n{}\", state.scroll,\nt.cursor_pos_with_state(area, state), terminal.backend())"
+---
+scroll: 1
+cursor: Some((0, 1))
+"efgh"
+" "
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_non_final_line_has_a_visible_cursor_row.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_non_final_line_has_a_visible_cursor_row.snap
new file mode 100644
index 0000000000..1984373cbf
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_full_non_final_line_has_a_visible_cursor_row.snap
@@ -0,0 +1,8 @@
+---
+source: tui/src/bottom_pane/textarea.rs
+expression: "format!(\"cursor: {:?}\\n{}\", t.cursor_pos(area), terminal.backend())"
+---
+cursor: Some((0, 1))
+"abad"
+" "
+"ef "
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_halfwidth_sound_marks_wrap_and_align_with_cursor.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_halfwidth_sound_marks_wrap_and_align_with_cursor.snap
index 7ea4a38fba..403d087188 100644
--- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_halfwidth_sound_marks_wrap_and_align_with_cursor.snap
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_halfwidth_sound_marks_wrap_and_align_with_cursor.snap
@@ -1,6 +1,6 @@
---
source: tui/src/bottom_pane/textarea.rs
-expression: "format!(\"dakuten\\n{dakuten}\\n\\nhandakuten\\n{handakuten}\\n\\nstandalone\\n{standalone}\")"
+expression: "snapshots.join(\"\\n\\n\")"
---
dakuten
cursor: Some((1, 1))
@@ -9,12 +9,14 @@ cursor: Some((1, 1))
handakuten
-cursor: Some((3, 1))
+cursor: Some((0, 2))
"ab "
"パc" Hidden by multi-width symbols: [(1, " ")]
+" "
standalone
-cursor: Some((2, 1))
+cursor: Some((0, 2))
"a "
"゙b"
+" "
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_masked_graphemes_align_with_cursor.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_masked_graphemes_align_with_cursor.snap
index b82038f930..2b3b4ec43e 100644
--- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_masked_graphemes_align_with_cursor.snap
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_masked_graphemes_align_with_cursor.snap
@@ -2,5 +2,6 @@
source: tui/src/bottom_pane/textarea.rs
expression: "format!(\"cursor: {:?}\\n{}\", t.cursor_pos(area), terminal.backend())"
---
-cursor: Some((4, 0))
+cursor: Some((0, 1))
"****"
+" "
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_styled_overlays_stay_inside_the_textarea.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_styled_overlays_stay_inside_the_textarea.snap
new file mode 100644
index 0000000000..91e2d72f80
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_styled_overlays_stay_inside_the_textarea.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/bottom_pane/textarea.rs
+expression: "snapshots.join(\"\\n\\n\")"
+---
+element
+" KEEP"
+"next "
+" "
+
+
+highlight
+" KEEP"
+"next "
+" "
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_trailing_spaces_wrap_without_cursor_overflow.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_trailing_spaces_wrap_without_cursor_overflow.snap
new file mode 100644
index 0000000000..e192d6d73d
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__textarea__tests__textarea_trailing_spaces_wrap_without_cursor_overflow.snap
@@ -0,0 +1,8 @@
+---
+source: tui/src/bottom_pane/textarea.rs
+expression: "format!(\"cursor: {:?}\\n{}\", t.cursor_pos(area), terminal.backend())"
+---
+cursor: Some((2, 2))
+"abad "
+" "
+" "
diff --git a/codex-rs/tui/src/bottom_pane/textarea.rs b/codex-rs/tui/src/bottom_pane/textarea.rs
index 98bf0126d8..36ab177ee0 100644
--- a/codex-rs/tui/src/bottom_pane/textarea.rs
+++ b/codex-rs/tui/src/bottom_pane/textarea.rs
@@ -9,6 +9,9 @@
//!
//! This module does not implement an Emacs-style multi-entry kill ring. It keeps only the most
//! recent killed span.
+//!
+//! Wrapping also reserves a visible insertion point: full logical lines get continuation rows,
+//! and overflowing spaces wrap instead of moving the cursor outside the textarea.
use crate::key_hint::KeyBindingListExt;
use crate::key_hint::is_altgr;
@@ -437,13 +440,20 @@ impl TextArea {
self.cursor_pos_with_state(area, TextAreaState::default())
}
- /// Compute the on-screen cursor position taking scrolling into account.
+ /// Returns an on-screen cursor position within `area`, accounting for wrapping and scrolling.
+ ///
+ /// Returns `None` when the viewport has no visible cells.
pub fn cursor_pos_with_state(&self, area: Rect, state: TextAreaState) -> Option<(u16, u16)> {
+ if area.is_empty() {
+ return None;
+ }
+
let lines = self.wrapped_lines(area.width);
let effective_scroll = self.effective_scroll(area.height, &lines, state.scroll);
let i = Self::wrapped_line_index_by_start(&lines, self.cursor_pos)?;
let ls = &lines[i];
- let col = display_width(&self.text[ls.start..self.cursor_pos]) as u16;
+ let col = display_width(&self.text[ls.start..self.cursor_pos])
+ .min(usize::from(area.width.saturating_sub(1))) as u16;
let screen_row = i
.saturating_sub(effective_scroll as usize)
.try_into()
@@ -1231,7 +1241,10 @@ impl TextArea {
if idx > 0 {
let prev = &lines[idx - 1];
let line_start = prev.start;
- let line_end = prev.end.saturating_sub(1);
+ let mut line_end = prev.end.saturating_sub(1);
+ if line_end == cur_range.start {
+ line_end = self.prev_atomic_boundary(line_end).max(line_start);
+ }
Some((target_col, Some((line_start, line_end))))
} else {
Some((target_col, None))
@@ -1294,7 +1307,13 @@ impl TextArea {
if idx + 1 < lines.len() {
let next = &lines[idx + 1];
let line_start = next.start;
- let line_end = next.end.saturating_sub(1);
+ let mut line_end = next.end.saturating_sub(1);
+ if lines
+ .get(idx + 2)
+ .is_some_and(|following| following.start == line_end)
+ {
+ line_end = self.prev_atomic_boundary(line_end).max(line_start);
+ }
Some((target_col, Some((line_start, line_end))))
} else {
Some((target_col, None))
@@ -1860,6 +1879,10 @@ impl TextArea {
}
}
+ /// Returns cached grapheme-safe visual ranges, including cursor-position sentinel bytes.
+ ///
+ /// Overflowing spaces get their own rows, and full logical lines receive a continuation row
+ /// so their insertion point stays visible.
#[expect(clippy::unwrap_used)]
fn wrapped_lines(&self, width: u16) -> Ref<'_, Vec<Range<usize>>> {
// Ensure cache is ready (potentially mutably borrow, then drop)
@@ -1871,10 +1894,39 @@ impl TextArea {
};
if needs_recalc {
let display_text = text_for_display(&self.text);
- let lines = crate::wrapping::wrap_ranges(
+ let mut lines = crate::wrapping::wrap_ranges(
display_text.as_ref(),
Options::new(width as usize).wrap_algorithm(textwrap::WrapAlgorithm::FirstFit),
);
+ if width > 0 {
+ let wrapped_lines = lines;
+ lines = Vec::with_capacity(wrapped_lines.len());
+ for wrapped_line in wrapped_lines {
+ let line_end = wrapped_line.end.saturating_sub(1);
+ let mut line_start = wrapped_line.start;
+ let mut line_width = 0;
+
+ for (offset, grapheme) in display_text[wrapped_line.start..line_end]
+ .grapheme_indices(/*is_extended*/ true)
+ {
+ let grapheme_width = display_width(grapheme);
+ if line_width > 0 && line_width + grapheme_width > usize::from(width) {
+ let next_line_start = wrapped_line.start + offset;
+ lines.push(line_start..next_line_start + 1);
+ line_start = next_line_start;
+ line_width = 0;
+ }
+ line_width += grapheme_width;
+ }
+
+ lines.push(line_start..line_end + 1);
+ if line_width >= usize::from(width)
+ && matches!(display_text.as_bytes().get(line_end), None | Some(b'\n'))
+ {
+ lines.push(line_end..line_end + 1);
+ }
+ }
+ }
*cache = Some(WrapCache { width, lines });
}
}
@@ -1920,7 +1972,14 @@ impl TextArea {
impl WidgetRef for &TextArea {
fn render_ref(&self, area: Rect, buf: &mut Buffer) {
let lines = self.wrapped_lines(area.width);
- self.render_lines(area, buf, &lines, 0..lines.len(), Style::default(), &[]);
+ self.render_lines(
+ area,
+ buf,
+ &lines,
+ 0..lines.len().min(usize::from(area.height)),
+ Style::default(),
+ &[],
+ );
}
}
@@ -1976,6 +2035,7 @@ impl TextArea {
self.render_lines(area, buf, &lines, start..end, base_style, highlights);
}
+ /// Renders visible text and styled overlays without writing outside the textarea viewport.
fn render_lines(
&self,
area: Rect,
@@ -1991,10 +2051,11 @@ impl TextArea {
let line_range = r.start..r.end - 1;
buf.set_style(Rect::new(area.x, y, area.width, 1), base_style);
// Draw base line with the provided style.
- buf.set_string(
+ buf.set_stringn(
area.x,
y,
text_for_display(&self.text[line_range.clone()]),
+ usize::from(area.width),
base_style,
);
@@ -2009,7 +2070,13 @@ impl TextArea {
let styled = &self.text[overlap_start..overlap_end];
let x_off = display_width(&self.text[line_range.start..overlap_start]) as u16;
let style = base_style.fg(Color::Cyan);
- buf.set_string(area.x + x_off, y, text_for_display(styled), style);
+ buf.set_stringn(
+ area.x + x_off,
+ y,
+ text_for_display(styled),
+ usize::from(area.width.saturating_sub(x_off)),
+ style,
+ );
}
// Overlay render-only highlight ranges last so transient search highlighting remains
@@ -2022,11 +2089,18 @@ impl TextArea {
}
let highlighted = &self.text[overlap_start..overlap_end];
let x_off = display_width(&self.text[line_range.start..overlap_start]) as u16;
- buf.set_string(area.x + x_off, y, text_for_display(highlighted), *style);
+ buf.set_stringn(
+ area.x + x_off,
+ y,
+ text_for_display(highlighted),
+ usize::from(area.width.saturating_sub(x_off)),
+ *style,
+ );
}
}
}
+ /// Renders width-preserving mask glyphs without writing outside the textarea viewport.
fn render_lines_masked(
&self,
area: Rect,
@@ -2043,7 +2117,13 @@ impl TextArea {
.graphemes(/*is_extended*/ true)
.flat_map(|grapheme| std::iter::repeat_n(mask_char, display_width(grapheme)))
.collect::<String>();
- buf.set_string(area.x, y, &masked, Style::default());
+ buf.set_stringn(
+ area.x,
+ y,
+ &masked,
+ usize::from(area.width),
+ Style::default(),
+ );
}
}
}
@@ -2055,6 +2135,8 @@ mod tests {
// crossterm types are intentionally not imported here to avoid unused warnings
use pretty_assertions::assert_eq;
use rand::prelude::*;
+ use ratatui::Terminal;
+ use ratatui::backend::TestBackend;
fn rand_grapheme(rng: &mut rand::rngs::StdRng) -> String {
let r: u8 = rng.random_range(0..100);
@@ -3452,6 +3534,185 @@ mod tests {
assert!(state.scroll < effective_lines);
}
+ #[test]
+ fn cursor_wraps_after_filling_the_final_line() {
+ for text in ["abad", "界界", "abガ"] {
+ let mut t = ta_with(text);
+ t.set_cursor(t.text().len());
+ let area = Rect::new(2, 3, /*width*/ 4, /*height*/ 2);
+
+ assert_eq!(t.desired_height(area.width), 2);
+ assert_eq!(t.cursor_pos(area), Some((2, 4)));
+ }
+ }
+
+ #[test]
+ fn full_non_final_lines_reserve_visible_cursor_rows() {
+ for text in ["abad\nef", "界界\nef", "abガ\nef"] {
+ let mut t = ta_with(text);
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
+ let newline = text.find('\n').unwrap();
+
+ assert_eq!(t.desired_height(area.width), 3);
+
+ t.set_cursor(newline);
+ assert_eq!(t.cursor_pos(area), Some((0, 1)));
+
+ t.set_cursor(newline + 1);
+ assert_eq!(t.cursor_pos(area), Some((0, 2)));
+ }
+ }
+
+ #[test]
+ fn full_non_final_line_cursor_snapshot() {
+ let mut t = ta_with("abad\nef");
+ t.set_cursor(/*pos*/ 4);
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
+ let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
+ let mut state = TextAreaState::default();
+ terminal
+ .draw(|frame| {
+ StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
+ })
+ .unwrap();
+
+ insta::assert_snapshot!(
+ "textarea_full_non_final_line_has_a_visible_cursor_row",
+ format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
+ );
+ }
+
+ #[test]
+ fn trailing_spaces_wrap_without_letting_the_cursor_escape() {
+ let mut t = ta_with("abad ");
+ t.set_cursor(t.text().len());
+ let area = Rect::new(0, 0, /*width*/ 5, /*height*/ 3);
+ let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
+ let mut state = TextAreaState::default();
+ terminal
+ .draw(|frame| {
+ StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
+ })
+ .unwrap();
+
+ assert_eq!(t.desired_height(area.width), 3);
+ insta::assert_snapshot!(
+ "textarea_trailing_spaces_wrap_without_cursor_overflow",
+ format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
+ );
+ }
+
+ #[test]
+ fn space_runs_wrap_before_later_text() {
+ let mut t = ta_with("abad next");
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 5);
+
+ assert_eq!(t.desired_height(area.width), 5);
+
+ for (cursor, expected) in [(4, (0, 1)), (6, (2, 1)), (8, (0, 2)), (9, (0, 3))] {
+ t.set_cursor(cursor);
+ assert_eq!(t.cursor_pos(area), Some(expected));
+ }
+ }
+
+ #[test]
+ fn full_final_line_scrolls_to_its_visible_cursor_row() {
+ let mut t = ta_with("abcdefgh");
+ t.set_cursor(t.text().len());
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 2);
+ let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
+ let mut state = TextAreaState::default();
+ terminal
+ .draw(|frame| {
+ StatefulWidgetRef::render_ref(&(&t), frame.area(), frame.buffer_mut(), &mut state);
+ })
+ .unwrap();
+
+ assert_eq!(t.desired_height(area.width), 3);
+ insta::assert_snapshot!(
+ "textarea_full_final_line_scrolls_to_visible_cursor_row",
+ format!(
+ "scroll: {}\ncursor: {:?}\n{}",
+ state.scroll,
+ t.cursor_pos_with_state(area, state),
+ terminal.backend()
+ )
+ );
+ }
+
+ #[test]
+ fn text_rendering_does_not_overwrite_cells_outside_the_textarea() {
+ let t = ta_with("abad next");
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
+ let mut state = TextAreaState::default();
+ let mut buf = Buffer::empty(Rect::new(0, 0, /*width*/ 8, /*height*/ 3));
+ let protected_style = Style::default().fg(Color::Red);
+ buf.set_style(Rect::new(4, 0, /*width*/ 4, /*height*/ 3), protected_style);
+ let protected_cell = buf[(4, 0)].clone();
+
+ StatefulWidgetRef::render_ref(&(&t), area, &mut buf, &mut state);
+
+ assert_eq!(buf[(4, 0)], protected_cell);
+ }
+
+ #[test]
+ fn styled_text_rendering_does_not_overwrite_cells_outside_the_textarea() {
+ let mut snapshots = Vec::new();
+ for overlay in ["element", "highlight"] {
+ let mut t = ta_with("abad next");
+ if overlay == "element" {
+ t.add_element_range(0..9);
+ }
+ let highlights = if overlay == "highlight" {
+ vec![(0..9, Style::default().fg(Color::Magenta))]
+ } else {
+ Vec::new()
+ };
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 3);
+ let mut terminal = Terminal::new(TestBackend::new(/*width*/ 8, area.height)).unwrap();
+ let mut state = TextAreaState::default();
+ terminal
+ .draw(|frame| {
+ frame.buffer_mut().set_string(
+ /*x*/ 4,
+ /*y*/ 0,
+ "KEEP",
+ Style::default().fg(Color::Red),
+ );
+ t.render_ref_styled_with_highlights(
+ area,
+ frame.buffer_mut(),
+ &mut state,
+ Style::default(),
+ &highlights,
+ );
+ })
+ .unwrap();
+
+ assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "K");
+ snapshots.push(format!("{overlay}\n{}", terminal.backend()));
+ }
+
+ insta::assert_snapshot!(
+ "textarea_styled_overlays_stay_inside_the_textarea",
+ snapshots.join("\n\n")
+ );
+ }
+
+ #[test]
+ fn empty_textarea_areas_do_not_have_a_cursor() {
+ let t = ta_with("abad");
+
+ assert_eq!(
+ t.cursor_pos(Rect::new(0, 0, /*width*/ 0, /*height*/ 1)),
+ None
+ );
+ assert_eq!(
+ t.cursor_pos(Rect::new(0, 0, /*width*/ 1, /*height*/ 0)),
+ None
+ );
+ }
+
#[test]
fn render_highlights_apply_style_without_mutating_text() {
let t = ta_with("hello world");
@@ -3537,14 +3798,21 @@ mod tests {
use ratatui::backend::TestBackend;
let mut snapshots = Vec::new();
- for (label, text, width, cursor, cells) in [
- ("dakuten", "12ガx", 4, (1, 1), [(2, 0, "ガ"), (0, 1, "x")]),
- ("handakuten", "abパc", 3, (3, 1), [(0, 1, "パ"), (2, 1, "c")]),
- ("standalone", "a ゙b", 2, (2, 1), [(0, 1, "゙"), (1, 1, "b")]),
+ for (label, text, width, height, cursor, cells) in [
+ ("dakuten", "12ガx", 4, 2, (1, 1), [(2, 0, "ガ"), (0, 1, "x")]),
+ (
+ "handakuten",
+ "abパc",
+ 3,
+ 3,
+ (0, 2),
+ [(0, 1, "パ"), (2, 1, "c")],
+ ),
+ ("standalone", "a ゙b", 2, 3, (0, 2), [(0, 1, "゙"), (1, 1, "b")]),
] {
let mut t = ta_with(text);
t.set_cursor(text.len());
- let area = Rect::new(0, 0, width, /*height*/ 2);
+ let area = Rect::new(0, 0, width, height);
let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
terminal
.draw(|frame| {
@@ -3556,7 +3824,7 @@ mod tests {
})
.unwrap();
- assert_eq!(t.desired_height(area.width), 2);
+ assert_eq!(t.desired_height(area.width), height);
assert_eq!(t.cursor_pos(area), Some(cursor));
for (x, y, expected) in cells {
assert_eq!(terminal.backend().buffer()[(x, y)].symbol(), expected);
@@ -3582,7 +3850,7 @@ mod tests {
let text = "界゙a";
let mut t = ta_with(text);
t.set_cursor(text.len());
- let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 1);
+ let area = Rect::new(0, 0, /*width*/ 4, /*height*/ 2);
let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
let mut state = TextAreaState::default();
terminal
@@ -3591,7 +3859,7 @@ mod tests {
})
.unwrap();
- assert_eq!(t.cursor_pos(area), Some((4, 0)));
+ assert_eq!(t.cursor_pos(area), Some((0, 1)));
insta::assert_snapshot!(
"textarea_masked_graphemes_align_with_cursor",
format!("cursor: {:?}\n{}", t.cursor_pos(area), terminal.backend())
@@ -3599,16 +3867,16 @@ mod tests {
}
#[test]
- fn overwide_halfwidth_sound_marks_do_not_add_a_phantom_cursor_row() {
- let area = Rect::new(0, 0, /*width*/ 2, /*height*/ 2);
+ fn overwide_halfwidth_sound_marks_keep_the_final_cursor_visible() {
+ let area = Rect::new(0, 0, /*width*/ 2, /*height*/ 3);
for grapheme in ["ガ゙", "界゙"] {
let text = format!("{grapheme}ab");
let mut t = ta_with(&text);
t.set_cursor(text.len());
- assert_eq!(t.desired_height(area.width), 2);
- assert_eq!(t.cursor_pos(area), Some((2, 1)));
+ assert_eq!(t.desired_height(area.width), 3);
+ assert_eq!(t.cursor_pos(area), Some((0, 2)));
t.set_cursor(grapheme.len());
assert_eq!(t.cursor_pos(area), Some((0, 1)));
@@ -3742,18 +4010,24 @@ mod tests {
fn wrapped_navigation_with_newlines_and_spaces() {
// Include spaces and an explicit newline to exercise boundaries
let mut t = ta_with("word1 word2\nword3");
- // Width 6 will wrap "word1 " and then "word2" before the newline
+ // Width 6 wraps "word1 ", its remaining space, and then "word2" before the newline.
let _ = t.desired_height(/*width*/ 6);
- // Put cursor on the second wrapped line before the newline, at column 1 of "word2"
+ // Put the cursor at column 1 of "word2".
let start_word2 = t.text().find("word2").unwrap();
t.set_cursor(start_word2 + 1);
- // Up should go to first wrapped line, column 1 -> index 1
+ // Up first lands on the short whitespace continuation instead of skipping it.
+ t.move_cursor_up();
+ assert_eq!(t.cursor(), start_word2 - 1);
+
+ // A second Up preserves the preferred column on the first wrapped line.
t.move_cursor_up();
assert_eq!(t.cursor(), 1);
- // Down should return to the same visual column on "word2"
+ // Down visits the whitespace continuation before returning to "word2".
+ t.move_cursor_down();
+ assert_eq!(t.cursor(), start_word2 - 1);
t.move_cursor_down();
assert_eq!(t.cursor(), start_word2 + 1);
@@ -3987,13 +4261,16 @@ mod tests {
let mut buf = Buffer::empty(full_area);
ratatui::widgets::WidgetRef::render_ref(&(&ta), full_area, &mut buf);
- // cursor_pos: x must be within width when present
- let _ = ta.cursor_pos(area);
-
- // cursor_pos_with_state: always within viewport rows
- let (_x, _y) = ta
- .cursor_pos_with_state(area, state)
- .unwrap_or((area.x, area.y));
+ // Both cursor helpers must keep the insertion point inside the viewport.
+ for (x, y) in [ta.cursor_pos(area), ta.cursor_pos_with_state(area, state)]
+ .into_iter()
+ .flatten()
+ {
+ assert!(
+ area.contains((x, y).into()),
+ "cursor escaped {area:?}: ({x}, {y})"
+ );
+ }
// Stateful render should not panic, and updates scroll
let mut sbuf = Buffer::empty(area);