1use super::*;
2use clock::ReplicaId;
3use collections::BTreeMap;
4use gpui::{ModelHandle, MutableAppContext};
5use rand::prelude::*;
6use std::{
7 cell::RefCell,
8 env,
9 ops::Range,
10 rc::Rc,
11 time::{Duration, Instant},
12};
13use text::network::Network;
14use unindent::Unindent as _;
15use util::post_inc;
16
17#[cfg(test)]
18#[ctor::ctor]
19fn init_logger() {
20 if std::env::var("RUST_LOG").is_ok() {
21 env_logger::init();
22 }
23}
24
25#[gpui::test]
26fn test_select_language() {
27 let registry = LanguageRegistry::test();
28 registry.add(Arc::new(Language::new(
29 LanguageConfig {
30 name: "Rust".into(),
31 path_suffixes: vec!["rs".to_string()],
32 ..Default::default()
33 },
34 Some(tree_sitter_rust::language()),
35 )));
36 registry.add(Arc::new(Language::new(
37 LanguageConfig {
38 name: "Make".into(),
39 path_suffixes: vec!["Makefile".to_string(), "mk".to_string()],
40 ..Default::default()
41 },
42 Some(tree_sitter_rust::language()),
43 )));
44
45 // matching file extension
46 assert_eq!(
47 registry.select_language("zed/lib.rs").map(|l| l.name()),
48 Some("Rust".into())
49 );
50 assert_eq!(
51 registry.select_language("zed/lib.mk").map(|l| l.name()),
52 Some("Make".into())
53 );
54
55 // matching filename
56 assert_eq!(
57 registry.select_language("zed/Makefile").map(|l| l.name()),
58 Some("Make".into())
59 );
60
61 // matching suffix that is not the full file extension or filename
62 assert_eq!(registry.select_language("zed/cars").map(|l| l.name()), None);
63 assert_eq!(
64 registry.select_language("zed/a.cars").map(|l| l.name()),
65 None
66 );
67 assert_eq!(registry.select_language("zed/sumk").map(|l| l.name()), None);
68}
69
70#[gpui::test]
71fn test_edit_events(cx: &mut gpui::MutableAppContext) {
72 let mut now = Instant::now();
73 let buffer_1_events = Rc::new(RefCell::new(Vec::new()));
74 let buffer_2_events = Rc::new(RefCell::new(Vec::new()));
75
76 let buffer1 = cx.add_model(|cx| Buffer::new(0, "abcdef", cx));
77 let buffer2 = cx.add_model(|cx| Buffer::new(1, "abcdef", cx));
78 let buffer1_ops = Rc::new(RefCell::new(Vec::new()));
79 buffer1.update(cx, {
80 let buffer1_ops = buffer1_ops.clone();
81 |buffer, cx| {
82 let buffer_1_events = buffer_1_events.clone();
83 cx.subscribe(&buffer1, move |_, _, event, _| match event.clone() {
84 Event::Operation(op) => buffer1_ops.borrow_mut().push(op),
85 event @ _ => buffer_1_events.borrow_mut().push(event),
86 })
87 .detach();
88 let buffer_2_events = buffer_2_events.clone();
89 cx.subscribe(&buffer2, move |_, _, event, _| {
90 buffer_2_events.borrow_mut().push(event.clone())
91 })
92 .detach();
93
94 // An edit emits an edited event, followed by a dirtied event,
95 // since the buffer was previously in a clean state.
96 buffer.edit([(2..4, "XYZ")], cx);
97
98 // An empty transaction does not emit any events.
99 buffer.start_transaction();
100 buffer.end_transaction(cx);
101
102 // A transaction containing two edits emits one edited event.
103 now += Duration::from_secs(1);
104 buffer.start_transaction_at(now);
105 buffer.edit([(5..5, "u")], cx);
106 buffer.edit([(6..6, "w")], cx);
107 buffer.end_transaction_at(now, cx);
108
109 // Undoing a transaction emits one edited event.
110 buffer.undo(cx);
111 }
112 });
113
114 // Incorporating a set of remote ops emits a single edited event,
115 // followed by a dirtied event.
116 buffer2.update(cx, |buffer, cx| {
117 buffer
118 .apply_ops(buffer1_ops.borrow_mut().drain(..), cx)
119 .unwrap();
120 });
121
122 let buffer_1_events = buffer_1_events.borrow();
123 assert_eq!(
124 *buffer_1_events,
125 vec![Event::Edited, Event::Dirtied, Event::Edited, Event::Edited]
126 );
127
128 let buffer_2_events = buffer_2_events.borrow();
129 assert_eq!(*buffer_2_events, vec![Event::Edited, Event::Dirtied]);
130}
131
132#[gpui::test]
133async fn test_apply_diff(cx: &mut gpui::TestAppContext) {
134 let text = "a\nbb\nccc\ndddd\neeeee\nffffff\n";
135 let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
136
137 let text = "a\nccc\ndddd\nffffff\n";
138 let diff = buffer.read_with(cx, |b, cx| b.diff(text.into(), cx)).await;
139 buffer.update(cx, |buffer, cx| {
140 buffer.apply_diff(diff, cx).unwrap();
141 });
142 cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
143
144 let text = "a\n1\n\nccc\ndd2dd\nffffff\n";
145 let diff = buffer.read_with(cx, |b, cx| b.diff(text.into(), cx)).await;
146 buffer.update(cx, |buffer, cx| {
147 buffer.apply_diff(diff, cx).unwrap();
148 });
149 cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
150}
151
152#[gpui::test]
153async fn test_reparse(cx: &mut gpui::TestAppContext) {
154 let text = "fn a() {}";
155 let buffer =
156 cx.add_model(|cx| Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx));
157
158 // Wait for the initial text to parse
159 buffer
160 .condition(&cx, |buffer, _| !buffer.is_parsing())
161 .await;
162 assert_eq!(
163 get_tree_sexp(&buffer, &cx),
164 concat!(
165 "(source_file (function_item name: (identifier) ",
166 "parameters: (parameters) ",
167 "body: (block)))"
168 )
169 );
170
171 buffer.update(cx, |buffer, _| {
172 buffer.set_sync_parse_timeout(Duration::ZERO)
173 });
174
175 // Perform some edits (add parameter and variable reference)
176 // Parsing doesn't begin until the transaction is complete
177 buffer.update(cx, |buf, cx| {
178 buf.start_transaction();
179
180 let offset = buf.text().find(")").unwrap();
181 buf.edit([(offset..offset, "b: C")], cx);
182 assert!(!buf.is_parsing());
183
184 let offset = buf.text().find("}").unwrap();
185 buf.edit([(offset..offset, " d; ")], cx);
186 assert!(!buf.is_parsing());
187
188 buf.end_transaction(cx);
189 assert_eq!(buf.text(), "fn a(b: C) { d; }");
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 (expression_statement (identifier)))))"
201 )
202 );
203
204 // Perform a series of edits without waiting for the current parse to complete:
205 // * turn identifier into a field expression
206 // * turn field expression into a method call
207 // * add a turbofish to the method call
208 buffer.update(cx, |buf, cx| {
209 let offset = buf.text().find(";").unwrap();
210 buf.edit([(offset..offset, ".e")], cx);
211 assert_eq!(buf.text(), "fn a(b: C) { d.e; }");
212 assert!(buf.is_parsing());
213 });
214 buffer.update(cx, |buf, cx| {
215 let offset = buf.text().find(";").unwrap();
216 buf.edit([(offset..offset, "(f)")], cx);
217 assert_eq!(buf.text(), "fn a(b: C) { d.e(f); }");
218 assert!(buf.is_parsing());
219 });
220 buffer.update(cx, |buf, cx| {
221 let offset = buf.text().find("(f)").unwrap();
222 buf.edit([(offset..offset, "::<G>")], cx);
223 assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
224 assert!(buf.is_parsing());
225 });
226 buffer
227 .condition(&cx, |buffer, _| !buffer.is_parsing())
228 .await;
229 assert_eq!(
230 get_tree_sexp(&buffer, &cx),
231 concat!(
232 "(source_file (function_item name: (identifier) ",
233 "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
234 "body: (block (expression_statement (call_expression ",
235 "function: (generic_function ",
236 "function: (field_expression value: (identifier) field: (field_identifier)) ",
237 "type_arguments: (type_arguments (type_identifier))) ",
238 "arguments: (arguments (identifier)))))))",
239 )
240 );
241
242 buffer.update(cx, |buf, cx| {
243 buf.undo(cx);
244 assert_eq!(buf.text(), "fn a() {}");
245 assert!(buf.is_parsing());
246 });
247 buffer
248 .condition(&cx, |buffer, _| !buffer.is_parsing())
249 .await;
250 assert_eq!(
251 get_tree_sexp(&buffer, &cx),
252 concat!(
253 "(source_file (function_item name: (identifier) ",
254 "parameters: (parameters) ",
255 "body: (block)))"
256 )
257 );
258
259 buffer.update(cx, |buf, cx| {
260 buf.redo(cx);
261 assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
262 assert!(buf.is_parsing());
263 });
264 buffer
265 .condition(&cx, |buffer, _| !buffer.is_parsing())
266 .await;
267 assert_eq!(
268 get_tree_sexp(&buffer, &cx),
269 concat!(
270 "(source_file (function_item name: (identifier) ",
271 "parameters: (parameters (parameter pattern: (identifier) type: (type_identifier))) ",
272 "body: (block (expression_statement (call_expression ",
273 "function: (generic_function ",
274 "function: (field_expression value: (identifier) field: (field_identifier)) ",
275 "type_arguments: (type_arguments (type_identifier))) ",
276 "arguments: (arguments (identifier)))))))",
277 )
278 );
279}
280
281#[gpui::test]
282async fn test_resetting_language(cx: &mut gpui::TestAppContext) {
283 let buffer = cx.add_model(|cx| {
284 let mut buffer = Buffer::new(0, "{}", cx).with_language(Arc::new(rust_lang()), cx);
285 buffer.set_sync_parse_timeout(Duration::ZERO);
286 buffer
287 });
288
289 // Wait for the initial text to parse
290 buffer
291 .condition(&cx, |buffer, _| !buffer.is_parsing())
292 .await;
293 assert_eq!(
294 get_tree_sexp(&buffer, &cx),
295 "(source_file (expression_statement (block)))"
296 );
297
298 buffer.update(cx, |buffer, cx| {
299 buffer.set_language(Some(Arc::new(json_lang())), cx)
300 });
301 buffer
302 .condition(&cx, |buffer, _| !buffer.is_parsing())
303 .await;
304 assert_eq!(get_tree_sexp(&buffer, &cx), "(document (object))");
305}
306
307#[gpui::test]
308async fn test_outline(cx: &mut gpui::TestAppContext) {
309 let text = r#"
310 struct Person {
311 name: String,
312 age: usize,
313 }
314
315 mod module {
316 enum LoginState {
317 LoggedOut,
318 LoggingOn,
319 LoggedIn {
320 person: Person,
321 time: Instant,
322 }
323 }
324 }
325
326 impl Eq for Person {}
327
328 impl Drop for Person {
329 fn drop(&mut self) {
330 println!("bye");
331 }
332 }
333 "#
334 .unindent();
335
336 let buffer =
337 cx.add_model(|cx| Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx));
338 let outline = buffer
339 .read_with(cx, |buffer, _| buffer.snapshot().outline(None))
340 .unwrap();
341
342 assert_eq!(
343 outline
344 .items
345 .iter()
346 .map(|item| (item.text.as_str(), item.depth))
347 .collect::<Vec<_>>(),
348 &[
349 ("struct Person", 0),
350 ("name", 1),
351 ("age", 1),
352 ("mod module", 0),
353 ("enum LoginState", 1),
354 ("LoggedOut", 2),
355 ("LoggingOn", 2),
356 ("LoggedIn", 2),
357 ("person", 3),
358 ("time", 3),
359 ("impl Eq for Person", 0),
360 ("impl Drop for Person", 0),
361 ("fn drop", 1),
362 ]
363 );
364
365 // Without space, we only match on names
366 assert_eq!(
367 search(&outline, "oon", &cx).await,
368 &[
369 ("mod module", vec![]), // included as the parent of a match
370 ("enum LoginState", vec![]), // included as the parent of a match
371 ("LoggingOn", vec![1, 7, 8]), // matches
372 ("impl Drop for Person", vec![7, 18, 19]), // matches in two disjoint names
373 ]
374 );
375
376 assert_eq!(
377 search(&outline, "dp p", &cx).await,
378 &[
379 ("impl Drop for Person", vec![5, 8, 9, 14]),
380 ("fn drop", vec![]),
381 ]
382 );
383 assert_eq!(
384 search(&outline, "dpn", &cx).await,
385 &[("impl Drop for Person", vec![5, 14, 19])]
386 );
387 assert_eq!(
388 search(&outline, "impl ", &cx).await,
389 &[
390 ("impl Eq for Person", vec![0, 1, 2, 3, 4]),
391 ("impl Drop for Person", vec![0, 1, 2, 3, 4]),
392 ("fn drop", vec![]),
393 ]
394 );
395
396 async fn search<'a>(
397 outline: &'a Outline<Anchor>,
398 query: &str,
399 cx: &gpui::TestAppContext,
400 ) -> Vec<(&'a str, Vec<usize>)> {
401 let matches = cx
402 .read(|cx| outline.search(query, cx.background().clone()))
403 .await;
404 matches
405 .into_iter()
406 .map(|mat| (outline.items[mat.candidate_id].text.as_str(), mat.positions))
407 .collect::<Vec<_>>()
408 }
409}
410
411#[gpui::test]
412async fn test_symbols_containing(cx: &mut gpui::TestAppContext) {
413 let text = r#"
414 impl Person {
415 fn one() {
416 1
417 }
418
419 fn two() {
420 2
421 }fn three() {
422 3
423 }
424 }
425 "#
426 .unindent();
427
428 let buffer =
429 cx.add_model(|cx| Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx));
430 let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
431
432 // point is at the start of an item
433 assert_eq!(
434 symbols_containing(Point::new(1, 4), &snapshot),
435 vec![
436 (
437 "impl Person".to_string(),
438 Point::new(0, 0)..Point::new(10, 1)
439 ),
440 ("fn one".to_string(), Point::new(1, 4)..Point::new(3, 5))
441 ]
442 );
443
444 // point is in the middle of an item
445 assert_eq!(
446 symbols_containing(Point::new(2, 8), &snapshot),
447 vec![
448 (
449 "impl Person".to_string(),
450 Point::new(0, 0)..Point::new(10, 1)
451 ),
452 ("fn one".to_string(), Point::new(1, 4)..Point::new(3, 5))
453 ]
454 );
455
456 // point is at the end of an item
457 assert_eq!(
458 symbols_containing(Point::new(3, 5), &snapshot),
459 vec![
460 (
461 "impl Person".to_string(),
462 Point::new(0, 0)..Point::new(10, 1)
463 ),
464 ("fn one".to_string(), Point::new(1, 4)..Point::new(3, 5))
465 ]
466 );
467
468 // point is in between two adjacent items
469 assert_eq!(
470 symbols_containing(Point::new(7, 5), &snapshot),
471 vec![
472 (
473 "impl Person".to_string(),
474 Point::new(0, 0)..Point::new(10, 1)
475 ),
476 ("fn two".to_string(), Point::new(5, 4)..Point::new(7, 5))
477 ]
478 );
479
480 fn symbols_containing<'a>(
481 position: Point,
482 snapshot: &'a BufferSnapshot,
483 ) -> Vec<(String, Range<Point>)> {
484 snapshot
485 .symbols_containing(position, None)
486 .unwrap()
487 .into_iter()
488 .map(|item| {
489 (
490 item.text,
491 item.range.start.to_point(snapshot)..item.range.end.to_point(snapshot),
492 )
493 })
494 .collect()
495 }
496}
497
498#[gpui::test]
499fn test_enclosing_bracket_ranges(cx: &mut MutableAppContext) {
500 let buffer = cx.add_model(|cx| {
501 let text = "
502 mod x {
503 mod y {
504
505 }
506 }
507 "
508 .unindent();
509 Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx)
510 });
511 let buffer = buffer.read(cx);
512 assert_eq!(
513 buffer.enclosing_bracket_point_ranges(Point::new(1, 6)..Point::new(1, 6)),
514 Some((
515 Point::new(0, 6)..Point::new(0, 7),
516 Point::new(4, 0)..Point::new(4, 1)
517 ))
518 );
519 assert_eq!(
520 buffer.enclosing_bracket_point_ranges(Point::new(1, 10)..Point::new(1, 10)),
521 Some((
522 Point::new(1, 10)..Point::new(1, 11),
523 Point::new(3, 4)..Point::new(3, 5)
524 ))
525 );
526 assert_eq!(
527 buffer.enclosing_bracket_point_ranges(Point::new(3, 5)..Point::new(3, 5)),
528 Some((
529 Point::new(1, 10)..Point::new(1, 11),
530 Point::new(3, 4)..Point::new(3, 5)
531 ))
532 );
533}
534
535#[gpui::test]
536fn test_range_for_syntax_ancestor(cx: &mut MutableAppContext) {
537 cx.add_model(|cx| {
538 let text = "fn a() { b(|c| {}) }";
539 let buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
540 let snapshot = buffer.snapshot();
541
542 assert_eq!(
543 snapshot.range_for_syntax_ancestor(empty_range_at(text, "|")),
544 Some(range_of(text, "|"))
545 );
546 assert_eq!(
547 snapshot.range_for_syntax_ancestor(range_of(text, "|")),
548 Some(range_of(text, "|c|"))
549 );
550 assert_eq!(
551 snapshot.range_for_syntax_ancestor(range_of(text, "|c|")),
552 Some(range_of(text, "|c| {}"))
553 );
554 assert_eq!(
555 snapshot.range_for_syntax_ancestor(range_of(text, "|c| {}")),
556 Some(range_of(text, "(|c| {})"))
557 );
558
559 buffer
560 });
561
562 fn empty_range_at(text: &str, part: &str) -> Range<usize> {
563 let start = text.find(part).unwrap();
564 start..start
565 }
566
567 fn range_of(text: &str, part: &str) -> Range<usize> {
568 let start = text.find(part).unwrap();
569 start..start + part.len()
570 }
571}
572
573#[gpui::test]
574fn test_autoindent_with_soft_tabs(cx: &mut MutableAppContext) {
575 cx.add_model(|cx| {
576 let text = "fn a() {}";
577 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
578
579 buffer.edit_with_autoindent([(8..8, "\n\n")], IndentSize::spaces(4), cx);
580 assert_eq!(buffer.text(), "fn a() {\n \n}");
581
582 buffer.edit_with_autoindent(
583 [(Point::new(1, 4)..Point::new(1, 4), "b()\n")],
584 IndentSize::spaces(4),
585 cx,
586 );
587 assert_eq!(buffer.text(), "fn a() {\n b()\n \n}");
588
589 // Create a field expression on a new line, causing that line
590 // to be indented.
591 buffer.edit_with_autoindent(
592 [(Point::new(2, 4)..Point::new(2, 4), ".c")],
593 IndentSize::spaces(4),
594 cx,
595 );
596 assert_eq!(buffer.text(), "fn a() {\n b()\n .c\n}");
597
598 // Remove the dot so that the line is no longer a field expression,
599 // causing the line to be outdented.
600 buffer.edit_with_autoindent(
601 [(Point::new(2, 8)..Point::new(2, 9), "")],
602 IndentSize::spaces(4),
603 cx,
604 );
605 assert_eq!(buffer.text(), "fn a() {\n b()\n c\n}");
606
607 buffer
608 });
609}
610
611#[gpui::test]
612fn test_autoindent_with_hard_tabs(cx: &mut MutableAppContext) {
613 cx.add_model(|cx| {
614 let text = "fn a() {}";
615 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
616
617 buffer.edit_with_autoindent([(8..8, "\n\n")], IndentSize::tab(), cx);
618 assert_eq!(buffer.text(), "fn a() {\n\t\n}");
619
620 buffer.edit_with_autoindent(
621 [(Point::new(1, 1)..Point::new(1, 1), "b()\n")],
622 IndentSize::tab(),
623 cx,
624 );
625 assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\n}");
626
627 // Create a field expression on a new line, causing that line
628 // to be indented.
629 buffer.edit_with_autoindent(
630 [(Point::new(2, 1)..Point::new(2, 1), ".c")],
631 IndentSize::tab(),
632 cx,
633 );
634 assert_eq!(buffer.text(), "fn a() {\n\tb()\n\t\t.c\n}");
635
636 // Remove the dot so that the line is no longer a field expression,
637 // causing the line to be outdented.
638 buffer.edit_with_autoindent(
639 [(Point::new(2, 2)..Point::new(2, 3), "")],
640 IndentSize::tab(),
641 cx,
642 );
643 assert_eq!(buffer.text(), "fn a() {\n\tb()\n\tc\n}");
644
645 buffer
646 });
647}
648
649#[gpui::test]
650fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut MutableAppContext) {
651 cx.add_model(|cx| {
652 let text = "
653 fn a() {
654 c;
655 d;
656 }
657 "
658 .unindent();
659
660 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
661
662 // Lines 2 and 3 don't match the indentation suggestion. When editing these lines,
663 // their indentation is not adjusted.
664 buffer.edit_with_autoindent(
665 [
666 (empty(Point::new(1, 1)), "()"),
667 (empty(Point::new(2, 1)), "()"),
668 ],
669 IndentSize::spaces(4),
670 cx,
671 );
672 assert_eq!(
673 buffer.text(),
674 "
675 fn a() {
676 c();
677 d();
678 }
679 "
680 .unindent()
681 );
682
683 // When appending new content after these lines, the indentation is based on the
684 // preceding lines' actual indentation.
685 buffer.edit_with_autoindent(
686 [
687 (empty(Point::new(1, 1)), "\n.f\n.g"),
688 (empty(Point::new(2, 1)), "\n.f\n.g"),
689 ],
690 IndentSize::spaces(4),
691 cx,
692 );
693 assert_eq!(
694 buffer.text(),
695 "
696 fn a() {
697 c
698 .f
699 .g();
700 d
701 .f
702 .g();
703 }
704 "
705 .unindent()
706 );
707 buffer
708 });
709
710 cx.add_model(|cx| {
711 let text = "fn a() {\n {\n b()?\n }\n\n Ok(())\n}";
712 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
713 buffer.edit_with_autoindent(
714 [(Point::new(3, 4)..Point::new(3, 5), "")],
715 IndentSize::spaces(4),
716 cx,
717 );
718 assert_eq!(
719 buffer.text(),
720 "fn a() {\n {\n b()?\n \n\n Ok(())\n}"
721 );
722
723 buffer.edit_with_autoindent(
724 [(Point::new(3, 0)..Point::new(3, 12), "")],
725 IndentSize::spaces(4),
726 cx,
727 );
728 assert_eq!(
729 buffer.text(),
730 "fn a() {\n {\n b()?\n\n\n Ok(())\n}"
731 );
732 buffer
733 });
734}
735
736#[gpui::test]
737fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut MutableAppContext) {
738 cx.add_model(|cx| {
739 let text = "
740 fn a() {}
741 "
742 .unindent();
743
744 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
745
746 buffer.edit_with_autoindent([(5..5, "\nb")], IndentSize::spaces(4), cx);
747 assert_eq!(
748 buffer.text(),
749 "
750 fn a(
751 b) {}
752 "
753 .unindent()
754 );
755
756 // The indentation suggestion changed because `@end` node (a close paren)
757 // is now at the beginning of the line.
758 buffer.edit_with_autoindent(
759 [(Point::new(1, 4)..Point::new(1, 5), "")],
760 IndentSize::spaces(4),
761 cx,
762 );
763 assert_eq!(
764 buffer.text(),
765 "
766 fn a(
767 ) {}
768 "
769 .unindent()
770 );
771
772 buffer
773 });
774}
775
776#[gpui::test]
777fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut MutableAppContext) {
778 cx.add_model(|cx| {
779 let text = "a\nb";
780 let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
781 buffer.edit_with_autoindent([(0..1, "\n"), (2..3, "\n")], IndentSize::spaces(4), cx);
782 assert_eq!(buffer.text(), "\n\n\n");
783 buffer
784 });
785}
786
787#[gpui::test]
788fn test_serialization(cx: &mut gpui::MutableAppContext) {
789 let mut now = Instant::now();
790
791 let buffer1 = cx.add_model(|cx| {
792 let mut buffer = Buffer::new(0, "abc", cx);
793 buffer.edit([(3..3, "D")], cx);
794
795 now += Duration::from_secs(1);
796 buffer.start_transaction_at(now);
797 buffer.edit([(4..4, "E")], cx);
798 buffer.end_transaction_at(now, cx);
799 assert_eq!(buffer.text(), "abcDE");
800
801 buffer.undo(cx);
802 assert_eq!(buffer.text(), "abcD");
803
804 buffer.edit([(4..4, "F")], cx);
805 assert_eq!(buffer.text(), "abcDF");
806 buffer
807 });
808 assert_eq!(buffer1.read(cx).text(), "abcDF");
809
810 let message = buffer1.read(cx).to_proto();
811 let buffer2 = cx.add_model(|cx| Buffer::from_proto(1, message, None, cx).unwrap());
812 assert_eq!(buffer2.read(cx).text(), "abcDF");
813}
814
815#[gpui::test(iterations = 100)]
816fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
817 let min_peers = env::var("MIN_PEERS")
818 .map(|i| i.parse().expect("invalid `MIN_PEERS` variable"))
819 .unwrap_or(1);
820 let max_peers = env::var("MAX_PEERS")
821 .map(|i| i.parse().expect("invalid `MAX_PEERS` variable"))
822 .unwrap_or(5);
823 let operations = env::var("OPERATIONS")
824 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
825 .unwrap_or(10);
826
827 let base_text_len = rng.gen_range(0..10);
828 let base_text = RandomCharIter::new(&mut rng)
829 .take(base_text_len)
830 .collect::<String>();
831 let mut replica_ids = Vec::new();
832 let mut buffers = Vec::new();
833 let network = Rc::new(RefCell::new(Network::new(rng.clone())));
834 let base_buffer = cx.add_model(|cx| Buffer::new(0, base_text.as_str(), cx));
835
836 for i in 0..rng.gen_range(min_peers..=max_peers) {
837 let buffer = cx.add_model(|cx| {
838 let mut buffer =
839 Buffer::from_proto(i as ReplicaId, base_buffer.read(cx).to_proto(), None, cx)
840 .unwrap();
841 buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
842 let network = network.clone();
843 cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
844 if let Event::Operation(op) = event {
845 network
846 .borrow_mut()
847 .broadcast(buffer.replica_id(), vec![proto::serialize_operation(&op)]);
848 }
849 })
850 .detach();
851 buffer
852 });
853 buffers.push(buffer);
854 replica_ids.push(i as ReplicaId);
855 network.borrow_mut().add_peer(i as ReplicaId);
856 log::info!("Adding initial peer with replica id {}", i);
857 }
858
859 log::info!("initial text: {:?}", base_text);
860
861 let mut now = Instant::now();
862 let mut mutation_count = operations;
863 let mut next_diagnostic_id = 0;
864 let mut active_selections = BTreeMap::default();
865 loop {
866 let replica_index = rng.gen_range(0..replica_ids.len());
867 let replica_id = replica_ids[replica_index];
868 let buffer = &mut buffers[replica_index];
869 let mut new_buffer = None;
870 match rng.gen_range(0..100) {
871 0..=29 if mutation_count != 0 => {
872 buffer.update(cx, |buffer, cx| {
873 buffer.start_transaction_at(now);
874 buffer.randomly_edit(&mut rng, 5, cx);
875 buffer.end_transaction_at(now, cx);
876 log::info!("buffer {} text: {:?}", buffer.replica_id(), buffer.text());
877 });
878 mutation_count -= 1;
879 }
880 30..=39 if mutation_count != 0 => {
881 buffer.update(cx, |buffer, cx| {
882 let mut selections = Vec::new();
883 for id in 0..rng.gen_range(1..=5) {
884 let range = buffer.random_byte_range(0, &mut rng);
885 selections.push(Selection {
886 id,
887 start: buffer.anchor_before(range.start),
888 end: buffer.anchor_before(range.end),
889 reversed: false,
890 goal: SelectionGoal::None,
891 });
892 }
893 let selections: Arc<[Selection<Anchor>]> = selections.into();
894 log::info!(
895 "peer {} setting active selections: {:?}",
896 replica_id,
897 selections
898 );
899 active_selections.insert(replica_id, selections.clone());
900 buffer.set_active_selections(selections, false, cx);
901 });
902 mutation_count -= 1;
903 }
904 40..=49 if mutation_count != 0 && replica_id == 0 => {
905 let entry_count = rng.gen_range(1..=5);
906 buffer.update(cx, |buffer, cx| {
907 let diagnostics = DiagnosticSet::new(
908 (0..entry_count).map(|_| {
909 let range = buffer.random_byte_range(0, &mut rng);
910 let range = range.to_point_utf16(buffer);
911 DiagnosticEntry {
912 range,
913 diagnostic: Diagnostic {
914 message: post_inc(&mut next_diagnostic_id).to_string(),
915 ..Default::default()
916 },
917 }
918 }),
919 buffer,
920 );
921 log::info!("peer {} setting diagnostics: {:?}", replica_id, diagnostics);
922 buffer.update_diagnostics(diagnostics, cx);
923 });
924 mutation_count -= 1;
925 }
926 50..=59 if replica_ids.len() < max_peers => {
927 let old_buffer = buffer.read(cx).to_proto();
928 let new_replica_id = (0..=replica_ids.len() as ReplicaId)
929 .filter(|replica_id| *replica_id != buffer.read(cx).replica_id())
930 .choose(&mut rng)
931 .unwrap();
932 log::info!(
933 "Adding new replica {} (replicating from {})",
934 new_replica_id,
935 replica_id
936 );
937 new_buffer = Some(cx.add_model(|cx| {
938 let mut new_buffer =
939 Buffer::from_proto(new_replica_id, old_buffer, None, cx).unwrap();
940 log::info!(
941 "New replica {} text: {:?}",
942 new_buffer.replica_id(),
943 new_buffer.text()
944 );
945 new_buffer.set_group_interval(Duration::from_millis(rng.gen_range(0..=200)));
946 let network = network.clone();
947 cx.subscribe(&cx.handle(), move |buffer, _, event, _| {
948 if let Event::Operation(op) = event {
949 network.borrow_mut().broadcast(
950 buffer.replica_id(),
951 vec![proto::serialize_operation(&op)],
952 );
953 }
954 })
955 .detach();
956 new_buffer
957 }));
958 network.borrow_mut().replicate(replica_id, new_replica_id);
959
960 if new_replica_id as usize == replica_ids.len() {
961 replica_ids.push(new_replica_id);
962 } else {
963 let new_buffer = new_buffer.take().unwrap();
964 while network.borrow().has_unreceived(new_replica_id) {
965 let ops = network
966 .borrow_mut()
967 .receive(new_replica_id)
968 .into_iter()
969 .map(|op| proto::deserialize_operation(op).unwrap());
970 if ops.len() > 0 {
971 log::info!(
972 "peer {} (version: {:?}) applying {} ops from the network. {:?}",
973 new_replica_id,
974 buffer.read(cx).version(),
975 ops.len(),
976 ops
977 );
978 new_buffer.update(cx, |new_buffer, cx| {
979 new_buffer.apply_ops(ops, cx).unwrap();
980 });
981 }
982 }
983 buffers[new_replica_id as usize] = new_buffer;
984 }
985 }
986 60..=69 if mutation_count != 0 => {
987 buffer.update(cx, |buffer, cx| {
988 buffer.randomly_undo_redo(&mut rng, cx);
989 log::info!("buffer {} text: {:?}", buffer.replica_id(), buffer.text());
990 });
991 mutation_count -= 1;
992 }
993 _ if network.borrow().has_unreceived(replica_id) => {
994 let ops = network
995 .borrow_mut()
996 .receive(replica_id)
997 .into_iter()
998 .map(|op| proto::deserialize_operation(op).unwrap());
999 if ops.len() > 0 {
1000 log::info!(
1001 "peer {} (version: {:?}) applying {} ops from the network. {:?}",
1002 replica_id,
1003 buffer.read(cx).version(),
1004 ops.len(),
1005 ops
1006 );
1007 buffer.update(cx, |buffer, cx| buffer.apply_ops(ops, cx).unwrap());
1008 }
1009 }
1010 _ => {}
1011 }
1012
1013 now += Duration::from_millis(rng.gen_range(0..=200));
1014 buffers.extend(new_buffer);
1015
1016 for buffer in &buffers {
1017 buffer.read(cx).check_invariants();
1018 }
1019
1020 if mutation_count == 0 && network.borrow().is_idle() {
1021 break;
1022 }
1023 }
1024
1025 let first_buffer = buffers[0].read(cx).snapshot();
1026 for buffer in &buffers[1..] {
1027 let buffer = buffer.read(cx).snapshot();
1028 assert_eq!(
1029 buffer.version(),
1030 first_buffer.version(),
1031 "Replica {} version != Replica 0 version",
1032 buffer.replica_id()
1033 );
1034 assert_eq!(
1035 buffer.text(),
1036 first_buffer.text(),
1037 "Replica {} text != Replica 0 text",
1038 buffer.replica_id()
1039 );
1040 assert_eq!(
1041 buffer
1042 .diagnostics_in_range::<_, usize>(0..buffer.len(), false)
1043 .collect::<Vec<_>>(),
1044 first_buffer
1045 .diagnostics_in_range::<_, usize>(0..first_buffer.len(), false)
1046 .collect::<Vec<_>>(),
1047 "Replica {} diagnostics != Replica 0 diagnostics",
1048 buffer.replica_id()
1049 );
1050 }
1051
1052 for buffer in &buffers {
1053 let buffer = buffer.read(cx).snapshot();
1054 let actual_remote_selections = buffer
1055 .remote_selections_in_range(Anchor::MIN..Anchor::MAX)
1056 .map(|(replica_id, _, selections)| (replica_id, selections.collect::<Vec<_>>()))
1057 .collect::<Vec<_>>();
1058 let expected_remote_selections = active_selections
1059 .iter()
1060 .filter(|(replica_id, _)| **replica_id != buffer.replica_id())
1061 .map(|(replica_id, selections)| (*replica_id, selections.iter().collect::<Vec<_>>()))
1062 .collect::<Vec<_>>();
1063 assert_eq!(
1064 actual_remote_selections,
1065 expected_remote_selections,
1066 "Replica {} remote selections != expected selections",
1067 buffer.replica_id()
1068 );
1069 }
1070}
1071
1072#[test]
1073fn test_contiguous_ranges() {
1074 assert_eq!(
1075 contiguous_ranges([1, 2, 3, 5, 6, 9, 10, 11, 12].into_iter(), 100).collect::<Vec<_>>(),
1076 &[1..4, 5..7, 9..13]
1077 );
1078
1079 // Respects the `max_len` parameter
1080 assert_eq!(
1081 contiguous_ranges(
1082 [2, 3, 4, 5, 6, 7, 8, 9, 23, 24, 25, 26, 30, 31].into_iter(),
1083 3
1084 )
1085 .collect::<Vec<_>>(),
1086 &[2..5, 5..8, 8..10, 23..26, 26..27, 30..32],
1087 );
1088}
1089
1090impl Buffer {
1091 pub fn enclosing_bracket_point_ranges<T: ToOffset>(
1092 &self,
1093 range: Range<T>,
1094 ) -> Option<(Range<Point>, Range<Point>)> {
1095 self.snapshot()
1096 .enclosing_bracket_ranges(range)
1097 .map(|(start, end)| {
1098 let point_start = start.start.to_point(self)..start.end.to_point(self);
1099 let point_end = end.start.to_point(self)..end.end.to_point(self);
1100 (point_start, point_end)
1101 })
1102 }
1103}
1104
1105fn rust_lang() -> Language {
1106 Language::new(
1107 LanguageConfig {
1108 name: "Rust".into(),
1109 path_suffixes: vec!["rs".to_string()],
1110 ..Default::default()
1111 },
1112 Some(tree_sitter_rust::language()),
1113 )
1114 .with_indents_query(
1115 r#"
1116 (call_expression) @indent
1117 (field_expression) @indent
1118 (_ "(" ")" @end) @indent
1119 (_ "{" "}" @end) @indent
1120 "#,
1121 )
1122 .unwrap()
1123 .with_brackets_query(
1124 r#"
1125 ("{" @open "}" @close)
1126 "#,
1127 )
1128 .unwrap()
1129 .with_outline_query(
1130 r#"
1131 (struct_item
1132 "struct" @context
1133 name: (_) @name) @item
1134 (enum_item
1135 "enum" @context
1136 name: (_) @name) @item
1137 (enum_variant
1138 name: (_) @name) @item
1139 (field_declaration
1140 name: (_) @name) @item
1141 (impl_item
1142 "impl" @context
1143 trait: (_)? @name
1144 "for"? @context
1145 type: (_) @name) @item
1146 (function_item
1147 "fn" @context
1148 name: (_) @name) @item
1149 (mod_item
1150 "mod" @context
1151 name: (_) @name) @item
1152 "#,
1153 )
1154 .unwrap()
1155}
1156
1157fn json_lang() -> Language {
1158 Language::new(
1159 LanguageConfig {
1160 name: "Json".into(),
1161 path_suffixes: vec!["js".to_string()],
1162 ..Default::default()
1163 },
1164 Some(tree_sitter_json::language()),
1165 )
1166}
1167
1168fn get_tree_sexp(buffer: &ModelHandle<Buffer>, cx: &gpui::TestAppContext) -> String {
1169 buffer.read_with(cx, |buffer, _| {
1170 buffer.syntax_tree().unwrap().root_node().to_sexp()
1171 })
1172}
1173
1174fn empty(point: Point) -> Range<Point> {
1175 point..point
1176}