use crate::{ motion::{self, Motion}, object::Object, state::Mode, Vim,};use editor::{ display_map::ToDisplayPoint, scroll::Autoscroll, Anchor, Bias, Editor, EditorSnapshot, ToOffset, ToPoint,};use gpui::{actions, Context, Window};use language::{Point, SelectionGoal};use std::ops::Range;use std::sync::Arc; actions!(vim, [ToggleReplace, UndoReplace]); pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) { Vim::action(editor, cx, |vim, _: &ToggleReplace, window, cx| { vim.replacements = vec![]; vim.start_recording(cx); vim.switch_mode(Mode::Replace, false, window, cx); }); Vim::action(editor, cx, |vim, _: &UndoReplace, window, cx| { if vim.mode != Mode::Replace { return; } let count = Vim::take_count(cx); vim.undo_replace(count, window, cx) });} struct VimExchange; impl Vim { pub(crate) fn multi_replace( &mut self, text: Arc<str>, window: &mut Window, cx: &mut Context<Self>, ) { self.update_editor(window, cx, |vim, editor, window, cx| { editor.transact(window, cx, |editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let map = editor.snapshot(window, cx); let display_selections = editor.selections.all::<Point>(cx); // Handles all string that require manipulation, including inserts and replaces let edits = display_selections .into_iter() .map(|selection| { let is_new_line = text.as_ref() == "\n"; let mut range = selection.range(); // "\n" need to be handled separately, because when a "\n" is typing, // we don't do a replace, we need insert a "\n" if !is_new_line { range.end.column += 1; range.end = map.buffer_snapshot.clip_point(range.end, Bias::Right); } let replace_range = map.buffer_snapshot.anchor_before(range.start) ..map.buffer_snapshot.anchor_after(range.end); let current_text = map .buffer_snapshot .text_for_range(replace_range.clone()) .collect(); vim.replacements.push((replace_range.clone(), current_text)); (replace_range, text.clone()) }) .collect::<Vec<_>>(); editor.edit_with_block_indent(edits.clone(), Vec::new(), cx); editor.change_selections(None, window, cx, |s| { s.select_anchor_ranges(edits.iter().map(|(range, _)| range.end..range.end)); }); editor.set_clip_at_line_ends(true, cx); }); }); } fn undo_replace( &mut self, maybe_times: Option<usize>, window: &mut Window, cx: &mut Context<Self>, ) { self.update_editor(window, cx, |vim, editor, window, cx| { editor.transact(window, cx, |editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let map = editor.snapshot(window, cx); let selections = editor.selections.all::<Point>(cx); let mut new_selections = vec![]; let edits: Vec<(Range<Point>, String)> = selections .into_iter() .filter_map(|selection| { let end = selection.head(); let start = motion::backspace( &map, end.to_display_point(&map), maybe_times.unwrap_or(1), ) .to_point(&map); new_selections.push( map.buffer_snapshot.anchor_before(start) ..map.buffer_snapshot.anchor_before(start), ); let mut undo = None; let edit_range = start..end; for (i, (range, inverse)) in vim.replacements.iter().rev().enumerate() { if range.start.to_point(&map.buffer_snapshot) <= edit_range.start && range.end.to_point(&map.buffer_snapshot) >= edit_range.end { undo = Some(inverse.clone()); vim.replacements.remove(vim.replacements.len() - i - 1); break; } } Some((edit_range, undo?)) }) .collect::<Vec<_>>(); editor.edit(edits, cx); editor.change_selections(None, window, cx, |s| { s.select_ranges(new_selections); }); editor.set_clip_at_line_ends(true, cx); }); }); } pub fn exchange_object( &mut self, object: Object, around: bool, window: &mut Window, cx: &mut Context<Self>, ) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let mut selection = editor.selections.newest_display(cx); let snapshot = editor.snapshot(window, cx); object.expand_selection(&snapshot, &mut selection, around); let start = snapshot .buffer_snapshot .anchor_before(selection.start.to_point(&snapshot)); let end = snapshot .buffer_snapshot .anchor_before(selection.end.to_point(&snapshot)); let new_range = start..end; vim.exchange_impl(new_range, editor, &snapshot, window, cx); editor.set_clip_at_line_ends(true, cx); }); } pub fn exchange_visual(&mut self, window: &mut Window, cx: &mut Context<Self>) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { let selection = editor.selections.newest_anchor(); let new_range = selection.start..selection.end; let snapshot = editor.snapshot(window, cx); vim.exchange_impl(new_range, editor, &snapshot, window, cx); }); self.switch_mode(Mode::Normal, false, window, cx); } pub fn clear_exchange(&mut self, window: &mut Window, cx: &mut Context<Self>) { self.stop_recording(cx); self.update_editor(window, cx, |_, editor, _, cx| { editor.clear_background_highlights::<VimExchange>(cx); }); self.clear_operator(window, cx); } pub fn exchange_motion( &mut self, motion: Motion, times: Option<usize>, window: &mut Window, cx: &mut Context<Self>, ) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let text_layout_details = editor.text_layout_details(window); let mut selection = editor.selections.newest_display(cx); let snapshot = editor.snapshot(window, cx); motion.expand_selection( &snapshot, &mut selection, times, false, &text_layout_details, ); let start = snapshot .buffer_snapshot .anchor_before(selection.start.to_point(&snapshot)); let end = snapshot .buffer_snapshot .anchor_before(selection.end.to_point(&snapshot)); let new_range = start..end; vim.exchange_impl(new_range, editor, &snapshot, window, cx); editor.set_clip_at_line_ends(true, cx); }); } pub fn exchange_impl( &self, new_range: Range<Anchor>, editor: &mut Editor, snapshot: &EditorSnapshot, window: &mut Window, cx: &mut Context<Editor>, ) { if let Some((_, ranges)) = editor.clear_background_highlights::<VimExchange>(cx) { let previous_range = ranges[0].clone(); let new_range_start = new_range.start.to_offset(&snapshot.buffer_snapshot); let new_range_end = new_range.end.to_offset(&snapshot.buffer_snapshot); let previous_range_end = previous_range.end.to_offset(&snapshot.buffer_snapshot); let previous_range_start = previous_range.start.to_offset(&snapshot.buffer_snapshot); let text_for = |range: Range<Anchor>| { snapshot .buffer_snapshot .text_for_range(range) .collect::<String>() }; let mut final_cursor_position = None; if previous_range_end < new_range_start || new_range_end < previous_range_start { let previous_text = text_for(previous_range.clone()); let new_text = text_for(new_range.clone()); final_cursor_position = Some(new_range.start.to_display_point(snapshot)); editor.edit([(previous_range, new_text), (new_range, previous_text)], cx); } else if new_range_start <= previous_range_start && new_range_end >= previous_range_end { final_cursor_position = Some(new_range.start.to_display_point(snapshot)); editor.edit([(new_range, text_for(previous_range))], cx); } else if previous_range_start <= new_range_start && previous_range_end >= new_range_end { final_cursor_position = Some(previous_range.start.to_display_point(snapshot)); editor.edit([(previous_range, text_for(new_range))], cx); } if let Some(position) = final_cursor_position { editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| { s.move_with(|_map, selection| { selection.collapse_to(position, SelectionGoal::None); }); }) } } else { let ranges = [new_range]; editor.highlight_background::<VimExchange>( &ranges, |theme| theme.editor_document_highlight_read_background, cx, ); } }} #[cfg(test)]mod test { use indoc::indoc; use crate::{ state::Mode, test::{NeovimBackedTestContext, VimTestContext}, }; #[gpui::test] async fn test_enter_and_exit_replace_mode(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.simulate_keystrokes("shift-r"); assert_eq!(cx.mode(), Mode::Replace); cx.simulate_keystrokes("escape"); assert_eq!(cx.mode(), Mode::Normal); } #[gpui::test] #[cfg(not(any(target_os = "linux", target_os = "freebsd")))] async fn test_replace_mode(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; // test normal replace cx.set_shared_state(indoc! {" ˇThe quick brown fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" Oneˇ quick brown fox jumps over the lazy dog."}); // test replace with line ending cx.set_shared_state(indoc! {" The quick browˇn fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" The quick browOneˇ fox jumps over the lazy dog."}); // test replace with blank line cx.set_shared_state(indoc! {" The quick brown ˇ fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" The quick brown Oneˇ fox jumps over the lazy dog."}); // test replace with newline cx.set_shared_state(indoc! {" The quˇick brown fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r enter O n e").await; cx.shared_state().await.assert_eq(indoc! {" The qu Oneˇ brown fox jumps over the lazy dog."}); // test replace with multi cursor and newline cx.set_state( indoc! {" ˇThe quick brown fox jumps over the lazy ˇdog."}, Mode::Normal, ); cx.simulate_keystrokes("shift-r O n e"); cx.assert_state( indoc! {" Oneˇ quick brown fox jumps over the lazy Oneˇ."}, Mode::Replace, ); cx.simulate_keystrokes("enter T w o"); cx.assert_state( indoc! {" One Twoˇck brown fox jumps over the lazy One Twoˇ"}, Mode::Replace, ); } #[gpui::test] async fn test_replace_mode_with_counts(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; cx.set_shared_state("ˇhello\n").await; cx.simulate_shared_keystrokes("3 shift-r - escape").await; cx.shared_state().await.assert_eq("--ˇ-lo\n"); cx.set_shared_state("ˇhello\n").await; cx.simulate_shared_keystrokes("3 shift-r a b c escape") .await; cx.shared_state().await.assert_eq("abcabcabˇc\n"); } #[gpui::test] async fn test_replace_mode_repeat(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; cx.set_shared_state("ˇhello world\n").await; cx.simulate_shared_keystrokes("shift-r - - - escape 4 l .") .await; cx.shared_state().await.assert_eq("---lo --ˇ-ld\n"); } #[gpui::test] async fn test_replace_mode_undo(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; const UNDO_REPLACE_EXAMPLES: &[&str] = &[ // replace undo with single line "ˇThe quick brown fox jumps over the lazy dog.", // replace undo with ending line indoc! {" The quick browˇn fox jumps over the lazy dog." }, // replace undo with empty line indoc! {" The quick brown ˇ fox jumps over the lazy dog." }, ]; for example in UNDO_REPLACE_EXAMPLES { // normal undo cx.simulate("shift-r O n e backspace backspace backspace", example) .await .assert_matches(); // undo with new line cx.simulate("shift-r O enter e backspace backspace backspace", example) .await .assert_matches(); cx.simulate( "shift-r O enter n enter e backspace backspace backspace backspace backspace", example, ) .await .assert_matches(); } } #[gpui::test] async fn test_replace_multicursor(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇabcˇabcabc", Mode::Normal); cx.simulate_keystrokes("shift-r 1 2 3 4"); cx.assert_state("1234ˇ234ˇbc", Mode::Replace); assert_eq!(cx.mode(), Mode::Replace); cx.simulate_keystrokes("backspace backspace backspace backspace backspace"); cx.assert_state("ˇabˇcabcabc", Mode::Replace); } #[gpui::test] async fn test_replace_undo(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇaaaa", Mode::Normal); cx.simulate_keystrokes("0 shift-r b b b escape u"); cx.assert_state("ˇaaaa", Mode::Normal); } #[gpui::test] async fn test_exchange_separate_range(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x i w w c x i w"); cx.assert_state("world ˇhello", Mode::Normal); } #[gpui::test] async fn test_exchange_complete_overlap(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x x w c x i w"); cx.assert_state("ˇworld", Mode::Normal); // the focus should still be at the start of the word if we reverse the // order of selections (smaller -> larger) cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x i w c x x"); cx.assert_state("ˇhello", Mode::Normal); } #[gpui::test] async fn test_exchange_partial_overlap(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x t r w c x i w"); cx.assert_state("hello ˇworld", Mode::Normal); } #[gpui::test] async fn test_clear_exchange_clears_operator(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇirrelevant", Mode::Normal); cx.simulate_keystrokes("c x c"); assert_eq!(cx.active_operator(), None); } #[gpui::test] async fn test_clear_exchange(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await;Lines 1–500 of 510. Load more
use crate::{ motion::{self, Motion}, object::Object, state::Mode, Vim, }; use editor::{ display_map::ToDisplayPoint, scroll::Autoscroll, Anchor, Bias, Editor, EditorSnapshot, ToOffset, ToPoint, }; use gpui::{actions, Context, Window}; use language::{Point, SelectionGoal}; use std::ops::Range; use std::sync::Arc; actions!(vim, [ToggleReplace, UndoReplace]); pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) { Vim::action(editor, cx, |vim, _: &ToggleReplace, window, cx| { vim.replacements = vec![]; vim.start_recording(cx); vim.switch_mode(Mode::Replace, false, window, cx); }); Vim::action(editor, cx, |vim, _: &UndoReplace, window, cx| { if vim.mode != Mode::Replace { return; } let count = Vim::take_count(cx); vim.undo_replace(count, window, cx) }); } struct VimExchange; impl Vim { pub(crate) fn multi_replace( &mut self, text: Arc<str>, window: &mut Window, cx: &mut Context<Self>, ) { self.update_editor(window, cx, |vim, editor, window, cx| { editor.transact(window, cx, |editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let map = editor.snapshot(window, cx); let display_selections = editor.selections.all::<Point>(cx); // Handles all string that require manipulation, including inserts and replaces let edits = display_selections .into_iter() .map(|selection| { let is_new_line = text.as_ref() == "\n"; let mut range = selection.range(); // "\n" need to be handled separately, because when a "\n" is typing, // we don't do a replace, we need insert a "\n" if !is_new_line { range.end.column += 1; range.end = map.buffer_snapshot.clip_point(range.end, Bias::Right); } let replace_range = map.buffer_snapshot.anchor_before(range.start) ..map.buffer_snapshot.anchor_after(range.end); let current_text = map .buffer_snapshot .text_for_range(replace_range.clone()) .collect(); vim.replacements.push((replace_range.clone(), current_text)); (replace_range, text.clone()) }) .collect::<Vec<_>>(); editor.edit_with_block_indent(edits.clone(), Vec::new(), cx); editor.change_selections(None, window, cx, |s| { s.select_anchor_ranges(edits.iter().map(|(range, _)| range.end..range.end)); }); editor.set_clip_at_line_ends(true, cx); }); }); } fn undo_replace( &mut self, maybe_times: Option<usize>, window: &mut Window, cx: &mut Context<Self>, ) { self.update_editor(window, cx, |vim, editor, window, cx| { editor.transact(window, cx, |editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let map = editor.snapshot(window, cx); let selections = editor.selections.all::<Point>(cx); let mut new_selections = vec![]; let edits: Vec<(Range<Point>, String)> = selections .into_iter() .filter_map(|selection| { let end = selection.head(); let start = motion::backspace( &map, end.to_display_point(&map), maybe_times.unwrap_or(1), ) .to_point(&map); new_selections.push( map.buffer_snapshot.anchor_before(start) ..map.buffer_snapshot.anchor_before(start), ); let mut undo = None; let edit_range = start..end; for (i, (range, inverse)) in vim.replacements.iter().rev().enumerate() { if range.start.to_point(&map.buffer_snapshot) <= edit_range.start && range.end.to_point(&map.buffer_snapshot) >= edit_range.end { undo = Some(inverse.clone()); vim.replacements.remove(vim.replacements.len() - i - 1); break; } } Some((edit_range, undo?)) }) .collect::<Vec<_>>(); editor.edit(edits, cx); editor.change_selections(None, window, cx, |s| { s.select_ranges(new_selections); }); editor.set_clip_at_line_ends(true, cx); }); }); } pub fn exchange_object( &mut self, object: Object, around: bool, window: &mut Window, cx: &mut Context<Self>, ) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let mut selection = editor.selections.newest_display(cx); let snapshot = editor.snapshot(window, cx); object.expand_selection(&snapshot, &mut selection, around); let start = snapshot .buffer_snapshot .anchor_before(selection.start.to_point(&snapshot)); let end = snapshot .buffer_snapshot .anchor_before(selection.end.to_point(&snapshot)); let new_range = start..end; vim.exchange_impl(new_range, editor, &snapshot, window, cx); editor.set_clip_at_line_ends(true, cx); }); } pub fn exchange_visual(&mut self, window: &mut Window, cx: &mut Context<Self>) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { let selection = editor.selections.newest_anchor(); let new_range = selection.start..selection.end; let snapshot = editor.snapshot(window, cx); vim.exchange_impl(new_range, editor, &snapshot, window, cx); }); self.switch_mode(Mode::Normal, false, window, cx); } pub fn clear_exchange(&mut self, window: &mut Window, cx: &mut Context<Self>) { self.stop_recording(cx); self.update_editor(window, cx, |_, editor, _, cx| { editor.clear_background_highlights::<VimExchange>(cx); }); self.clear_operator(window, cx); } pub fn exchange_motion( &mut self, motion: Motion, times: Option<usize>, window: &mut Window, cx: &mut Context<Self>, ) { self.stop_recording(cx); self.update_editor(window, cx, |vim, editor, window, cx| { editor.set_clip_at_line_ends(false, cx); let text_layout_details = editor.text_layout_details(window); let mut selection = editor.selections.newest_display(cx); let snapshot = editor.snapshot(window, cx); motion.expand_selection( &snapshot, &mut selection, times, false, &text_layout_details, ); let start = snapshot .buffer_snapshot .anchor_before(selection.start.to_point(&snapshot)); let end = snapshot .buffer_snapshot .anchor_before(selection.end.to_point(&snapshot)); let new_range = start..end; vim.exchange_impl(new_range, editor, &snapshot, window, cx); editor.set_clip_at_line_ends(true, cx); }); } pub fn exchange_impl( &self, new_range: Range<Anchor>, editor: &mut Editor, snapshot: &EditorSnapshot, window: &mut Window, cx: &mut Context<Editor>, ) { if let Some((_, ranges)) = editor.clear_background_highlights::<VimExchange>(cx) { let previous_range = ranges[0].clone(); let new_range_start = new_range.start.to_offset(&snapshot.buffer_snapshot); let new_range_end = new_range.end.to_offset(&snapshot.buffer_snapshot); let previous_range_end = previous_range.end.to_offset(&snapshot.buffer_snapshot); let previous_range_start = previous_range.start.to_offset(&snapshot.buffer_snapshot); let text_for = |range: Range<Anchor>| { snapshot .buffer_snapshot .text_for_range(range) .collect::<String>() }; let mut final_cursor_position = None; if previous_range_end < new_range_start || new_range_end < previous_range_start { let previous_text = text_for(previous_range.clone()); let new_text = text_for(new_range.clone()); final_cursor_position = Some(new_range.start.to_display_point(snapshot)); editor.edit([(previous_range, new_text), (new_range, previous_text)], cx); } else if new_range_start <= previous_range_start && new_range_end >= previous_range_end { final_cursor_position = Some(new_range.start.to_display_point(snapshot)); editor.edit([(new_range, text_for(previous_range))], cx); } else if previous_range_start <= new_range_start && previous_range_end >= new_range_end { final_cursor_position = Some(previous_range.start.to_display_point(snapshot)); editor.edit([(previous_range, text_for(new_range))], cx); } if let Some(position) = final_cursor_position { editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| { s.move_with(|_map, selection| { selection.collapse_to(position, SelectionGoal::None); }); }) } } else { let ranges = [new_range]; editor.highlight_background::<VimExchange>( &ranges, |theme| theme.editor_document_highlight_read_background, cx, ); } } } #[cfg(test)] mod test { use indoc::indoc; use crate::{ state::Mode, test::{NeovimBackedTestContext, VimTestContext}, }; #[gpui::test] async fn test_enter_and_exit_replace_mode(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.simulate_keystrokes("shift-r"); assert_eq!(cx.mode(), Mode::Replace); cx.simulate_keystrokes("escape"); assert_eq!(cx.mode(), Mode::Normal); } #[gpui::test] #[cfg(not(any(target_os = "linux", target_os = "freebsd")))] async fn test_replace_mode(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; // test normal replace cx.set_shared_state(indoc! {" ˇThe quick brown fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" Oneˇ quick brown fox jumps over the lazy dog."}); // test replace with line ending cx.set_shared_state(indoc! {" The quick browˇn fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" The quick browOneˇ fox jumps over the lazy dog."}); // test replace with blank line cx.set_shared_state(indoc! {" The quick brown ˇ fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r O n e").await; cx.shared_state().await.assert_eq(indoc! {" The quick brown Oneˇ fox jumps over the lazy dog."}); // test replace with newline cx.set_shared_state(indoc! {" The quˇick brown fox jumps over the lazy dog."}) .await; cx.simulate_shared_keystrokes("shift-r enter O n e").await; cx.shared_state().await.assert_eq(indoc! {" The qu Oneˇ brown fox jumps over the lazy dog."}); // test replace with multi cursor and newline cx.set_state( indoc! {" ˇThe quick brown fox jumps over the lazy ˇdog."}, Mode::Normal, ); cx.simulate_keystrokes("shift-r O n e"); cx.assert_state( indoc! {" Oneˇ quick brown fox jumps over the lazy Oneˇ."}, Mode::Replace, ); cx.simulate_keystrokes("enter T w o"); cx.assert_state( indoc! {" One Twoˇck brown fox jumps over the lazy One Twoˇ"}, Mode::Replace, ); } #[gpui::test] async fn test_replace_mode_with_counts(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; cx.set_shared_state("ˇhello\n").await; cx.simulate_shared_keystrokes("3 shift-r - escape").await; cx.shared_state().await.assert_eq("--ˇ-lo\n"); cx.set_shared_state("ˇhello\n").await; cx.simulate_shared_keystrokes("3 shift-r a b c escape") .await; cx.shared_state().await.assert_eq("abcabcabˇc\n"); } #[gpui::test] async fn test_replace_mode_repeat(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; cx.set_shared_state("ˇhello world\n").await; cx.simulate_shared_keystrokes("shift-r - - - escape 4 l .") .await; cx.shared_state().await.assert_eq("---lo --ˇ-ld\n"); } #[gpui::test] async fn test_replace_mode_undo(cx: &mut gpui::TestAppContext) { let mut cx: NeovimBackedTestContext = NeovimBackedTestContext::new(cx).await; const UNDO_REPLACE_EXAMPLES: &[&str] = &[ // replace undo with single line "ˇThe quick brown fox jumps over the lazy dog.", // replace undo with ending line indoc! {" The quick browˇn fox jumps over the lazy dog." }, // replace undo with empty line indoc! {" The quick brown ˇ fox jumps over the lazy dog." }, ]; for example in UNDO_REPLACE_EXAMPLES { // normal undo cx.simulate("shift-r O n e backspace backspace backspace", example) .await .assert_matches(); // undo with new line cx.simulate("shift-r O enter e backspace backspace backspace", example) .await .assert_matches(); cx.simulate( "shift-r O enter n enter e backspace backspace backspace backspace backspace", example, ) .await .assert_matches(); } } #[gpui::test] async fn test_replace_multicursor(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇabcˇabcabc", Mode::Normal); cx.simulate_keystrokes("shift-r 1 2 3 4"); cx.assert_state("1234ˇ234ˇbc", Mode::Replace); assert_eq!(cx.mode(), Mode::Replace); cx.simulate_keystrokes("backspace backspace backspace backspace backspace"); cx.assert_state("ˇabˇcabcabc", Mode::Replace); } #[gpui::test] async fn test_replace_undo(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇaaaa", Mode::Normal); cx.simulate_keystrokes("0 shift-r b b b escape u"); cx.assert_state("ˇaaaa", Mode::Normal); } #[gpui::test] async fn test_exchange_separate_range(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x i w w c x i w"); cx.assert_state("world ˇhello", Mode::Normal); } #[gpui::test] async fn test_exchange_complete_overlap(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x x w c x i w"); cx.assert_state("ˇworld", Mode::Normal); // the focus should still be at the start of the word if we reverse the // order of selections (smaller -> larger) cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x i w c x x"); cx.assert_state("ˇhello", Mode::Normal); } #[gpui::test] async fn test_exchange_partial_overlap(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇhello world", Mode::Normal); cx.simulate_keystrokes("c x t r w c x i w"); cx.assert_state("hello ˇworld", Mode::Normal); } #[gpui::test] async fn test_clear_exchange_clears_operator(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await; cx.set_state("ˇirrelevant", Mode::Normal); cx.simulate_keystrokes("c x c"); assert_eq!(cx.active_operator(), None); } #[gpui::test] async fn test_clear_exchange(cx: &mut gpui::TestAppContext) { let mut cx = VimTestContext::new(cx, true).await;