1use gpui::{px, size, AppContext as _, UpdateGlobal};
2use indoc::indoc;
3use settings::SettingsStore;
4use std::{
5 ops::{Deref, DerefMut},
6 panic, thread,
7};
8
9use language::language_settings::{AllLanguageSettings, SoftWrap};
10use util::test::marked_text_offsets;
11
12use super::{neovim_connection::NeovimConnection, VimTestContext};
13use crate::state::{Mode, VimGlobals};
14
15pub struct NeovimBackedTestContext {
16 cx: VimTestContext,
17 pub(crate) neovim: NeovimConnection,
18
19 last_set_state: Option<String>,
20 recent_keystrokes: Vec<String>,
21}
22
23#[derive(Default)]
24pub struct SharedState {
25 neovim: String,
26 editor: String,
27 initial: String,
28 neovim_mode: Mode,
29 editor_mode: Mode,
30 recent_keystrokes: String,
31}
32
33impl SharedState {
34 #[track_caller]
35 pub fn assert_matches(&self) {
36 if self.neovim != self.editor || self.neovim_mode != self.editor_mode {
37 panic!(
38 indoc! {"Test failed (zed does not match nvim behavior)
39 # initial state:
40 {}
41 # keystrokes:
42 {}
43 # neovim ({}):
44 {}
45 # zed ({}):
46 {}"},
47 self.initial,
48 self.recent_keystrokes,
49 self.neovim_mode,
50 self.neovim,
51 self.editor_mode,
52 self.editor,
53 )
54 }
55 }
56
57 #[track_caller]
58 pub fn assert_eq(&mut self, marked_text: &str) {
59 let marked_text = marked_text.replace('•', " ");
60 if self.neovim == marked_text
61 && self.neovim == self.editor
62 && self.neovim_mode == self.editor_mode
63 {
64 return;
65 }
66
67 let message = if self.neovim != marked_text {
68 "Test is incorrect (currently expected != neovim_state)"
69 } else {
70 "Editor does not match nvim behavior"
71 };
72 panic!(
73 indoc! {"{}
74 # initial state:
75 {}
76 # keystrokes:
77 {}
78 # currently expected:
79 {}
80 # neovim ({}):
81 {}
82 # zed ({}):
83 {}"},
84 message,
85 self.initial,
86 self.recent_keystrokes,
87 marked_text.replace(" \n", "•\n"),
88 self.neovim_mode,
89 self.neovim.replace(" \n", "•\n"),
90 self.editor_mode,
91 self.editor.replace(" \n", "•\n"),
92 )
93 }
94}
95
96pub struct SharedClipboard {
97 register: char,
98 neovim: String,
99 editor: String,
100 state: SharedState,
101}
102
103impl SharedClipboard {
104 #[track_caller]
105 pub fn assert_eq(&self, expected: &str) {
106 if expected == self.neovim && self.neovim == self.editor {
107 return;
108 }
109
110 let message = if expected == self.neovim {
111 "Test is incorrect (currently expected != neovim_state)"
112 } else {
113 "Editor does not match nvim behavior"
114 };
115
116 panic!(
117 indoc! {"{}
118 # initial state:
119 {}
120 # keystrokes:
121 {}
122 # currently expected:
123 {}
124 # neovim register \"{}:
125 {}
126 # zed register \"{}:
127 {}"},
128 message,
129 self.state.initial,
130 self.state.recent_keystrokes,
131 expected,
132 self.register,
133 self.neovim,
134 self.register,
135 self.editor
136 )
137 }
138}
139
140impl NeovimBackedTestContext {
141 pub async fn new(cx: &mut gpui::TestAppContext) -> NeovimBackedTestContext {
142 #[cfg(feature = "neovim")]
143 cx.executor().allow_parking();
144 // rust stores the name of the test on the current thread.
145 // We use this to automatically name a file that will store
146 // the neovim connection's requests/responses so that we can
147 // run without neovim on CI.
148 let thread = thread::current();
149 let test_name = thread
150 .name()
151 .expect("thread is not named")
152 .split(':')
153 .last()
154 .unwrap()
155 .to_string();
156 Self {
157 cx: VimTestContext::new(cx, true).await,
158 neovim: NeovimConnection::new(test_name).await,
159
160 last_set_state: None,
161 recent_keystrokes: Default::default(),
162 }
163 }
164
165 pub async fn new_html(cx: &mut gpui::TestAppContext) -> NeovimBackedTestContext {
166 #[cfg(feature = "neovim")]
167 cx.executor().allow_parking();
168 // rust stores the name of the test on the current thread.
169 // We use this to automatically name a file that will store
170 // the neovim connection's requests/responses so that we can
171 // run without neovim on CI.
172 let thread = thread::current();
173 let test_name = thread
174 .name()
175 .expect("thread is not named")
176 .split(':')
177 .last()
178 .unwrap()
179 .to_string();
180 Self {
181 cx: VimTestContext::new_html(cx).await,
182 neovim: NeovimConnection::new(test_name).await,
183
184 last_set_state: None,
185 recent_keystrokes: Default::default(),
186 }
187 }
188
189 pub async fn set_shared_state(&mut self, marked_text: &str) {
190 let mode = if marked_text.contains('»') {
191 Mode::Visual
192 } else {
193 Mode::Normal
194 };
195 self.set_state(marked_text, mode);
196 self.last_set_state = Some(marked_text.to_string());
197 self.recent_keystrokes = Vec::new();
198 self.neovim.set_state(marked_text).await;
199 }
200
201 pub async fn simulate_shared_keystrokes(&mut self, keystroke_texts: &str) {
202 for keystroke_text in keystroke_texts.split(' ') {
203 self.recent_keystrokes.push(keystroke_text.to_string());
204 self.neovim.send_keystroke(keystroke_text).await;
205 }
206 self.simulate_keystrokes(keystroke_texts);
207 }
208
209 #[must_use]
210 pub async fn simulate(&mut self, keystrokes: &str, initial_state: &str) -> SharedState {
211 self.set_shared_state(initial_state).await;
212 self.simulate_shared_keystrokes(keystrokes).await;
213 self.shared_state().await
214 }
215
216 pub async fn set_shared_wrap(&mut self, columns: u32) {
217 if columns < 12 {
218 panic!("nvim doesn't support columns < 12")
219 }
220 self.neovim.set_option("wrap").await;
221 self.neovim
222 .set_option(&format!("columns={}", columns))
223 .await;
224
225 self.update(|_, cx| {
226 SettingsStore::update_global(cx, |settings, cx| {
227 settings.update_user_settings::<AllLanguageSettings>(cx, |settings| {
228 settings.defaults.soft_wrap = Some(SoftWrap::PreferredLineLength);
229 settings.defaults.preferred_line_length = Some(columns);
230 });
231 })
232 })
233 }
234
235 pub async fn set_scroll_height(&mut self, rows: u32) {
236 // match Zed's scrolling behavior
237 self.neovim.set_option(&format!("scrolloff={}", 3)).await;
238 // +2 to account for the vim command UI at the bottom.
239 self.neovim.set_option(&format!("lines={}", rows + 2)).await;
240 let (line_height, visible_line_count) = self.editor(|editor, window, _cx| {
241 (
242 editor
243 .style()
244 .unwrap()
245 .text
246 .line_height_in_pixels(window.rem_size()),
247 editor.visible_line_count().unwrap(),
248 )
249 });
250
251 let window = self.window;
252 let margin = self
253 .update_window(window, |_, window, _cx| {
254 window.viewport_size().height - line_height * visible_line_count
255 })
256 .unwrap();
257
258 self.simulate_window_resize(
259 self.window,
260 size(px(1000.), margin + (rows as f32) * line_height),
261 );
262 }
263
264 pub async fn set_neovim_option(&mut self, option: &str) {
265 self.neovim.set_option(option).await;
266 }
267
268 #[must_use]
269 pub async fn shared_clipboard(&mut self) -> SharedClipboard {
270 SharedClipboard {
271 register: '"',
272 state: self.shared_state().await,
273 neovim: self.neovim.read_register('"').await,
274 editor: self
275 .read_from_clipboard()
276 .unwrap()
277 .text()
278 .unwrap()
279 .to_owned(),
280 }
281 }
282
283 #[must_use]
284 pub async fn shared_register(&mut self, register: char) -> SharedClipboard {
285 SharedClipboard {
286 register,
287 state: self.shared_state().await,
288 neovim: self.neovim.read_register(register).await,
289 editor: self.update(|_, cx| {
290 cx.global::<VimGlobals>()
291 .registers
292 .get(®ister)
293 .cloned()
294 .unwrap_or_default()
295 .text
296 .into()
297 }),
298 }
299 }
300
301 #[must_use]
302 pub async fn shared_state(&mut self) -> SharedState {
303 let (mode, marked_text) = self.neovim.state().await;
304 SharedState {
305 neovim: marked_text,
306 neovim_mode: mode,
307 editor: self.editor_state(),
308 editor_mode: self.mode(),
309 initial: self
310 .last_set_state
311 .as_ref()
312 .cloned()
313 .unwrap_or("N/A".to_string()),
314 recent_keystrokes: self.recent_keystrokes.join(" "),
315 }
316 }
317
318 #[must_use]
319 pub async fn simulate_at_each_offset(
320 &mut self,
321 keystrokes: &str,
322 marked_positions: &str,
323 ) -> SharedState {
324 let (unmarked_text, cursor_offsets) = marked_text_offsets(marked_positions);
325
326 for cursor_offset in cursor_offsets.iter() {
327 let mut marked_text = unmarked_text.clone();
328 marked_text.insert(*cursor_offset, 'ˇ');
329
330 let state = self.simulate(keystrokes, &marked_text).await;
331 if state.neovim != state.editor || state.neovim_mode != state.editor_mode {
332 return state;
333 }
334 }
335
336 SharedState::default()
337 }
338}
339
340impl Deref for NeovimBackedTestContext {
341 type Target = VimTestContext;
342
343 fn deref(&self) -> &Self::Target {
344 &self.cx
345 }
346}
347
348impl DerefMut for NeovimBackedTestContext {
349 fn deref_mut(&mut self) -> &mut Self::Target {
350 &mut self.cx
351 }
352}
353
354#[cfg(test)]
355mod test {
356 use crate::test::NeovimBackedTestContext;
357 use gpui::TestAppContext;
358
359 #[gpui::test]
360 async fn neovim_backed_test_context_works(cx: &mut TestAppContext) {
361 let mut cx = NeovimBackedTestContext::new(cx).await;
362 cx.shared_state().await.assert_matches();
363 cx.set_shared_state("This is a tesˇt").await;
364 cx.shared_state().await.assert_matches();
365 }
366}