084a0233b6
Implements [vim-exchange](https://github.com/tommcdo/vim-exchange) functionality. Lets you swap the content of one selection/object/motion with another. The default key bindings are the same as in exchange: - `cx` to begin the exchange in normal mode. Visual mode does not have a default binding due to conflicts. - `cxx` selects the current line - `cxc` clears the selection - If the previous operation was an exchange, `.` will repeat that operation. Closes #22759 ## Overlapping regions According to the vim exchange readme: > If one region is fully contained within the other, it will replace the containing region. Zed does the following: - If one range is completely contained within another: the smaller region replaces the larger region (as in exchange.vim) - If the ranges only partially overlap, then we abort and cancel the exchange. I don't think we can do anything sensible with that. Not sure what the original does, evil-exchange aborts. ## Not implemented: cross-window exchange Emacs's evil-exchange allows you to exchange across buffers. There is no code to accommodate that in this PR. Personally, it'd never occurred to me before working on this and I've never needed it. As such, I'll leave that implementation for whomever needs it. As an upside; this allows you to have concurrent exchange states per buffer, which may come in handy. ## Bonus Also adds "replace with register" for the full line with `grr` 🐕 This was an oversight from a previous PR. Release notes: - Added an implementation of `vim-exchange` - Fixed: Added missing default key binding for `Vim::CurrentLine` for replace with register mode (`grr`) --------- Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
486 lines
18 KiB
Rust
486 lines
18 KiB
Rust
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_highlights::<VimExchange>(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);
|
|
}
|
|
}
|