zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-11-08 07:35:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Fixed some neovim test context issues, added repeated commands in vim mode, and ported some tests to use the neovim testing strategy

Browse Source
This commit is contained in:
K Simmons 2022-10-08 21:20:47 -07:00
parent b82db3a254
commit 515c1ea123
971 changed files with 838 additions and 11898 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7629
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

59
assets/keymaps/vim.json
View File

@ -9,11 +9,10 @@
}
],
"h": "vim::Left",
"backspace": "vim::Left",
"backspace": "vim::Backspace",
"j": "vim::Down",
"k": "vim::Up",
"l": "vim::Right",
"0": "vim::StartOfLine",
"$": "vim::EndOfLine",
"shift-g": "vim::EndOfDocument",
"w": "vim::NextWordStart",
@ -54,6 +53,43 @@
"around": true
}
}
],
"0": "vim::StartOfLine", // When no number operator present, use start of line motion
"1": [
"vim::Number",
1
],
"2": [
"vim::Number",
2
],
"3": [
"vim::Number",
3
],
"4": [
"vim::Number",
4
],
"5": [
"vim::Number",
5
],
"6": [
"vim::Number",
6
],
"7": [
"vim::Number",
7
],
"8": [
"vim::Number",
8
],
"9": [
"vim::Number",
9
]
}
},
@ -114,6 +150,15 @@
]
}
},
{
"context": "Editor && vim_operator == n",
"bindings": {
"0": [
"vim::Number",
0
]
}
},
{
"context": "Editor && vim_operator == g",
"bindings": {
@ -128,13 +173,6 @@
{
"context": "Editor && vim_operator == c",
"bindings": {
"w": "vim::ChangeWord",
"shift-w": [
"vim::ChangeWord",
{
"ignorePunctuation": true
}
],
"c": "vim::CurrentLine"
}
},
@ -160,8 +198,7 @@
"ignorePunctuation": true
}
],
"s": "vim::Sentence",
"p": "vim::Paragraph"
"s": "vim::Sentence"
}
},
{

2
crates/collab/src/integration_tests.rs
View File

@ -4961,6 +4961,7 @@ async fn test_random_collaboration(
cx.font_cache(),
cx.leak_detector(),
next_entity_id,
cx.function_name.clone(),
);
let host = server.create_client(&mut host_cx, "host").await;
let host_project = host_cx.update(|cx| {
@ -5194,6 +5195,7 @@ async fn test_random_collaboration(
cx.font_cache(),
cx.leak_detector(),
next_entity_id,
cx.function_name.clone(),
);
deterministic.start_waiting();

57
crates/editor/src/test.rs
View File

@ -4,19 +4,25 @@ use crate::{
AnchorRangeExt, Autoscroll, DisplayPoint, Editor, EditorMode, MultiBuffer, ToPoint,
};
use anyhow::Result;
use collections::BTreeMap;
use futures::{Future, StreamExt};
use gpui::{
json, keymap::Keystroke, AppContext, ModelContext, ModelHandle, ViewContext, ViewHandle,
};
use indoc::indoc;
use itertools::Itertools;
use language::{point_to_lsp, Buffer, BufferSnapshot, FakeLspAdapter, Language, LanguageConfig};
use lsp::{notification, request};
use parking_lot::RwLock;
use project::Project;
use settings::Settings;
use std::{
any::TypeId,
ops::{Deref, DerefMut, Range},
sync::Arc,
sync::{
atomic::{AtomicUsize, Ordering},
Arc,
},
};
use util::{
assert_set_eq, set_eq,
@ -85,6 +91,7 @@ pub struct EditorTestContext<'a> {
pub cx: &'a mut gpui::TestAppContext,
pub window_id: usize,
pub editor: ViewHandle<Editor>,
pub assertion_context: AssertionContextManager,
}
impl<'a> EditorTestContext<'a> {
@ -106,9 +113,14 @@ impl<'a> EditorTestContext<'a> {
cx,
window_id,
editor,
assertion_context: AssertionContextManager::new(),
}
}
pub fn add_assertion_context(&self, context: String) -> ContextHandle {
self.assertion_context.add_context(context)
}
pub fn condition(
&self,
predicate: impl FnMut(&Editor, &AppContext) -> bool,
@ -394,6 +406,7 @@ impl<'a> EditorLspTestContext<'a> {
cx,
window_id,
editor,
assertion_context: AssertionContextManager::new(),
},
lsp,
workspace,
@ -507,3 +520,45 @@ impl<'a> DerefMut for EditorLspTestContext<'a> {
&mut self.cx
}
}
#[derive(Clone)]
pub struct AssertionContextManager {
id: Arc<AtomicUsize>,
contexts: Arc<RwLock<BTreeMap<usize, String>>>,
}
impl AssertionContextManager {
pub fn new() -> Self {
Self {
id: Arc::new(AtomicUsize::new(0)),
contexts: Arc::new(RwLock::new(BTreeMap::new())),
}
}
pub fn add_context(&self, context: String) -> ContextHandle {
let id = self.id.fetch_add(1, Ordering::Relaxed);
let mut contexts = self.contexts.write();
contexts.insert(id, context);
ContextHandle {
id,
manager: self.clone(),
}
}
pub fn context(&self) -> String {
let contexts = self.contexts.read();
format!("\n{}\n", contexts.values().join("\n"))
}
}
pub struct ContextHandle {
id: usize,
manager: AssertionContextManager,
}
impl Drop for ContextHandle {
fn drop(&mut self) {
let mut contexts = self.manager.contexts.write();
contexts.remove(&self.id);
}
}

3
crates/gpui/src/app.rs
View File

@ -182,6 +182,7 @@ pub struct TestAppContext {
cx: Rc<RefCell<MutableAppContext>>,
foreground_platform: Rc<platform::test::ForegroundPlatform>,
condition_duration: Option<Duration>,
pub function_name: String,
}
pub struct WindowInputHandler {
@ -437,6 +438,7 @@ impl TestAppContext {
font_cache: Arc<FontCache>,
leak_detector: Arc<Mutex<LeakDetector>>,
first_entity_id: usize,
function_name: String,
) -> Self {
let mut cx = MutableAppContext::new(
foreground,
@ -456,6 +458,7 @@ impl TestAppContext {
cx: Rc::new(RefCell::new(cx)),
foreground_platform,
condition_duration: None,
function_name,
};
cx.cx.borrow_mut().weak_self = Some(Rc::downgrade(&cx.cx));
cx

2
crates/gpui/src/test.rs
View File

@ -37,6 +37,7 @@ pub fn run_test(
u64,
bool,
)),
fn_name: String,
) {
// let _profiler = dhat::Profiler::new_heap();
@ -78,6 +79,7 @@ pub fn run_test(
font_cache.clone(),
leak_detector.clone(),
0,
fn_name.clone(),
);
cx.update(|cx| {
test_fn(

7
crates/gpui_macros/src/gpui_macros.rs
View File

@ -117,6 +117,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
cx.font_cache().clone(),
cx.leak_detector(),
#first_entity_id,
stringify!(#outer_fn_name).to_string(),
);
));
cx_teardowns.extend(quote!(
@ -149,7 +150,8 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
#cx_vars
cx.foreground().run(#inner_fn_name(#inner_fn_args));
#cx_teardowns
}
},
stringify!(#outer_fn_name).to_string(),
);
}
}
@ -187,7 +189,8 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
#num_iterations as u64,
#starting_seed as u64,
#max_retries,
&mut |cx, _, _, seed, is_last_iteration| #inner_fn_name(#inner_fn_args)
&mut |cx, _, _, seed, is_last_iteration| #inner_fn_name(#inner_fn_args),
stringify!(#outer_fn_name).to_string(),
);
}
}

1
crates/vim/Cargo.toml
View File

@ -33,6 +33,7 @@ workspace = { path = "../workspace" }
[dev-dependencies]
indoc = "1.0.4"
parking_lot = "0.11.1"
editor = { path = "../editor", features = ["test-support"] }
gpui = { path = "../gpui", features = ["test-support"] }

35
crates/vim/src/motion.rs
View File

@ -18,6 +18,7 @@ use crate::{
#[derive(Copy, Clone, Debug)]
pub enum Motion {
Left,
Backspace,
Down,
Up,
Right,
@ -58,6 +59,7 @@ actions!(
vim,
[
Left,
Backspace,
Down,
Up,
Right,
@ -74,6 +76,7 @@ impl_actions!(vim, [NextWordStart, NextWordEnd, PreviousWordStart]);
pub fn init(cx: &mut MutableAppContext) {
cx.add_action(|_: &mut Workspace, _: &Left, cx: _| motion(Motion::Left, cx));
cx.add_action(|_: &mut Workspace, _: &Backspace, cx: _| motion(Motion::Backspace, cx));
cx.add_action(|_: &mut Workspace, _: &Down, cx: _| motion(Motion::Down, cx));
cx.add_action(|_: &mut Workspace, _: &Up, cx: _| motion(Motion::Up, cx));
cx.add_action(|_: &mut Workspace, _: &Right, cx: _| motion(Motion::Right, cx));
@ -106,19 +109,21 @@ pub fn init(cx: &mut MutableAppContext) {
);
}
fn motion(motion: Motion, cx: &mut MutableAppContext) {
Vim::update(cx, |vim, cx| {
if let Some(Operator::Namespace(_)) = vim.active_operator() {
vim.pop_operator(cx);
}
});
pub(crate) fn motion(motion: Motion, cx: &mut MutableAppContext) {
if let Some(Operator::Namespace(_)) = Vim::read(cx).active_operator() {
Vim::update(cx, |vim, cx| vim.pop_operator(cx));
}
let times = Vim::update(cx, |vim, cx| vim.pop_number_operator(cx));
let operator = Vim::read(cx).active_operator();
match Vim::read(cx).state.mode {
Mode::Normal => normal_motion(motion, cx),
Mode::Visual { .. } => visual_motion(motion, cx),
Mode::Normal => normal_motion(motion, operator, times, cx),
Mode::Visual { .. } => visual_motion(motion, times, cx),
Mode::Insert => {
// Shouldn't execute a motion in insert mode. Ignoring
}
}
Vim::update(cx, |vim, cx| vim.clear_operator(cx));
}
// Motion handling is specified here:
@ -154,6 +159,7 @@ impl Motion {
use Motion::*;
match self {
Left => (left(map, point), SelectionGoal::None),
Backspace => (movement::left(map, point), SelectionGoal::None),
Down => movement::down(map, point, goal, true),
Up => movement::up(map, point, goal, true),
Right => (right(map, point), SelectionGoal::None),
@ -184,10 +190,13 @@ impl Motion {
self,
map: &DisplaySnapshot,
selection: &mut Selection<DisplayPoint>,
times: usize,
expand_to_surrounding_newline: bool,
) {
let (head, goal) = self.move_point(map, selection.head(), selection.goal);
selection.set_head(head, goal);
for _ in 0..times {
let (head, goal) = self.move_point(map, selection.head(), selection.goal);
selection.set_head(head, goal);
}
if self.linewise() {
selection.start = map.prev_line_boundary(selection.start.to_point(map)).1;
@ -272,17 +281,13 @@ fn next_word_end(
ignore_punctuation: bool,
) -> DisplayPoint {
*point.column_mut() += 1;
dbg!(point);
point = movement::find_boundary(map, point, |left, right| {
dbg!(left);
let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
left_kind != right_kind && left_kind != CharKind::Whitespace
});
dbg!(point);
// find_boundary clips, so if the character after the next character is a newline or at the end of the document, we know
// we have backtraced already
if !map
@ -293,7 +298,7 @@ fn next_word_end(
{
*point.column_mut() = point.column().saturating_sub(1);
}
dbg!(map.clip_point(point, Bias::Left))
map.clip_point(point, Bias::Left)
}
fn previous_word_start(

555
crates/vim/src/normal.rs
View File

@ -10,7 +10,6 @@ use crate::{
state::{Mode, Operator},
Vim,
};
use change::init as change_init;
use collections::HashSet;
use editor::{Autoscroll, Bias, ClipboardSelection, DisplayPoint};
use gpui::{actions, MutableAppContext, ViewContext};
@ -48,41 +47,47 @@ pub fn init(cx: &mut MutableAppContext) {
cx.add_action(insert_line_below);
cx.add_action(|_: &mut Workspace, _: &DeleteLeft, cx| {
Vim::update(cx, |vim, cx| {
delete_motion(vim, Motion::Left, cx);
let times = vim.pop_number_operator(cx);
delete_motion(vim, Motion::Left, times, cx);
})
});
cx.add_action(|_: &mut Workspace, _: &DeleteRight, cx| {
Vim::update(cx, |vim, cx| {
delete_motion(vim, Motion::Right, cx);
let times = vim.pop_number_operator(cx);
delete_motion(vim, Motion::Right, times, cx);
})
});
cx.add_action(|_: &mut Workspace, _: &ChangeToEndOfLine, cx| {
Vim::update(cx, |vim, cx| {
change_motion(vim, Motion::EndOfLine, cx);
let times = vim.pop_number_operator(cx);
change_motion(vim, Motion::EndOfLine, times, cx);
})
});
cx.add_action(|_: &mut Workspace, _: &DeleteToEndOfLine, cx| {
Vim::update(cx, |vim, cx| {
delete_motion(vim, Motion::EndOfLine, cx);
let times = vim.pop_number_operator(cx);
delete_motion(vim, Motion::EndOfLine, times, cx);
})
});
cx.add_action(paste);
change_init(cx);
}
pub fn normal_motion(motion: Motion, cx: &mut MutableAppContext) {
pub fn normal_motion(
motion: Motion,
operator: Option<Operator>,
times: usize,
cx: &mut MutableAppContext,
) {
Vim::update(cx, |vim, cx| {
match vim.state.operator_stack.pop() {
None => move_cursor(vim, motion, cx),
Some(Operator::Change) => change_motion(vim, motion, cx),
Some(Operator::Delete) => delete_motion(vim, motion, cx),
Some(Operator::Yank) => yank_motion(vim, motion, cx),
match operator {
None => move_cursor(vim, motion, times, cx),
Some(Operator::Change) => change_motion(vim, motion, times, cx),
Some(Operator::Delete) => delete_motion(vim, motion, times, cx),
Some(Operator::Yank) => yank_motion(vim, motion, times, cx),
_ => {
// Can't do anything for text objects or namespace operators. Ignoring
}
}
vim.clear_operator(cx);
});
}
@ -105,10 +110,16 @@ pub fn normal_object(object: Object, cx: &mut MutableAppContext) {
})
}
fn move_cursor(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext) {
fn move_cursor(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
vim.update_active_editor(cx, |editor, cx| {
editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.move_cursors_with(|map, cursor, goal| motion.move_point(map, cursor, goal))
s.move_cursors_with(|map, cursor, goal| {
let mut result = (cursor, goal);
for _ in 0..times {
result = motion.move_point(map, result.0, result.1);
}
result
})
})
});
}
@ -328,311 +339,139 @@ mod test {
Mode::{self, *},
Namespace, Operator,
},
test_contexts::VimTestContext,
test_contexts::{NeovimBackedTestContext, VimTestContext},
};
#[gpui::test]
async fn test_h(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["h"]);
cx.assert("The qˇuick", "The ˇquick");
cx.assert("ˇThe quick", "ˇThe quick");
cx.assert(
indoc! {"
The quick
ˇbrown"},
indoc! {"
The quick
ˇbrown"},
);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["h"]);
cx.assert_all(indoc! {"
ˇThe qˇuick
ˇbrown"
})
.await;
}
#[gpui::test]
async fn test_backspace(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["backspace"]);
cx.assert("The qˇuick", "The ˇquick");
cx.assert("ˇThe quick", "ˇThe quick");
cx.assert(
indoc! {"
The quick
ˇbrown"},
indoc! {"
The quick
ˇbrown"},
);
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["backspace"]);
cx.assert_all(indoc! {"
ˇThe qˇuick
ˇbrown"
})
.await;
}
#[gpui::test]
async fn test_j(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["j"]);
cx.assert(
indoc! {"
The ˇquick
brown fox"},
indoc! {"
The quick
browˇn fox"},
);
cx.assert(
indoc! {"
The quick
browˇn fox"},
indoc! {"
The quick
browˇn fox"},
);
cx.assert(
indoc! {"
The quicˇk
brown"},
indoc! {"
The quick
browˇn"},
);
cx.assert(
indoc! {"
The quick
ˇbrown"},
indoc! {"
The quick
ˇbrown"},
);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["j"]);
cx.assert_all(indoc! {"
ˇThe qˇuick broˇwn
ˇfox jumps"
})
.await;
}
#[gpui::test]
async fn test_k(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["k"]);
cx.assert(
indoc! {"
The ˇquick
brown fox"},
indoc! {"
The ˇquick
brown fox"},
);
cx.assert(
indoc! {"
The quick
browˇn fox"},
indoc! {"
The ˇquick
brown fox"},
);
cx.assert(
indoc! {"
The
quicˇk"},
indoc! {"
Thˇe
quick"},
);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["k"]);
cx.assert_all(indoc! {"
ˇThe qˇuick
ˇbrown fˇox jumˇps"
})
.await;
}
#[gpui::test]
async fn test_l(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["l"]);
cx.assert("The qˇuick", "The quˇick");
cx.assert("The quicˇk", "The quicˇk");
cx.assert(
indoc! {"
The quicˇk
brown"},
indoc! {"
The quicˇk
brown"},
);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["l"]);
cx.assert_all(indoc! {"
ˇThe qˇuicˇk
ˇbrowˇn"})
.await;
}
#[gpui::test]
async fn test_jump_to_line_boundaries(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["$"]);
cx.assert("Tˇest test", "Test tesˇt");
cx.assert("Test tesˇt", "Test tesˇt");
cx.assert(
let mut cx = NeovimBackedTestContext::new(cx).await;
cx.assert_binding_matches_all(
["$"],
indoc! {"
The ˇquick
brown"},
ˇThe qˇuicˇk
ˇbrowˇn"},
)
.await;
cx.assert_binding_matches_all(
["0"],
indoc! {"
The quicˇk
brown"},
);
cx.assert(
indoc! {"
The quicˇk
brown"},
indoc! {"
The quicˇk
brown"},
);
let mut cx = cx.binding(["0"]);
cx.assert("Test ˇtest", "ˇTest test");
cx.assert("ˇTest test", "ˇTest test");
cx.assert(
indoc! {"
The ˇquick
brown"},
indoc! {"
ˇThe quick
brown"},
);
cx.assert(
indoc! {"
ˇThe quick
brown"},
indoc! {"
ˇThe quick
brown"},
);
ˇThe qˇuicˇk
ˇbrowˇn"},
)
.await;
}
#[gpui::test]
async fn test_jump_to_end(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["shift-g"]);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["shift-g"]);
cx.assert(
indoc! {"
cx.assert_all(indoc! {"
The ˇquick
brown fox jumps
over the lazy dog"},
indoc! {"
The quick
brown fox jumps
overˇ the lazy dog"},
);
cx.assert(
indoc! {"
The quick
brown fox jumps
overˇ the lazy dog"},
indoc! {"
The quick
brown fox jumps
overˇ the lazy dog"},
);
cx.assert(
indoc! {"
overˇ the lazy doˇg"})
.await;
cx.assert(indoc! {"
The quiˇck
brown"},
indoc! {"
The quick
browˇn"},
);
cx.assert(
indoc! {"
brown"})
.await;
cx.assert(indoc! {"
The quiˇck
"},
indoc! {"
The quick
ˇ"},
);
"})
.await;
}
#[gpui::test]
async fn test_w(cx: &mut gpui::TestAppContext) {
let mut cx = VimTestContext::new(cx, true).await;
let (_, cursor_offsets) = marked_text_offsets(indoc! {"
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["w"]);
cx.assert_all(indoc! {"
The ˇquickˇ-ˇbrown
ˇ
ˇ
ˇfox_jumps ˇover
ˇthˇˇe"});
cx.set_state(
indoc! {"
ˇThe quick-brown
fox_jumps over
the"},
Mode::Normal,
);
for cursor_offset in cursor_offsets {
cx.simulate_keystroke("w");
cx.assert_editor_selections(vec![cursor_offset..cursor_offset]);
}
// Reset and test ignoring punctuation
let (_, cursor_offsets) = marked_text_offsets(indoc! {"
The ˇquick-brown
ˇthˇe"})
.await;
let mut cx = cx.binding(["shift-w"]);
cx.assert_all(indoc! {"
The ˇquickˇ-ˇbrown
ˇ
ˇ
ˇfox_jumps ˇover
ˇthˇˇe"});
cx.set_state(
indoc! {"
ˇThe quick-brown
fox_jumps over
the"},
Mode::Normal,
);
for cursor_offset in cursor_offsets {
cx.simulate_keystroke("shift-w");
cx.assert_editor_selections(vec![cursor_offset..cursor_offset]);
}
ˇthˇe"})
.await;
}
#[gpui::test]
async fn test_e(cx: &mut gpui::TestAppContext) {
let mut cx = VimTestContext::new(cx, true).await;
let (_, cursor_offsets) = marked_text_offsets(indoc! {"
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["e"]);
cx.assert_all(indoc! {"
Thˇe quicˇkˇ-browˇn
fox_jumpˇs oveˇr
thˇe"});
cx.set_state(
indoc! {"
ˇThe quick-brown
fox_jumps over
the"},
Mode::Normal,
);
for cursor_offset in cursor_offsets {
cx.simulate_keystroke("e");
cx.assert_editor_selections(vec![cursor_offset..cursor_offset]);
}
// Reset and test ignoring punctuation
let (_, cursor_offsets) = marked_text_offsets(indoc! {"
Thˇe quick-browˇn
thˇe"})
.await;
let mut cx = cx.binding(["shift-e"]);
cx.assert_all(indoc! {"
Thˇe quicˇkˇ-browˇn
fox_jumpˇs oveˇr
thˇˇe"});
cx.set_state(
indoc! {"
ˇThe quick-brown
fox_jumps over
the"},
Mode::Normal,
);
for cursor_offset in cursor_offsets {
cx.simulate_keystroke("shift-e");
cx.assert_editor_selections(vec![cursor_offset..cursor_offset]);
}
thˇe"})
.await;
}
#[gpui::test]
@ -699,90 +538,35 @@ mod test {
#[gpui::test]
async fn test_gg(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["g", "g"]);
cx.assert(
indoc! {"
The quick
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["g", "g"]);
cx.assert_all(indoc! {"
The qˇuick
brown fox jumps
over ˇthe laˇzy dog"})
.await;
cx.assert(indoc! {"
brown fox jumps
over ˇthe lazy dog"},
indoc! {"
The qˇuick
brown fox jumps
over the lazy dog"},
);
cx.assert(
indoc! {"
The qˇuick
brown fox jumps
over the lazy dog"},
indoc! {"
The qˇuick
brown fox jumps
over the lazy dog"},
);
cx.assert(
indoc! {"
The quick
brown fox jumps
over the laˇzy dog"},
indoc! {"
The quicˇk
brown fox jumps
over the lazy dog"},
);
cx.assert(
indoc! {"
brown fox jumps
over the laˇzy dog"},
indoc! {"
ˇ
brown fox jumps
over the lazy dog"},
);
brown fox jumps
over the laˇzy dog"})
.await;
}
#[gpui::test]
async fn test_a(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["a"]).mode_after(Mode::Insert);
cx.assert("The qˇuick", "The quˇick");
cx.assert("The quicˇk", "The quickˇ");
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["a"]);
cx.assert_all("The qˇuicˇk").await;
}
#[gpui::test]
async fn test_insert_end_of_line(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["shift-a"]).mode_after(Mode::Insert);
cx.assert("The qˇuick", "The quickˇ");
cx.assert("The qˇuick ", "The quick ˇ");
cx.assert("ˇ", "ˇ");
cx.assert(
indoc! {"
The qˇuick
brown fox"},
indoc! {"
The quickˇ
brown fox"},
);
cx.assert(
indoc! {"
ˇ
The quick"},
indoc! {"
ˇ
The quick"},
);
let mut cx = NeovimBackedTestContext::new(cx).await.binding(["shift-a"]);
cx.assert_all(indoc! {"
ˇ
The qˇuick
brown ˇfox "})
.await;
}
#[gpui::test]
@ -984,84 +768,45 @@ mod test {
#[gpui::test]
async fn test_insert_line_above(cx: &mut gpui::TestAppContext) {
let cx = VimTestContext::new(cx, true).await;
let mut cx = cx.binding(["shift-o"]).mode_after(Mode::Insert);
let cx = NeovimBackedTestContext::new(cx).await;
let mut cx = cx.binding(["shift-o"]);
cx.assert("ˇ").await;
cx.assert("The ˇquick").await;
cx.assert_all(indoc! {"
The qˇuick
brown ˇfox
jumps ˇover"})
.await;
cx.assert(indoc! {"
The quick
ˇ
brown fox"})
.await;
cx.assert(
"ˇ",
indoc! {"
ˇ
"},
);
cx.assert(
"The ˇquick",
indoc! {"
ˇ
The quick"},
);
cx.assert(
indoc! {"
The quick
brown ˇfox
jumps over"},
indoc! {"
The quick
ˇ
brown fox
jumps over"},
);
cx.assert(
indoc! {"
The quick
brown fox
jumps ˇover"},
indoc! {"
The quick
brown fox
ˇ
jumps over"},
);
cx.assert(
indoc! {"
The qˇuick
brown fox
jumps over"},
indoc! {"
ˇ
The quick
brown fox
jumps over"},
);
cx.assert(
indoc! {"
The quick
ˇ
brown fox"},
indoc! {"
The quick
ˇ
brown fox"},
);
cx.assert(
// Our indentation is smarter than vims. So we don't match here
cx.assert_manual(
indoc! {"
fn test()
println!(ˇ);"},
Mode::Normal,
indoc! {"
fn test()
ˇ
println!();"},
Mode::Insert,
);
cx.assert(
cx.assert_manual(
indoc! {"
fn test(ˇ) {
println!();
}"},
Mode::Normal,
indoc! {"
ˇ
fn test() {
println!();
}"},
Mode::Insert,
);
}
@ -1208,4 +953,22 @@ mod test {
Mode::Normal,
);
}
#[gpui::test]
async fn test_repeated_word(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
for count in 1..=5 {
cx.assert_binding_matches_all(
[&count.to_string(), "w"],
indoc! {"
ˇThe quˇickˇ browˇn
ˇ
ˇfox ˇjumpsˇ-ˇoˇver
ˇthe lazy dog
"},
)
.await;
}
}
}

164
crates/vim/src/normal/change.rs
View File

@ -1,30 +1,20 @@
use crate::{motion::Motion, object::Object, state::Mode, utils::copy_selections_content, Vim};
use editor::{char_kind, movement, Autoscroll};
use gpui::{impl_actions, MutableAppContext, ViewContext};
use serde::Deserialize;
use workspace::Workspace;
use editor::{char_kind, display_map::DisplaySnapshot, movement, Autoscroll, DisplayPoint};
use gpui::MutableAppContext;
use language::Selection;
#[derive(Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
struct ChangeWord {
#[serde(default)]
ignore_punctuation: bool,
}
impl_actions!(vim, [ChangeWord]);
pub fn init(cx: &mut MutableAppContext) {
cx.add_action(change_word);
}
pub fn change_motion(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext) {
pub fn change_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
vim.update_active_editor(cx, |editor, cx| {
editor.transact(cx, |editor, cx| {
// We are swapping to insert mode anyway. Just set the line end clipping behavior now
editor.set_clip_at_line_ends(false, cx);
editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.move_with(|map, selection| {
motion.expand_selection(map, selection, false);
if let Motion::NextWordStart { ignore_punctuation } = motion {
expand_changed_word_selection(map, selection, times, ignore_punctuation);
} else {
motion.expand_selection(map, selection, times, false);
}
});
});
copy_selections_content(editor, motion.linewise(), cx);
@ -56,38 +46,30 @@ pub fn change_object(vim: &mut Vim, object: Object, around: bool, cx: &mut Mutab
// white space after a word, they only change up to the end of the word. This is
// because Vim interprets "cw" as change-word, and a word does not include the
// following white space.
fn change_word(
_: &mut Workspace,
&ChangeWord { ignore_punctuation }: &ChangeWord,
cx: &mut ViewContext<Workspace>,
fn expand_changed_word_selection(
map: &DisplaySnapshot,
selection: &mut Selection<DisplayPoint>,
times: usize,
ignore_punctuation: bool,
) {
Vim::update(cx, |vim, cx| {
vim.update_active_editor(cx, |editor, cx| {
editor.transact(cx, |editor, cx| {
// We are swapping to insert mode anyway. Just set the line end clipping behavior now
editor.set_clip_at_line_ends(false, cx);
editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.move_with(|map, selection| {
if selection.end.column() == map.line_len(selection.end.row()) {
return;
}
if times > 1 {
Motion::NextWordStart { ignore_punctuation }.expand_selection(
map,
selection,
times - 1,
false,
);
}
selection.end =
movement::find_boundary(map, selection.end, |left, right| {
let left_kind =
char_kind(left).coerce_punctuation(ignore_punctuation);
let right_kind =
char_kind(right).coerce_punctuation(ignore_punctuation);
if times == 1 && selection.end.column() == map.line_len(selection.end.row()) {
return;
}
left_kind != right_kind || left == '\n' || right == '\n'
});
});
});
copy_selections_content(editor, false, cx);
editor.insert("", cx);
});
});
vim.switch_mode(Mode::Insert, false, cx);
selection.end = movement::find_boundary(map, selection.end, |left, right| {
let left_kind = char_kind(left).coerce_punctuation(ignore_punctuation);
let right_kind = char_kind(right).coerce_punctuation(ignore_punctuation);
left_kind != right_kind || left == '\n' || right == '\n'
});
}
@ -95,7 +77,10 @@ fn change_word(
mod test {
use indoc::indoc;
use crate::{state::Mode, test_contexts::VimTestContext};
use crate::{
state::Mode,
test_contexts::{NeovimBackedTestContext, VimTestContext},
};
#[gpui::test]
async fn test_change_h(cx: &mut gpui::TestAppContext) {
@ -459,4 +444,85 @@ mod test {
the lazy"},
);
}
#[gpui::test]
async fn test_repeated_cj(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
for count in 1..=5 {
cx.assert_binding_matches_all(
["c", &count.to_string(), "j"],
indoc! {"
ˇThe quˇickˇ browˇn
ˇ
ˇfox ˇjumpsˇ-ˇoˇver
ˇthe lazy dog
"},
)
.await;
}
}
#[gpui::test]
async fn test_repeated_cl(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
for count in 1..=5 {
cx.assert_binding_matches_all(
["c", &count.to_string(), "l"],
indoc! {"
ˇThe quˇickˇ browˇn
ˇ
ˇfox ˇjumpsˇ-ˇoˇver
ˇthe lazy dog
"},
)
.await;
}
}
#[gpui::test]
async fn test_repeated_cb(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
// Changing back any number of times from the start of the file doesn't
// switch to insert mode in vim. This is weird and painful to implement
cx.add_initial_state_exemption(indoc! {"
ˇThe quick brown
fox jumps-over
the lazy dog
"});
for count in 1..=5 {
cx.assert_binding_matches_all(
["c", &count.to_string(), "b"],
indoc! {"
ˇThe quˇickˇ browˇn
ˇ
ˇfox ˇjumpsˇ-ˇoˇver
ˇthe lazy dog
"},
)
.await;
}
}
#[gpui::test]
async fn test_repeated_ce(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
for count in 1..=5 {
cx.assert_binding_matches_all(
["c", &count.to_string(), "e"],
indoc! {"
ˇThe quˇickˇ browˇn
ˇ
ˇfox ˇjumpsˇ-ˇoˇver
ˇthe lazy dog
"},
)
.await;
}
}
}

4
crates/vim/src/normal/delete.rs
View File

@ -3,7 +3,7 @@ use collections::{HashMap, HashSet};
use editor::{display_map::ToDisplayPoint, Autoscroll, Bias};
use gpui::MutableAppContext;
pub fn delete_motion(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext) {
pub fn delete_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
vim.update_active_editor(cx, |editor, cx| {
editor.transact(cx, |editor, cx| {
editor.set_clip_at_line_ends(false, cx);
@ -11,8 +11,8 @@ pub fn delete_motion(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext)
editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.move_with(|map, selection| {
let original_head = selection.head();
motion.expand_selection(map, selection, true);
original_columns.insert(selection.id, original_head.column());
motion.expand_selection(map, selection, times, true);
});
});
copy_selections_content(editor, motion.linewise(), cx);

4
crates/vim/src/normal/yank.rs
View File

@ -2,7 +2,7 @@ use crate::{motion::Motion, object::Object, utils::copy_selections_content, Vim}
use collections::HashMap;
use gpui::MutableAppContext;
pub fn yank_motion(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext) {
pub fn yank_motion(vim: &mut Vim, motion: Motion, times: usize, cx: &mut MutableAppContext) {
vim.update_active_editor(cx, |editor, cx| {
editor.transact(cx, |editor, cx| {
editor.set_clip_at_line_ends(false, cx);
@ -10,8 +10,8 @@ pub fn yank_motion(vim: &mut Vim, motion: Motion, cx: &mut MutableAppContext) {
editor.change_selections(None, cx, |s| {
s.move_with(|map, selection| {
let original_position = (selection.head(), selection.goal);
motion.expand_selection(map, selection, true);
original_positions.insert(selection.id, original_position);
motion.expand_selection(map, selection, times, true);
});
});
copy_selections_content(editor, motion.linewise(), cx);

178
crates/vim/src/object.rs
View File

@ -12,7 +12,6 @@ use crate::{motion, normal::normal_object, state::Mode, visual::visual_object, V
pub enum Object {
Word { ignore_punctuation: bool },
Sentence,
Paragraph,
}
#[derive(Clone, Deserialize, PartialEq)]
@ -22,7 +21,7 @@ struct Word {
ignore_punctuation: bool,
}
actions!(vim, [Sentence, Paragraph]);
actions!(vim, [Sentence]);
impl_actions!(vim, [Word]);
pub fn init(cx: &mut MutableAppContext) {
@ -32,7 +31,6 @@ pub fn init(cx: &mut MutableAppContext) {
},
);
cx.add_action(|_: &mut Workspace, _: &Sentence, cx: _| object(Object::Sentence, cx));
cx.add_action(|_: &mut Workspace, _: &Paragraph, cx: _| object(Object::Paragraph, cx));
}
fn object(object: Object, cx: &mut MutableAppContext) {
@ -61,7 +59,6 @@ impl Object {
}
}
Object::Sentence => sentence(map, relative_to, around),
_ => relative_to..relative_to,
}
}
@ -172,71 +169,19 @@ fn around_next_word(
start..end
}
// /// Return the range containing a sentence.
// fn sentence(map: &DisplaySnapshot, relative_to: DisplayPoint, around: bool) -> Range<DisplayPoint> {
// let mut previous_end = relative_to;
// let mut start = None;
// // Seek backwards to find a period or double newline. Record the last non whitespace character as the
// // possible start of the sentence. Alternatively if two newlines are found right after each other, return that.
// let mut rev_chars = map.reverse_chars_at(relative_to).peekable();
// while let Some((char, point)) = rev_chars.next() {
// dbg!(char, point);
// if char == '.' {
// break;
// }
// if char == '\n'
// && (rev_chars.peek().map(|(c, _)| c == &'\n').unwrap_or(false) || start.is_none())
// {
// break;
// }
// if !char.is_whitespace() {
// start = Some(point);
// }
// previous_end = point;
// }
// let mut end = relative_to;
// let mut chars = map.chars_at(relative_to).peekable();
// while let Some((char, point)) = chars.next() {
// if !char.is_whitespace() {
// if start.is_none() {
// start = Some(point);
// }
// // Set the end to the point after the current non whitespace character
// end = point;
// *end.column_mut() += char.len_utf8() as u32;
// }
// if char == '.' {
// break;
// }
// if char == '\n' {
// if start.is_none() {
// if let Some((_, next_point)) = chars.peek() {
// end = *next_point;
// }
// break;
// if chars.peek().map(|(c, _)| c == &'\n').unwrap_or(false) {
// break;
// }
// }
// }
// start.unwrap_or(previous_end)..end
// }
fn sentence(map: &DisplaySnapshot, relative_to: DisplayPoint, around: bool) -> Range<DisplayPoint> {
let mut start = None;
let mut previous_end = relative_to;
for (char, point) in map.reverse_chars_at(relative_to) {
let mut chars = map.chars_at(relative_to).peekable();
// Search backwards for the previous sentence end or current sentence start. Include the character under relative_to
for (char, point) in chars
.peek()
.cloned()
.into_iter()
.chain(map.reverse_chars_at(relative_to))
{
if is_sentence_end(map, point) {
break;
}
@ -248,36 +193,26 @@ fn sentence(map: &DisplaySnapshot, relative_to: DisplayPoint, around: bool) -> R
previous_end = point;
}
// Handle case where cursor was before the sentence start
let mut chars = map.chars_at(relative_to).peekable();
if start.is_none() {
if let Some((char, point)) = chars.peek() {
if is_possible_sentence_start(*char) {
start = Some(*point);
}
}
}
// Search forward for the end of the current sentence or if we are between sentences, the start of the next one
let mut end = relative_to;
for (char, point) in chars {
if start.is_some() {
if !char.is_whitespace() {
end = point;
*end.column_mut() += char.len_utf8() as u32;
end = map.clip_point(end, Bias::Left);
}
if is_sentence_end(map, point) {
break;
}
} else if is_possible_sentence_start(char) {
if start.is_none() && is_possible_sentence_start(char) {
if around {
start = Some(point);
continue;
} else {
end = point;
break;
}
}
end = point;
*end.column_mut() += char.len_utf8() as u32;
end = map.clip_point(end, Bias::Left);
if is_sentence_end(map, end) {
break;
}
}
let mut range = start.unwrap_or(previous_end)..end;
@ -296,22 +231,21 @@ const SENTENCE_END_PUNCTUATION: &[char] = &['.', '!', '?'];
const SENTENCE_END_FILLERS: &[char] = &[')', ']', '"', '\''];
const SENTENCE_END_WHITESPACE: &[char] = &[' ', '\t', '\n'];
fn is_sentence_end(map: &DisplaySnapshot, point: DisplayPoint) -> bool {
let mut chars = map.chars_at(point).peekable();
if let Some((char, _)) = chars.next() {
if char == '\n' && chars.peek().map(|(c, _)| c == &'\n').unwrap_or(false) {
let mut next_chars = map.chars_at(point).peekable();
if let Some((char, _)) = next_chars.next() {
// We are at a double newline. This position is a sentence end.
if char == '\n' && next_chars.peek().map(|(c, _)| c == &'\n').unwrap_or(false) {
return true;
}
if !SENTENCE_END_PUNCTUATION.contains(&char) {
// The next text is not a valid whitespace. This is not a sentence end
if !SENTENCE_END_WHITESPACE.contains(&char) {
return false;
}
} else {
return false;
}
for (char, _) in chars {
if SENTENCE_END_WHITESPACE.contains(&char) {
for (char, _) in map.reverse_chars_at(point) {
if SENTENCE_END_PUNCTUATION.contains(&char) {
return true;
}
@ -320,7 +254,7 @@ fn is_sentence_end(map: &DisplaySnapshot, point: DisplayPoint) -> bool {
}
}
return true;
return false;
}
/// Expands the passed range to include whitespace on one side or the other in a line. Attempts to add the
@ -331,16 +265,26 @@ fn expand_to_include_whitespace(
stop_at_newline: bool,
) -> Range<DisplayPoint> {
let mut whitespace_included = false;
for (char, point) in map.chars_at(range.end) {
range.end = point;
let mut chars = map.chars_at(range.end).peekable();
while let Some((char, point)) = chars.next() {
if char == '\n' && stop_at_newline {
break;
}
if char.is_whitespace() {
whitespace_included = true;
// Set end to the next display_point or the character position after the current display_point
range.end = chars.peek().map(|(_, point)| *point).unwrap_or_else(|| {
let mut end = point;
*end.column_mut() += char.len_utf8() as u32;
map.clip_point(end, Bias::Left)
});
if char != '\n' {
whitespace_included = true;
}
} else {
// Found non whitespace. Quit out.
break;
}
}
@ -385,7 +329,7 @@ mod test {
#[gpui::test]
async fn test_change_in_word(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_change_in_word", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["c", "i", "w"]);
cx.assert_all(WORD_LOCATIONS).await;
@ -395,7 +339,7 @@ mod test {
#[gpui::test]
async fn test_delete_in_word(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_delete_in_word", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["d", "i", "w"]);
cx.assert_all(WORD_LOCATIONS).await;
@ -405,7 +349,7 @@ mod test {
#[gpui::test]
async fn test_change_around_word(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_change_around_word", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["c", "a", "w"]);
cx.assert_all(WORD_LOCATIONS).await;
@ -415,7 +359,7 @@ mod test {
#[gpui::test]
async fn test_delete_around_word(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_delete_around_word", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["d", "a", "w"]);
cx.assert_all(WORD_LOCATIONS).await;
@ -431,7 +375,8 @@ mod test {
the lazy doˇgˇ.ˇ ˇThe quick ˇ
brown fox jumps over
"},
// Double newlines are broken currently
// Position of the cursor after deletion between lines isn't quite right.
// Deletion in a sentence at the start of a line with whitespace is incorrect.
// indoc! {"
// The quick brown fox jumps.
// Over the lazy dog
@ -441,12 +386,12 @@ mod test {
// the lazy dog.ˇ
// ˇ
// "},
r#"The quick brown.)]'" Brown fox jumps."#,
r#"ˇThe ˇquick brownˇ.)ˇ]ˇ'ˇ" Brown ˇfox jumpsˇ.ˇ "#,
];
#[gpui::test]
async fn test_change_in_sentence(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_change_in_sentence", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["c", "i", "s"]);
for sentence_example in SENTENCE_EXAMPLES {
@ -456,31 +401,42 @@ mod test {
#[gpui::test]
async fn test_delete_in_sentence(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_delete_in_sentence", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["d", "i", "s"]);
for sentence_example in SENTENCE_EXAMPLES {
cx.assert_all(sentence_example).await;
}
}
#[gpui::test]
#[ignore] // End cursor position is incorrect
async fn test_change_around_sentence(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_change_around_sentence", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["c", "a", "s"]);
// Resulting position is slightly incorrect for unintuitive reasons.
cx.add_initial_state_exemption("The quick brown?ˇ Fox Jumps! Over the lazy.");
// Changing around the sentence at the end of the line doesn't remove whitespace.'
cx.add_initial_state_exemption("The quick brown.)]\'\" Brown fox jumps.ˇ ");
for sentence_example in SENTENCE_EXAMPLES {
cx.assert_all(sentence_example).await;
}
}
#[gpui::test]
#[ignore] // End cursor position is incorrect
async fn test_delete_around_sentence(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_delete_around_sentence", cx)
let mut cx = NeovimBackedTestContext::new(cx)
.await
.binding(["d", "a", "s"]);
// Resulting position is slightly incorrect for unintuitive reasons.
cx.add_initial_state_exemption("The quick brown?ˇ Fox Jumps! Over the lazy.");
// Changing around the sentence at the end of the line doesn't remove whitespace.'
cx.add_initial_state_exemption("The quick brown.)]\'\" Brown fox jumps.ˇ ");
for sentence_example in SENTENCE_EXAMPLES {
cx.assert_all(sentence_example).await;
}

3
crates/vim/src/state.rs
View File

@ -22,6 +22,7 @@ pub enum Namespace {
#[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize)]
pub enum Operator {
Number(usize),
Namespace(Namespace),
Change,
Delete,
@ -92,12 +93,14 @@ impl VimState {
impl Operator {
pub fn set_context(operator: Option<&Operator>, context: &mut Context) {
let operator_context = match operator {
Some(Operator::Number(_)) => "n",
Some(Operator::Namespace(Namespace::G)) => "g",
Some(Operator::Object { around: false }) => "i",
Some(Operator::Object { around: true }) => "a",
Some(Operator::Change) => "c",
Some(Operator::Delete) => "d",
Some(Operator::Yank) => "y",
None => "none",
}
.to_owned();

39
crates/vim/src/test_contexts/neovim_backed_binding_test_context.rs
View File

@ -1,6 +1,6 @@
use std::ops::{Deref, DerefMut};
use util::test::marked_text_offsets;
use crate::state::Mode;
use super::NeovimBackedTestContext;
@ -24,20 +24,39 @@ impl<'a, const COUNT: usize> NeovimBackedBindingTestContext<'a, COUNT> {
self.cx
}
pub async fn assert(&mut self, initial_state: &str) {
pub fn binding<const NEW_COUNT: usize>(
self,
keystrokes: [&'static str; NEW_COUNT],
) -> NeovimBackedBindingTestContext<'a, NEW_COUNT> {
self.consume().binding(keystrokes)
}
pub async fn assert(&mut self, marked_positions: &str) {
self.cx
.assert_binding_matches(self.keystrokes_under_test, initial_state)
.assert_binding_matches(self.keystrokes_under_test, marked_positions)
.await
}
pub async fn assert_all(&mut self, marked_positions: &str) {
let (unmarked_text, cursor_offsets) = marked_text_offsets(marked_positions);
pub fn assert_manual(
&mut self,
initial_state: &str,
mode_before: Mode,
state_after: &str,
mode_after: Mode,
) {
self.cx.assert_binding(
self.keystrokes_under_test,
initial_state,
mode_before,
state_after,
mode_after,
);
}
for cursor_offset in cursor_offsets.iter() {
let mut marked_text = unmarked_text.clone();
marked_text.insert(*cursor_offset, 'ˇ');
self.assert(&marked_text).await;
}
pub async fn assert_all(&mut self, marked_positions: &str) {
self.cx
.assert_binding_matches_all(self.keystrokes_under_test, marked_positions)
.await
}
}

398
crates/vim/src/test_contexts/neovim_backed_test_context.rs
View File

@ -3,6 +3,7 @@ use std::{
path::PathBuf,
};
use collections::{HashMap, HashSet, VecDeque};
use editor::DisplayPoint;
use gpui::keymap::Keystroke;
@ -14,11 +15,13 @@ use async_trait::async_trait;
use nvim_rs::{
create::tokio::new_child_cmd, error::LoopError, Handler, Neovim, UiAttachOptions, Value,
};
use serde::{Deserialize, Serialize};
#[cfg(feature = "neovim")]
use tokio::{
process::{Child, ChildStdin, Command},
task::JoinHandle,
};
use util::test::marked_text_offsets;
use crate::state::Mode;
@ -26,60 +29,43 @@ use super::{NeovimBackedBindingTestContext, VimTestContext};
pub struct NeovimBackedTestContext<'a> {
cx: VimTestContext<'a>,
test_case_id: &'static str,
data_counter: usize,
#[cfg(feature = "neovim")]
nvim: Neovim<nvim_rs::compat::tokio::Compat<ChildStdin>>,
#[cfg(feature = "neovim")]
_join_handle: JoinHandle<Result<(), Box<LoopError>>>,
#[cfg(feature = "neovim")]
_child: Child,
// Lookup for exempted assertions. Keyed by the insertion text, and with a value indicating which
// bindings are exempted. If None, all bindings are ignored for that insertion text.
exemptions: HashMap<String, Option<HashSet<String>>>,
neovim: NeovimConnection,
}
impl<'a> NeovimBackedTestContext<'a> {
pub async fn new(
test_case_id: &'static str,
cx: &'a mut gpui::TestAppContext,
) -> NeovimBackedTestContext<'a> {
pub async fn new(cx: &'a mut gpui::TestAppContext) -> NeovimBackedTestContext<'a> {
let function_name = cx.function_name.clone();
let cx = VimTestContext::new(cx, true).await;
#[cfg(feature = "neovim")]
let handler = NvimHandler {};
#[cfg(feature = "neovim")]
let (nvim, join_handle, child) = Compat::new(async {
let (nvim, join_handle, child) = new_child_cmd(
&mut Command::new("nvim").arg("--embed").arg("--clean"),
handler,
)
.await
.expect("Could not connect to neovim process");
nvim.ui_attach(100, 100, &UiAttachOptions::default())
.await
.expect("Could not attach to ui");
(nvim, join_handle, child)
})
.await;
let result = Self {
Self {
cx,
test_case_id,
data_counter: 0,
#[cfg(feature = "neovim")]
nvim,
#[cfg(feature = "neovim")]
_join_handle: join_handle,
#[cfg(feature = "neovim")]
_child: child,
};
#[cfg(feature = "neovim")]
{
result.clear_test_data()
exemptions: Default::default(),
neovim: NeovimConnection::new(function_name).await,
}
}
result
pub fn add_initial_state_exemption(&mut self, initial_state: &str) {
let initial_state = initial_state.to_string();
// None represents all keybindings being exempted for that initial state
self.exemptions.insert(initial_state, None);
}
pub fn add_keybinding_exemption<const COUNT: usize>(
&mut self,
keybinding: [&str; COUNT],
initial_state: &str,
) {
let initial_state = initial_state.to_string();
let exempted_keybindings = self
.exemptions
.entry(initial_state)
.or_insert(Some(Default::default()));
if let Some(exempted_bindings) = exempted_keybindings.as_mut() {
exempted_bindings.insert(format!("{keybinding:?}"));
}
}
pub async fn simulate_shared_keystroke(&mut self, keystroke_text: &str) {
@ -101,7 +87,7 @@ impl<'a> NeovimBackedTestContext<'a> {
let key = format!("{start}{shift}{ctrl}{alt}{cmd}{}{end}", keystroke.key);
self.nvim
self.neovim
.input(&key)
.await
.expect("Could not input keystroke");
@ -128,37 +114,32 @@ impl<'a> NeovimBackedTestContext<'a> {
let cursor_point =
self.editor(|editor, cx| editor.selections.newest::<language::Point>(cx));
let nvim_buffer = self
.nvim
.neovim
.get_current_buf()
.await
.expect("Could not get neovim buffer");
let mut lines = self
.buffer_text()
.lines()
.split('\n')
.map(|line| line.to_string())
.collect::<Vec<_>>();
if lines.len() > 1 {
// Add final newline which is missing from buffer_text
lines.push("".to_string());
}
nvim_buffer
.set_lines(0, -1, false, lines)
.await
.expect("Could not set nvim buffer text");
self.nvim
self.neovim
.input("<escape>")
.await
.expect("Could not send escape to nvim");
self.nvim
self.neovim
.input("<escape>")
.await
.expect("Could not send escape to nvim");
let nvim_window = self
.nvim
.neovim
.get_current_win()
.await
.expect("Could not get neovim window");
@ -173,18 +154,161 @@ impl<'a> NeovimBackedTestContext<'a> {
}
pub async fn assert_state_matches(&mut self) {
assert_eq!(self.neovim_text().await, self.buffer_text());
assert_eq!(
self.neovim.text().await,
self.buffer_text(),
"{}",
self.assertion_context.context()
);
let zed_head = self.update_editor(|editor, cx| editor.selections.newest_display(cx).head());
assert_eq!(self.neovim_head().await, zed_head);
assert_eq!(
self.neovim.head().await,
zed_head,
"{}",
self.assertion_context.context()
);
if let Some(neovim_mode) = self.neovim_mode().await {
assert_eq!(neovim_mode, self.mode());
if let Some(neovim_mode) = self.neovim.mode().await {
assert_eq!(
neovim_mode,
self.mode(),
"{}",
self.assertion_context.context()
);
}
}
pub async fn assert_binding_matches<const COUNT: usize>(
&mut self,
keystrokes: [&str; COUNT],
initial_state: &str,
) {
if let Some(possible_exempted_keystrokes) = self.exemptions.get(initial_state) {
match possible_exempted_keystrokes {
Some(exempted_keystrokes) => {
if exempted_keystrokes.contains(&format!("{keystrokes:?}")) {
// This keystroke was exempted for this insertion text
return;
}
}
None => {
// All keystrokes for this insertion text are exempted
return;
}
}
}
let _keybinding_context_handle =
self.add_assertion_context(format!("Key Binding Under Test: {:?}", keystrokes));
let _initial_state_context_handle = self.add_assertion_context(format!(
"Initial State: \"{}\"",
initial_state.escape_debug().to_string()
));
self.set_shared_state(initial_state).await;
self.simulate_shared_keystrokes(keystrokes).await;
self.assert_state_matches().await;
}
pub async fn assert_binding_matches_all<const COUNT: usize>(
&mut self,
keystrokes: [&str; COUNT],
marked_positions: &str,
) {
let (unmarked_text, cursor_offsets) = marked_text_offsets(marked_positions);
for cursor_offset in cursor_offsets.iter() {
let mut marked_text = unmarked_text.clone();
marked_text.insert(*cursor_offset, 'ˇ');
self.assert_binding_matches(keystrokes, &marked_text).await;
}
}
pub fn binding<const COUNT: usize>(
self,
keystrokes: [&'static str; COUNT],
) -> NeovimBackedBindingTestContext<'a, COUNT> {
NeovimBackedBindingTestContext::new(keystrokes, self)
}
}
impl<'a> Deref for NeovimBackedTestContext<'a> {
type Target = VimTestContext<'a>;
fn deref(&self) -> &Self::Target {
&self.cx
}
}
impl<'a> DerefMut for NeovimBackedTestContext<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.cx
}
}
#[derive(Serialize, Deserialize)]
pub enum NeovimData {
Text(String),
Head { row: u32, column: u32 },
Mode(Option<Mode>),
}
struct NeovimConnection {
data: VecDeque<NeovimData>,
#[cfg(feature = "neovim")]
test_case_id: String,
#[cfg(feature = "neovim")]
nvim: Neovim<nvim_rs::compat::tokio::Compat<ChildStdin>>,
#[cfg(feature = "neovim")]
_join_handle: JoinHandle<Result<(), Box<LoopError>>>,
#[cfg(feature = "neovim")]
_child: Child,
}
impl NeovimConnection {
async fn new(test_case_id: String) -> Self {
#[cfg(feature = "neovim")]
let handler = NvimHandler {};
#[cfg(feature = "neovim")]
let (nvim, join_handle, child) = Compat::new(async {
let (nvim, join_handle, child) = new_child_cmd(
&mut Command::new("nvim").arg("--embed").arg("--clean"),
handler,
)
.await
.expect("Could not connect to neovim process");
nvim.ui_attach(100, 100, &UiAttachOptions::default())
.await
.expect("Could not attach to ui");
nvim.set_option("smartindent", nvim_rs::Value::Boolean(true))
.await
.expect("Could not set smartindent on startup");
(nvim, join_handle, child)
})
.await;
Self {
#[cfg(feature = "neovim")]
data: Default::default(),
#[cfg(not(feature = "neovim"))]
data: Self::read_test_data(&test_case_id),
#[cfg(feature = "neovim")]
test_case_id,
#[cfg(feature = "neovim")]
nvim,
#[cfg(feature = "neovim")]
_join_handle: join_handle,
#[cfg(feature = "neovim")]
_child: child,
}
}
#[cfg(feature = "neovim")]
pub async fn neovim_text(&mut self) -> String {
pub async fn text(&mut self) -> String {
let nvim_buffer = self
.nvim
.get_current_buf()
@ -196,17 +320,22 @@ impl<'a> NeovimBackedTestContext<'a> {
.expect("Could not get buffer text")
.join("\n");
self.write_test_data(text.clone(), "text");
self.data.push_back(NeovimData::Text(text.clone()));
text
}
#[cfg(not(feature = "neovim"))]
pub async fn neovim_text(&mut self) -> String {
self.read_test_data("text")
pub async fn text(&mut self) -> String {
if let Some(NeovimData::Text(text)) = self.data.pop_front() {
text
} else {
panic!("Invalid test data. Is test deterministic? Try running with '--features neovim' to regenerate");
}
}
#[cfg(feature = "neovim")]
pub async fn neovim_head(&mut self) -> DisplayPoint {
pub async fn head(&mut self) -> DisplayPoint {
let nvim_row: u32 = self
.nvim
.command_output("echo line('.')")
@ -224,24 +353,25 @@ impl<'a> NeovimBackedTestContext<'a> {
.unwrap()
- 1; // Neovim columns start at 1
let serialized = format!("{},{}", nvim_row.to_string(), nvim_column.to_string());
self.write_test_data(serialized, "head");
self.data.push_back(NeovimData::Head {
row: nvim_row,
column: nvim_column,
});
DisplayPoint::new(nvim_row, nvim_column)
}
#[cfg(not(feature = "neovim"))]
pub async fn neovim_head(&mut self) -> DisplayPoint {
let serialized = self.read_test_data("head");
let mut components = serialized.split(',');
let nvim_row = components.next().unwrap().parse::<u32>().unwrap();
let nvim_column = components.next().unwrap().parse::<u32>().unwrap();
DisplayPoint::new(nvim_row, nvim_column)
pub async fn head(&mut self) -> DisplayPoint {
if let Some(NeovimData::Head { row, column }) = self.data.pop_front() {
DisplayPoint::new(row, column)
} else {
panic!("Invalid test data. Is test deterministic? Try running with '--features neovim' to regenerate");
}
}
#[cfg(feature = "neovim")]
pub async fn neovim_mode(&mut self) -> Option<Mode> {
pub async fn mode(&mut self) -> Option<Mode> {
let nvim_mode_text = self
.nvim
.get_mode()
@ -265,74 +395,67 @@ impl<'a> NeovimBackedTestContext<'a> {
_ => None,
};
let serialized = serde_json::to_string(&mode).expect("Could not serialize mode");
self.write_test_data(serialized, "mode");
self.data.push_back(NeovimData::Mode(mode.clone()));
mode
}
#[cfg(not(feature = "neovim"))]
pub async fn neovim_mode(&mut self) -> Option<Mode> {
let serialized = self.read_test_data("mode");
serde_json::from_str(&serialized).expect("Could not deserialize test data")
pub async fn mode(&mut self) -> Option<Mode> {
if let Some(NeovimData::Mode(mode)) = self.data.pop_front() {
mode
} else {
panic!("Invalid test data. Is test deterministic? Try running with '--features neovim' to regenerate");
}
}
fn test_data_directory(&self) -> PathBuf {
fn test_data_path(test_case_id: &str) -> PathBuf {
let mut data_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
data_path.push("test_data");
data_path.push(self.test_case_id);
data_path
}
fn next_data_path(&mut self, kind: &str) -> PathBuf {
let mut data_path = self.test_data_directory();
data_path.push(format!("{}{}.txt", self.data_counter, kind));
self.data_counter += 1;
data_path.push(format!("{}.json", test_case_id));
data_path
}
#[cfg(not(feature = "neovim"))]
fn read_test_data(&mut self, kind: &str) -> String {
let path = self.next_data_path(kind);
std::fs::read_to_string(path).expect(
fn read_test_data(test_case_id: &str) -> VecDeque<NeovimData> {
let path = Self::test_data_path(test_case_id);
let json = std::fs::read_to_string(path).expect(
"Could not read test data. Is it generated? Try running test with '--features neovim'",
)
}
);
#[cfg(feature = "neovim")]
fn write_test_data(&mut self, data: String, kind: &str) {
let path = self.next_data_path(kind);
std::fs::create_dir_all(path.parent().unwrap())
.expect("Could not create test data directory");
std::fs::write(path, data).expect("Could not write out test data");
}
#[cfg(feature = "neovim")]
fn clear_test_data(&self) {
// If the path does not exist, no biggy, we will create it
std::fs::remove_dir_all(self.test_data_directory()).ok();
}
pub async fn assert_binding_matches<const COUNT: usize>(
&mut self,
keystrokes: [&str; COUNT],
initial_state: &str,
) {
dbg!(keystrokes, initial_state);
self.set_shared_state(initial_state).await;
self.simulate_shared_keystrokes(keystrokes).await;
self.assert_state_matches().await;
}
pub fn binding<const COUNT: usize>(
self,
keystrokes: [&'static str; COUNT],
) -> NeovimBackedBindingTestContext<'a, COUNT> {
NeovimBackedBindingTestContext::new(keystrokes, self)
serde_json::from_str(&json)
.expect("Test data corrupted. Try regenerating it with '--features neovim'")
}
}
#[cfg(feature = "neovim")]
impl Deref for NeovimConnection {
type Target = Neovim<nvim_rs::compat::tokio::Compat<ChildStdin>>;
fn deref(&self) -> &Self::Target {
&self.nvim
}
}
#[cfg(feature = "neovim")]
impl DerefMut for NeovimConnection {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.nvim
}
}
#[cfg(feature = "neovim")]
impl Drop for NeovimConnection {
fn drop(&mut self) {
let path = Self::test_data_path(&self.test_case_id);
std::fs::create_dir_all(path.parent().unwrap())
.expect("Could not create test data directory");
let json = serde_json::to_string(&self.data).expect("Could not serialize test data");
std::fs::write(path, json).expect("Could not write out test data");
}
}
#[cfg(feature = "neovim")]
#[derive(Clone)]
struct NvimHandler {}
@ -359,16 +482,17 @@ impl Handler for NvimHandler {
}
}
impl<'a> Deref for NeovimBackedTestContext<'a> {
type Target = VimTestContext<'a>;
#[cfg(test)]
mod test {
use gpui::TestAppContext;
fn deref(&self) -> &Self::Target {
&self.cx
}
}
impl<'a> DerefMut for NeovimBackedTestContext<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.cx
use crate::test_contexts::NeovimBackedTestContext;
#[gpui::test]
async fn neovim_backed_test_context_works(cx: &mut TestAppContext) {
let mut cx = NeovimBackedTestContext::new(cx).await;
cx.assert_state_matches().await;
cx.set_shared_state("This is a tesˇt").await;
cx.assert_state_matches().await;
}
}

3
crates/vim/src/test_contexts/vim_test_context.rs
View File

@ -1,6 +1,6 @@
use std::ops::{Deref, DerefMut};
use editor::test::EditorTestContext;
use editor::test::{AssertionContextManager, EditorTestContext};
use gpui::{json::json, AppContext, ViewHandle};
use project::Project;
use search::{BufferSearchBar, ProjectSearchBar};
@ -82,6 +82,7 @@ impl<'a> VimTestContext<'a> {
cx,
window_id,
editor,
assertion_context: AssertionContextManager::new(),
},
workspace,
}

28
crates/vim/src/vim.rs
View File

@ -26,7 +26,10 @@ pub struct SwitchMode(pub Mode);
#[derive(Clone, Deserialize, PartialEq)]
pub struct PushOperator(pub Operator);
impl_actions!(vim, [SwitchMode, PushOperator]);
#[derive(Clone, Deserialize, PartialEq)]
struct Number(u8);
impl_actions!(vim, [Number, SwitchMode, PushOperator]);
pub fn init(cx: &mut MutableAppContext) {
editor_events::init(cx);
@ -45,6 +48,9 @@ pub fn init(cx: &mut MutableAppContext) {
Vim::update(cx, |vim, cx| vim.push_operator(operator, cx))
},
);
cx.add_action(|_: &mut Workspace, n: &Number, cx: _| {
Vim::update(cx, |vim, cx| vim.push_number(n, cx));
});
// Editor Actions
cx.add_action(|_: &mut Editor, _: &Cancel, cx| {
@ -145,6 +151,15 @@ impl Vim {
self.sync_vim_settings(cx);
}
fn push_number(&mut self, Number(number): &Number, cx: &mut MutableAppContext) {
if let Some(Operator::Number(current_number)) = self.active_operator() {
self.pop_operator(cx);
self.push_operator(Operator::Number(current_number * 10 + *number as usize), cx);
} else {
self.push_operator(Operator::Number(*number as usize), cx);
}
}
fn pop_operator(&mut self, cx: &mut MutableAppContext) -> Operator {
let popped_operator = self.state.operator_stack.pop()
.expect("Operator popped when no operator was on the stack. This likely means there is an invalid keymap config");
@ -152,6 +167,15 @@ impl Vim {
popped_operator
}
fn pop_number_operator(&mut self, cx: &mut MutableAppContext) -> usize {
let mut times = 1;
if let Some(Operator::Number(number)) = self.active_operator() {
times = number;
self.pop_operator(cx);
}
times
}
fn clear_operator(&mut self, cx: &mut MutableAppContext) {
self.state.operator_stack.clear();
self.sync_vim_settings(cx);
@ -227,7 +251,7 @@ mod test {
#[gpui::test]
async fn test_neovim(cx: &mut gpui::TestAppContext) {
let mut cx = NeovimBackedTestContext::new("test_neovim", cx).await;
let mut cx = NeovimBackedTestContext::new(cx).await;
cx.simulate_shared_keystroke("i").await;
cx.simulate_shared_keystrokes([

10
crates/vim/src/visual.rs
View File

@ -17,14 +17,18 @@ pub fn init(cx: &mut MutableAppContext) {
cx.add_action(paste);
}
pub fn visual_motion(motion: Motion, cx: &mut MutableAppContext) {
pub fn visual_motion(motion: Motion, times: usize, cx: &mut MutableAppContext) {
Vim::update(cx, |vim, cx| {
vim.update_active_editor(cx, |editor, cx| {
editor.change_selections(Some(Autoscroll::Fit), cx, |s| {
s.move_with(|map, selection| {
let (new_head, goal) = motion.move_point(map, selection.head(), selection.goal);
let was_reversed = selection.reversed;
selection.set_head(new_head, goal);
for _ in 0..times {
let (new_head, goal) =
motion.move_point(map, selection.head(), selection.goal);
selection.set_head(new_head, goal);
}
if was_reversed && !selection.reversed {
// Head was at the start of the selection, and now is at the end. We need to move the start

1
crates/vim/test_data/neovim_backed_test_context_works.json Normal file
View File

@ -0,0 +1 @@
[{"Text":""},{"Head":{"row":0,"column":0}},{"Mode":"Normal"},{"Text":"This is a test"},{"Head":{"row":0,"column":13}},{"Mode":"Normal"}]

1
crates/vim/test_data/test_a.json Normal file
View File

@ -0,0 +1 @@
[{"Text":"The quick"},{"Head":{"row":0,"column":6}},{"Mode":"Insert"},{"Text":"The quick"},{"Head":{"row":0,"column":9}},{"Mode":"Insert"}]

1
crates/vim/test_data/test_backspace.json Normal file
View File

@ -0,0 +1 @@
[{"Text":"The quick\nbrown"},{"Head":{"row":0,"column":0}},{"Mode":"Normal"},{"Text":"The quick\nbrown"},{"Head":{"row":0,"column":4}},{"Mode":"Normal"},{"Text":"The quick\nbrown"},{"Head":{"row":0,"column":8}},{"Mode":"Normal"}]

1
crates/vim/test_data/test_change_around_sentence.json Normal file
View File

@ -0,0 +1 @@
[{"Text":"Fox Jumps! Over the lazy."},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Fox Jumps! Over the lazy."},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Fox Jumps! Over the lazy."},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick brown? Over the lazy."},{"Head":{"row":0,"column":17}},{"Mode":"Insert"},{"Text":"The quick brown? Over the lazy."},{"Head":{"row":0,"column":17}},{"Mode":"Insert"},{"Text":"The quick brown? Over the lazy."},{"Head":{"row":0,"column":17}},{"Mode":"Insert"},{"Text":"The quick brown? Fox Jumps!"},{"Head":{"row":0,"column":27}},{"Mode":"Insert"},{"Text":"The quick brown? Fox Jumps!"},{"Head":{"row":0,"column":27}},{"Mode":"Insert"},{"Text":"The quick brown? Fox Jumps!"},{"Head":{"row":0,"column":27}},{"Mode":"Insert"},{"Text":"The quick brown? Fox Jumps!"},{"Head":{"row":0,"column":27}},{"Mode":"Insert"},{"Text":"The quick \nbrown fox jumps over\n"},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick \nbrown fox jumps over\n"},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick \nbrown fox jumps over\n"},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick \nbrown fox jumps over\n"},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick \nbrown fox jumps over\n"},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick brown \nfox jumps over\nthe lazy dog.\n"},{"Head":{"row":2,"column":13}},{"Mode":"Insert"},{"Text":"The quick brown \nfox jumps over\nthe lazy dog.\n"},{"Head":{"row":2,"column":13}},{"Mode":"Insert"},{"Text":"The quick brown \nfox jumps over\nthe lazy dog.\n"},{"Head":{"row":2,"column":13}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"Brown fox jumps. "},{"Head":{"row":0,"column":0}},{"Mode":"Insert"},{"Text":"The quick brown.)]'\" "},{"Head":{"row":0,"column":21}},{"Mode":"Insert"},{"Text":"The quick brown.)]'\" "},{"Head":{"row":0,"column":21}},{"Mode":"Insert"}]

1
crates/vim/test_data/test_change_around_sentence/0text.txt
View File

@ -1 +0,0 @@
Fox Jumps! Over the lazy.

1
crates/vim/test_data/test_change_around_sentence/10head.txt
View File

@ -1 +0,0 @@
0,16

1
crates/vim/test_data/test_change_around_sentence/1head.txt
View File

@ -1 +0,0 @@
0,0

1
crates/vim/test_data/test_change_around_sentence/2mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_sentence/3text.txt
View File

@ -1 +0,0 @@
Fox Jumps! Over the lazy.

1
crates/vim/test_data/test_change_around_sentence/4head.txt
View File

@ -1 +0,0 @@
0,0

1
crates/vim/test_data/test_change_around_sentence/5mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_sentence/6text.txt
View File

@ -1 +0,0 @@
Fox Jumps! Over the lazy.

1
crates/vim/test_data/test_change_around_sentence/7head.txt
View File

@ -1 +0,0 @@
0,0

1
crates/vim/test_data/test_change_around_sentence/8mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_sentence/9text.txt
View File

@ -1 +0,0 @@
The quick brown? Over the lazy.

1
crates/vim/test_data/test_change_around_word.json Normal file
View File

File diff suppressed because one or more lines are too long

12
crates/vim/test_data/test_change_around_word/0text.txt
View File

@ -1,12 +0,0 @@
The quick
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/100head.txt
View File

@ -1 +0,0 @@
6,0

1
crates/vim/test_data/test_change_around_word/101mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/102text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/103head.txt
View File

@ -1 +0,0 @@
6,0

1
crates/vim/test_data/test_change_around_word/104mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/105text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/106head.txt
View File

@ -1 +0,0 @@
6,0

1
crates/vim/test_data/test_change_around_word/107mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/108text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/109head.txt
View File

@ -1 +0,0 @@
6,0

1
crates/vim/test_data/test_change_around_word/10head.txt
View File

@ -1 +0,0 @@
1,4

1
crates/vim/test_data/test_change_around_word/110mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/111text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/112head.txt
View File

@ -1 +0,0 @@
6,9

1
crates/vim/test_data/test_change_around_word/113mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/114text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/115head.txt
View File

@ -1 +0,0 @@
6,10

1
crates/vim/test_data/test_change_around_word/116mode.txt
View File

@ -1 +0,0 @@
"Insert"

9
crates/vim/test_data/test_change_around_word/117text.txt
View File

@ -1,9 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown over
the lazy dog

1
crates/vim/test_data/test_change_around_word/118head.txt
View File

@ -1 +0,0 @@
6,15

1
crates/vim/test_data/test_change_around_word/119mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_word/11mode.txt
View File

@ -1 +0,0 @@
"Insert"

10
crates/vim/test_data/test_change_around_word/120text.txt
View File

@ -1,10 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
over
the lazy dog

1
crates/vim/test_data/test_change_around_word/121head.txt
View File

@ -1 +0,0 @@
7,0

1
crates/vim/test_data/test_change_around_word/122mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/123text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
over
the lazy dog

1
crates/vim/test_data/test_change_around_word/124head.txt
View File

@ -1 +0,0 @@
8,0

1
crates/vim/test_data/test_change_around_word/125mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/126text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
over
the lazy dog

1
crates/vim/test_data/test_change_around_word/127head.txt
View File

@ -1 +0,0 @@
9,0

1
crates/vim/test_data/test_change_around_word/128mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/129text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
over
the lazy dog

12
crates/vim/test_data/test_change_around_word/12text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/130head.txt
View File

@ -1 +0,0 @@
9,2

1
crates/vim/test_data/test_change_around_word/131mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/132text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/133head.txt
View File

@ -1 +0,0 @@
10,12

1
crates/vim/test_data/test_change_around_word/134mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/135text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/136head.txt
View File

@ -1 +0,0 @@
11,0

1
crates/vim/test_data/test_change_around_word/137mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_word/13head.txt
View File

@ -1 +0,0 @@
1,4

1
crates/vim/test_data/test_change_around_word/14mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/15text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/16head.txt
View File

@ -1 +0,0 @@
1,9

1
crates/vim/test_data/test_change_around_word/17mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/18text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/19head.txt
View File

@ -1 +0,0 @@
2,12

1
crates/vim/test_data/test_change_around_word/1head.txt
View File

@ -1 +0,0 @@
0,10

1
crates/vim/test_data/test_change_around_word/20mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/21text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/22head.txt
View File

@ -1 +0,0 @@
3,0

1
crates/vim/test_data/test_change_around_word/23mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/24text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
The-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/25head.txt
View File

@ -1 +0,0 @@
4,0

1
crates/vim/test_data/test_change_around_word/26mode.txt
View File

@ -1 +0,0 @@
"Insert"

11
crates/vim/test_data/test_change_around_word/27text.txt
View File

@ -1,11 +0,0 @@
The quick brown
fox jumps over
the lazy dog
-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/28head.txt
View File

@ -1 +0,0 @@
5,0

1
crates/vim/test_data/test_change_around_word/29mode.txt
View File

@ -1 +0,0 @@
"Insert"

1
crates/vim/test_data/test_change_around_word/2mode.txt
View File

@ -1 +0,0 @@
"Insert"

12
crates/vim/test_data/test_change_around_word/30text.txt
View File

@ -1,12 +0,0 @@
The quick brown
fox jumps over
the lazy dog
-quick brown
fox-jumps over
the lazy dog

1
crates/vim/test_data/test_change_around_word/31head.txt
View File

@ -1 +0,0 @@
6,0

1
crates/vim/test_data/test_change_around_word/32mode.txt
View File

@ -1 +0,0 @@
"Insert"

Some files were not shown because too many files have changed in this diff Show More