1use super::*;
2use gpui::{ModelHandle, MutableAppContext};
3use std::rc::Rc;
4use unindent::Unindent as _;
5
6#[gpui::test]
7fn test_edit_events(cx: &mut gpui::MutableAppContext) {
8 let mut now = Instant::now();
9 let buffer_1_events = Rc::new(RefCell::new(Vec::new()));
10 let buffer_2_events = Rc::new(RefCell::new(Vec::new()));
11
12 let buffer1 = cx.add_model(|cx| Buffer::new(0, "abcdef", cx));
13 let buffer2 = cx.add_model(|cx| Buffer::new(1, "abcdef", cx));
14 let buffer_ops = buffer1.update(cx, |buffer, cx| {
15 let buffer_1_events = buffer_1_events.clone();
16 cx.subscribe(&buffer1, move |_, _, event, _| {
17 buffer_1_events.borrow_mut().push(event.clone())
18 })
19 .detach();
20 let buffer_2_events = buffer_2_events.clone();
21 cx.subscribe(&buffer2, move |_, _, event, _| {
22 buffer_2_events.borrow_mut().push(event.clone())
23 })
24 .detach();
25
26 // An edit emits an edited event, followed by a dirtied event,
27 // since the buffer was previously in a clean state.
28 buffer.edit(Some(2..4), "XYZ", cx);
29
30 // An empty transaction does not emit any events.
31 buffer.start_transaction(None).unwrap();
32 buffer.end_transaction(None, cx).unwrap();
33
34 // A transaction containing two edits emits one edited event.
35 now += Duration::from_secs(1);
36 buffer.start_transaction_at(None, now).unwrap();
37 buffer.edit(Some(5..5), "u", cx);
38 buffer.edit(Some(6..6), "w", cx);
39 buffer.end_transaction_at(None, now, cx).unwrap();
40
41 // Undoing a transaction emits one edited event.
42 buffer.undo(cx);
43
44 buffer.operations.clone()
45 });
46
47 // Incorporating a set of remote ops emits a single edited event,
48 // followed by a dirtied event.
49 buffer2.update(cx, |buffer, cx| {
50 buffer.apply_ops(buffer_ops, cx).unwrap();
51 });
52
53 let buffer_1_events = buffer_1_events.borrow();
54 assert_eq!(
55 *buffer_1_events,
56 vec![Event::Edited, Event::Dirtied, Event::Edited, Event::Edited]
57 );
58
59 let buffer_2_events = buffer_2_events.borrow();
60 assert_eq!(*buffer_2_events, vec![Event::Edited, Event::Dirtied]);
61}
62
63#[gpui::test]
64async fn test_apply_diff(mut cx: gpui::TestAppContext) {
65 let text = "a\nbb\nccc\ndddd\neeeee\nffffff\n";
66 let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
67
68 let text = "a\nccc\ndddd\nffffff\n";
69 let diff = buffer.read_with(&cx, |b, cx| b.diff(text.into(), cx)).await;
70 buffer.update(&mut cx, |b, cx| b.apply_diff(diff, cx));
71 cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
72
73 let text = "a\n1\n\nccc\ndd2dd\nffffff\n";
74 let diff = buffer.read_with(&cx, |b, cx| b.diff(text.into(), cx)).await;
75 buffer.update(&mut cx, |b, cx| b.apply_diff(diff, cx));
76 cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
77}
78
79#[gpui::test]
80async fn test_reparse(mut cx: gpui::TestAppContext) {
81 let buffer = cx.add_model(|cx| {
82 let text = "fn a() {}".into();
83 Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx)
84 });
85
86 // Wait for the initial text to parse
87 buffer
88 .condition(&cx, |buffer, _| !buffer.is_parsing())
89 .await;
90 assert_eq!(
91 get_tree_sexp(&buffer, &cx),
92 concat!(
93 "(source_file (function_item name: (identifier) ",
94 "parameters: (parameters) ",
95 "body: (block)))"
96 )
97 );
98
99 buffer.update(&mut cx, |buffer, _| {
100 buffer.set_sync_parse_timeout(Duration::ZERO)
101 });
102
103 // Perform some edits (add parameter and variable reference)
104 // Parsing doesn't begin until the transaction is complete
105 buffer.update(&mut cx, |buf, cx| {
106 buf.start_transaction(None).unwrap();
107
108 let offset = buf.text().find(")").unwrap();
109 buf.edit(vec![offset..offset], "b: C", cx);
110 assert!(!buf.is_parsing());
111
112 let offset = buf.text().find("}").unwrap();
113 buf.edit(vec![offset..offset], " d; ", cx);
114 assert!(!buf.is_parsing());
115
116 buf.end_transaction(None, cx).unwrap();
117 assert_eq!(buf.text(), "fn a(b: C) { d; }");
118 assert!(buf.is_parsing());
119 });
120 buffer
121 .condition(&cx, |buffer, _| !buffer.is_parsing())
122 .await;
123 assert_eq!(
124 get_tree_sexp(&buffer, &cx),
125 concat!(
126 "(source_file (function_item name: (identifier) ",
127 "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
128 "body: (block (identifier))))"
129 )
130 );
131
132 // Perform a series of edits without waiting for the current parse to complete:
133 // * turn identifier into a field expression
134 // * turn field expression into a method call
135 // * add a turbofish to the method call
136 buffer.update(&mut cx, |buf, cx| {
137 let offset = buf.text().find(";").unwrap();
138 buf.edit(vec![offset..offset], ".e", cx);
139 assert_eq!(buf.text(), "fn a(b: C) { d.e; }");
140 assert!(buf.is_parsing());
141 });
142 buffer.update(&mut cx, |buf, cx| {
143 let offset = buf.text().find(";").unwrap();
144 buf.edit(vec![offset..offset], "(f)", cx);
145 assert_eq!(buf.text(), "fn a(b: C) { d.e(f); }");
146 assert!(buf.is_parsing());
147 });
148 buffer.update(&mut cx, |buf, cx| {
149 let offset = buf.text().find("(f)").unwrap();
150 buf.edit(vec![offset..offset], "::<G>", cx);
151 assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
152 assert!(buf.is_parsing());
153 });
154 buffer
155 .condition(&cx, |buffer, _| !buffer.is_parsing())
156 .await;
157 assert_eq!(
158 get_tree_sexp(&buffer, &cx),
159 concat!(
160 "(source_file (function_item name: (identifier) ",
161 "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
162 "body: (block (call_expression ",
163 "function: (generic_function ",
164 "function: (field_expression value: (identifier) field: (field_identifier)) ",
165 "type_arguments: (type_arguments (type_identifier))) ",
166 "arguments: (arguments (identifier))))))",
167 )
168 );
169
170 buffer.update(&mut cx, |buf, cx| {
171 buf.undo(cx);
172 assert_eq!(buf.text(), "fn a() {}");
173 assert!(buf.is_parsing());
174 });
175 buffer
176 .condition(&cx, |buffer, _| !buffer.is_parsing())
177 .await;
178 assert_eq!(
179 get_tree_sexp(&buffer, &cx),
180 concat!(
181 "(source_file (function_item name: (identifier) ",
182 "parameters: (parameters) ",
183 "body: (block)))"
184 )
185 );
186
187 buffer.update(&mut cx, |buf, cx| {
188 buf.redo(cx);
189 assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
190 assert!(buf.is_parsing());
191 });
192 buffer
193 .condition(&cx, |buffer, _| !buffer.is_parsing())
194 .await;
195 assert_eq!(
196 get_tree_sexp(&buffer, &cx),
197 concat!(
198 "(source_file (function_item name: (identifier) ",
199 "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
200 "body: (block (call_expression ",
201 "function: (generic_function ",
202 "function: (field_expression value: (identifier) field: (field_identifier)) ",
203 "type_arguments: (type_arguments (type_identifier))) ",
204 "arguments: (arguments (identifier))))))",
205 )
206 );
207
208 fn get_tree_sexp(buffer: &ModelHandle<Buffer>, cx: &gpui::TestAppContext) -> String {
209 buffer.read_with(cx, |buffer, _| {
210 buffer.syntax_tree().unwrap().root_node().to_sexp()
211 })
212 }
213}
214
215#[gpui::test]
216fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) {
217 let buffer = cx.add_model(|cx| {
218 let text = "
219 mod x {
220 mod y {
221
222 }
223 }
224 "
225 .unindent()
226 .into();
227 Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx)
228 });
229 let buffer = buffer.read(cx);
230 assert_eq!(
231 buffer.enclosing_bracket_point_ranges(Point::new(1, 6)..Point::new(1, 6)),
232 Some((
233 Point::new(0, 6)..Point::new(0, 7),
234 Point::new(4, 0)..Point::new(4, 1)
235 ))
236 );
237 assert_eq!(
238 buffer.enclosing_bracket_point_ranges(Point::new(1, 10)..Point::new(1, 10)),
239 Some((
240 Point::new(1, 10)..Point::new(1, 11),
241 Point::new(3, 4)..Point::new(3, 5)
242 ))
243 );
244 assert_eq!(
245 buffer.enclosing_bracket_point_ranges(Point::new(3, 5)..Point::new(3, 5)),
246 Some((
247 Point::new(1, 10)..Point::new(1, 11),
248 Point::new(3, 4)..Point::new(3, 5)
249 ))
250 );
251}
252
253#[gpui::test]
254fn test_edit_with_autoindent(cx: &mut MutableAppContext) {
255 cx.add_model(|cx| {
256 let text = "fn a() {}".into();
257 let mut buffer = Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx);
258
259 buffer.edit_with_autoindent([8..8], "\n\n", cx);
260 assert_eq!(buffer.text(), "fn a() {\n \n}");
261
262 buffer.edit_with_autoindent([Point::new(1, 4)..Point::new(1, 4)], "b()\n", cx);
263 assert_eq!(buffer.text(), "fn a() {\n b()\n \n}");
264
265 buffer.edit_with_autoindent([Point::new(2, 4)..Point::new(2, 4)], ".c", cx);
266 assert_eq!(buffer.text(), "fn a() {\n b()\n .c\n}");
267
268 buffer
269 });
270}
271
272#[gpui::test]
273fn test_autoindent_moves_selections(cx: &mut MutableAppContext) {
274 cx.add_model(|cx| {
275 let text = History::new("fn a() {}".into());
276 let mut buffer = Buffer::from_history(0, text, None, Some(rust_lang()), cx);
277
278 let selection_set_id = buffer.add_selection_set(Vec::new(), cx);
279 buffer.start_transaction(Some(selection_set_id)).unwrap();
280 buffer.edit_with_autoindent([5..5, 9..9], "\n\n", cx);
281 buffer
282 .update_selection_set(
283 selection_set_id,
284 vec![
285 Selection {
286 id: 0,
287 start: buffer.anchor_before(Point::new(1, 0)),
288 end: buffer.anchor_before(Point::new(1, 0)),
289 reversed: false,
290 goal: SelectionGoal::None,
291 },
292 Selection {
293 id: 1,
294 start: buffer.anchor_before(Point::new(4, 0)),
295 end: buffer.anchor_before(Point::new(4, 0)),
296 reversed: false,
297 goal: SelectionGoal::None,
298 },
299 ],
300 cx,
301 )
302 .unwrap();
303 assert_eq!(buffer.text(), "fn a(\n\n) {}\n\n");
304
305 // Ending the transaction runs the auto-indent. The selection
306 // at the start of the auto-indented row is pushed to the right.
307 buffer.end_transaction(Some(selection_set_id), cx).unwrap();
308 assert_eq!(buffer.text(), "fn a(\n \n) {}\n\n");
309 let selection_ranges = buffer
310 .selection_set(selection_set_id)
311 .unwrap()
312 .selections
313 .iter()
314 .map(|selection| selection.point_range(&buffer))
315 .collect::<Vec<_>>();
316
317 assert_eq!(selection_ranges[0], empty(Point::new(1, 4)));
318 assert_eq!(selection_ranges[1], empty(Point::new(4, 0)));
319
320 buffer
321 });
322}
323
324#[gpui::test]
325fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut MutableAppContext) {
326 cx.add_model(|cx| {
327 let text = "
328 fn a() {
329 c;
330 d;
331 }
332 "
333 .unindent()
334 .into();
335 let mut buffer = Buffer::from_history(0, History::new(text), None, Some(rust_lang()), cx);
336
337 // Lines 2 and 3 don't match the indentation suggestion. When editing these lines,
338 // their indentation is not adjusted.
339 buffer.edit_with_autoindent([empty(Point::new(1, 1)), empty(Point::new(2, 1))], "()", cx);
340 assert_eq!(
341 buffer.text(),
342 "
343 fn a() {
344 c();
345 d();
346 }
347 "
348 .unindent()
349 );
350
351 // When appending new content after these lines, the indentation is based on the
352 // preceding lines' actual indentation.
353 buffer.edit_with_autoindent(
354 [empty(Point::new(1, 1)), empty(Point::new(2, 1))],
355 "\n.f\n.g",
356 cx,
357 );
358 assert_eq!(
359 buffer.text(),
360 "
361 fn a() {
362 c
363 .f
364 .g();
365 d
366 .f
367 .g();
368 }
369 "
370 .unindent()
371 );
372 buffer
373 });
374}
375
376#[gpui::test]
377fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppContext) {
378 cx.add_model(|cx| {
379 let text = History::new(
380 "
381 fn a() {}
382 "
383 .unindent()
384 .into(),
385 );
386 let mut buffer = Buffer::from_history(0, text, None, Some(rust_lang()), cx);
387
388 buffer.edit_with_autoindent([5..5], "\nb", cx);
389 assert_eq!(
390 buffer.text(),
391 "
392 fn a(
393 b) {}
394 "
395 .unindent()
396 );
397
398 // The indentation suggestion changed because `@end` node (a close paren)
399 // is now at the beginning of the line.
400 buffer.edit_with_autoindent([Point::new(1, 4)..Point::new(1, 5)], "", cx);
401 assert_eq!(
402 buffer.text(),
403 "
404 fn a(
405 ) {}
406 "
407 .unindent()
408 );
409
410 buffer
411 });
412}
413
414#[test]
415fn test_contiguous_ranges() {
416 assert_eq!(
417 contiguous_ranges([1, 2, 3, 5, 6, 9, 10, 11, 12], 100).collect::<Vec<_>>(),
418 &[1..4, 5..7, 9..13]
419 );
420
421 // Respects the `max_len` parameter
422 assert_eq!(
423 contiguous_ranges([2, 3, 4, 5, 6, 7, 8, 9, 23, 24, 25, 26, 30, 31], 3).collect::<Vec<_>>(),
424 &[2..5, 5..8, 8..10, 23..26, 26..27, 30..32],
425 );
426}
427
428impl Buffer {
429 pub fn enclosing_bracket_point_ranges<T: ToOffset>(
430 &self,
431 range: Range<T>,
432 ) -> Option<(Range<Point>, Range<Point>)> {
433 self.enclosing_bracket_ranges(range).map(|(start, end)| {
434 let point_start = start.start.to_point(self)..start.end.to_point(self);
435 let point_end = end.start.to_point(self)..end.end.to_point(self);
436 (point_start, point_end)
437 })
438 }
439}
440
441fn rust_lang() -> Arc<Language> {
442 Arc::new(
443 Language::new(
444 LanguageConfig {
445 name: "Rust".to_string(),
446 path_suffixes: vec!["rs".to_string()],
447 ..Default::default()
448 },
449 tree_sitter_rust::language(),
450 )
451 .with_indents_query(
452 r#"
453 (call_expression) @indent
454 (field_expression) @indent
455 (_ "(" ")" @end) @indent
456 (_ "{" "}" @end) @indent
457 "#,
458 )
459 .unwrap()
460 .with_brackets_query(r#" ("{" @open "}" @close) "#)
461 .unwrap(),
462 )
463}
464
465fn empty(point: Point) -> Range<Point> {
466 point..point
467}