Files
codex/codex-rs/tui/src/transcript_view/select_mode_tests.rs
T
Felipe Coury 9302bb553e Select and copy Markdown blocks in the transcript (#63047)
## What changed

Press `m` in transcript selection mode to mark the Markdown block at the cursor. Move between sibling blocks with `h` and `l`, or extend the selection with `j` and `k`. Use `Tab` to expand to an enclosing block or heading section and `Shift+Tab` to shrink the selection.

Copy with `y` to retain Markdown structure, including list markers, code fence languages, and table formatting. For example, you can copy a fenced code block on its own from inside a blockquote.

## Testing

Add coverage for wrapped blocks, nested lists and sections, table selection, copying from the displayed revision during streaming, and conflicts with customized keybindings.

GitOrigin-RevId: 5d4d873c0e378294128c128f472e4dae122831c6
2026-11-21 21:51:31 +00:00

1470 lines
50 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_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
}
fn mark_markdown(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>]) {
press(view, cells, KeyCode::Char('m'));
}
#[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_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::BOLD | Modifier::REVERSED) {
"@"
} 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_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_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_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_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_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_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_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}"
);
}
}
fn marked_markdown_at(
markdown: &str,
width: u16,
query: &str,
) -> (TranscriptView, [Arc<dyn HistoryCell>; 1]) {
let cells: [Arc<dyn HistoryCell>; 1] = [Arc::new(AgentMarkdownCell::new(
markdown.into(),
std::path::Path::new("/"),
))];
let mut view = select_at_match(&cells, width, query);
mark_markdown(&mut view, &cells);
(view, cells)
}
#[test]
fn markdown_mark_copies_wrapped_siblings_from_the_displayed_revision() {
let (mut view, cells) = marked_markdown_at(
"## Release notes\n\nRead the **界 changes** before updating.\n\nRead the **界 changes** before updating.",
/*width*/ 20,
"Release",
);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("## Release notes")
);
press(&mut view, &cells, KeyCode::Down);
let pair = "## Release notes\n\nRead the **界 changes** before updating.";
assert_eq!(view.selected_text(&cells).as_deref(), Some(pair));
press(&mut view, &cells, KeyCode::Tab);
let section = format!("{pair}\n\nRead the **界 changes** before updating.");
press(&mut view, &cells, KeyCode::Char('/'));
press(&mut view, &cells, KeyCode::Esc);
let updated = [cell(&["new revision"])];
let painted = crate::transcript_view::tests::render(
&mut view, &updated, /*width*/ 24, /*height*/ 8,
);
let hints = [120, 45].map(|width| {
view.footer_with_navigation(width, crate::motion::MotionMode::Reduced, "")
.unwrap()
.text
.to_string()
});
let selected = painted
.content()
.chunks(24)
.map(|row| {
row.iter()
.filter(|c| c.modifier.contains(ratatui::style::Modifier::REVERSED))
.map(ratatui::buffer::Cell::symbol)
.collect::<String>()
.trim_end()
.to_owned()
})
.collect::<Vec<_>>()
.join("\n");
insta::assert_snapshot!(format!("{}\n{}", selected.trim_end(), hints.join("\n")));
let Some(ViewAction::Copy(text)) = view.handle_key(KeyCode::Char('y').into(), &updated) else {
panic!("expected copy")
};
view.copy_selected_text_with(
&updated,
&text,
/*clear_selection*/ false,
|text, format| {
assert_eq!(
(text, format),
(
section.as_str(),
crate::clipboard_copy::CopyFormat::Markdown
)
);
Ok(CopyStatus::Confirmed)
},
)
.unwrap();
press(&mut view, &updated, KeyCode::BackTab);
assert_eq!(view.selected_text(&updated).as_deref(), Some(pair));
press(&mut view, &updated, KeyCode::Char('o'));
press(&mut view, &updated, KeyCode::Down);
assert_eq!(
view.selected_text(&updated).as_deref(),
Some("Read the **界 changes** before updating.")
);
}
#[test]
fn markdown_mark_expands_and_moves_between_sections() {
let macos = "### macOS\n\nOpen the **disk image**.\n\nDrag the app.";
let linux = "### Linux\n\nUnpack the archive.\n\n***";
let platforms = format!("{macos}\n\n{linux}");
let install = format!("## Install\n\n{platforms}");
let (mut view, cells) = marked_markdown_at(
&format!("{install}\n\n## Usage"),
/*width*/ 32,
"macOS",
);
assert_eq!(view.selected_text(&cells).as_deref(), Some("### macOS"));
for (key, expected) in [
(KeyCode::Right, "Open the **disk image**."),
(KeyCode::Left, "### macOS"),
(KeyCode::Tab, macos),
(KeyCode::Char('l'), linux),
(KeyCode::BackTab, "### Linux"),
(KeyCode::Tab, linux),
(KeyCode::Char('h'), macos),
(KeyCode::Char('j'), platforms.as_str()),
(KeyCode::Tab, install.as_str()),
(KeyCode::BackTab, platforms.as_str()),
(KeyCode::Char('k'), macos),
(KeyCode::Tab, install.as_str()),
(KeyCode::BackTab, macos),
] {
press(&mut view, &cells, key);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some(expected),
"{key:?}"
);
}
}
#[test]
fn markdown_sections_respect_heading_rank_and_parser_containers() {
let (mut view, cells) = marked_markdown_at(
"# Guide\n\n> Intro\n> -----\n>\n> #### Example\n>\n> ```sh\n> # a comment\n> ```\n\nOutside the quote.\n\n# Usage",
/*width*/ 40,
"Example",
);
for (key, expected) in [
(KeyCode::Tab, "#### Example\n\n```sh\n# a comment\n```"),
(
KeyCode::Tab,
"## Intro\n\n#### Example\n\n```sh\n# a comment\n```",
),
(KeyCode::BackTab, "#### Example\n\n```sh\n# a comment\n```"),
(KeyCode::BackTab, "#### Example"),
] {
press(&mut view, &cells, key);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some(expected),
"{key:?}"
);
}
}
#[test]
fn markdown_mark_expands_nested_items_and_recovers_original_sibling_range() {
let (mut view, cells) = marked_markdown_at(
"- First\n- Parent\n - **Nested**\n - Second\n - Third\n- Last",
/*width*/ 32,
"Nested",
);
assert_eq!(view.selected_text(&cells).as_deref(), Some("- **Nested**"));
press(&mut view, &cells, KeyCode::Char('j'));
let pair = "- **Nested**\n- Second";
assert_eq!(view.selected_text(&cells).as_deref(), Some(pair));
// Move from the active end of the pair, staying within the nested list.
for (key, expected) in [
(KeyCode::Char('l'), "- Third"),
(KeyCode::Right, "- Third"),
(KeyCode::Left, "- Second"),
(KeyCode::Tab, "- **Nested**\n- Second\n- Third"),
(KeyCode::BackTab, "- Second"),
(KeyCode::Char('h'), "- **Nested**"),
(KeyCode::Left, "- **Nested**"),
(KeyCode::Right, "- Second"),
(KeyCode::Char('k'), pair),
] {
press(&mut view, &cells, key);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some(expected),
"{key:?}"
);
}
press(&mut view, &cells, KeyCode::Char('o'));
press(&mut view, &cells, KeyCode::Tab);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("- **Nested**\n- Second\n- Third")
);
let hints = [120, 40].map(|width| {
use ratatui::style::Modifier;
let footer = view
.footer_with_navigation(width, crate::motion::MotionMode::Reduced, "")
.unwrap();
footer.text.lines[0]
.spans
.iter()
.map(|span| {
if span.style.add_modifier.contains(Modifier::BOLD) {
format!("**{}**", span.content)
} else {
span.content.to_string()
}
})
.collect::<String>()
});
insta::assert_snapshot!("markdown_list_footer", hints.join("\n"));
press(&mut view, &cells, KeyCode::Tab);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("- Parent\n - **Nested**\n - Second\n - Third")
);
press(&mut view, &cells, KeyCode::BackTab);
press(&mut view, &cells, KeyCode::BackTab);
assert_eq!(view.selected_text(&cells).as_deref(), Some(pair));
press(&mut view, &cells, KeyCode::Char('v'));
assert_eq!(view.selected_text(&cells).as_deref(), Some("S"));
}
#[test]
fn markdown_mark_copies_code_with_language_and_only_selected_quote_levels() {
let (mut view, cells) = marked_markdown_at(
"> > ```rust\n> > let example = 1;\n> >\n> > example\n> > ```",
/*width*/ 16,
"example",
);
let code = "```rust\nlet example = 1;\n\nexample\n```";
assert_eq!(view.selected_text(&cells).as_deref(), Some(code));
view.handle_key(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT), &cells);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("> ```rust\n> let example = 1;\n> \n> example\n> ```")
);
view.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::ALT), &cells);
assert_eq!(view.selected_text(&cells).as_deref(), Some(code));
}
#[test]
fn markdown_mark_copies_empty_items_at_the_edges_of_a_list() {
let (mut view, cells) =
marked_markdown_at("- [ ] \n- [x] Done\n- [ ] ", /*width*/ 32, "Done");
press(&mut view, &cells, KeyCode::Tab); // Paragraph to item.
press(&mut view, &cells, KeyCode::Tab); // Item to list.
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("- [ ] \n- [x] Done\n- [ ] ")
);
let buffer = render(&mut view, &cells);
let highlighted: Vec<_> = buffer
.content()
.chunks(usize::from(buffer.area.width))
.map(|row| {
row.iter()
.filter(|cell| cell.modifier.contains(ratatui::style::Modifier::REVERSED))
.map(ratatui::buffer::Cell::symbol)
.collect::<String>()
})
.map(|row| row.trim().to_owned())
.filter(|row| !row.is_empty())
.collect();
insta::assert_snapshot!(highlighted.join("\n"), @"
• ☐
☑ Done
☐
");
press(&mut view, &cells, KeyCode::BackTab);
press(&mut view, &cells, KeyCode::Right);
assert_eq!(view.selected_text(&cells).as_deref(), Some("- [ ] "));
}
#[test]
fn markdown_mark_can_start_on_a_list_with_no_item_text() {
let cells: [Arc<dyn HistoryCell>; 1] = [Arc::new(AgentMarkdownCell::new(
"- [ ] \n- [x] ".into(),
std::path::Path::new("/"),
))];
let mut view = TranscriptView::default();
render(&mut view, &cells);
assert!(view.begin_select_mode(&cells));
mark_markdown(&mut view, &cells);
assert_eq!(view.selected_text(&cells).as_deref(), Some("- [x] "));
press(&mut view, &cells, KeyCode::Tab);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("- [ ] \n- [x] ")
);
}
#[test]
fn markdown_mark_fences_rendered_mermaid_as_plain_code() {
let (mut view, cells) = marked_markdown_at(
"```mermaid\nflowchart LR\nA[Start] --> B[Finish]\n```",
/*width*/ 80,
"Finish",
);
let text = view.selected_text(&cells).unwrap();
let body = text
.strip_prefix("```\n")
.and_then(|text| text.strip_suffix("\n```"))
.unwrap();
assert!(body.contains("Start") && body.contains("Finish"));
assert!(!body.contains("flowchart LR"));
}
#[test]
fn markdown_mark_can_round_trip_from_rectangle_to_table() {
let table = "| Left | Right |\n|---|---|\n| alpha | **Beta** |\n| Gamma | delta |";
for width in [10, 32] {
let (mut view, cells) = marked_markdown_at(table, width, "Beta");
press(&mut view, &cells, KeyCode::Down);
let rectangle = view.selected_text(&cells).unwrap();
press(&mut view, &cells, KeyCode::Tab);
assert_eq!(view.selected_text(&cells).as_deref(), Some(table));
press(&mut view, &cells, KeyCode::BackTab);
assert_eq!(view.selected_text(&cells), Some(rectangle));
}
}
#[test]
fn markdown_mark_copies_the_visible_task_label_and_only_the_selected_container() {
let (mut view, cells) = marked_markdown_at(
"- [x] :codex-followup[Check **status**]{prompt=\"hidden instruction\"}\n\n Read the logs.\n\n- [ ] Retry",
/*width*/ 24,
"status",
);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("Check **status**")
);
press(&mut view, &cells, KeyCode::Tab);
assert_eq!(
view.selected_text(&cells).as_deref(),
Some("- [x] Check **status**\n\n Read the logs.")
);
}
#[test]
fn markdown_mark_expands_the_live_table_at_the_revision_seen_before_the_next_delta() {
let mut stream = crate::streaming::controller::StreamController::new(
/*width*/ Some(32),
std::path::Path::new("/"),
crate::history_cell::HistoryRenderMode::Rich,
);
stream.push("| Left | Right |\n|---|---|\n| alpha | **Beta** |\n");
let mut view = TranscriptView::default();
view.sync_live_tail(
/*width*/ 32,
/*key*/ None,
|_| Some(stream.current_tail_lines()),
);
render(&mut view, &[]);
assert!(view.begin_select_mode(&[]));
mark_markdown(&mut view, &[]);
stream.push("| newer | delta |\n");
view.sync_live_tail(
/*width*/ 32,
/*key*/ None,
|_| Some(stream.current_tail_lines()),
);
render(&mut view, &[]);
press(&mut view, &[], KeyCode::Tab);
assert_eq!(
view.selected_text(&[]).as_deref(),
Some("| Left | Right |\n|---|---|\n| alpha | **Beta** |")
);
}