mirror of
https://github.com/openai/codex.git
synced 2026-11-16 22:00:36 +00:00
## What changed - Add configurable `pager.mark_markdown`, bound to the leader followed by `v`, to mark the table cell under the selection caret. - Use arrows or `hjkl` to extend a rectangular cell selection, `o` to swap corners, and `y` to copy. Press `v` to select text within the active cell without including neighboring cells, including across wrapped lines. - Show table-specific footer hints and route the marking chord in both the main transcript and transcript overlays. ## Testing Add coverage for cell rectangles, header-only selections, empty cells, wrapped text, Unicode and escaped pipes, Markdown copying, search cancellation, mouse takeover, and chord routing with remapped find and leader keys. GitOrigin-RevId: 81ed9e52092bba3c7ef064e95043d2c070df0f4c
1119 lines
38 KiB
Rust
1119 lines
38 KiB
Rust
use super::*;
|
|
use crate::clipboard_copy::CopyStatus;
|
|
use crate::history_cell::AgentMarkdownCell;
|
|
use crate::history_cell::PlainHistoryCell;
|
|
use crossterm::event::MouseButton;
|
|
use crossterm::event::MouseEvent;
|
|
use crossterm::event::MouseEventKind;
|
|
use pretty_assertions::assert_eq;
|
|
use ratatui::text::Line;
|
|
use ratatui::widgets::Paragraph;
|
|
use ratatui::widgets::Widget;
|
|
|
|
fn cell(lines: &[&str]) -> Arc<dyn HistoryCell> {
|
|
Arc::new(PlainHistoryCell::new(
|
|
lines
|
|
.iter()
|
|
.map(|line| Line::from((*line).to_owned()))
|
|
.collect(),
|
|
))
|
|
}
|
|
fn render(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>]) -> Buffer {
|
|
let area = Rect::new(
|
|
/*x*/ 0, /*y*/ 0, /*width*/ 32, /*height*/ 6,
|
|
);
|
|
let mut buffer = Buffer::empty(area);
|
|
view.render(area, &mut buffer, cells);
|
|
buffer
|
|
}
|
|
|
|
fn press(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>], code: KeyCode) {
|
|
assert!(matches!(
|
|
view.handle_key(KeyEvent::new(code, KeyModifiers::NONE), cells),
|
|
Some(ViewAction::Changed)
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn entry_starts_on_the_last_selectable_visible_line() {
|
|
for (cells, expected) in [
|
|
(vec![cell(&["top"]), cell(&["bottom"])], "b"),
|
|
(vec![cell(&["text"]), cell(&[""])], "t"),
|
|
(vec![cell(&["abc", "", "", "", "", "", ""])], "c"),
|
|
] {
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some(expected));
|
|
}
|
|
|
|
let cells = vec![cell(&["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
view.scroll(&cells, /*rows*/ -2);
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("h"));
|
|
|
|
let cells = vec![cell(&["a", "", "", "", "", "", "", "", "", ""])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
assert!(matches!(view.position, Position::Reading(_)));
|
|
|
|
let cells = vec![cell(&[""])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(!view.begin_select_mode(&cells));
|
|
}
|
|
|
|
#[test]
|
|
fn character_motion_crosses_line_and_entry_boundaries_without_invisible_stops() {
|
|
let cells = vec![cell(&["a", ""]), cell(&[""]), cell(&["", "b"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Left);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("a"));
|
|
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("b"));
|
|
|
|
let cells = vec![cell(&["ab"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
let separator = Anchor {
|
|
key: EntryKey::cell(&cells[0]),
|
|
index: 0,
|
|
offset: 0,
|
|
row_bias: 1,
|
|
};
|
|
view.selection
|
|
.as_mut()
|
|
.expect("selection")
|
|
.set_keyboard_range(separator, separator);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("a"));
|
|
|
|
let wrapped = format!("{} one", "1234567890".repeat(3));
|
|
let cells = vec![cell(&[&wrapped])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Left);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("0"));
|
|
|
|
let cells = vec![cell(&["ab"]), cell(&["cd"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
let start = Anchor {
|
|
key: EntryKey::cell(&cells[0]),
|
|
index: 0,
|
|
offset: 0,
|
|
row_bias: 0,
|
|
};
|
|
let end = Anchor {
|
|
key: EntryKey::cell(&cells[1]),
|
|
index: 1,
|
|
offset: 0,
|
|
row_bias: 0,
|
|
};
|
|
let mut selection = Selection::keyboard(view.capture_snapshot(&cells), start);
|
|
selection.set_keyboard_range(start, end);
|
|
view.selection = Some(selection);
|
|
assert!(view.begin_select_mode(&cells));
|
|
assert_eq!(
|
|
view.select_mode
|
|
.and_then(|mode| mode.mark)
|
|
.expect("marked range")
|
|
.active,
|
|
Anchor { offset: 1, ..start }
|
|
);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("ab\n"));
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("ab\n"));
|
|
press(&mut view, &cells, KeyCode::Char('l'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("b"));
|
|
|
|
let cells = vec![cell(&["abc"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
let start = Anchor {
|
|
key: EntryKey::cell(&cells[0]),
|
|
index: 0,
|
|
offset: 1,
|
|
row_bias: 0,
|
|
};
|
|
let end = Anchor { offset: 3, ..start };
|
|
let mut selection = Selection::keyboard(view.capture_snapshot(&cells), start);
|
|
selection.set_keyboard_range(start, end);
|
|
view.selection = Some(selection);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('h'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("b"));
|
|
press(&mut view, &cells, KeyCode::Char('h'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("ab"));
|
|
}
|
|
|
|
#[test]
|
|
fn vertical_motion_keeps_the_preferred_display_column() {
|
|
let cells = vec![cell(&["abcdef", "x", "abcdef"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
for _ in 0..3 {
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
}
|
|
press(&mut view, &cells, KeyCode::Up);
|
|
press(&mut view, &cells, KeyCode::Up);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("d"));
|
|
}
|
|
|
|
#[test]
|
|
fn enter_without_a_mark_exits_but_enter_with_a_mark_copies_and_follows() {
|
|
let cells = vec![cell(&["copy me"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Enter.into(), &cells),
|
|
Some(ViewAction::ExitSelectMode)
|
|
));
|
|
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert!(matches!(
|
|
view.handle_key(
|
|
KeyEvent::new_with_kind(KeyCode::Char('v'), KeyModifiers::NONE, KeyEventKind::Repeat,),
|
|
&cells,
|
|
),
|
|
Some(ViewAction::Changed)
|
|
));
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Enter.into(), &cells),
|
|
Some(ViewAction::CopyAndFollow(text)) if text == "c"
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn word_motion_crosses_entries_and_word_end_selects_the_destination_word() {
|
|
let cells = vec![cell(&["alpha"]), cell(&["beta gamma"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
|
|
press(&mut view, &cells, KeyCode::Char('w'));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Char('e'));
|
|
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("beta"));
|
|
}
|
|
|
|
#[test]
|
|
fn reverse_line_selection_copies_complete_lines_in_document_order() {
|
|
let cells = vec![cell(&["first", "second", "third"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::Char('V'));
|
|
press(&mut view, &cells, KeyCode::Char('k'));
|
|
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("second\nthird"));
|
|
}
|
|
|
|
#[test]
|
|
fn logical_line_end_handles_empty_lines_and_shifted_dollar() {
|
|
let cells = vec![cell(&["abc", "", "z"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
assert!(matches!(
|
|
view.handle_key(
|
|
KeyEvent::new(KeyCode::Char('$'), KeyModifiers::SHIFT),
|
|
&cells,
|
|
),
|
|
Some(ViewAction::Changed)
|
|
));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("c"));
|
|
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::End);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells), None);
|
|
|
|
let cells = vec![cell(&["abc", ""])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::End);
|
|
}
|
|
|
|
#[test]
|
|
fn configured_pager_page_motion_moves_the_select_cursor() {
|
|
let cells = vec![Arc::new(PlainHistoryCell::new(
|
|
(0..12).map(|row| format!("line {row}").into()).collect(),
|
|
)) as Arc<dyn HistoryCell>];
|
|
let config = serde_json::from_value(serde_json::json!({
|
|
"pager": {"page_down": "c"}
|
|
}))
|
|
.expect("keymap config");
|
|
let keymap = crate::keymap::RuntimeKeymap::from_config(&config).expect("configured page down");
|
|
let mut view = TranscriptView::default();
|
|
view.set_keymap_bindings(&keymap);
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert!(view.select_mode.is_some_and(|mode| mode.mark.is_some()));
|
|
press(&mut view, &cells, KeyCode::Char('c'));
|
|
|
|
let cursor = view
|
|
.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"));
|
|
let layout = view.layout(&cells, cursor.index).expect("cursor layout");
|
|
assert_eq!(
|
|
layout
|
|
.row_for_offset(cursor.offset)
|
|
.saturating_add_signed(cursor.row_bias.saturating_neg()),
|
|
5
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn transcript_end_character_selection_includes_the_last_grapheme() {
|
|
let cells = vec![cell(&["start"]), cell(&["tail🙂"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('G'));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("🙂"));
|
|
}
|
|
|
|
#[test]
|
|
fn swapping_the_active_end_preserves_text_and_moves_the_shrinking_endpoint() {
|
|
let cells = vec![cell(&["abcdef"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("a"));
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
for _ in 0..3 {
|
|
press(&mut view, &cells, KeyCode::Char('l'));
|
|
}
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("abcd"));
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
press(&mut view, &cells, KeyCode::Char('l'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("bcd"));
|
|
}
|
|
|
|
#[test]
|
|
fn confirmed_copy_keeps_the_select_mode_caret_on_the_active_grapheme() {
|
|
let cells = vec![cell(&["abc"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Char('l'));
|
|
let Some(ViewAction::Copy(text)) = view.handle_key(KeyCode::Char('y').into(), &cells) else {
|
|
panic!("copy key should copy the marked range");
|
|
};
|
|
assert_eq!(text, "ab");
|
|
assert_eq!(
|
|
view.copy_selected_text_with(
|
|
&cells,
|
|
&text,
|
|
/*clear_selection*/ true,
|
|
|_, _| { Ok(CopyStatus::Confirmed) }
|
|
),
|
|
Ok(CopyStatus::Confirmed)
|
|
);
|
|
assert!(view.select_mode.is_some());
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("b"));
|
|
}
|
|
|
|
#[test]
|
|
fn find_accepts_at_the_match_and_cancel_restores_the_saved_selection() {
|
|
let mut cells = vec![cell(&["alpha beta gamma"])];
|
|
for _ in 0..6 {
|
|
cells.push(cell(&["filler"]));
|
|
}
|
|
cells.push(cell(&["distant"]));
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("gamma"));
|
|
while view.advance_search(&cells) {}
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
let accepted_cursor = view
|
|
.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"));
|
|
let accepted_position = view.position;
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("distant"));
|
|
while view.advance_search(&cells) {}
|
|
render(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
|
|
assert_eq!(view.position, accepted_position);
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection")),
|
|
accepted_cursor
|
|
);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("ga"));
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
let narrow = Rect::new(
|
|
/*x*/ 0, /*y*/ 0, /*width*/ 8, /*height*/ 6,
|
|
);
|
|
view.render(narrow, &mut Buffer::empty(narrow), &cells);
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
view.render(narrow, &mut Buffer::empty(narrow), &cells);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(matches!(
|
|
view.handle_key(
|
|
KeyEvent::new(KeyCode::Char('\u{3}'), KeyModifiers::NONE),
|
|
&cells,
|
|
),
|
|
Some(ViewAction::Changed)
|
|
));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("ga"));
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("alpha"));
|
|
while view.advance_search(&cells) {}
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
0
|
|
);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("alpha beta g"));
|
|
|
|
let key = accepted_cursor.key;
|
|
view.select_mode = None;
|
|
view.selection
|
|
.as_mut()
|
|
.expect("selection")
|
|
.set_keyboard_range(
|
|
Anchor {
|
|
offset: 6,
|
|
..accepted_cursor
|
|
},
|
|
Anchor {
|
|
key,
|
|
offset: 10,
|
|
..accepted_cursor
|
|
},
|
|
);
|
|
assert!(view.begin_select_mode(&cells));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("beta"));
|
|
|
|
for (query, expected_offset, expected_text) in [("\u{301}", 0, "a\u{301}"), ("\nbeta", 4, "b")]
|
|
{
|
|
let cells = vec![cell(&["a\u{301}", "beta"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search(query));
|
|
while view.advance_search(&cells) {}
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
expected_offset
|
|
);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some(expected_text));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn accepted_find_repeats_into_the_select_cursor() {
|
|
let cells = vec![cell(&["needle first needle second"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("needle"));
|
|
while view.advance_search(&cells) {}
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
13
|
|
);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
13
|
|
);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('n'));
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
while view.advance_search(&cells) {}
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
14
|
|
);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('n'));
|
|
while view.advance_search(&cells) {}
|
|
assert_eq!(
|
|
view.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
0
|
|
);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert!(matches!(
|
|
view.handle_key(
|
|
KeyEvent::new(KeyCode::Char('n'), KeyModifiers::SHIFT),
|
|
&cells,
|
|
),
|
|
Some(ViewAction::Changed)
|
|
));
|
|
while view.advance_search(&cells) {}
|
|
let mode = view.select_mode.expect("select mode");
|
|
assert!(mode.mark.is_some());
|
|
assert_eq!(
|
|
mode.cursor(view.selection.as_ref().expect("selection"))
|
|
.offset,
|
|
13
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn accepted_find_pins_an_expanded_match_before_select_mode_exits() {
|
|
let output = format!(
|
|
"{}hidden needle\n{}",
|
|
"head\n".repeat(/*n*/ 20),
|
|
"tail\n".repeat(/*n*/ 20)
|
|
);
|
|
let command = crate::exec_cell::ExecCell::new(
|
|
crate::exec_cell::ExecCall {
|
|
call_id: "command".to_string(),
|
|
command: vec!["echo".to_string()],
|
|
parsed: Vec::new(),
|
|
output: Some(crate::exec_cell::CommandOutput::new(
|
|
/*exit_code*/ 0, output,
|
|
)),
|
|
source: codex_app_server_protocol::CommandExecutionSource::Agent,
|
|
start_time: None,
|
|
duration: None,
|
|
interaction_input: None,
|
|
},
|
|
/*animations_enabled*/ false,
|
|
);
|
|
let cells = vec![Arc::new(command) as Arc<dyn HistoryCell>];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("needle"));
|
|
while view.advance_search(&cells) {}
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
|
|
let anchor = view.search.match_anchor().expect("accepted hidden match");
|
|
render(&mut view, &cells);
|
|
let cursor = view
|
|
.select_mode
|
|
.expect("select mode")
|
|
.cursor(view.selection.as_ref().expect("selection"));
|
|
let index = view.resolve(&cells, cursor);
|
|
let row = view
|
|
.layout(&cells, index)
|
|
.expect("cursor layout")
|
|
.row_for_offset(cursor.offset);
|
|
assert!(
|
|
view.visible
|
|
.iter()
|
|
.any(|visible| visible.index == index && visible.row == row)
|
|
);
|
|
let expanded = view
|
|
.search
|
|
.match_layout(anchor.key)
|
|
.expect("expanded search layout")
|
|
.text()
|
|
.to_owned();
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
assert_eq!(
|
|
view.selection
|
|
.as_ref()
|
|
.expect("selection")
|
|
.snapshot
|
|
.pinned
|
|
.get(&anchor.key)
|
|
.expect("expanded origin pinned")
|
|
.text(),
|
|
expanded
|
|
);
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Char('q').into(), &cells),
|
|
Some(ViewAction::ExitSelectMode)
|
|
));
|
|
assert_eq!(
|
|
view.held_reading
|
|
.as_ref()
|
|
.expect("paused snapshot")
|
|
.pinned
|
|
.get(&anchor.key)
|
|
.expect("expanded match pinned")
|
|
.text(),
|
|
expanded
|
|
);
|
|
}
|
|
#[test]
|
|
fn beginning_motion_finishes_at_the_first_grapheme_after_paging() {
|
|
let mut cells = vec![cell(&["newer"])];
|
|
let mut view = TranscriptView {
|
|
history: TranscriptHistoryState::Partial,
|
|
..Default::default()
|
|
};
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
assert_eq!(view.history, TranscriptHistoryState::LoadingBeginning);
|
|
|
|
cells.insert(/*index*/ 0, cell(&["older"]));
|
|
view.history_loaded(&cells, 0..1);
|
|
view.history = TranscriptHistoryState::Complete;
|
|
view.complete_select_beginning(&cells);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("o"));
|
|
}
|
|
|
|
#[test]
|
|
fn shift_click_extends_from_the_keyboard_marks_fixed_anchor() {
|
|
let cells = vec![cell(&["abcdef"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("cde"));
|
|
|
|
view.handle_mouse(
|
|
MouseEvent {
|
|
kind: MouseEventKind::Down(crossterm::event::MouseButton::Left),
|
|
column: 0,
|
|
row: 0,
|
|
modifiers: KeyModifiers::SHIFT,
|
|
},
|
|
&cells,
|
|
);
|
|
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("abc"));
|
|
}
|
|
|
|
#[test]
|
|
fn existing_mouse_selection_keeps_its_word_or_line_unit() {
|
|
let word_cells = vec![cell(&["alpha beta"])];
|
|
let mut word_view = TranscriptView::default();
|
|
render(&mut word_view, &word_cells);
|
|
word_view.begin_selection(
|
|
&word_cells,
|
|
/*column*/ 1,
|
|
/*row*/ 0,
|
|
/*clicks*/ 2,
|
|
);
|
|
assert!(word_view.begin_select_mode(&word_cells));
|
|
press(&mut word_view, &word_cells, KeyCode::Char('h'));
|
|
assert_eq!(
|
|
word_view.selected_text(&word_cells).as_deref(),
|
|
Some(&"alpha"[..4])
|
|
);
|
|
|
|
let line_cells = vec![cell(&["first", "second"])];
|
|
let mut line_view = TranscriptView::default();
|
|
render(&mut line_view, &line_cells);
|
|
line_view.begin_selection(
|
|
&line_cells,
|
|
/*column*/ 1,
|
|
/*row*/ 1,
|
|
/*clicks*/ 3,
|
|
);
|
|
assert!(line_view.begin_select_mode(&line_cells));
|
|
press(&mut line_view, &line_cells, KeyCode::Char('k'));
|
|
assert_eq!(
|
|
line_view.selected_text(&line_cells).as_deref(),
|
|
Some("first\nsecond")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn passive_mouse_events_do_not_reanchor_a_reverse_line_mark() {
|
|
let cells = vec![cell(&["first", "second", "third"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::Char('V'));
|
|
press(&mut view, &cells, KeyCode::Char('k'));
|
|
|
|
for kind in [MouseEventKind::Moved, MouseEventKind::ScrollDown] {
|
|
view.handle_mouse(
|
|
MouseEvent {
|
|
kind,
|
|
column: 0,
|
|
row: 0,
|
|
modifiers: KeyModifiers::NONE,
|
|
},
|
|
&cells,
|
|
);
|
|
}
|
|
view.handle_mouse(
|
|
MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Left),
|
|
column: 80,
|
|
row: 80,
|
|
modifiers: KeyModifiers::NONE,
|
|
},
|
|
&cells,
|
|
);
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("second\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn select_mode_renders_cursor_and_scannable_footer_hints() {
|
|
let cells = vec![cell(&["alpha beta", "gamma"])];
|
|
let mut view = TranscriptView::default();
|
|
render(&mut view, &cells);
|
|
assert!(view.begin_select_mode(&cells));
|
|
let buffer = render(&mut view, &cells);
|
|
let [unmarked_wide, footer, unmarked_narrow] = [240, 64, 32].map(|width| {
|
|
view.footer_with_navigation(
|
|
width,
|
|
crate::motion::MotionMode::Reduced,
|
|
/*latest_navigation*/ "",
|
|
)
|
|
.expect("select footer")
|
|
});
|
|
let area = Rect::new(
|
|
/*x*/ 0,
|
|
/*y*/ 0,
|
|
/*width*/ 64,
|
|
footer.text.height() as u16,
|
|
);
|
|
let mut footer_buffer = Buffer::empty(area);
|
|
Paragraph::new(footer.text).render(area, &mut footer_buffer);
|
|
|
|
press(&mut view, &cells, KeyCode::Char('g'));
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
for _ in 0..5 {
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
}
|
|
let marked_buffer = render(&mut view, &cells);
|
|
let [marked_wide, marked] = [240, 64].map(|width| {
|
|
view.footer_with_navigation(
|
|
width,
|
|
crate::motion::MotionMode::Reduced,
|
|
/*latest_navigation*/ "",
|
|
)
|
|
.expect("select footer")
|
|
});
|
|
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search("beta"));
|
|
while view.advance_search(&cells) {}
|
|
let find_buffer = render(&mut view, &cells);
|
|
let find_footer = view
|
|
.footer_with_navigation(
|
|
/*width*/ 64,
|
|
crate::motion::MotionMode::Reduced,
|
|
/*latest_navigation*/ "",
|
|
)
|
|
.expect("find footer");
|
|
let find_footer_text = find_footer
|
|
.text
|
|
.to_string()
|
|
.lines()
|
|
.map(str::trim_end)
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
press(&mut view, &cells, KeyCode::Enter);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
let find_marked_buffer = render(&mut view, &cells);
|
|
|
|
insta::assert_snapshot!(format!(
|
|
"{buffer:?}\nunmarked wide: {}\nunmarked:\n{footer_buffer:?}\nunmarked narrow: {}\nmarked:\n{marked_buffer:?}\nmarked wide: {}\nmarked: {}\nfind:\n{find_buffer:?}\nfind footer: {}\nfind cursor: {:?}\nfind marked:\n{find_marked_buffer:?}",
|
|
unmarked_wide.text,
|
|
unmarked_narrow.text,
|
|
marked_wide.text,
|
|
marked.text,
|
|
find_footer_text,
|
|
find_footer.cursor_column,
|
|
));
|
|
}
|
|
|
|
fn select_table_at_match(
|
|
cells: &[Arc<dyn HistoryCell>],
|
|
width: u16,
|
|
query: &str,
|
|
) -> TranscriptView {
|
|
let mut view = TranscriptView::default();
|
|
crate::transcript_view::tests::render(&mut view, cells, width, /*height*/ 32);
|
|
assert!(view.begin_select_mode(cells));
|
|
press(&mut view, cells, KeyCode::Char('/'));
|
|
assert!(view.paste_search(query));
|
|
while view.advance_search(cells) {}
|
|
press(&mut view, cells, KeyCode::Enter);
|
|
view
|
|
}
|
|
|
|
// These view tests receive the semantic event produced by the app's chord router.
|
|
fn mark_markdown(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>]) {
|
|
let key = crate::keymap::dispatch_event(crate::keymap::KeymapActionId {
|
|
context: crate::keymap::KeymapContext::Pager,
|
|
action: "mark_markdown",
|
|
})
|
|
.unwrap();
|
|
press(view, cells, key.code);
|
|
}
|
|
|
|
#[test]
|
|
fn keyboard_table_mark_selects_cells_and_swaps_rectangle_corners() {
|
|
let cells: [Arc<dyn HistoryCell>; 1] = [Arc::new(AgentMarkdownCell::new(
|
|
"| Left | Right |\n|---|---|\n| alpha | Beta |\n| Gamma | delta |".into(),
|
|
std::path::Path::new("/"),
|
|
))];
|
|
let mut view = select_table_at_match(&cells, /*width*/ 32, "Beta");
|
|
let footer = |view: &TranscriptView| {
|
|
view.footer_with_navigation(/*width*/ 32, crate::motion::MotionMode::Reduced, "")
|
|
.unwrap()
|
|
.text
|
|
};
|
|
let before = footer(&view);
|
|
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Down);
|
|
press(&mut view, &cells, KeyCode::Char('h'));
|
|
let rectangle = "| | |\n|---|---|\n| alpha | Beta |\n| Gamma | delta |";
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Char('y').into(), &cells),
|
|
Some(ViewAction::Copy(text)) if text == rectangle
|
|
));
|
|
|
|
let marked = crate::transcript_view::tests::render(
|
|
&mut view, &cells, /*width*/ 32, /*height*/ 5,
|
|
);
|
|
let highlight: String = marked
|
|
.content()
|
|
.chunks(32)
|
|
.map(|row| {
|
|
row.iter()
|
|
.map(|cell| {
|
|
use ratatui::style::Modifier;
|
|
if cell.modifier.contains(Modifier::UNDERLINED) {
|
|
"@"
|
|
} else if cell.modifier.contains(Modifier::REVERSED) {
|
|
cell.symbol()
|
|
} else {
|
|
" "
|
|
}
|
|
})
|
|
.collect::<String>()
|
|
.trim_end()
|
|
.to_owned()
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
insta::assert_snapshot!(format!("{before}\n{highlight}\n{}", footer(&view)));
|
|
|
|
press(&mut view, &cells, KeyCode::Char('/'));
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some(rectangle));
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
press(&mut view, &cells, KeyCode::Down);
|
|
press(&mut view, &cells, KeyCode::Left);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("Gamma"));
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
assert_eq!(view.selected_text(&cells), None);
|
|
}
|
|
|
|
#[test]
|
|
fn keyboard_table_header_rectangle_excludes_record_values() {
|
|
let cells = [Arc::new(AgentMarkdownCell::new(
|
|
"| Left | Right |\n|---|---|\n| alpha | Beta |".into(),
|
|
std::path::Path::new("/"),
|
|
)) as Arc<dyn HistoryCell>];
|
|
for width in [10, 32] {
|
|
let mut view = select_table_at_match(&cells, width, "Left");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
assert_eq!(
|
|
view.selected_text(&cells).as_deref(),
|
|
Some("| Left | Right |\n|---|---|"),
|
|
"width {width}",
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn shift_click_extends_from_the_fixed_in_cell_text_anchor() {
|
|
let cells = [Arc::new(AgentMarkdownCell::new(
|
|
"| Text | Other |\n|---|---|\n| abcde | 1 |".into(),
|
|
std::path::Path::new("/"),
|
|
)) as Arc<dyn HistoryCell>];
|
|
for (motion, target, expected) in [(KeyCode::Left, "e", "bcd"), (KeyCode::Right, "a", "ab")] {
|
|
let mut view = select_table_at_match(&cells, /*width*/ 32, "bcd");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, motion);
|
|
let buffer = crate::transcript_view::tests::render(
|
|
&mut view, &cells, /*width*/ 32, /*height*/ 12,
|
|
);
|
|
let index = buffer
|
|
.content()
|
|
.iter()
|
|
.rposition(|cell| cell.symbol() == target)
|
|
.unwrap();
|
|
let (column, row) = buffer.pos_of(index);
|
|
view.handle_selection_mouse(
|
|
MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Left),
|
|
column,
|
|
row,
|
|
modifiers: KeyModifiers::SHIFT,
|
|
},
|
|
&cells,
|
|
/*patch_approval*/ None,
|
|
);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some(expected));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn in_cell_word_motion_projects_boundaries_past_escaped_pipes() {
|
|
for (header, query, motion, expected) in [
|
|
(r"A\|界語", "語", 'b', "界語"),
|
|
(r"A\|alpha", "alpha", 'e', "alpha"),
|
|
] {
|
|
let cells = [Arc::new(AgentMarkdownCell::new(
|
|
format!("| {header} | B |\n|---|---|"),
|
|
std::path::Path::new("/"),
|
|
)) as Arc<dyn HistoryCell>];
|
|
let mut view = select_table_at_match(&cells, /*width*/ 8, query);
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Char(motion));
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Char('y').into(), &cells),
|
|
Some(ViewAction::Copy(text)) if text == expected
|
|
));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn shift_click_replaces_the_cell_mark_at_the_same_endpoint() {
|
|
let cells = [Arc::new(AgentMarkdownCell::new(
|
|
"| Left | Right |\n|---|---|\n| alpha | Beta |\n| Gamma | delta |".into(),
|
|
std::path::Path::new("/"),
|
|
)) as Arc<dyn HistoryCell>];
|
|
let mut view = select_table_at_match(&cells, /*width*/ 32, "Beta");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Down);
|
|
crate::transcript_view::tests::render(&mut view, &cells, /*width*/ 32, /*height*/ 12);
|
|
let selection = view.selection.as_ref().unwrap();
|
|
let bounds = (selection.start, selection.end);
|
|
let (row, line) = view
|
|
.visible
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, visible)| {
|
|
visible.key == bounds.1.key
|
|
&& visible.layout.row_for_offset(bounds.1.offset) == visible.row
|
|
})
|
|
.unwrap();
|
|
let column = line
|
|
.layout
|
|
.column_for_offset_on_row(line.row, bounds.1.offset);
|
|
view.handle_selection_mouse(
|
|
MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Left),
|
|
column,
|
|
row: row as u16,
|
|
modifiers: KeyModifiers::SHIFT,
|
|
},
|
|
&cells,
|
|
/*patch_approval*/ None,
|
|
);
|
|
let selection = view.selection.as_ref().unwrap();
|
|
assert_eq!((selection.start, selection.end), bounds);
|
|
assert!(view.table_mark().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn keyboard_cell_word_motion_crosses_a_wrapped_identifier() {
|
|
let cells = [Arc::new(AgentMarkdownCell::new(
|
|
"| Name | Value |\n|---|---|\n| abcdefghijklmnop next | 1 |".into(),
|
|
std::path::Path::new("/"),
|
|
)) as Arc<dyn HistoryCell>];
|
|
let mut view = select_table_at_match(&cells, /*width*/ 12, "abcd");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
press(&mut view, &cells, KeyCode::Char('e'));
|
|
assert_eq!(
|
|
view.selected_text(&cells).as_deref(),
|
|
Some("abcdefghijklmnop")
|
|
);
|
|
press(&mut view, &cells, KeyCode::Char('b'));
|
|
press(&mut view, &cells, KeyCode::Char('w'));
|
|
assert_eq!(
|
|
view.selected_text(&cells).as_deref(),
|
|
Some("abcdefghijklmnop n")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn keyboard_table_motion_skips_record_labels_and_reaches_empty_cells() {
|
|
let cells: [Arc<dyn HistoryCell>; 1] = [Arc::new(AgentMarkdownCell::new(
|
|
"| Left | Right |\n|---|---|\n| alpha | Beta |\n| Gamma | |\n| omega | delta |".into(),
|
|
std::path::Path::new("/"),
|
|
))];
|
|
for width in [32, 10] {
|
|
let mut view = select_table_at_match(&cells, width, "Beta");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
press(&mut view, &cells, KeyCode::Char('j'));
|
|
assert_eq!(
|
|
view.selected_text(&cells).as_deref(),
|
|
Some("| | |\n|---|---|\n| | Beta |\n| | |\n| | delta |"),
|
|
"width {width}"
|
|
);
|
|
press(&mut view, &cells, KeyCode::Char('k'));
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
mark_markdown(&mut view, &cells);
|
|
assert_eq!(view.selected_text(&cells), None);
|
|
press(&mut view, &cells, KeyCode::Char('k'));
|
|
assert!(
|
|
view.selected_text(&cells)
|
|
.is_some_and(|text| text.contains("Beta"))
|
|
);
|
|
if width == 32 {
|
|
press(&mut view, &cells, KeyCode::Down);
|
|
press(&mut view, &cells, KeyCode::Esc);
|
|
press(&mut view, &cells, KeyCode::Up); // Cross the separator.
|
|
press(&mut view, &cells, KeyCode::Up);
|
|
mark_markdown(&mut view, &cells);
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("Beta"));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn keyboard_cell_text_crosses_wraps_without_selecting_neighbors() {
|
|
let cells: [Arc<dyn HistoryCell>; 1] = [Arc::new(AgentMarkdownCell::new(
|
|
"| Description | Size |\n|---|---|\n| alpha **界 beta gamma delta** omega | 123 |\n| following | 456 |".into(),
|
|
std::path::Path::new("/"),
|
|
))];
|
|
for width in [34, 12] {
|
|
let mut view = select_table_at_match(&cells, width, "界");
|
|
mark_markdown(&mut view, &cells);
|
|
press(&mut view, &cells, KeyCode::Char('v'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("界"));
|
|
press(&mut view, &cells, KeyCode::Down);
|
|
assert!(
|
|
view.selected_text(&cells).unwrap().starts_with("界 beta"),
|
|
"width {width}"
|
|
);
|
|
press(&mut view, &cells, KeyCode::Up);
|
|
press(&mut view, &cells, KeyCode::Char('w'));
|
|
assert_eq!(view.selected_text(&cells).as_deref(), Some("界 b"));
|
|
press(&mut view, &cells, KeyCode::End);
|
|
press(&mut view, &cells, KeyCode::Right);
|
|
let text = "界 beta gamma delta omega";
|
|
assert!(matches!(
|
|
view.handle_key(KeyCode::Char('y').into(), &cells),
|
|
Some(ViewAction::Copy(copy)) if copy == text
|
|
));
|
|
view.copy_selected_text_with(
|
|
&cells,
|
|
text,
|
|
/*clear_selection*/ false,
|
|
|text, format| {
|
|
assert_eq!(
|
|
(text, format),
|
|
(
|
|
"界 beta gamma delta omega",
|
|
crate::clipboard_copy::CopyFormat::MarkdownSelection(
|
|
"**界 beta gamma delta** omega".into()
|
|
),
|
|
)
|
|
);
|
|
Ok(CopyStatus::Confirmed)
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
press(&mut view, &cells, KeyCode::Char('o'));
|
|
press(&mut view, &cells, KeyCode::Home);
|
|
press(&mut view, &cells, KeyCode::Left);
|
|
assert_eq!(
|
|
view.selected_text(&cells).as_deref(),
|
|
Some("alpha 界 beta gamma delta omega"),
|
|
"width {width}"
|
|
);
|
|
}
|
|
}
|