475 lines
15 KiB
Rust
475 lines
15 KiB
Rust
use crate::{motion::Motion, object::Object, utils::copy_selections_content, Vim};
|
|
use collections::{HashMap, HashSet};
|
|
use editor::{display_map::ToDisplayPoint, scroll::autoscroll::Autoscroll, Bias};
|
|
use gpui::WindowContext;
|
|
use language::Point;
|
|
|
|
pub fn delete_motion(vim: &mut Vim, motion: Motion, times: Option<usize>, cx: &mut WindowContext) {
|
|
vim.stop_recording();
|
|
vim.update_active_editor(cx, |editor, cx| {
|
|
let text_layout_details = editor.text_layout_details(cx);
|
|
editor.transact(cx, |editor, cx| {
|
|
editor.set_clip_at_line_ends(false, cx);
|
|
let mut original_columns: HashMap<_, _> = Default::default();
|
|
editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
|
|
s.move_with(|map, selection| {
|
|
let original_head = selection.head();
|
|
original_columns.insert(selection.id, original_head.column());
|
|
motion.expand_selection(map, selection, times, true, &text_layout_details);
|
|
|
|
// Motion::NextWordStart on an empty line should delete it.
|
|
if let Motion::NextWordStart {
|
|
ignore_punctuation: _,
|
|
} = motion
|
|
{
|
|
if selection.is_empty()
|
|
&& map
|
|
.buffer_snapshot
|
|
.line_len(selection.start.to_point(&map).row)
|
|
== 0
|
|
{
|
|
selection.end = map
|
|
.buffer_snapshot
|
|
.clip_point(
|
|
Point::new(selection.start.to_point(&map).row + 1, 0),
|
|
Bias::Left,
|
|
)
|
|
.to_display_point(map)
|
|
}
|
|
}
|
|
});
|
|
});
|
|
copy_selections_content(editor, motion.linewise(), cx);
|
|
editor.insert("", cx);
|
|
|
|
// Fixup cursor position after the deletion
|
|
editor.set_clip_at_line_ends(true, cx);
|
|
editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
|
|
s.move_with(|map, selection| {
|
|
let mut cursor = selection.head();
|
|
if motion.linewise() {
|
|
if let Some(column) = original_columns.get(&selection.id) {
|
|
*cursor.column_mut() = *column
|
|
}
|
|
}
|
|
cursor = map.clip_point(cursor, Bias::Left);
|
|
selection.collapse_to(cursor, selection.goal)
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
pub fn delete_object(vim: &mut Vim, object: Object, around: bool, cx: &mut WindowContext) {
|
|
vim.stop_recording();
|
|
vim.update_active_editor(cx, |editor, cx| {
|
|
editor.transact(cx, |editor, cx| {
|
|
editor.set_clip_at_line_ends(false, cx);
|
|
// Emulates behavior in vim where if we expanded backwards to include a newline
|
|
// the cursor gets set back to the start of the line
|
|
let mut should_move_to_start: HashSet<_> = Default::default();
|
|
editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
|
|
s.move_with(|map, selection| {
|
|
object.expand_selection(map, selection, around);
|
|
let offset_range = selection.map(|p| p.to_offset(map, Bias::Left)).range();
|
|
let contains_only_newlines = map
|
|
.chars_at(selection.start)
|
|
.take_while(|(_, p)| p < &selection.end)
|
|
.all(|(char, _)| char == '\n')
|
|
&& !offset_range.is_empty();
|
|
let end_at_newline = map
|
|
.chars_at(selection.end)
|
|
.next()
|
|
.map(|(c, _)| c == '\n')
|
|
.unwrap_or(false);
|
|
|
|
// If expanded range contains only newlines and
|
|
// the object is around or sentence, expand to include a newline
|
|
// at the end or start
|
|
if (around || object == Object::Sentence) && contains_only_newlines {
|
|
if end_at_newline {
|
|
selection.end =
|
|
(offset_range.end + '\n'.len_utf8()).to_display_point(map);
|
|
} else if selection.start.row() > 0 {
|
|
should_move_to_start.insert(selection.id);
|
|
selection.start =
|
|
(offset_range.start - '\n'.len_utf8()).to_display_point(map);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
copy_selections_content(editor, false, cx);
|
|
editor.insert("", cx);
|
|
|
|
// Fixup cursor position after the deletion
|
|
editor.set_clip_at_line_ends(true, cx);
|
|
editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
|
|
s.move_with(|map, selection| {
|
|
let mut cursor = selection.head();
|
|
if should_move_to_start.contains(&selection.id) {
|
|
*cursor.column_mut() = 0;
|
|
}
|
|
cursor = map.clip_point(cursor, Bias::Left);
|
|
selection.collapse_to(cursor, selection.goal)
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use indoc::indoc;
|
|
|
|
use crate::{
|
|
state::Mode,
|
|
test::{ExemptionFeatures, NeovimBackedTestContext, VimTestContext},
|
|
};
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_h(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "h"]);
|
|
cx.assert("Teˇst").await;
|
|
cx.assert("Tˇest").await;
|
|
cx.assert("ˇTest").await;
|
|
cx.assert(indoc! {"
|
|
Test
|
|
ˇtest"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_l(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "l"]);
|
|
cx.assert("ˇTest").await;
|
|
cx.assert("Teˇst").await;
|
|
cx.assert("Tesˇt").await;
|
|
cx.assert(indoc! {"
|
|
Tesˇt
|
|
test"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_w(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
Test tesˇt
|
|
test"},
|
|
["d", "w"],
|
|
)
|
|
.await;
|
|
|
|
cx.assert_neovim_compatible("Teˇst", ["d", "w"]).await;
|
|
cx.assert_neovim_compatible("Tˇest test", ["d", "w"]).await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
Test teˇst
|
|
test"},
|
|
["d", "w"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
Test tesˇt
|
|
test"},
|
|
["d", "w"],
|
|
)
|
|
.await;
|
|
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
Test test
|
|
ˇ
|
|
test"},
|
|
["d", "w"],
|
|
)
|
|
.await;
|
|
|
|
let mut cx = cx.binding(["d", "shift-w"]);
|
|
cx.assert_neovim_compatible("Test teˇst-test test", ["d", "shift-w"])
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_next_word_end(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "e"]);
|
|
// cx.assert("Teˇst Test").await;
|
|
// cx.assert("Tˇest test").await;
|
|
cx.assert(indoc! {"
|
|
Test teˇst
|
|
test"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
Test tesˇt
|
|
test"})
|
|
.await;
|
|
cx.assert_exempted(
|
|
indoc! {"
|
|
Test test
|
|
ˇ
|
|
test"},
|
|
ExemptionFeatures::OperatorLastNewlineRemains,
|
|
)
|
|
.await;
|
|
|
|
let mut cx = cx.binding(["d", "shift-e"]);
|
|
cx.assert("Test teˇst-test test").await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_b(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "b"]);
|
|
cx.assert("Teˇst Test").await;
|
|
cx.assert("Test ˇtest").await;
|
|
cx.assert("Test1 test2 ˇtest3").await;
|
|
cx.assert(indoc! {"
|
|
Test test
|
|
ˇtest"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
Test test
|
|
ˇ
|
|
test"})
|
|
.await;
|
|
|
|
let mut cx = cx.binding(["d", "shift-b"]);
|
|
cx.assert("Test test-test ˇtest").await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_end_of_line(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "$"]);
|
|
cx.assert(indoc! {"
|
|
The qˇuick
|
|
brown fox"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
ˇ
|
|
brown fox"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_0(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "0"]);
|
|
cx.assert(indoc! {"
|
|
The qˇuick
|
|
brown fox"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
ˇ
|
|
brown fox"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_k(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "k"]);
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
brown ˇfox
|
|
jumps over"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
brown fox
|
|
jumps ˇover"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The qˇuick
|
|
brown fox
|
|
jumps over"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
ˇbrown fox
|
|
jumps over"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_j(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["d", "j"]);
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
brown ˇfox
|
|
jumps over"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
brown fox
|
|
jumps ˇover"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The qˇuick
|
|
brown fox
|
|
jumps over"})
|
|
.await;
|
|
cx.assert(indoc! {"
|
|
The quick
|
|
brown fox
|
|
ˇ"})
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_end_of_document(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brownˇ fox
|
|
jumps over
|
|
the lazy"},
|
|
["d", "shift-g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brownˇ fox
|
|
jumps over
|
|
the lazy"},
|
|
["d", "shift-g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brown fox
|
|
jumps over
|
|
the lˇazy"},
|
|
["d", "shift-g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brown fox
|
|
jumps over
|
|
ˇ"},
|
|
["d", "shift-g"],
|
|
)
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_gg(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx)
|
|
.await
|
|
.binding(["d", "g", "g"]);
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brownˇ fox
|
|
jumps over
|
|
the lazy"},
|
|
["d", "g", "g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The quick
|
|
brown fox
|
|
jumps over
|
|
the lˇazy"},
|
|
["d", "g", "g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
The qˇuick
|
|
brown fox
|
|
jumps over
|
|
the lazy"},
|
|
["d", "g", "g"],
|
|
)
|
|
.await;
|
|
cx.assert_neovim_compatible(
|
|
indoc! {"
|
|
ˇ
|
|
brown fox
|
|
jumps over
|
|
the lazy"},
|
|
["d", "g", "g"],
|
|
)
|
|
.await;
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_cancel_delete_operator(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = VimTestContext::new(cx, true).await;
|
|
cx.set_state(
|
|
indoc! {"
|
|
The quick brown
|
|
fox juˇmps over
|
|
the lazy dog"},
|
|
Mode::Normal,
|
|
);
|
|
|
|
// Canceling operator twice reverts to normal mode with no active operator
|
|
cx.simulate_keystrokes(["d", "escape", "k"]);
|
|
assert_eq!(cx.active_operator(), None);
|
|
assert_eq!(cx.mode(), Mode::Normal);
|
|
cx.assert_editor_state(indoc! {"
|
|
The quˇick brown
|
|
fox jumps over
|
|
the lazy dog"});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_unbound_command_cancels_pending_operator(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = VimTestContext::new(cx, true).await;
|
|
cx.set_state(
|
|
indoc! {"
|
|
The quick brown
|
|
fox juˇmps over
|
|
the lazy dog"},
|
|
Mode::Normal,
|
|
);
|
|
|
|
// Canceling operator twice reverts to normal mode with no active operator
|
|
cx.simulate_keystrokes(["d", "y"]);
|
|
assert_eq!(cx.active_operator(), None);
|
|
assert_eq!(cx.mode(), Mode::Normal);
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_delete_with_counts(cx: &mut gpui::TestAppContext) {
|
|
let mut cx = NeovimBackedTestContext::new(cx).await;
|
|
cx.set_shared_state(indoc! {"
|
|
The ˇquick brown
|
|
fox jumps over
|
|
the lazy dog"})
|
|
.await;
|
|
cx.simulate_shared_keystrokes(["d", "2", "d"]).await;
|
|
cx.assert_shared_state(indoc! {"
|
|
the ˇlazy dog"})
|
|
.await;
|
|
|
|
cx.set_shared_state(indoc! {"
|
|
The ˇquick brown
|
|
fox jumps over
|
|
the lazy dog"})
|
|
.await;
|
|
cx.simulate_shared_keystrokes(["2", "d", "d"]).await;
|
|
cx.assert_shared_state(indoc! {"
|
|
the ˇlazy dog"})
|
|
.await;
|
|
|
|
cx.set_shared_state(indoc! {"
|
|
The ˇquick brown
|
|
fox jumps over
|
|
the moon,
|
|
a star, and
|
|
the lazy dog"})
|
|
.await;
|
|
cx.simulate_shared_keystrokes(["2", "d", "2", "d"]).await;
|
|
cx.assert_shared_state(indoc! {"
|
|
the ˇlazy dog"})
|
|
.await;
|
|
}
|
|
}
|