1mod anchor;
2
3pub use anchor::{Anchor, AnchorRangeExt};
4use anyhow::{anyhow, Result};
5use clock::ReplicaId;
6use collections::{BTreeMap, Bound, HashMap, HashSet};
7use futures::{channel::mpsc, SinkExt};
8use git::diff::DiffHunk;
9use gpui::{AppContext, EventEmitter, Model, ModelContext};
10pub use language::Completion;
11use language::{
12 char_kind,
13 language_settings::{language_settings, LanguageSettings},
14 AutoindentMode, Buffer, BufferChunks, BufferSnapshot, Capability, CharKind, Chunk, CursorShape,
15 DiagnosticEntry, File, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16,
16 Outline, OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _,
17 ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped,
18};
19use std::{
20 borrow::Cow,
21 cell::{Ref, RefCell},
22 cmp, fmt,
23 future::Future,
24 io,
25 iter::{self, FromIterator},
26 mem,
27 ops::{Range, RangeBounds, Sub},
28 str,
29 sync::Arc,
30 time::{Duration, Instant},
31};
32use sum_tree::{Bias, Cursor, SumTree};
33use text::{
34 locator::Locator,
35 subscription::{Subscription, Topic},
36 BufferId, Edit, TextSummary,
37};
38use theme::SyntaxTheme;
39
40use util::post_inc;
41
42#[cfg(any(test, feature = "test-support"))]
43use gpui::Context;
44
45const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];
46
47#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
48pub struct ExcerptId(usize);
49
50/// One or more [`Buffers`](Buffer) being edited in a single view.
51///
52/// See <https://zed.dev/features#multi-buffers>
53pub struct MultiBuffer {
54 /// A snapshot of the [`Excerpt`]s in the MultiBuffer.
55 /// Use [`MultiBuffer::snapshot`] to get a up-to-date snapshot.
56 snapshot: RefCell<MultiBufferSnapshot>,
57 /// Contains the state of the buffers being edited
58 buffers: RefCell<HashMap<BufferId, BufferState>>,
59 subscriptions: Topic,
60 /// If true, the multi-buffer only contains a single [`Buffer`] and a single [`Excerpt`]
61 singleton: bool,
62 replica_id: ReplicaId,
63 history: History,
64 title: Option<String>,
65 capability: Capability,
66}
67
68#[derive(Clone, Debug, PartialEq, Eq)]
69pub enum Event {
70 ExcerptsAdded {
71 buffer: Model<Buffer>,
72 predecessor: ExcerptId,
73 excerpts: Vec<(ExcerptId, ExcerptRange<language::Anchor>)>,
74 },
75 ExcerptsRemoved {
76 ids: Vec<ExcerptId>,
77 },
78 ExcerptsEdited {
79 ids: Vec<ExcerptId>,
80 },
81 Edited {
82 singleton_buffer_edited: bool,
83 },
84 TransactionUndone {
85 transaction_id: TransactionId,
86 },
87 Reloaded,
88 DiffBaseChanged,
89 LanguageChanged,
90 CapabilityChanged,
91 Reparsed,
92 Saved,
93 FileHandleChanged,
94 Closed,
95 DirtyChanged,
96 DiagnosticsUpdated,
97}
98
99#[derive(Clone)]
100struct History {
101 next_transaction_id: TransactionId,
102 undo_stack: Vec<Transaction>,
103 redo_stack: Vec<Transaction>,
104 transaction_depth: usize,
105 group_interval: Duration,
106}
107
108#[derive(Clone)]
109struct Transaction {
110 id: TransactionId,
111 buffer_transactions: HashMap<BufferId, text::TransactionId>,
112 first_edit_at: Instant,
113 last_edit_at: Instant,
114 suppress_grouping: bool,
115}
116
117pub trait ToOffset: 'static + fmt::Debug {
118 fn to_offset(&self, snapshot: &MultiBufferSnapshot) -> usize;
119}
120
121pub trait ToOffsetUtf16: 'static + fmt::Debug {
122 fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16;
123}
124
125pub trait ToPoint: 'static + fmt::Debug {
126 fn to_point(&self, snapshot: &MultiBufferSnapshot) -> Point;
127}
128
129pub trait ToPointUtf16: 'static + fmt::Debug {
130 fn to_point_utf16(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16;
131}
132
133struct BufferState {
134 buffer: Model<Buffer>,
135 last_version: clock::Global,
136 last_parse_count: usize,
137 last_selections_update_count: usize,
138 last_diagnostics_update_count: usize,
139 last_file_update_count: usize,
140 last_git_diff_update_count: usize,
141 excerpts: Vec<Locator>,
142 _subscriptions: [gpui::Subscription; 2],
143}
144
145/// The contents of a [`MultiBuffer`] at a single point in time.
146#[derive(Clone, Default)]
147pub struct MultiBufferSnapshot {
148 singleton: bool,
149 excerpts: SumTree<Excerpt>,
150 excerpt_ids: SumTree<ExcerptIdMapping>,
151 parse_count: usize,
152 diagnostics_update_count: usize,
153 trailing_excerpt_update_count: usize,
154 git_diff_update_count: usize,
155 edit_count: usize,
156 is_dirty: bool,
157 has_conflict: bool,
158}
159
160/// A boundary between [`Excerpt`]s in a [`MultiBuffer`]
161pub struct ExcerptBoundary {
162 pub id: ExcerptId,
163 /// The row in the `MultiBuffer` where the boundary is located
164 pub row: u32,
165 pub buffer: BufferSnapshot,
166 pub range: ExcerptRange<text::Anchor>,
167 /// It's possible to have multiple excerpts in the same buffer,
168 /// and they are rendered together without a new File header.
169 ///
170 /// This flag indicates that the excerpt is the first one in the buffer.
171 pub starts_new_buffer: bool,
172}
173
174/// A slice into a [`Buffer`] that is being edited in a [`MultiBuffer`].
175#[derive(Clone)]
176struct Excerpt {
177 /// The unique identifier for this excerpt
178 id: ExcerptId,
179 /// The location of the excerpt in the [`MultiBuffer`]
180 locator: Locator,
181 /// The buffer being excerpted
182 buffer_id: BufferId,
183 /// A snapshot of the buffer being excerpted
184 buffer: BufferSnapshot,
185 /// The range of the buffer to be shown in the excerpt
186 range: ExcerptRange<text::Anchor>,
187 /// The last row in the excerpted slice of the buffer
188 max_buffer_row: u32,
189 /// A summary of the text in the excerpt
190 text_summary: TextSummary,
191 has_trailing_newline: bool,
192}
193
194/// A public view into an [`Excerpt`] in a [`MultiBuffer`].
195///
196/// Contains methods for getting the [`Buffer`] of the excerpt,
197/// as well as mapping offsets to/from buffer and multibuffer coordinates.
198#[derive(Clone)]
199pub struct MultiBufferExcerpt<'a> {
200 excerpt: &'a Excerpt,
201 excerpt_offset: usize,
202}
203
204#[derive(Clone, Debug)]
205struct ExcerptIdMapping {
206 id: ExcerptId,
207 locator: Locator,
208}
209
210/// A range of text from a single [`Buffer`], to be shown as an [`Excerpt`].
211/// These ranges are relative to the buffer itself
212#[derive(Clone, Debug, Eq, PartialEq)]
213pub struct ExcerptRange<T> {
214 /// The full range of text to be shown in the excerpt.
215 pub context: Range<T>,
216 /// The primary range of text to be highlighted in the excerpt.
217 /// In a multi-buffer search, this would be the text that matched the search
218 pub primary: Option<Range<T>>,
219}
220
221#[derive(Clone, Debug, Default)]
222struct ExcerptSummary {
223 excerpt_id: ExcerptId,
224 /// The location of the last [`Excerpt`] being summarized
225 excerpt_locator: Locator,
226 /// The maximum row of the [`Excerpt`]s being summarized
227 max_buffer_row: u32,
228 text: TextSummary,
229}
230
231#[derive(Clone)]
232pub struct MultiBufferRows<'a> {
233 buffer_row_range: Range<u32>,
234 excerpts: Cursor<'a, Excerpt, Point>,
235}
236
237pub struct MultiBufferChunks<'a> {
238 range: Range<usize>,
239 excerpts: Cursor<'a, Excerpt, usize>,
240 excerpt_chunks: Option<ExcerptChunks<'a>>,
241 language_aware: bool,
242}
243
244pub struct MultiBufferBytes<'a> {
245 range: Range<usize>,
246 excerpts: Cursor<'a, Excerpt, usize>,
247 excerpt_bytes: Option<ExcerptBytes<'a>>,
248 chunk: &'a [u8],
249}
250
251pub struct ReversedMultiBufferBytes<'a> {
252 range: Range<usize>,
253 excerpts: Cursor<'a, Excerpt, usize>,
254 excerpt_bytes: Option<ExcerptBytes<'a>>,
255 chunk: &'a [u8],
256}
257
258struct ExcerptChunks<'a> {
259 content_chunks: BufferChunks<'a>,
260 footer_height: usize,
261}
262
263struct ExcerptBytes<'a> {
264 content_bytes: text::Bytes<'a>,
265 footer_height: usize,
266}
267
268impl MultiBuffer {
269 pub fn new(replica_id: ReplicaId, capability: Capability) -> Self {
270 Self {
271 snapshot: Default::default(),
272 buffers: Default::default(),
273 subscriptions: Default::default(),
274 singleton: false,
275 capability,
276 replica_id,
277 history: History {
278 next_transaction_id: Default::default(),
279 undo_stack: Default::default(),
280 redo_stack: Default::default(),
281 transaction_depth: 0,
282 group_interval: Duration::from_millis(300),
283 },
284 title: Default::default(),
285 }
286 }
287
288 pub fn clone(&self, new_cx: &mut ModelContext<Self>) -> Self {
289 let mut buffers = HashMap::default();
290 for (buffer_id, buffer_state) in self.buffers.borrow().iter() {
291 buffers.insert(
292 *buffer_id,
293 BufferState {
294 buffer: buffer_state.buffer.clone(),
295 last_version: buffer_state.last_version.clone(),
296 last_parse_count: buffer_state.last_parse_count,
297 last_selections_update_count: buffer_state.last_selections_update_count,
298 last_diagnostics_update_count: buffer_state.last_diagnostics_update_count,
299 last_file_update_count: buffer_state.last_file_update_count,
300 last_git_diff_update_count: buffer_state.last_git_diff_update_count,
301 excerpts: buffer_state.excerpts.clone(),
302 _subscriptions: [
303 new_cx.observe(&buffer_state.buffer, |_, _, cx| cx.notify()),
304 new_cx.subscribe(&buffer_state.buffer, Self::on_buffer_event),
305 ],
306 },
307 );
308 }
309 Self {
310 snapshot: RefCell::new(self.snapshot.borrow().clone()),
311 buffers: RefCell::new(buffers),
312 subscriptions: Default::default(),
313 singleton: self.singleton,
314 capability: self.capability,
315 replica_id: self.replica_id,
316 history: self.history.clone(),
317 title: self.title.clone(),
318 }
319 }
320
321 pub fn with_title(mut self, title: String) -> Self {
322 self.title = Some(title);
323 self
324 }
325
326 pub fn read_only(&self) -> bool {
327 self.capability == Capability::ReadOnly
328 }
329
330 pub fn singleton(buffer: Model<Buffer>, cx: &mut ModelContext<Self>) -> Self {
331 let mut this = Self::new(buffer.read(cx).replica_id(), buffer.read(cx).capability());
332 this.singleton = true;
333 this.push_excerpts(
334 buffer,
335 [ExcerptRange {
336 context: text::Anchor::MIN..text::Anchor::MAX,
337 primary: None,
338 }],
339 cx,
340 );
341 this.snapshot.borrow_mut().singleton = true;
342 this
343 }
344
345 pub fn replica_id(&self) -> ReplicaId {
346 self.replica_id
347 }
348
349 /// Returns an up-to-date snapshot of the MultiBuffer.
350 pub fn snapshot(&self, cx: &AppContext) -> MultiBufferSnapshot {
351 self.sync(cx);
352 self.snapshot.borrow().clone()
353 }
354
355 pub fn read(&self, cx: &AppContext) -> Ref<MultiBufferSnapshot> {
356 self.sync(cx);
357 self.snapshot.borrow()
358 }
359
360 pub fn as_singleton(&self) -> Option<Model<Buffer>> {
361 if self.singleton {
362 return Some(
363 self.buffers
364 .borrow()
365 .values()
366 .next()
367 .unwrap()
368 .buffer
369 .clone(),
370 );
371 } else {
372 None
373 }
374 }
375
376 pub fn is_singleton(&self) -> bool {
377 self.singleton
378 }
379
380 pub fn subscribe(&mut self) -> Subscription {
381 self.subscriptions.subscribe()
382 }
383
384 pub fn is_dirty(&self, cx: &AppContext) -> bool {
385 self.read(cx).is_dirty()
386 }
387
388 pub fn has_conflict(&self, cx: &AppContext) -> bool {
389 self.read(cx).has_conflict()
390 }
391
392 // The `is_empty` signature doesn't match what clippy expects
393 #[allow(clippy::len_without_is_empty)]
394 pub fn len(&self, cx: &AppContext) -> usize {
395 self.read(cx).len()
396 }
397
398 pub fn is_empty(&self, cx: &AppContext) -> bool {
399 self.len(cx) != 0
400 }
401
402 pub fn symbols_containing<T: ToOffset>(
403 &self,
404 offset: T,
405 theme: Option<&SyntaxTheme>,
406 cx: &AppContext,
407 ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
408 self.read(cx).symbols_containing(offset, theme)
409 }
410
411 pub fn edit<I, S, T>(
412 &mut self,
413 edits: I,
414 mut autoindent_mode: Option<AutoindentMode>,
415 cx: &mut ModelContext<Self>,
416 ) where
417 I: IntoIterator<Item = (Range<S>, T)>,
418 S: ToOffset,
419 T: Into<Arc<str>>,
420 {
421 if self.buffers.borrow().is_empty() {
422 return;
423 }
424
425 let snapshot = self.read(cx);
426 let edits = edits.into_iter().map(|(range, new_text)| {
427 let mut range = range.start.to_offset(&snapshot)..range.end.to_offset(&snapshot);
428 if range.start > range.end {
429 mem::swap(&mut range.start, &mut range.end);
430 }
431 (range, new_text)
432 });
433
434 if let Some(buffer) = self.as_singleton() {
435 return buffer.update(cx, |buffer, cx| {
436 buffer.edit(edits, autoindent_mode, cx);
437 });
438 }
439
440 let original_indent_columns = match &mut autoindent_mode {
441 Some(AutoindentMode::Block {
442 original_indent_columns,
443 }) => mem::take(original_indent_columns),
444 _ => Default::default(),
445 };
446
447 struct BufferEdit {
448 range: Range<usize>,
449 new_text: Arc<str>,
450 is_insertion: bool,
451 original_indent_column: u32,
452 }
453 let mut buffer_edits: HashMap<BufferId, Vec<BufferEdit>> = Default::default();
454 let mut edited_excerpt_ids = Vec::new();
455 let mut cursor = snapshot.excerpts.cursor::<usize>();
456 for (ix, (range, new_text)) in edits.enumerate() {
457 let new_text: Arc<str> = new_text.into();
458 let original_indent_column = original_indent_columns.get(ix).copied().unwrap_or(0);
459 cursor.seek(&range.start, Bias::Right, &());
460 if cursor.item().is_none() && range.start == *cursor.start() {
461 cursor.prev(&());
462 }
463 let start_excerpt = cursor.item().expect("start offset out of bounds");
464 let start_overshoot = range.start - cursor.start();
465 let buffer_start = start_excerpt
466 .range
467 .context
468 .start
469 .to_offset(&start_excerpt.buffer)
470 + start_overshoot;
471 edited_excerpt_ids.push(start_excerpt.id);
472
473 cursor.seek(&range.end, Bias::Right, &());
474 if cursor.item().is_none() && range.end == *cursor.start() {
475 cursor.prev(&());
476 }
477 let end_excerpt = cursor.item().expect("end offset out of bounds");
478 let end_overshoot = range.end - cursor.start();
479 let buffer_end = end_excerpt
480 .range
481 .context
482 .start
483 .to_offset(&end_excerpt.buffer)
484 + end_overshoot;
485
486 if start_excerpt.id == end_excerpt.id {
487 buffer_edits
488 .entry(start_excerpt.buffer_id)
489 .or_insert(Vec::new())
490 .push(BufferEdit {
491 range: buffer_start..buffer_end,
492 new_text,
493 is_insertion: true,
494 original_indent_column,
495 });
496 } else {
497 edited_excerpt_ids.push(end_excerpt.id);
498 let start_excerpt_range = buffer_start
499 ..start_excerpt
500 .range
501 .context
502 .end
503 .to_offset(&start_excerpt.buffer);
504 let end_excerpt_range = end_excerpt
505 .range
506 .context
507 .start
508 .to_offset(&end_excerpt.buffer)
509 ..buffer_end;
510 buffer_edits
511 .entry(start_excerpt.buffer_id)
512 .or_insert(Vec::new())
513 .push(BufferEdit {
514 range: start_excerpt_range,
515 new_text: new_text.clone(),
516 is_insertion: true,
517 original_indent_column,
518 });
519 buffer_edits
520 .entry(end_excerpt.buffer_id)
521 .or_insert(Vec::new())
522 .push(BufferEdit {
523 range: end_excerpt_range,
524 new_text: new_text.clone(),
525 is_insertion: false,
526 original_indent_column,
527 });
528
529 cursor.seek(&range.start, Bias::Right, &());
530 cursor.next(&());
531 while let Some(excerpt) = cursor.item() {
532 if excerpt.id == end_excerpt.id {
533 break;
534 }
535 buffer_edits
536 .entry(excerpt.buffer_id)
537 .or_insert(Vec::new())
538 .push(BufferEdit {
539 range: excerpt.range.context.to_offset(&excerpt.buffer),
540 new_text: new_text.clone(),
541 is_insertion: false,
542 original_indent_column,
543 });
544 edited_excerpt_ids.push(excerpt.id);
545 cursor.next(&());
546 }
547 }
548 }
549
550 drop(cursor);
551 drop(snapshot);
552 // Non-generic part of edit, hoisted out to avoid blowing up LLVM IR.
553 fn tail(
554 this: &mut MultiBuffer,
555 buffer_edits: HashMap<BufferId, Vec<BufferEdit>>,
556 autoindent_mode: Option<AutoindentMode>,
557 edited_excerpt_ids: Vec<ExcerptId>,
558 cx: &mut ModelContext<MultiBuffer>,
559 ) {
560 for (buffer_id, mut edits) in buffer_edits {
561 edits.sort_unstable_by_key(|edit| edit.range.start);
562 this.buffers.borrow()[&buffer_id]
563 .buffer
564 .update(cx, |buffer, cx| {
565 let mut edits = edits.into_iter().peekable();
566 let mut insertions = Vec::new();
567 let mut original_indent_columns = Vec::new();
568 let mut deletions = Vec::new();
569 let empty_str: Arc<str> = "".into();
570 while let Some(BufferEdit {
571 mut range,
572 new_text,
573 mut is_insertion,
574 original_indent_column,
575 }) = edits.next()
576 {
577 while let Some(BufferEdit {
578 range: next_range,
579 is_insertion: next_is_insertion,
580 ..
581 }) = edits.peek()
582 {
583 if range.end >= next_range.start {
584 range.end = cmp::max(next_range.end, range.end);
585 is_insertion |= *next_is_insertion;
586 edits.next();
587 } else {
588 break;
589 }
590 }
591
592 if is_insertion {
593 original_indent_columns.push(original_indent_column);
594 insertions.push((
595 buffer.anchor_before(range.start)
596 ..buffer.anchor_before(range.end),
597 new_text.clone(),
598 ));
599 } else if !range.is_empty() {
600 deletions.push((
601 buffer.anchor_before(range.start)
602 ..buffer.anchor_before(range.end),
603 empty_str.clone(),
604 ));
605 }
606 }
607
608 let deletion_autoindent_mode =
609 if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
610 Some(AutoindentMode::Block {
611 original_indent_columns: Default::default(),
612 })
613 } else {
614 None
615 };
616 let insertion_autoindent_mode =
617 if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
618 Some(AutoindentMode::Block {
619 original_indent_columns,
620 })
621 } else {
622 None
623 };
624
625 buffer.edit(deletions, deletion_autoindent_mode, cx);
626 buffer.edit(insertions, insertion_autoindent_mode, cx);
627 })
628 }
629
630 cx.emit(Event::ExcerptsEdited {
631 ids: edited_excerpt_ids,
632 });
633 }
634 tail(self, buffer_edits, autoindent_mode, edited_excerpt_ids, cx);
635 }
636
637 pub fn start_transaction(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
638 self.start_transaction_at(Instant::now(), cx)
639 }
640
641 pub fn start_transaction_at(
642 &mut self,
643 now: Instant,
644 cx: &mut ModelContext<Self>,
645 ) -> Option<TransactionId> {
646 if let Some(buffer) = self.as_singleton() {
647 return buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));
648 }
649
650 for BufferState { buffer, .. } in self.buffers.borrow().values() {
651 buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));
652 }
653 self.history.start_transaction(now)
654 }
655
656 pub fn end_transaction(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
657 self.end_transaction_at(Instant::now(), cx)
658 }
659
660 pub fn end_transaction_at(
661 &mut self,
662 now: Instant,
663 cx: &mut ModelContext<Self>,
664 ) -> Option<TransactionId> {
665 if let Some(buffer) = self.as_singleton() {
666 return buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx));
667 }
668
669 let mut buffer_transactions = HashMap::default();
670 for BufferState { buffer, .. } in self.buffers.borrow().values() {
671 if let Some(transaction_id) =
672 buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))
673 {
674 buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);
675 }
676 }
677
678 if self.history.end_transaction(now, buffer_transactions) {
679 let transaction_id = self.history.group().unwrap();
680 Some(transaction_id)
681 } else {
682 None
683 }
684 }
685
686 pub fn merge_transactions(
687 &mut self,
688 transaction: TransactionId,
689 destination: TransactionId,
690 cx: &mut ModelContext<Self>,
691 ) {
692 if let Some(buffer) = self.as_singleton() {
693 buffer.update(cx, |buffer, _| {
694 buffer.merge_transactions(transaction, destination)
695 });
696 } else {
697 if let Some(transaction) = self.history.forget(transaction) {
698 if let Some(destination) = self.history.transaction_mut(destination) {
699 for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {
700 if let Some(destination_buffer_transaction_id) =
701 destination.buffer_transactions.get(&buffer_id)
702 {
703 if let Some(state) = self.buffers.borrow().get(&buffer_id) {
704 state.buffer.update(cx, |buffer, _| {
705 buffer.merge_transactions(
706 buffer_transaction_id,
707 *destination_buffer_transaction_id,
708 )
709 });
710 }
711 } else {
712 destination
713 .buffer_transactions
714 .insert(buffer_id, buffer_transaction_id);
715 }
716 }
717 }
718 }
719 }
720 }
721
722 pub fn finalize_last_transaction(&mut self, cx: &mut ModelContext<Self>) {
723 self.history.finalize_last_transaction();
724 for BufferState { buffer, .. } in self.buffers.borrow().values() {
725 buffer.update(cx, |buffer, _| {
726 buffer.finalize_last_transaction();
727 });
728 }
729 }
730
731 pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &mut ModelContext<Self>)
732 where
733 T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
734 {
735 self.history
736 .push_transaction(buffer_transactions, Instant::now(), cx);
737 self.history.finalize_last_transaction();
738 }
739
740 pub fn group_until_transaction(
741 &mut self,
742 transaction_id: TransactionId,
743 cx: &mut ModelContext<Self>,
744 ) {
745 if let Some(buffer) = self.as_singleton() {
746 buffer.update(cx, |buffer, _| {
747 buffer.group_until_transaction(transaction_id)
748 });
749 } else {
750 self.history.group_until(transaction_id);
751 }
752 }
753
754 pub fn set_active_selections(
755 &mut self,
756 selections: &[Selection<Anchor>],
757 line_mode: bool,
758 cursor_shape: CursorShape,
759 cx: &mut ModelContext<Self>,
760 ) {
761 let mut selections_by_buffer: HashMap<BufferId, Vec<Selection<text::Anchor>>> =
762 Default::default();
763 let snapshot = self.read(cx);
764 let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
765 for selection in selections {
766 let start_locator = snapshot.excerpt_locator_for_id(selection.start.excerpt_id);
767 let end_locator = snapshot.excerpt_locator_for_id(selection.end.excerpt_id);
768
769 cursor.seek(&Some(start_locator), Bias::Left, &());
770 while let Some(excerpt) = cursor.item() {
771 if excerpt.locator > *end_locator {
772 break;
773 }
774
775 let mut start = excerpt.range.context.start;
776 let mut end = excerpt.range.context.end;
777 if excerpt.id == selection.start.excerpt_id {
778 start = selection.start.text_anchor;
779 }
780 if excerpt.id == selection.end.excerpt_id {
781 end = selection.end.text_anchor;
782 }
783 selections_by_buffer
784 .entry(excerpt.buffer_id)
785 .or_default()
786 .push(Selection {
787 id: selection.id,
788 start,
789 end,
790 reversed: selection.reversed,
791 goal: selection.goal,
792 });
793
794 cursor.next(&());
795 }
796 }
797
798 for (buffer_id, buffer_state) in self.buffers.borrow().iter() {
799 if !selections_by_buffer.contains_key(buffer_id) {
800 buffer_state
801 .buffer
802 .update(cx, |buffer, cx| buffer.remove_active_selections(cx));
803 }
804 }
805
806 for (buffer_id, mut selections) in selections_by_buffer {
807 self.buffers.borrow()[&buffer_id]
808 .buffer
809 .update(cx, |buffer, cx| {
810 selections.sort_unstable_by(|a, b| a.start.cmp(&b.start, buffer));
811 let mut selections = selections.into_iter().peekable();
812 let merged_selections = Arc::from_iter(iter::from_fn(|| {
813 let mut selection = selections.next()?;
814 while let Some(next_selection) = selections.peek() {
815 if selection.end.cmp(&next_selection.start, buffer).is_ge() {
816 let next_selection = selections.next().unwrap();
817 if next_selection.end.cmp(&selection.end, buffer).is_ge() {
818 selection.end = next_selection.end;
819 }
820 } else {
821 break;
822 }
823 }
824 Some(selection)
825 }));
826 buffer.set_active_selections(merged_selections, line_mode, cursor_shape, cx);
827 });
828 }
829 }
830
831 pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
832 for buffer in self.buffers.borrow().values() {
833 buffer
834 .buffer
835 .update(cx, |buffer, cx| buffer.remove_active_selections(cx));
836 }
837 }
838
839 pub fn undo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
840 let mut transaction_id = None;
841 if let Some(buffer) = self.as_singleton() {
842 transaction_id = buffer.update(cx, |buffer, cx| buffer.undo(cx));
843 } else {
844 while let Some(transaction) = self.history.pop_undo() {
845 let mut undone = false;
846 for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {
847 if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
848 undone |= buffer.update(cx, |buffer, cx| {
849 let undo_to = *buffer_transaction_id;
850 if let Some(entry) = buffer.peek_undo_stack() {
851 *buffer_transaction_id = entry.transaction_id();
852 }
853 buffer.undo_to_transaction(undo_to, cx)
854 });
855 }
856 }
857
858 if undone {
859 transaction_id = Some(transaction.id);
860 break;
861 }
862 }
863 }
864
865 if let Some(transaction_id) = transaction_id {
866 cx.emit(Event::TransactionUndone { transaction_id });
867 }
868
869 transaction_id
870 }
871
872 pub fn redo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
873 if let Some(buffer) = self.as_singleton() {
874 return buffer.update(cx, |buffer, cx| buffer.redo(cx));
875 }
876
877 while let Some(transaction) = self.history.pop_redo() {
878 let mut redone = false;
879 for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {
880 if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
881 redone |= buffer.update(cx, |buffer, cx| {
882 let redo_to = *buffer_transaction_id;
883 if let Some(entry) = buffer.peek_redo_stack() {
884 *buffer_transaction_id = entry.transaction_id();
885 }
886 buffer.redo_to_transaction(redo_to, cx)
887 });
888 }
889 }
890
891 if redone {
892 return Some(transaction.id);
893 }
894 }
895
896 None
897 }
898
899 pub fn undo_transaction(&mut self, transaction_id: TransactionId, cx: &mut ModelContext<Self>) {
900 if let Some(buffer) = self.as_singleton() {
901 buffer.update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
902 } else if let Some(transaction) = self.history.remove_from_undo(transaction_id) {
903 for (buffer_id, transaction_id) in &transaction.buffer_transactions {
904 if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
905 buffer.update(cx, |buffer, cx| {
906 buffer.undo_transaction(*transaction_id, cx)
907 });
908 }
909 }
910 }
911 }
912
913 pub fn stream_excerpts_with_context_lines(
914 &mut self,
915 buffer: Model<Buffer>,
916 ranges: Vec<Range<text::Anchor>>,
917 context_line_count: u32,
918 cx: &mut ModelContext<Self>,
919 ) -> mpsc::Receiver<Range<Anchor>> {
920 let (buffer_id, buffer_snapshot) =
921 buffer.update(cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));
922
923 let (mut tx, rx) = mpsc::channel(256);
924 cx.spawn(move |this, mut cx| async move {
925 let mut excerpt_ranges = Vec::new();
926 let mut range_counts = Vec::new();
927 cx.background_executor()
928 .scoped(|scope| {
929 scope.spawn(async {
930 let (ranges, counts) =
931 build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
932 excerpt_ranges = ranges;
933 range_counts = counts;
934 });
935 })
936 .await;
937
938 let mut ranges = ranges.into_iter();
939 let mut range_counts = range_counts.into_iter();
940 for excerpt_ranges in excerpt_ranges.chunks(100) {
941 let excerpt_ids = match this.update(&mut cx, |this, cx| {
942 this.push_excerpts(buffer.clone(), excerpt_ranges.iter().cloned(), cx)
943 }) {
944 Ok(excerpt_ids) => excerpt_ids,
945 Err(_) => return,
946 };
947
948 for (excerpt_id, range_count) in excerpt_ids.into_iter().zip(range_counts.by_ref())
949 {
950 for range in ranges.by_ref().take(range_count) {
951 let start = Anchor {
952 buffer_id: Some(buffer_id),
953 excerpt_id: excerpt_id,
954 text_anchor: range.start,
955 };
956 let end = Anchor {
957 buffer_id: Some(buffer_id),
958 excerpt_id: excerpt_id,
959 text_anchor: range.end,
960 };
961 if tx.send(start..end).await.is_err() {
962 break;
963 }
964 }
965 }
966 }
967 })
968 .detach();
969
970 rx
971 }
972
973 pub fn push_excerpts<O>(
974 &mut self,
975 buffer: Model<Buffer>,
976 ranges: impl IntoIterator<Item = ExcerptRange<O>>,
977 cx: &mut ModelContext<Self>,
978 ) -> Vec<ExcerptId>
979 where
980 O: text::ToOffset,
981 {
982 self.insert_excerpts_after(ExcerptId::max(), buffer, ranges, cx)
983 }
984
985 pub fn push_excerpts_with_context_lines<O>(
986 &mut self,
987 buffer: Model<Buffer>,
988 ranges: Vec<Range<O>>,
989 context_line_count: u32,
990 cx: &mut ModelContext<Self>,
991 ) -> Vec<Range<Anchor>>
992 where
993 O: text::ToPoint + text::ToOffset,
994 {
995 let buffer_id = buffer.read(cx).remote_id();
996 let buffer_snapshot = buffer.read(cx).snapshot();
997 let (excerpt_ranges, range_counts) =
998 build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
999
1000 let excerpt_ids = self.push_excerpts(buffer, excerpt_ranges, cx);
1001
1002 let mut anchor_ranges = Vec::new();
1003 let mut ranges = ranges.into_iter();
1004 for (excerpt_id, range_count) in excerpt_ids.into_iter().zip(range_counts.into_iter()) {
1005 anchor_ranges.extend(ranges.by_ref().take(range_count).map(|range| {
1006 let start = Anchor {
1007 buffer_id: Some(buffer_id),
1008 excerpt_id: excerpt_id,
1009 text_anchor: buffer_snapshot.anchor_after(range.start),
1010 };
1011 let end = Anchor {
1012 buffer_id: Some(buffer_id),
1013 excerpt_id: excerpt_id,
1014 text_anchor: buffer_snapshot.anchor_after(range.end),
1015 };
1016 start..end
1017 }))
1018 }
1019 anchor_ranges
1020 }
1021
1022 pub fn insert_excerpts_after<O>(
1023 &mut self,
1024 prev_excerpt_id: ExcerptId,
1025 buffer: Model<Buffer>,
1026 ranges: impl IntoIterator<Item = ExcerptRange<O>>,
1027 cx: &mut ModelContext<Self>,
1028 ) -> Vec<ExcerptId>
1029 where
1030 O: text::ToOffset,
1031 {
1032 let mut ids = Vec::new();
1033 let mut next_excerpt_id =
1034 if let Some(last_entry) = self.snapshot.borrow().excerpt_ids.last() {
1035 last_entry.id.0 + 1
1036 } else {
1037 1
1038 };
1039 self.insert_excerpts_with_ids_after(
1040 prev_excerpt_id,
1041 buffer,
1042 ranges.into_iter().map(|range| {
1043 let id = ExcerptId(post_inc(&mut next_excerpt_id));
1044 ids.push(id);
1045 (id, range)
1046 }),
1047 cx,
1048 );
1049 ids
1050 }
1051
1052 pub fn insert_excerpts_with_ids_after<O>(
1053 &mut self,
1054 prev_excerpt_id: ExcerptId,
1055 buffer: Model<Buffer>,
1056 ranges: impl IntoIterator<Item = (ExcerptId, ExcerptRange<O>)>,
1057 cx: &mut ModelContext<Self>,
1058 ) where
1059 O: text::ToOffset,
1060 {
1061 assert_eq!(self.history.transaction_depth, 0);
1062 let mut ranges = ranges.into_iter().peekable();
1063 if ranges.peek().is_none() {
1064 return Default::default();
1065 }
1066
1067 self.sync(cx);
1068
1069 let buffer_id = buffer.read(cx).remote_id();
1070 let buffer_snapshot = buffer.read(cx).snapshot();
1071
1072 let mut buffers = self.buffers.borrow_mut();
1073 let buffer_state = buffers.entry(buffer_id).or_insert_with(|| BufferState {
1074 last_version: buffer_snapshot.version().clone(),
1075 last_parse_count: buffer_snapshot.parse_count(),
1076 last_selections_update_count: buffer_snapshot.selections_update_count(),
1077 last_diagnostics_update_count: buffer_snapshot.diagnostics_update_count(),
1078 last_file_update_count: buffer_snapshot.file_update_count(),
1079 last_git_diff_update_count: buffer_snapshot.git_diff_update_count(),
1080 excerpts: Default::default(),
1081 _subscriptions: [
1082 cx.observe(&buffer, |_, _, cx| cx.notify()),
1083 cx.subscribe(&buffer, Self::on_buffer_event),
1084 ],
1085 buffer: buffer.clone(),
1086 });
1087
1088 let mut snapshot = self.snapshot.borrow_mut();
1089
1090 let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone();
1091 let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids);
1092 let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
1093 let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &());
1094 prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone();
1095
1096 let edit_start = new_excerpts.summary().text.len;
1097 new_excerpts.update_last(
1098 |excerpt| {
1099 excerpt.has_trailing_newline = true;
1100 },
1101 &(),
1102 );
1103
1104 let next_locator = if let Some(excerpt) = cursor.item() {
1105 excerpt.locator.clone()
1106 } else {
1107 Locator::max()
1108 };
1109
1110 let mut excerpts = Vec::new();
1111 while let Some((id, range)) = ranges.next() {
1112 let locator = Locator::between(&prev_locator, &next_locator);
1113 if let Err(ix) = buffer_state.excerpts.binary_search(&locator) {
1114 buffer_state.excerpts.insert(ix, locator.clone());
1115 }
1116 let range = ExcerptRange {
1117 context: buffer_snapshot.anchor_before(&range.context.start)
1118 ..buffer_snapshot.anchor_after(&range.context.end),
1119 primary: range.primary.map(|primary| {
1120 buffer_snapshot.anchor_before(&primary.start)
1121 ..buffer_snapshot.anchor_after(&primary.end)
1122 }),
1123 };
1124 excerpts.push((id, range.clone()));
1125 let excerpt = Excerpt::new(
1126 id,
1127 locator.clone(),
1128 buffer_id,
1129 buffer_snapshot.clone(),
1130 range,
1131 ranges.peek().is_some() || cursor.item().is_some(),
1132 );
1133 new_excerpts.push(excerpt, &());
1134 prev_locator = locator.clone();
1135
1136 if let Some(last_mapping_entry) = new_excerpt_ids.last() {
1137 assert!(id > last_mapping_entry.id, "excerpt ids must be increasing");
1138 }
1139 new_excerpt_ids.push(ExcerptIdMapping { id, locator }, &());
1140 }
1141
1142 let edit_end = new_excerpts.summary().text.len;
1143
1144 let suffix = cursor.suffix(&());
1145 let changed_trailing_excerpt = suffix.is_empty();
1146 new_excerpts.append(suffix, &());
1147 drop(cursor);
1148 snapshot.excerpts = new_excerpts;
1149 snapshot.excerpt_ids = new_excerpt_ids;
1150 if changed_trailing_excerpt {
1151 snapshot.trailing_excerpt_update_count += 1;
1152 }
1153
1154 self.subscriptions.publish_mut([Edit {
1155 old: edit_start..edit_start,
1156 new: edit_start..edit_end,
1157 }]);
1158 cx.emit(Event::Edited {
1159 singleton_buffer_edited: false,
1160 });
1161 cx.emit(Event::ExcerptsAdded {
1162 buffer,
1163 predecessor: prev_excerpt_id,
1164 excerpts,
1165 });
1166 cx.notify();
1167 }
1168
1169 pub fn clear(&mut self, cx: &mut ModelContext<Self>) {
1170 self.sync(cx);
1171 let ids = self.excerpt_ids();
1172 self.buffers.borrow_mut().clear();
1173 let mut snapshot = self.snapshot.borrow_mut();
1174 let prev_len = snapshot.len();
1175 snapshot.excerpts = Default::default();
1176 snapshot.trailing_excerpt_update_count += 1;
1177 snapshot.is_dirty = false;
1178 snapshot.has_conflict = false;
1179
1180 self.subscriptions.publish_mut([Edit {
1181 old: 0..prev_len,
1182 new: 0..0,
1183 }]);
1184 cx.emit(Event::Edited {
1185 singleton_buffer_edited: false,
1186 });
1187 cx.emit(Event::ExcerptsRemoved { ids });
1188 cx.notify();
1189 }
1190
1191 pub fn excerpts_for_buffer(
1192 &self,
1193 buffer: &Model<Buffer>,
1194 cx: &AppContext,
1195 ) -> Vec<(ExcerptId, ExcerptRange<text::Anchor>)> {
1196 let mut excerpts = Vec::new();
1197 let snapshot = self.read(cx);
1198 let buffers = self.buffers.borrow();
1199 let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
1200 for locator in buffers
1201 .get(&buffer.read(cx).remote_id())
1202 .map(|state| &state.excerpts)
1203 .into_iter()
1204 .flatten()
1205 {
1206 cursor.seek_forward(&Some(locator), Bias::Left, &());
1207 if let Some(excerpt) = cursor.item() {
1208 if excerpt.locator == *locator {
1209 excerpts.push((excerpt.id, excerpt.range.clone()));
1210 }
1211 }
1212 }
1213
1214 excerpts
1215 }
1216
1217 pub fn excerpt_ids(&self) -> Vec<ExcerptId> {
1218 self.snapshot
1219 .borrow()
1220 .excerpts
1221 .iter()
1222 .map(|entry| entry.id)
1223 .collect()
1224 }
1225
1226 pub fn excerpt_containing(
1227 &self,
1228 position: impl ToOffset,
1229 cx: &AppContext,
1230 ) -> Option<(ExcerptId, Model<Buffer>, Range<text::Anchor>)> {
1231 let snapshot = self.read(cx);
1232 let position = position.to_offset(&snapshot);
1233
1234 let mut cursor = snapshot.excerpts.cursor::<usize>();
1235 cursor.seek(&position, Bias::Right, &());
1236 cursor
1237 .item()
1238 .or_else(|| snapshot.excerpts.last())
1239 .map(|excerpt| {
1240 (
1241 excerpt.id,
1242 self.buffers
1243 .borrow()
1244 .get(&excerpt.buffer_id)
1245 .unwrap()
1246 .buffer
1247 .clone(),
1248 excerpt.range.context.clone(),
1249 )
1250 })
1251 }
1252
1253 // If point is at the end of the buffer, the last excerpt is returned
1254 pub fn point_to_buffer_offset<T: ToOffset>(
1255 &self,
1256 point: T,
1257 cx: &AppContext,
1258 ) -> Option<(Model<Buffer>, usize, ExcerptId)> {
1259 let snapshot = self.read(cx);
1260 let offset = point.to_offset(&snapshot);
1261 let mut cursor = snapshot.excerpts.cursor::<usize>();
1262 cursor.seek(&offset, Bias::Right, &());
1263 if cursor.item().is_none() {
1264 cursor.prev(&());
1265 }
1266
1267 cursor.item().map(|excerpt| {
1268 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
1269 let buffer_point = excerpt_start + offset - *cursor.start();
1270 let buffer = self.buffers.borrow()[&excerpt.buffer_id].buffer.clone();
1271
1272 (buffer, buffer_point, excerpt.id)
1273 })
1274 }
1275
1276 pub fn range_to_buffer_ranges<T: ToOffset>(
1277 &self,
1278 range: Range<T>,
1279 cx: &AppContext,
1280 ) -> Vec<(Model<Buffer>, Range<usize>, ExcerptId)> {
1281 let snapshot = self.read(cx);
1282 let start = range.start.to_offset(&snapshot);
1283 let end = range.end.to_offset(&snapshot);
1284
1285 let mut result = Vec::new();
1286 let mut cursor = snapshot.excerpts.cursor::<usize>();
1287 cursor.seek(&start, Bias::Right, &());
1288 if cursor.item().is_none() {
1289 cursor.prev(&());
1290 }
1291
1292 while let Some(excerpt) = cursor.item() {
1293 if *cursor.start() > end {
1294 break;
1295 }
1296
1297 let mut end_before_newline = cursor.end(&());
1298 if excerpt.has_trailing_newline {
1299 end_before_newline -= 1;
1300 }
1301 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
1302 let start = excerpt_start + (cmp::max(start, *cursor.start()) - *cursor.start());
1303 let end = excerpt_start + (cmp::min(end, end_before_newline) - *cursor.start());
1304 let buffer = self.buffers.borrow()[&excerpt.buffer_id].buffer.clone();
1305 result.push((buffer, start..end, excerpt.id));
1306 cursor.next(&());
1307 }
1308
1309 result
1310 }
1311
1312 pub fn remove_excerpts(
1313 &mut self,
1314 excerpt_ids: impl IntoIterator<Item = ExcerptId>,
1315 cx: &mut ModelContext<Self>,
1316 ) {
1317 self.sync(cx);
1318 let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
1319 if ids.is_empty() {
1320 return;
1321 }
1322
1323 let mut buffers = self.buffers.borrow_mut();
1324 let mut snapshot = self.snapshot.borrow_mut();
1325 let mut new_excerpts = SumTree::new();
1326 let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
1327 let mut edits = Vec::new();
1328 let mut excerpt_ids = ids.iter().copied().peekable();
1329
1330 while let Some(excerpt_id) = excerpt_ids.next() {
1331 // Seek to the next excerpt to remove, preserving any preceding excerpts.
1332 let locator = snapshot.excerpt_locator_for_id(excerpt_id);
1333 new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
1334
1335 if let Some(mut excerpt) = cursor.item() {
1336 if excerpt.id != excerpt_id {
1337 continue;
1338 }
1339 let mut old_start = cursor.start().1;
1340
1341 // Skip over the removed excerpt.
1342 'remove_excerpts: loop {
1343 if let Some(buffer_state) = buffers.get_mut(&excerpt.buffer_id) {
1344 buffer_state.excerpts.retain(|l| l != &excerpt.locator);
1345 if buffer_state.excerpts.is_empty() {
1346 buffers.remove(&excerpt.buffer_id);
1347 }
1348 }
1349 cursor.next(&());
1350
1351 // Skip over any subsequent excerpts that are also removed.
1352 while let Some(&next_excerpt_id) = excerpt_ids.peek() {
1353 let next_locator = snapshot.excerpt_locator_for_id(next_excerpt_id);
1354 if let Some(next_excerpt) = cursor.item() {
1355 if next_excerpt.locator == *next_locator {
1356 excerpt_ids.next();
1357 excerpt = next_excerpt;
1358 continue 'remove_excerpts;
1359 }
1360 }
1361 break;
1362 }
1363
1364 break;
1365 }
1366
1367 // When removing the last excerpt, remove the trailing newline from
1368 // the previous excerpt.
1369 if cursor.item().is_none() && old_start > 0 {
1370 old_start -= 1;
1371 new_excerpts.update_last(|e| e.has_trailing_newline = false, &());
1372 }
1373
1374 // Push an edit for the removal of this run of excerpts.
1375 let old_end = cursor.start().1;
1376 let new_start = new_excerpts.summary().text.len;
1377 edits.push(Edit {
1378 old: old_start..old_end,
1379 new: new_start..new_start,
1380 });
1381 }
1382 }
1383 let suffix = cursor.suffix(&());
1384 let changed_trailing_excerpt = suffix.is_empty();
1385 new_excerpts.append(suffix, &());
1386 drop(cursor);
1387 snapshot.excerpts = new_excerpts;
1388
1389 if changed_trailing_excerpt {
1390 snapshot.trailing_excerpt_update_count += 1;
1391 }
1392
1393 self.subscriptions.publish_mut(edits);
1394 cx.emit(Event::Edited {
1395 singleton_buffer_edited: false,
1396 });
1397 cx.emit(Event::ExcerptsRemoved { ids });
1398 cx.notify();
1399 }
1400
1401 pub fn wait_for_anchors<'a>(
1402 &self,
1403 anchors: impl 'a + Iterator<Item = Anchor>,
1404 cx: &mut ModelContext<Self>,
1405 ) -> impl 'static + Future<Output = Result<()>> {
1406 let borrow = self.buffers.borrow();
1407 let mut error = None;
1408 let mut futures = Vec::new();
1409 for anchor in anchors {
1410 if let Some(buffer_id) = anchor.buffer_id {
1411 if let Some(buffer) = borrow.get(&buffer_id) {
1412 buffer.buffer.update(cx, |buffer, _| {
1413 futures.push(buffer.wait_for_anchors([anchor.text_anchor]))
1414 });
1415 } else {
1416 error = Some(anyhow!(
1417 "buffer {buffer_id} is not part of this multi-buffer"
1418 ));
1419 break;
1420 }
1421 }
1422 }
1423 async move {
1424 if let Some(error) = error {
1425 Err(error)?;
1426 }
1427 for future in futures {
1428 future.await?;
1429 }
1430 Ok(())
1431 }
1432 }
1433
1434 pub fn text_anchor_for_position<T: ToOffset>(
1435 &self,
1436 position: T,
1437 cx: &AppContext,
1438 ) -> Option<(Model<Buffer>, language::Anchor)> {
1439 let snapshot = self.read(cx);
1440 let anchor = snapshot.anchor_before(position);
1441 let buffer = self
1442 .buffers
1443 .borrow()
1444 .get(&anchor.buffer_id?)?
1445 .buffer
1446 .clone();
1447 Some((buffer, anchor.text_anchor))
1448 }
1449
1450 fn on_buffer_event(
1451 &mut self,
1452 buffer: Model<Buffer>,
1453 event: &language::Event,
1454 cx: &mut ModelContext<Self>,
1455 ) {
1456 cx.emit(match event {
1457 language::Event::Edited => Event::Edited {
1458 singleton_buffer_edited: true,
1459 },
1460 language::Event::DirtyChanged => Event::DirtyChanged,
1461 language::Event::Saved => Event::Saved,
1462 language::Event::FileHandleChanged => Event::FileHandleChanged,
1463 language::Event::Reloaded => Event::Reloaded,
1464 language::Event::DiffBaseChanged => Event::DiffBaseChanged,
1465 language::Event::LanguageChanged => Event::LanguageChanged,
1466 language::Event::Reparsed => Event::Reparsed,
1467 language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
1468 language::Event::Closed => Event::Closed,
1469 language::Event::CapabilityChanged => {
1470 self.capability = buffer.read(cx).capability();
1471 Event::CapabilityChanged
1472 }
1473
1474 //
1475 language::Event::Operation(_) => return,
1476 });
1477 }
1478
1479 pub fn all_buffers(&self) -> HashSet<Model<Buffer>> {
1480 self.buffers
1481 .borrow()
1482 .values()
1483 .map(|state| state.buffer.clone())
1484 .collect()
1485 }
1486
1487 pub fn buffer(&self, buffer_id: BufferId) -> Option<Model<Buffer>> {
1488 self.buffers
1489 .borrow()
1490 .get(&buffer_id)
1491 .map(|state| state.buffer.clone())
1492 }
1493
1494 pub fn is_completion_trigger(&self, position: Anchor, text: &str, cx: &AppContext) -> bool {
1495 let mut chars = text.chars();
1496 let char = if let Some(char) = chars.next() {
1497 char
1498 } else {
1499 return false;
1500 };
1501 if chars.next().is_some() {
1502 return false;
1503 }
1504
1505 let snapshot = self.snapshot(cx);
1506 let position = position.to_offset(&snapshot);
1507 let scope = snapshot.language_scope_at(position);
1508 if char_kind(&scope, char) == CharKind::Word {
1509 return true;
1510 }
1511
1512 let anchor = snapshot.anchor_before(position);
1513 anchor
1514 .buffer_id
1515 .and_then(|buffer_id| {
1516 let buffer = self.buffers.borrow().get(&buffer_id)?.buffer.clone();
1517 Some(
1518 buffer
1519 .read(cx)
1520 .completion_triggers()
1521 .iter()
1522 .any(|string| string == text),
1523 )
1524 })
1525 .unwrap_or(false)
1526 }
1527
1528 pub fn language_at<T: ToOffset>(&self, point: T, cx: &AppContext) -> Option<Arc<Language>> {
1529 self.point_to_buffer_offset(point, cx)
1530 .and_then(|(buffer, offset, _)| buffer.read(cx).language_at(offset))
1531 }
1532
1533 pub fn settings_at<'a, T: ToOffset>(
1534 &self,
1535 point: T,
1536 cx: &'a AppContext,
1537 ) -> &'a LanguageSettings {
1538 let mut language = None;
1539 let mut file = None;
1540 if let Some((buffer, offset, _)) = self.point_to_buffer_offset(point, cx) {
1541 let buffer = buffer.read(cx);
1542 language = buffer.language_at(offset);
1543 file = buffer.file();
1544 }
1545 language_settings(language.as_ref(), file, cx)
1546 }
1547
1548 pub fn for_each_buffer(&self, mut f: impl FnMut(&Model<Buffer>)) {
1549 self.buffers
1550 .borrow()
1551 .values()
1552 .for_each(|state| f(&state.buffer))
1553 }
1554
1555 pub fn title<'a>(&'a self, cx: &'a AppContext) -> Cow<'a, str> {
1556 if let Some(title) = self.title.as_ref() {
1557 return title.into();
1558 }
1559
1560 if let Some(buffer) = self.as_singleton() {
1561 if let Some(file) = buffer.read(cx).file() {
1562 return file.file_name(cx).to_string_lossy();
1563 }
1564 }
1565
1566 "untitled".into()
1567 }
1568
1569 #[cfg(any(test, feature = "test-support"))]
1570 pub fn is_parsing(&self, cx: &AppContext) -> bool {
1571 self.as_singleton().unwrap().read(cx).is_parsing()
1572 }
1573
1574 fn sync(&self, cx: &AppContext) {
1575 let mut snapshot = self.snapshot.borrow_mut();
1576 let mut excerpts_to_edit = Vec::new();
1577 let mut reparsed = false;
1578 let mut diagnostics_updated = false;
1579 let mut git_diff_updated = false;
1580 let mut is_dirty = false;
1581 let mut has_conflict = false;
1582 let mut edited = false;
1583 let mut buffers = self.buffers.borrow_mut();
1584 for buffer_state in buffers.values_mut() {
1585 let buffer = buffer_state.buffer.read(cx);
1586 let version = buffer.version();
1587 let parse_count = buffer.parse_count();
1588 let selections_update_count = buffer.selections_update_count();
1589 let diagnostics_update_count = buffer.diagnostics_update_count();
1590 let file_update_count = buffer.file_update_count();
1591 let git_diff_update_count = buffer.git_diff_update_count();
1592
1593 let buffer_edited = version.changed_since(&buffer_state.last_version);
1594 let buffer_reparsed = parse_count > buffer_state.last_parse_count;
1595 let buffer_selections_updated =
1596 selections_update_count > buffer_state.last_selections_update_count;
1597 let buffer_diagnostics_updated =
1598 diagnostics_update_count > buffer_state.last_diagnostics_update_count;
1599 let buffer_file_updated = file_update_count > buffer_state.last_file_update_count;
1600 let buffer_git_diff_updated =
1601 git_diff_update_count > buffer_state.last_git_diff_update_count;
1602 if buffer_edited
1603 || buffer_reparsed
1604 || buffer_selections_updated
1605 || buffer_diagnostics_updated
1606 || buffer_file_updated
1607 || buffer_git_diff_updated
1608 {
1609 buffer_state.last_version = version;
1610 buffer_state.last_parse_count = parse_count;
1611 buffer_state.last_selections_update_count = selections_update_count;
1612 buffer_state.last_diagnostics_update_count = diagnostics_update_count;
1613 buffer_state.last_file_update_count = file_update_count;
1614 buffer_state.last_git_diff_update_count = git_diff_update_count;
1615 excerpts_to_edit.extend(
1616 buffer_state
1617 .excerpts
1618 .iter()
1619 .map(|locator| (locator, buffer_state.buffer.clone(), buffer_edited)),
1620 );
1621 }
1622
1623 edited |= buffer_edited;
1624 reparsed |= buffer_reparsed;
1625 diagnostics_updated |= buffer_diagnostics_updated;
1626 git_diff_updated |= buffer_git_diff_updated;
1627 is_dirty |= buffer.is_dirty();
1628 has_conflict |= buffer.has_conflict();
1629 }
1630 if edited {
1631 snapshot.edit_count += 1;
1632 }
1633 if reparsed {
1634 snapshot.parse_count += 1;
1635 }
1636 if diagnostics_updated {
1637 snapshot.diagnostics_update_count += 1;
1638 }
1639 if git_diff_updated {
1640 snapshot.git_diff_update_count += 1;
1641 }
1642 snapshot.is_dirty = is_dirty;
1643 snapshot.has_conflict = has_conflict;
1644
1645 excerpts_to_edit.sort_unstable_by_key(|(locator, _, _)| *locator);
1646
1647 let mut edits = Vec::new();
1648 let mut new_excerpts = SumTree::new();
1649 let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
1650
1651 for (locator, buffer, buffer_edited) in excerpts_to_edit {
1652 new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
1653 let old_excerpt = cursor.item().unwrap();
1654 let buffer = buffer.read(cx);
1655 let buffer_id = buffer.remote_id();
1656
1657 let mut new_excerpt;
1658 if buffer_edited {
1659 edits.extend(
1660 buffer
1661 .edits_since_in_range::<usize>(
1662 old_excerpt.buffer.version(),
1663 old_excerpt.range.context.clone(),
1664 )
1665 .map(|mut edit| {
1666 let excerpt_old_start = cursor.start().1;
1667 let excerpt_new_start = new_excerpts.summary().text.len;
1668 edit.old.start += excerpt_old_start;
1669 edit.old.end += excerpt_old_start;
1670 edit.new.start += excerpt_new_start;
1671 edit.new.end += excerpt_new_start;
1672 edit
1673 }),
1674 );
1675
1676 new_excerpt = Excerpt::new(
1677 old_excerpt.id,
1678 locator.clone(),
1679 buffer_id,
1680 buffer.snapshot(),
1681 old_excerpt.range.clone(),
1682 old_excerpt.has_trailing_newline,
1683 );
1684 } else {
1685 new_excerpt = old_excerpt.clone();
1686 new_excerpt.buffer = buffer.snapshot();
1687 }
1688
1689 new_excerpts.push(new_excerpt, &());
1690 cursor.next(&());
1691 }
1692 new_excerpts.append(cursor.suffix(&()), &());
1693
1694 drop(cursor);
1695 snapshot.excerpts = new_excerpts;
1696
1697 self.subscriptions.publish(edits);
1698 }
1699}
1700
1701#[cfg(any(test, feature = "test-support"))]
1702impl MultiBuffer {
1703 pub fn build_simple(text: &str, cx: &mut gpui::AppContext) -> Model<Self> {
1704 let buffer = cx
1705 .new_model(|cx| Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), text));
1706 cx.new_model(|cx| Self::singleton(buffer, cx))
1707 }
1708
1709 pub fn build_multi<const COUNT: usize>(
1710 excerpts: [(&str, Vec<Range<Point>>); COUNT],
1711 cx: &mut gpui::AppContext,
1712 ) -> Model<Self> {
1713 let multi = cx.new_model(|_| Self::new(0, Capability::ReadWrite));
1714 for (text, ranges) in excerpts {
1715 let buffer = cx.new_model(|cx| {
1716 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), text)
1717 });
1718 let excerpt_ranges = ranges.into_iter().map(|range| ExcerptRange {
1719 context: range,
1720 primary: None,
1721 });
1722 multi.update(cx, |multi, cx| {
1723 multi.push_excerpts(buffer, excerpt_ranges, cx)
1724 });
1725 }
1726
1727 multi
1728 }
1729
1730 pub fn build_from_buffer(buffer: Model<Buffer>, cx: &mut gpui::AppContext) -> Model<Self> {
1731 cx.new_model(|cx| Self::singleton(buffer, cx))
1732 }
1733
1734 pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::AppContext) -> Model<Self> {
1735 cx.new_model(|cx| {
1736 let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
1737 let mutation_count = rng.gen_range(1..=5);
1738 multibuffer.randomly_edit_excerpts(rng, mutation_count, cx);
1739 multibuffer
1740 })
1741 }
1742
1743 pub fn randomly_edit(
1744 &mut self,
1745 rng: &mut impl rand::Rng,
1746 edit_count: usize,
1747 cx: &mut ModelContext<Self>,
1748 ) {
1749 use util::RandomCharIter;
1750
1751 let snapshot = self.read(cx);
1752 let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
1753 let mut last_end = None;
1754 for _ in 0..edit_count {
1755 if last_end.map_or(false, |last_end| last_end >= snapshot.len()) {
1756 break;
1757 }
1758
1759 let new_start = last_end.map_or(0, |last_end| last_end + 1);
1760 let end = snapshot.clip_offset(rng.gen_range(new_start..=snapshot.len()), Bias::Right);
1761 let start = snapshot.clip_offset(rng.gen_range(new_start..=end), Bias::Right);
1762 last_end = Some(end);
1763
1764 let mut range = start..end;
1765 if rng.gen_bool(0.2) {
1766 mem::swap(&mut range.start, &mut range.end);
1767 }
1768
1769 let new_text_len = rng.gen_range(0..10);
1770 let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
1771
1772 edits.push((range, new_text.into()));
1773 }
1774 log::info!("mutating multi-buffer with {:?}", edits);
1775 drop(snapshot);
1776
1777 self.edit(edits, None, cx);
1778 }
1779
1780 pub fn randomly_edit_excerpts(
1781 &mut self,
1782 rng: &mut impl rand::Rng,
1783 mutation_count: usize,
1784 cx: &mut ModelContext<Self>,
1785 ) {
1786 use rand::prelude::*;
1787 use std::env;
1788 use util::RandomCharIter;
1789
1790 let max_excerpts = env::var("MAX_EXCERPTS")
1791 .map(|i| i.parse().expect("invalid `MAX_EXCERPTS` variable"))
1792 .unwrap_or(5);
1793
1794 let mut buffers = Vec::new();
1795 for _ in 0..mutation_count {
1796 if rng.gen_bool(0.05) {
1797 log::info!("Clearing multi-buffer");
1798 self.clear(cx);
1799 continue;
1800 }
1801
1802 let excerpt_ids = self.excerpt_ids();
1803 if excerpt_ids.is_empty() || (rng.gen() && excerpt_ids.len() < max_excerpts) {
1804 let buffer_handle = if rng.gen() || self.buffers.borrow().is_empty() {
1805 let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
1806 buffers.push(cx.new_model(|cx| {
1807 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), text)
1808 }));
1809 let buffer = buffers.last().unwrap().read(cx);
1810 log::info!(
1811 "Creating new buffer {} with text: {:?}",
1812 buffer.remote_id(),
1813 buffer.text()
1814 );
1815 buffers.last().unwrap().clone()
1816 } else {
1817 self.buffers
1818 .borrow()
1819 .values()
1820 .choose(rng)
1821 .unwrap()
1822 .buffer
1823 .clone()
1824 };
1825
1826 let buffer = buffer_handle.read(cx);
1827 let buffer_text = buffer.text();
1828 let ranges = (0..rng.gen_range(0..5))
1829 .map(|_| {
1830 let end_ix =
1831 buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
1832 let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
1833 ExcerptRange {
1834 context: start_ix..end_ix,
1835 primary: None,
1836 }
1837 })
1838 .collect::<Vec<_>>();
1839 log::info!(
1840 "Inserting excerpts from buffer {} and ranges {:?}: {:?}",
1841 buffer_handle.read(cx).remote_id(),
1842 ranges.iter().map(|r| &r.context).collect::<Vec<_>>(),
1843 ranges
1844 .iter()
1845 .map(|r| &buffer_text[r.context.clone()])
1846 .collect::<Vec<_>>()
1847 );
1848
1849 let excerpt_id = self.push_excerpts(buffer_handle.clone(), ranges, cx);
1850 log::info!("Inserted with ids: {:?}", excerpt_id);
1851 } else {
1852 let remove_count = rng.gen_range(1..=excerpt_ids.len());
1853 let mut excerpts_to_remove = excerpt_ids
1854 .choose_multiple(rng, remove_count)
1855 .cloned()
1856 .collect::<Vec<_>>();
1857 let snapshot = self.snapshot.borrow();
1858 excerpts_to_remove.sort_unstable_by(|a, b| a.cmp(b, &snapshot));
1859 drop(snapshot);
1860 log::info!("Removing excerpts {:?}", excerpts_to_remove);
1861 self.remove_excerpts(excerpts_to_remove, cx);
1862 }
1863 }
1864 }
1865
1866 pub fn randomly_mutate(
1867 &mut self,
1868 rng: &mut impl rand::Rng,
1869 mutation_count: usize,
1870 cx: &mut ModelContext<Self>,
1871 ) {
1872 use rand::prelude::*;
1873
1874 if rng.gen_bool(0.7) || self.singleton {
1875 let buffer = self
1876 .buffers
1877 .borrow()
1878 .values()
1879 .choose(rng)
1880 .map(|state| state.buffer.clone());
1881
1882 if let Some(buffer) = buffer {
1883 buffer.update(cx, |buffer, cx| {
1884 if rng.gen() {
1885 buffer.randomly_edit(rng, mutation_count, cx);
1886 } else {
1887 buffer.randomly_undo_redo(rng, cx);
1888 }
1889 });
1890 } else {
1891 self.randomly_edit(rng, mutation_count, cx);
1892 }
1893 } else {
1894 self.randomly_edit_excerpts(rng, mutation_count, cx);
1895 }
1896
1897 self.check_invariants(cx);
1898 }
1899
1900 fn check_invariants(&self, cx: &mut ModelContext<Self>) {
1901 let snapshot = self.read(cx);
1902 let excerpts = snapshot.excerpts.items(&());
1903 let excerpt_ids = snapshot.excerpt_ids.items(&());
1904
1905 for (ix, excerpt) in excerpts.iter().enumerate() {
1906 if ix == 0 {
1907 if excerpt.locator <= Locator::min() {
1908 panic!("invalid first excerpt locator {:?}", excerpt.locator);
1909 }
1910 } else {
1911 if excerpt.locator <= excerpts[ix - 1].locator {
1912 panic!("excerpts are out-of-order: {:?}", excerpts);
1913 }
1914 }
1915 }
1916
1917 for (ix, entry) in excerpt_ids.iter().enumerate() {
1918 if ix == 0 {
1919 if entry.id.cmp(&ExcerptId::min(), &snapshot).is_le() {
1920 panic!("invalid first excerpt id {:?}", entry.id);
1921 }
1922 } else {
1923 if entry.id <= excerpt_ids[ix - 1].id {
1924 panic!("excerpt ids are out-of-order: {:?}", excerpt_ids);
1925 }
1926 }
1927 }
1928 }
1929}
1930
1931impl EventEmitter<Event> for MultiBuffer {}
1932
1933impl MultiBufferSnapshot {
1934 pub fn text(&self) -> String {
1935 self.chunks(0..self.len(), false)
1936 .map(|chunk| chunk.text)
1937 .collect()
1938 }
1939
1940 pub fn reversed_chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
1941 let mut offset = position.to_offset(self);
1942 let mut cursor = self.excerpts.cursor::<usize>();
1943 cursor.seek(&offset, Bias::Left, &());
1944 let mut excerpt_chunks = cursor.item().map(|excerpt| {
1945 let end_before_footer = cursor.start() + excerpt.text_summary.len;
1946 let start = excerpt.range.context.start.to_offset(&excerpt.buffer);
1947 let end = start + (cmp::min(offset, end_before_footer) - cursor.start());
1948 excerpt.buffer.reversed_chunks_in_range(start..end)
1949 });
1950 iter::from_fn(move || {
1951 if offset == *cursor.start() {
1952 cursor.prev(&());
1953 let excerpt = cursor.item()?;
1954 excerpt_chunks = Some(
1955 excerpt
1956 .buffer
1957 .reversed_chunks_in_range(excerpt.range.context.clone()),
1958 );
1959 }
1960
1961 let excerpt = cursor.item().unwrap();
1962 if offset == cursor.end(&()) && excerpt.has_trailing_newline {
1963 offset -= 1;
1964 Some("\n")
1965 } else {
1966 let chunk = excerpt_chunks.as_mut().unwrap().next().unwrap();
1967 offset -= chunk.len();
1968 Some(chunk)
1969 }
1970 })
1971 .flat_map(|c| c.chars().rev())
1972 }
1973
1974 pub fn chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
1975 let offset = position.to_offset(self);
1976 self.text_for_range(offset..self.len())
1977 .flat_map(|chunk| chunk.chars())
1978 }
1979
1980 pub fn text_for_range<T: ToOffset>(&self, range: Range<T>) -> impl Iterator<Item = &str> + '_ {
1981 self.chunks(range, false).map(|chunk| chunk.text)
1982 }
1983
1984 pub fn is_line_blank(&self, row: u32) -> bool {
1985 self.text_for_range(Point::new(row, 0)..Point::new(row, self.line_len(row)))
1986 .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
1987 }
1988
1989 pub fn contains_str_at<T>(&self, position: T, needle: &str) -> bool
1990 where
1991 T: ToOffset,
1992 {
1993 let position = position.to_offset(self);
1994 position == self.clip_offset(position, Bias::Left)
1995 && self
1996 .bytes_in_range(position..self.len())
1997 .flatten()
1998 .copied()
1999 .take(needle.len())
2000 .eq(needle.bytes())
2001 }
2002
2003 pub fn surrounding_word<T: ToOffset>(&self, start: T) -> (Range<usize>, Option<CharKind>) {
2004 let mut start = start.to_offset(self);
2005 let mut end = start;
2006 let mut next_chars = self.chars_at(start).peekable();
2007 let mut prev_chars = self.reversed_chars_at(start).peekable();
2008
2009 let scope = self.language_scope_at(start);
2010 let kind = |c| char_kind(&scope, c);
2011 let word_kind = cmp::max(
2012 prev_chars.peek().copied().map(kind),
2013 next_chars.peek().copied().map(kind),
2014 );
2015
2016 for ch in prev_chars {
2017 if Some(kind(ch)) == word_kind && ch != '\n' {
2018 start -= ch.len_utf8();
2019 } else {
2020 break;
2021 }
2022 }
2023
2024 for ch in next_chars {
2025 if Some(kind(ch)) == word_kind && ch != '\n' {
2026 end += ch.len_utf8();
2027 } else {
2028 break;
2029 }
2030 }
2031
2032 (start..end, word_kind)
2033 }
2034
2035 pub fn as_singleton(&self) -> Option<(&ExcerptId, BufferId, &BufferSnapshot)> {
2036 if self.singleton {
2037 self.excerpts
2038 .iter()
2039 .next()
2040 .map(|e| (&e.id, e.buffer_id, &e.buffer))
2041 } else {
2042 None
2043 }
2044 }
2045
2046 pub fn len(&self) -> usize {
2047 self.excerpts.summary().text.len
2048 }
2049
2050 pub fn is_empty(&self) -> bool {
2051 self.excerpts.summary().text.len == 0
2052 }
2053
2054 pub fn max_buffer_row(&self) -> u32 {
2055 self.excerpts.summary().max_buffer_row
2056 }
2057
2058 pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize {
2059 if let Some((_, _, buffer)) = self.as_singleton() {
2060 return buffer.clip_offset(offset, bias);
2061 }
2062
2063 let mut cursor = self.excerpts.cursor::<usize>();
2064 cursor.seek(&offset, Bias::Right, &());
2065 let overshoot = if let Some(excerpt) = cursor.item() {
2066 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
2067 let buffer_offset = excerpt
2068 .buffer
2069 .clip_offset(excerpt_start + (offset - cursor.start()), bias);
2070 buffer_offset.saturating_sub(excerpt_start)
2071 } else {
2072 0
2073 };
2074 cursor.start() + overshoot
2075 }
2076
2077 pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
2078 if let Some((_, _, buffer)) = self.as_singleton() {
2079 return buffer.clip_point(point, bias);
2080 }
2081
2082 let mut cursor = self.excerpts.cursor::<Point>();
2083 cursor.seek(&point, Bias::Right, &());
2084 let overshoot = if let Some(excerpt) = cursor.item() {
2085 let excerpt_start = excerpt.range.context.start.to_point(&excerpt.buffer);
2086 let buffer_point = excerpt
2087 .buffer
2088 .clip_point(excerpt_start + (point - cursor.start()), bias);
2089 buffer_point.saturating_sub(excerpt_start)
2090 } else {
2091 Point::zero()
2092 };
2093 *cursor.start() + overshoot
2094 }
2095
2096 pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 {
2097 if let Some((_, _, buffer)) = self.as_singleton() {
2098 return buffer.clip_offset_utf16(offset, bias);
2099 }
2100
2101 let mut cursor = self.excerpts.cursor::<OffsetUtf16>();
2102 cursor.seek(&offset, Bias::Right, &());
2103 let overshoot = if let Some(excerpt) = cursor.item() {
2104 let excerpt_start = excerpt.range.context.start.to_offset_utf16(&excerpt.buffer);
2105 let buffer_offset = excerpt
2106 .buffer
2107 .clip_offset_utf16(excerpt_start + (offset - cursor.start()), bias);
2108 OffsetUtf16(buffer_offset.0.saturating_sub(excerpt_start.0))
2109 } else {
2110 OffsetUtf16(0)
2111 };
2112 *cursor.start() + overshoot
2113 }
2114
2115 pub fn clip_point_utf16(&self, point: Unclipped<PointUtf16>, bias: Bias) -> PointUtf16 {
2116 if let Some((_, _, buffer)) = self.as_singleton() {
2117 return buffer.clip_point_utf16(point, bias);
2118 }
2119
2120 let mut cursor = self.excerpts.cursor::<PointUtf16>();
2121 cursor.seek(&point.0, Bias::Right, &());
2122 let overshoot = if let Some(excerpt) = cursor.item() {
2123 let excerpt_start = excerpt
2124 .buffer
2125 .offset_to_point_utf16(excerpt.range.context.start.to_offset(&excerpt.buffer));
2126 let buffer_point = excerpt
2127 .buffer
2128 .clip_point_utf16(Unclipped(excerpt_start + (point.0 - cursor.start())), bias);
2129 buffer_point.saturating_sub(excerpt_start)
2130 } else {
2131 PointUtf16::zero()
2132 };
2133 *cursor.start() + overshoot
2134 }
2135
2136 pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> MultiBufferBytes {
2137 let range = range.start.to_offset(self)..range.end.to_offset(self);
2138 let mut excerpts = self.excerpts.cursor::<usize>();
2139 excerpts.seek(&range.start, Bias::Right, &());
2140
2141 let mut chunk = &[][..];
2142 let excerpt_bytes = if let Some(excerpt) = excerpts.item() {
2143 let mut excerpt_bytes = excerpt
2144 .bytes_in_range(range.start - excerpts.start()..range.end - excerpts.start());
2145 chunk = excerpt_bytes.next().unwrap_or(&[][..]);
2146 Some(excerpt_bytes)
2147 } else {
2148 None
2149 };
2150 MultiBufferBytes {
2151 range,
2152 excerpts,
2153 excerpt_bytes,
2154 chunk,
2155 }
2156 }
2157
2158 pub fn reversed_bytes_in_range<T: ToOffset>(
2159 &self,
2160 range: Range<T>,
2161 ) -> ReversedMultiBufferBytes {
2162 let range = range.start.to_offset(self)..range.end.to_offset(self);
2163 let mut excerpts = self.excerpts.cursor::<usize>();
2164 excerpts.seek(&range.end, Bias::Left, &());
2165
2166 let mut chunk = &[][..];
2167 let excerpt_bytes = if let Some(excerpt) = excerpts.item() {
2168 let mut excerpt_bytes = excerpt.reversed_bytes_in_range(
2169 range.start - excerpts.start()..range.end - excerpts.start(),
2170 );
2171 chunk = excerpt_bytes.next().unwrap_or(&[][..]);
2172 Some(excerpt_bytes)
2173 } else {
2174 None
2175 };
2176
2177 ReversedMultiBufferBytes {
2178 range,
2179 excerpts,
2180 excerpt_bytes,
2181 chunk,
2182 }
2183 }
2184
2185 pub fn buffer_rows(&self, start_row: u32) -> MultiBufferRows {
2186 let mut result = MultiBufferRows {
2187 buffer_row_range: 0..0,
2188 excerpts: self.excerpts.cursor(),
2189 };
2190 result.seek(start_row);
2191 result
2192 }
2193
2194 pub fn chunks<T: ToOffset>(&self, range: Range<T>, language_aware: bool) -> MultiBufferChunks {
2195 let range = range.start.to_offset(self)..range.end.to_offset(self);
2196 let mut chunks = MultiBufferChunks {
2197 range: range.clone(),
2198 excerpts: self.excerpts.cursor(),
2199 excerpt_chunks: None,
2200 language_aware,
2201 };
2202 chunks.seek(range.start);
2203 chunks
2204 }
2205
2206 pub fn offset_to_point(&self, offset: usize) -> Point {
2207 if let Some((_, _, buffer)) = self.as_singleton() {
2208 return buffer.offset_to_point(offset);
2209 }
2210
2211 let mut cursor = self.excerpts.cursor::<(usize, Point)>();
2212 cursor.seek(&offset, Bias::Right, &());
2213 if let Some(excerpt) = cursor.item() {
2214 let (start_offset, start_point) = cursor.start();
2215 let overshoot = offset - start_offset;
2216 let excerpt_start_offset = excerpt.range.context.start.to_offset(&excerpt.buffer);
2217 let excerpt_start_point = excerpt.range.context.start.to_point(&excerpt.buffer);
2218 let buffer_point = excerpt
2219 .buffer
2220 .offset_to_point(excerpt_start_offset + overshoot);
2221 *start_point + (buffer_point - excerpt_start_point)
2222 } else {
2223 self.excerpts.summary().text.lines
2224 }
2225 }
2226
2227 pub fn offset_to_point_utf16(&self, offset: usize) -> PointUtf16 {
2228 if let Some((_, _, buffer)) = self.as_singleton() {
2229 return buffer.offset_to_point_utf16(offset);
2230 }
2231
2232 let mut cursor = self.excerpts.cursor::<(usize, PointUtf16)>();
2233 cursor.seek(&offset, Bias::Right, &());
2234 if let Some(excerpt) = cursor.item() {
2235 let (start_offset, start_point) = cursor.start();
2236 let overshoot = offset - start_offset;
2237 let excerpt_start_offset = excerpt.range.context.start.to_offset(&excerpt.buffer);
2238 let excerpt_start_point = excerpt.range.context.start.to_point_utf16(&excerpt.buffer);
2239 let buffer_point = excerpt
2240 .buffer
2241 .offset_to_point_utf16(excerpt_start_offset + overshoot);
2242 *start_point + (buffer_point - excerpt_start_point)
2243 } else {
2244 self.excerpts.summary().text.lines_utf16()
2245 }
2246 }
2247
2248 pub fn point_to_point_utf16(&self, point: Point) -> PointUtf16 {
2249 if let Some((_, _, buffer)) = self.as_singleton() {
2250 return buffer.point_to_point_utf16(point);
2251 }
2252
2253 let mut cursor = self.excerpts.cursor::<(Point, PointUtf16)>();
2254 cursor.seek(&point, Bias::Right, &());
2255 if let Some(excerpt) = cursor.item() {
2256 let (start_offset, start_point) = cursor.start();
2257 let overshoot = point - start_offset;
2258 let excerpt_start_point = excerpt.range.context.start.to_point(&excerpt.buffer);
2259 let excerpt_start_point_utf16 =
2260 excerpt.range.context.start.to_point_utf16(&excerpt.buffer);
2261 let buffer_point = excerpt
2262 .buffer
2263 .point_to_point_utf16(excerpt_start_point + overshoot);
2264 *start_point + (buffer_point - excerpt_start_point_utf16)
2265 } else {
2266 self.excerpts.summary().text.lines_utf16()
2267 }
2268 }
2269
2270 pub fn point_to_offset(&self, point: Point) -> usize {
2271 if let Some((_, _, buffer)) = self.as_singleton() {
2272 return buffer.point_to_offset(point);
2273 }
2274
2275 let mut cursor = self.excerpts.cursor::<(Point, usize)>();
2276 cursor.seek(&point, Bias::Right, &());
2277 if let Some(excerpt) = cursor.item() {
2278 let (start_point, start_offset) = cursor.start();
2279 let overshoot = point - start_point;
2280 let excerpt_start_offset = excerpt.range.context.start.to_offset(&excerpt.buffer);
2281 let excerpt_start_point = excerpt.range.context.start.to_point(&excerpt.buffer);
2282 let buffer_offset = excerpt
2283 .buffer
2284 .point_to_offset(excerpt_start_point + overshoot);
2285 *start_offset + buffer_offset - excerpt_start_offset
2286 } else {
2287 self.excerpts.summary().text.len
2288 }
2289 }
2290
2291 pub fn offset_utf16_to_offset(&self, offset_utf16: OffsetUtf16) -> usize {
2292 if let Some((_, _, buffer)) = self.as_singleton() {
2293 return buffer.offset_utf16_to_offset(offset_utf16);
2294 }
2295
2296 let mut cursor = self.excerpts.cursor::<(OffsetUtf16, usize)>();
2297 cursor.seek(&offset_utf16, Bias::Right, &());
2298 if let Some(excerpt) = cursor.item() {
2299 let (start_offset_utf16, start_offset) = cursor.start();
2300 let overshoot = offset_utf16 - start_offset_utf16;
2301 let excerpt_start_offset = excerpt.range.context.start.to_offset(&excerpt.buffer);
2302 let excerpt_start_offset_utf16 =
2303 excerpt.buffer.offset_to_offset_utf16(excerpt_start_offset);
2304 let buffer_offset = excerpt
2305 .buffer
2306 .offset_utf16_to_offset(excerpt_start_offset_utf16 + overshoot);
2307 *start_offset + (buffer_offset - excerpt_start_offset)
2308 } else {
2309 self.excerpts.summary().text.len
2310 }
2311 }
2312
2313 pub fn offset_to_offset_utf16(&self, offset: usize) -> OffsetUtf16 {
2314 if let Some((_, _, buffer)) = self.as_singleton() {
2315 return buffer.offset_to_offset_utf16(offset);
2316 }
2317
2318 let mut cursor = self.excerpts.cursor::<(usize, OffsetUtf16)>();
2319 cursor.seek(&offset, Bias::Right, &());
2320 if let Some(excerpt) = cursor.item() {
2321 let (start_offset, start_offset_utf16) = cursor.start();
2322 let overshoot = offset - start_offset;
2323 let excerpt_start_offset_utf16 =
2324 excerpt.range.context.start.to_offset_utf16(&excerpt.buffer);
2325 let excerpt_start_offset = excerpt
2326 .buffer
2327 .offset_utf16_to_offset(excerpt_start_offset_utf16);
2328 let buffer_offset_utf16 = excerpt
2329 .buffer
2330 .offset_to_offset_utf16(excerpt_start_offset + overshoot);
2331 *start_offset_utf16 + (buffer_offset_utf16 - excerpt_start_offset_utf16)
2332 } else {
2333 self.excerpts.summary().text.len_utf16
2334 }
2335 }
2336
2337 pub fn point_utf16_to_offset(&self, point: PointUtf16) -> usize {
2338 if let Some((_, _, buffer)) = self.as_singleton() {
2339 return buffer.point_utf16_to_offset(point);
2340 }
2341
2342 let mut cursor = self.excerpts.cursor::<(PointUtf16, usize)>();
2343 cursor.seek(&point, Bias::Right, &());
2344 if let Some(excerpt) = cursor.item() {
2345 let (start_point, start_offset) = cursor.start();
2346 let overshoot = point - start_point;
2347 let excerpt_start_offset = excerpt.range.context.start.to_offset(&excerpt.buffer);
2348 let excerpt_start_point = excerpt
2349 .buffer
2350 .offset_to_point_utf16(excerpt.range.context.start.to_offset(&excerpt.buffer));
2351 let buffer_offset = excerpt
2352 .buffer
2353 .point_utf16_to_offset(excerpt_start_point + overshoot);
2354 *start_offset + (buffer_offset - excerpt_start_offset)
2355 } else {
2356 self.excerpts.summary().text.len
2357 }
2358 }
2359
2360 pub fn point_to_buffer_offset<T: ToOffset>(
2361 &self,
2362 point: T,
2363 ) -> Option<(&BufferSnapshot, usize)> {
2364 let offset = point.to_offset(self);
2365 let mut cursor = self.excerpts.cursor::<usize>();
2366 cursor.seek(&offset, Bias::Right, &());
2367 if cursor.item().is_none() {
2368 cursor.prev(&());
2369 }
2370
2371 cursor.item().map(|excerpt| {
2372 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
2373 let buffer_point = excerpt_start + offset - *cursor.start();
2374 (&excerpt.buffer, buffer_point)
2375 })
2376 }
2377
2378 pub fn suggested_indents(
2379 &self,
2380 rows: impl IntoIterator<Item = u32>,
2381 cx: &AppContext,
2382 ) -> BTreeMap<u32, IndentSize> {
2383 let mut result = BTreeMap::new();
2384
2385 let mut rows_for_excerpt = Vec::new();
2386 let mut cursor = self.excerpts.cursor::<Point>();
2387 let mut rows = rows.into_iter().peekable();
2388 let mut prev_row = u32::MAX;
2389 let mut prev_language_indent_size = IndentSize::default();
2390
2391 while let Some(row) = rows.next() {
2392 cursor.seek(&Point::new(row, 0), Bias::Right, &());
2393 let excerpt = match cursor.item() {
2394 Some(excerpt) => excerpt,
2395 _ => continue,
2396 };
2397
2398 // Retrieve the language and indent size once for each disjoint region being indented.
2399 let single_indent_size = if row.saturating_sub(1) == prev_row {
2400 prev_language_indent_size
2401 } else {
2402 excerpt
2403 .buffer
2404 .language_indent_size_at(Point::new(row, 0), cx)
2405 };
2406 prev_language_indent_size = single_indent_size;
2407 prev_row = row;
2408
2409 let start_buffer_row = excerpt.range.context.start.to_point(&excerpt.buffer).row;
2410 let start_multibuffer_row = cursor.start().row;
2411
2412 rows_for_excerpt.push(row);
2413 while let Some(next_row) = rows.peek().copied() {
2414 if cursor.end(&()).row > next_row {
2415 rows_for_excerpt.push(next_row);
2416 rows.next();
2417 } else {
2418 break;
2419 }
2420 }
2421
2422 let buffer_rows = rows_for_excerpt
2423 .drain(..)
2424 .map(|row| start_buffer_row + row - start_multibuffer_row);
2425 let buffer_indents = excerpt
2426 .buffer
2427 .suggested_indents(buffer_rows, single_indent_size);
2428 let multibuffer_indents = buffer_indents
2429 .into_iter()
2430 .map(|(row, indent)| (start_multibuffer_row + row - start_buffer_row, indent));
2431 result.extend(multibuffer_indents);
2432 }
2433
2434 result
2435 }
2436
2437 pub fn indent_size_for_line(&self, row: u32) -> IndentSize {
2438 if let Some((buffer, range)) = self.buffer_line_for_row(row) {
2439 let mut size = buffer.indent_size_for_line(range.start.row);
2440 size.len = size
2441 .len
2442 .min(range.end.column)
2443 .saturating_sub(range.start.column);
2444 size
2445 } else {
2446 IndentSize::spaces(0)
2447 }
2448 }
2449
2450 pub fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
2451 while row > 0 {
2452 row -= 1;
2453 if !self.is_line_blank(row) {
2454 return Some(row);
2455 }
2456 }
2457 None
2458 }
2459
2460 pub fn line_len(&self, row: u32) -> u32 {
2461 if let Some((_, range)) = self.buffer_line_for_row(row) {
2462 range.end.column - range.start.column
2463 } else {
2464 0
2465 }
2466 }
2467
2468 pub fn buffer_line_for_row(&self, row: u32) -> Option<(&BufferSnapshot, Range<Point>)> {
2469 let mut cursor = self.excerpts.cursor::<Point>();
2470 let point = Point::new(row, 0);
2471 cursor.seek(&point, Bias::Right, &());
2472 if cursor.item().is_none() && *cursor.start() == point {
2473 cursor.prev(&());
2474 }
2475 if let Some(excerpt) = cursor.item() {
2476 let overshoot = row - cursor.start().row;
2477 let excerpt_start = excerpt.range.context.start.to_point(&excerpt.buffer);
2478 let excerpt_end = excerpt.range.context.end.to_point(&excerpt.buffer);
2479 let buffer_row = excerpt_start.row + overshoot;
2480 let line_start = Point::new(buffer_row, 0);
2481 let line_end = Point::new(buffer_row, excerpt.buffer.line_len(buffer_row));
2482 return Some((
2483 &excerpt.buffer,
2484 line_start.max(excerpt_start)..line_end.min(excerpt_end),
2485 ));
2486 }
2487 None
2488 }
2489
2490 pub fn max_point(&self) -> Point {
2491 self.text_summary().lines
2492 }
2493
2494 pub fn text_summary(&self) -> TextSummary {
2495 self.excerpts.summary().text.clone()
2496 }
2497
2498 pub fn text_summary_for_range<D, O>(&self, range: Range<O>) -> D
2499 where
2500 D: TextDimension,
2501 O: ToOffset,
2502 {
2503 let mut summary = D::default();
2504 let mut range = range.start.to_offset(self)..range.end.to_offset(self);
2505 let mut cursor = self.excerpts.cursor::<usize>();
2506 cursor.seek(&range.start, Bias::Right, &());
2507 if let Some(excerpt) = cursor.item() {
2508 let mut end_before_newline = cursor.end(&());
2509 if excerpt.has_trailing_newline {
2510 end_before_newline -= 1;
2511 }
2512
2513 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
2514 let start_in_excerpt = excerpt_start + (range.start - cursor.start());
2515 let end_in_excerpt =
2516 excerpt_start + (cmp::min(end_before_newline, range.end) - cursor.start());
2517 summary.add_assign(
2518 &excerpt
2519 .buffer
2520 .text_summary_for_range(start_in_excerpt..end_in_excerpt),
2521 );
2522
2523 if range.end > end_before_newline {
2524 summary.add_assign(&D::from_text_summary(&TextSummary::from("\n")));
2525 }
2526
2527 cursor.next(&());
2528 }
2529
2530 if range.end > *cursor.start() {
2531 summary.add_assign(&D::from_text_summary(&cursor.summary::<_, TextSummary>(
2532 &range.end,
2533 Bias::Right,
2534 &(),
2535 )));
2536 if let Some(excerpt) = cursor.item() {
2537 range.end = cmp::max(*cursor.start(), range.end);
2538
2539 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
2540 let end_in_excerpt = excerpt_start + (range.end - cursor.start());
2541 summary.add_assign(
2542 &excerpt
2543 .buffer
2544 .text_summary_for_range(excerpt_start..end_in_excerpt),
2545 );
2546 }
2547 }
2548
2549 summary
2550 }
2551
2552 pub fn summary_for_anchor<D>(&self, anchor: &Anchor) -> D
2553 where
2554 D: TextDimension + Ord + Sub<D, Output = D>,
2555 {
2556 let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
2557 let locator = self.excerpt_locator_for_id(anchor.excerpt_id);
2558
2559 cursor.seek(locator, Bias::Left, &());
2560 if cursor.item().is_none() {
2561 cursor.next(&());
2562 }
2563
2564 let mut position = D::from_text_summary(&cursor.start().text);
2565 if let Some(excerpt) = cursor.item() {
2566 if excerpt.id == anchor.excerpt_id {
2567 let excerpt_buffer_start =
2568 excerpt.range.context.start.summary::<D>(&excerpt.buffer);
2569 let excerpt_buffer_end = excerpt.range.context.end.summary::<D>(&excerpt.buffer);
2570 let buffer_position = cmp::min(
2571 excerpt_buffer_end,
2572 anchor.text_anchor.summary::<D>(&excerpt.buffer),
2573 );
2574 if buffer_position > excerpt_buffer_start {
2575 position.add_assign(&(buffer_position - excerpt_buffer_start));
2576 }
2577 }
2578 }
2579 position
2580 }
2581
2582 pub fn summaries_for_anchors<'a, D, I>(&'a self, anchors: I) -> Vec<D>
2583 where
2584 D: TextDimension + Ord + Sub<D, Output = D>,
2585 I: 'a + IntoIterator<Item = &'a Anchor>,
2586 {
2587 if let Some((_, _, buffer)) = self.as_singleton() {
2588 return buffer
2589 .summaries_for_anchors(anchors.into_iter().map(|a| &a.text_anchor))
2590 .collect();
2591 }
2592
2593 let mut anchors = anchors.into_iter().peekable();
2594 let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
2595 let mut summaries = Vec::new();
2596 while let Some(anchor) = anchors.peek() {
2597 let excerpt_id = anchor.excerpt_id;
2598 let excerpt_anchors = iter::from_fn(|| {
2599 let anchor = anchors.peek()?;
2600 if anchor.excerpt_id == excerpt_id {
2601 Some(&anchors.next().unwrap().text_anchor)
2602 } else {
2603 None
2604 }
2605 });
2606
2607 let locator = self.excerpt_locator_for_id(excerpt_id);
2608 cursor.seek_forward(locator, Bias::Left, &());
2609 if cursor.item().is_none() {
2610 cursor.next(&());
2611 }
2612
2613 let position = D::from_text_summary(&cursor.start().text);
2614 if let Some(excerpt) = cursor.item() {
2615 if excerpt.id == excerpt_id {
2616 let excerpt_buffer_start =
2617 excerpt.range.context.start.summary::<D>(&excerpt.buffer);
2618 let excerpt_buffer_end =
2619 excerpt.range.context.end.summary::<D>(&excerpt.buffer);
2620 summaries.extend(
2621 excerpt
2622 .buffer
2623 .summaries_for_anchors::<D, _>(excerpt_anchors)
2624 .map(move |summary| {
2625 let summary = cmp::min(excerpt_buffer_end.clone(), summary);
2626 let mut position = position.clone();
2627 let excerpt_buffer_start = excerpt_buffer_start.clone();
2628 if summary > excerpt_buffer_start {
2629 position.add_assign(&(summary - excerpt_buffer_start));
2630 }
2631 position
2632 }),
2633 );
2634 continue;
2635 }
2636 }
2637
2638 summaries.extend(excerpt_anchors.map(|_| position.clone()));
2639 }
2640
2641 summaries
2642 }
2643
2644 pub fn refresh_anchors<'a, I>(&'a self, anchors: I) -> Vec<(usize, Anchor, bool)>
2645 where
2646 I: 'a + IntoIterator<Item = &'a Anchor>,
2647 {
2648 let mut anchors = anchors.into_iter().enumerate().peekable();
2649 let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
2650 cursor.next(&());
2651
2652 let mut result = Vec::new();
2653
2654 while let Some((_, anchor)) = anchors.peek() {
2655 let old_excerpt_id = anchor.excerpt_id;
2656
2657 // Find the location where this anchor's excerpt should be.
2658 let old_locator = self.excerpt_locator_for_id(old_excerpt_id);
2659 cursor.seek_forward(&Some(old_locator), Bias::Left, &());
2660
2661 if cursor.item().is_none() {
2662 cursor.next(&());
2663 }
2664
2665 let next_excerpt = cursor.item();
2666 let prev_excerpt = cursor.prev_item();
2667
2668 // Process all of the anchors for this excerpt.
2669 while let Some((_, anchor)) = anchors.peek() {
2670 if anchor.excerpt_id != old_excerpt_id {
2671 break;
2672 }
2673 let (anchor_ix, anchor) = anchors.next().unwrap();
2674 let mut anchor = *anchor;
2675
2676 // Leave min and max anchors unchanged if invalid or
2677 // if the old excerpt still exists at this location
2678 let mut kept_position = next_excerpt
2679 .map_or(false, |e| e.id == old_excerpt_id && e.contains(&anchor))
2680 || old_excerpt_id == ExcerptId::max()
2681 || old_excerpt_id == ExcerptId::min();
2682
2683 // If the old excerpt no longer exists at this location, then attempt to
2684 // find an equivalent position for this anchor in an adjacent excerpt.
2685 if !kept_position {
2686 for excerpt in [next_excerpt, prev_excerpt].iter().filter_map(|e| *e) {
2687 if excerpt.contains(&anchor) {
2688 anchor.excerpt_id = excerpt.id;
2689 kept_position = true;
2690 break;
2691 }
2692 }
2693 }
2694
2695 // If there's no adjacent excerpt that contains the anchor's position,
2696 // then report that the anchor has lost its position.
2697 if !kept_position {
2698 anchor = if let Some(excerpt) = next_excerpt {
2699 let mut text_anchor = excerpt
2700 .range
2701 .context
2702 .start
2703 .bias(anchor.text_anchor.bias, &excerpt.buffer);
2704 if text_anchor
2705 .cmp(&excerpt.range.context.end, &excerpt.buffer)
2706 .is_gt()
2707 {
2708 text_anchor = excerpt.range.context.end;
2709 }
2710 Anchor {
2711 buffer_id: Some(excerpt.buffer_id),
2712 excerpt_id: excerpt.id,
2713 text_anchor,
2714 }
2715 } else if let Some(excerpt) = prev_excerpt {
2716 let mut text_anchor = excerpt
2717 .range
2718 .context
2719 .end
2720 .bias(anchor.text_anchor.bias, &excerpt.buffer);
2721 if text_anchor
2722 .cmp(&excerpt.range.context.start, &excerpt.buffer)
2723 .is_lt()
2724 {
2725 text_anchor = excerpt.range.context.start;
2726 }
2727 Anchor {
2728 buffer_id: Some(excerpt.buffer_id),
2729 excerpt_id: excerpt.id,
2730 text_anchor,
2731 }
2732 } else if anchor.text_anchor.bias == Bias::Left {
2733 Anchor::min()
2734 } else {
2735 Anchor::max()
2736 };
2737 }
2738
2739 result.push((anchor_ix, anchor, kept_position));
2740 }
2741 }
2742 result.sort_unstable_by(|a, b| a.1.cmp(&b.1, self));
2743 result
2744 }
2745
2746 pub fn anchor_before<T: ToOffset>(&self, position: T) -> Anchor {
2747 self.anchor_at(position, Bias::Left)
2748 }
2749
2750 pub fn anchor_after<T: ToOffset>(&self, position: T) -> Anchor {
2751 self.anchor_at(position, Bias::Right)
2752 }
2753
2754 pub fn anchor_at<T: ToOffset>(&self, position: T, mut bias: Bias) -> Anchor {
2755 let offset = position.to_offset(self);
2756 if let Some((excerpt_id, buffer_id, buffer)) = self.as_singleton() {
2757 return Anchor {
2758 buffer_id: Some(buffer_id),
2759 excerpt_id: *excerpt_id,
2760 text_anchor: buffer.anchor_at(offset, bias),
2761 };
2762 }
2763
2764 let mut cursor = self.excerpts.cursor::<(usize, Option<ExcerptId>)>();
2765 cursor.seek(&offset, Bias::Right, &());
2766 if cursor.item().is_none() && offset == cursor.start().0 && bias == Bias::Left {
2767 cursor.prev(&());
2768 }
2769 if let Some(excerpt) = cursor.item() {
2770 let mut overshoot = offset.saturating_sub(cursor.start().0);
2771 if excerpt.has_trailing_newline && offset == cursor.end(&()).0 {
2772 overshoot -= 1;
2773 bias = Bias::Right;
2774 }
2775
2776 let buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
2777 let text_anchor =
2778 excerpt.clip_anchor(excerpt.buffer.anchor_at(buffer_start + overshoot, bias));
2779 Anchor {
2780 buffer_id: Some(excerpt.buffer_id),
2781 excerpt_id: excerpt.id,
2782 text_anchor,
2783 }
2784 } else if offset == 0 && bias == Bias::Left {
2785 Anchor::min()
2786 } else {
2787 Anchor::max()
2788 }
2789 }
2790
2791 pub fn anchor_in_excerpt(&self, excerpt_id: ExcerptId, text_anchor: text::Anchor) -> Anchor {
2792 let locator = self.excerpt_locator_for_id(excerpt_id);
2793 let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
2794 cursor.seek(locator, Bias::Left, &());
2795 if let Some(excerpt) = cursor.item() {
2796 if excerpt.id == excerpt_id {
2797 let text_anchor = excerpt.clip_anchor(text_anchor);
2798 drop(cursor);
2799 return Anchor {
2800 buffer_id: Some(excerpt.buffer_id),
2801 excerpt_id,
2802 text_anchor,
2803 };
2804 }
2805 }
2806 panic!("excerpt not found");
2807 }
2808
2809 pub fn can_resolve(&self, anchor: &Anchor) -> bool {
2810 if anchor.excerpt_id == ExcerptId::min() || anchor.excerpt_id == ExcerptId::max() {
2811 true
2812 } else if let Some(excerpt) = self.excerpt(anchor.excerpt_id) {
2813 excerpt.buffer.can_resolve(&anchor.text_anchor)
2814 } else {
2815 false
2816 }
2817 }
2818
2819 pub fn excerpts(
2820 &self,
2821 ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, ExcerptRange<text::Anchor>)> {
2822 self.excerpts
2823 .iter()
2824 .map(|excerpt| (excerpt.id, &excerpt.buffer, excerpt.range.clone()))
2825 }
2826
2827 fn excerpts_for_range<T: ToOffset>(
2828 &self,
2829 range: Range<T>,
2830 ) -> impl Iterator<Item = (&Excerpt, usize)> + '_ {
2831 let range = range.start.to_offset(self)..range.end.to_offset(self);
2832
2833 let mut cursor = self.excerpts.cursor::<usize>();
2834 cursor.seek(&range.start, Bias::Right, &());
2835 cursor.prev(&());
2836
2837 iter::from_fn(move || {
2838 cursor.next(&());
2839 if cursor.start() < &range.end {
2840 cursor.item().map(|item| (item, *cursor.start()))
2841 } else {
2842 None
2843 }
2844 })
2845 }
2846
2847 pub fn excerpt_boundaries_in_range<R, T>(
2848 &self,
2849 range: R,
2850 ) -> impl Iterator<Item = ExcerptBoundary> + '_
2851 where
2852 R: RangeBounds<T>,
2853 T: ToOffset,
2854 {
2855 let start_offset;
2856 let start = match range.start_bound() {
2857 Bound::Included(start) => {
2858 start_offset = start.to_offset(self);
2859 Bound::Included(start_offset)
2860 }
2861 Bound::Excluded(start) => {
2862 start_offset = start.to_offset(self);
2863 Bound::Excluded(start_offset)
2864 }
2865 Bound::Unbounded => {
2866 start_offset = 0;
2867 Bound::Unbounded
2868 }
2869 };
2870 let end = match range.end_bound() {
2871 Bound::Included(end) => Bound::Included(end.to_offset(self)),
2872 Bound::Excluded(end) => Bound::Excluded(end.to_offset(self)),
2873 Bound::Unbounded => Bound::Unbounded,
2874 };
2875 let bounds = (start, end);
2876
2877 let mut cursor = self.excerpts.cursor::<(usize, Point)>();
2878 cursor.seek(&start_offset, Bias::Right, &());
2879 if cursor.item().is_none() {
2880 cursor.prev(&());
2881 }
2882 if !bounds.contains(&cursor.start().0) {
2883 cursor.next(&());
2884 }
2885
2886 let mut prev_buffer_id = cursor.prev_item().map(|excerpt| excerpt.buffer_id);
2887 std::iter::from_fn(move || {
2888 if self.singleton {
2889 None
2890 } else if bounds.contains(&cursor.start().0) {
2891 let excerpt = cursor.item()?;
2892 let starts_new_buffer = Some(excerpt.buffer_id) != prev_buffer_id;
2893 let boundary = ExcerptBoundary {
2894 id: excerpt.id,
2895 row: cursor.start().1.row,
2896 buffer: excerpt.buffer.clone(),
2897 range: excerpt.range.clone(),
2898 starts_new_buffer,
2899 };
2900
2901 prev_buffer_id = Some(excerpt.buffer_id);
2902 cursor.next(&());
2903 Some(boundary)
2904 } else {
2905 None
2906 }
2907 })
2908 }
2909
2910 pub fn edit_count(&self) -> usize {
2911 self.edit_count
2912 }
2913
2914 pub fn parse_count(&self) -> usize {
2915 self.parse_count
2916 }
2917
2918 /// Returns the smallest enclosing bracket ranges containing the given range or
2919 /// None if no brackets contain range or the range is not contained in a single
2920 /// excerpt
2921 ///
2922 /// Can optionally pass a range_filter to filter the ranges of brackets to consider
2923 pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(
2924 &self,
2925 range: Range<T>,
2926 range_filter: Option<&dyn Fn(Range<usize>, Range<usize>) -> bool>,
2927 ) -> Option<(Range<usize>, Range<usize>)> {
2928 let range = range.start.to_offset(self)..range.end.to_offset(self);
2929 let excerpt = self.excerpt_containing(range.clone())?;
2930
2931 // Filter to ranges contained in the excerpt
2932 let range_filter = |open: Range<usize>, close: Range<usize>| -> bool {
2933 excerpt.contains_buffer_range(open.start..close.end)
2934 && range_filter.map_or(true, |filter| {
2935 filter(
2936 excerpt.map_range_from_buffer(open),
2937 excerpt.map_range_from_buffer(close),
2938 )
2939 })
2940 };
2941
2942 let (open, close) = excerpt.buffer().innermost_enclosing_bracket_ranges(
2943 excerpt.map_range_to_buffer(range),
2944 Some(&range_filter),
2945 )?;
2946
2947 Some((
2948 excerpt.map_range_from_buffer(open),
2949 excerpt.map_range_from_buffer(close),
2950 ))
2951 }
2952
2953 /// Returns enclosing bracket ranges containing the given range or returns None if the range is
2954 /// not contained in a single excerpt
2955 pub fn enclosing_bracket_ranges<T: ToOffset>(
2956 &self,
2957 range: Range<T>,
2958 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
2959 let range = range.start.to_offset(self)..range.end.to_offset(self);
2960 let excerpt = self.excerpt_containing(range.clone())?;
2961
2962 Some(
2963 excerpt
2964 .buffer()
2965 .enclosing_bracket_ranges(excerpt.map_range_to_buffer(range))
2966 .filter_map(move |(open, close)| {
2967 if excerpt.contains_buffer_range(open.start..close.end) {
2968 Some((
2969 excerpt.map_range_from_buffer(open),
2970 excerpt.map_range_from_buffer(close),
2971 ))
2972 } else {
2973 None
2974 }
2975 }),
2976 )
2977 }
2978
2979 /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is
2980 /// not contained in a single excerpt
2981 pub fn bracket_ranges<T: ToOffset>(
2982 &self,
2983 range: Range<T>,
2984 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
2985 let range = range.start.to_offset(self)..range.end.to_offset(self);
2986 let excerpt = self.excerpt_containing(range.clone())?;
2987
2988 Some(
2989 excerpt
2990 .buffer()
2991 .bracket_ranges(excerpt.map_range_to_buffer(range))
2992 .filter_map(move |(start_bracket_range, close_bracket_range)| {
2993 let buffer_range = start_bracket_range.start..close_bracket_range.end;
2994 if excerpt.contains_buffer_range(buffer_range) {
2995 Some((
2996 excerpt.map_range_from_buffer(start_bracket_range),
2997 excerpt.map_range_from_buffer(close_bracket_range),
2998 ))
2999 } else {
3000 None
3001 }
3002 }),
3003 )
3004 }
3005
3006 pub fn redacted_ranges<'a, T: ToOffset>(
3007 &'a self,
3008 range: Range<T>,
3009 redaction_enabled: impl Fn(Option<&Arc<dyn File>>) -> bool + 'a,
3010 ) -> impl Iterator<Item = Range<usize>> + 'a {
3011 let range = range.start.to_offset(self)..range.end.to_offset(self);
3012 self.excerpts_for_range(range.clone())
3013 .filter_map(move |(excerpt, excerpt_offset)| {
3014 redaction_enabled(excerpt.buffer.file()).then(move || {
3015 let excerpt_buffer_start =
3016 excerpt.range.context.start.to_offset(&excerpt.buffer);
3017
3018 excerpt
3019 .buffer
3020 .redacted_ranges(excerpt.range.context.clone())
3021 .map(move |mut redacted_range| {
3022 // Re-base onto the excerpts coordinates in the multibuffer
3023 redacted_range.start =
3024 excerpt_offset + (redacted_range.start - excerpt_buffer_start);
3025 redacted_range.end =
3026 excerpt_offset + (redacted_range.end - excerpt_buffer_start);
3027
3028 redacted_range
3029 })
3030 .skip_while(move |redacted_range| redacted_range.end < range.start)
3031 .take_while(move |redacted_range| redacted_range.start < range.end)
3032 })
3033 })
3034 .flatten()
3035 }
3036
3037 pub fn diagnostics_update_count(&self) -> usize {
3038 self.diagnostics_update_count
3039 }
3040
3041 pub fn git_diff_update_count(&self) -> usize {
3042 self.git_diff_update_count
3043 }
3044
3045 pub fn trailing_excerpt_update_count(&self) -> usize {
3046 self.trailing_excerpt_update_count
3047 }
3048
3049 pub fn file_at<T: ToOffset>(&self, point: T) -> Option<&Arc<dyn File>> {
3050 self.point_to_buffer_offset(point)
3051 .and_then(|(buffer, _)| buffer.file())
3052 }
3053
3054 pub fn language_at<T: ToOffset>(&self, point: T) -> Option<&Arc<Language>> {
3055 self.point_to_buffer_offset(point)
3056 .and_then(|(buffer, offset)| buffer.language_at(offset))
3057 }
3058
3059 pub fn settings_at<'a, T: ToOffset>(
3060 &'a self,
3061 point: T,
3062 cx: &'a AppContext,
3063 ) -> &'a LanguageSettings {
3064 let mut language = None;
3065 let mut file = None;
3066 if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
3067 language = buffer.language_at(offset);
3068 file = buffer.file();
3069 }
3070 language_settings(language, file, cx)
3071 }
3072
3073 pub fn language_scope_at<T: ToOffset>(&self, point: T) -> Option<LanguageScope> {
3074 self.point_to_buffer_offset(point)
3075 .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
3076 }
3077
3078 pub fn language_indent_size_at<T: ToOffset>(
3079 &self,
3080 position: T,
3081 cx: &AppContext,
3082 ) -> Option<IndentSize> {
3083 let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
3084 Some(buffer_snapshot.language_indent_size_at(offset, cx))
3085 }
3086
3087 pub fn is_dirty(&self) -> bool {
3088 self.is_dirty
3089 }
3090
3091 pub fn has_conflict(&self) -> bool {
3092 self.has_conflict
3093 }
3094
3095 pub fn has_diagnostics(&self) -> bool {
3096 self.excerpts
3097 .iter()
3098 .any(|excerpt| excerpt.buffer.has_diagnostics())
3099 }
3100
3101 pub fn diagnostic_group<'a, O>(
3102 &'a self,
3103 group_id: usize,
3104 ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
3105 where
3106 O: text::FromAnchor + 'a,
3107 {
3108 self.as_singleton()
3109 .into_iter()
3110 .flat_map(move |(_, _, buffer)| buffer.diagnostic_group(group_id))
3111 }
3112
3113 pub fn diagnostics_in_range<'a, T, O>(
3114 &'a self,
3115 range: Range<T>,
3116 reversed: bool,
3117 ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
3118 where
3119 T: 'a + ToOffset,
3120 O: 'a + text::FromAnchor + Ord,
3121 {
3122 self.as_singleton()
3123 .into_iter()
3124 .flat_map(move |(_, _, buffer)| {
3125 buffer.diagnostics_in_range(
3126 range.start.to_offset(self)..range.end.to_offset(self),
3127 reversed,
3128 )
3129 })
3130 }
3131
3132 pub fn has_git_diffs(&self) -> bool {
3133 for excerpt in self.excerpts.iter() {
3134 if excerpt.buffer.has_git_diff() {
3135 return true;
3136 }
3137 }
3138 false
3139 }
3140
3141 pub fn git_diff_hunks_in_range_rev(
3142 &self,
3143 row_range: Range<u32>,
3144 ) -> impl Iterator<Item = DiffHunk<u32>> + '_ {
3145 let mut cursor = self.excerpts.cursor::<Point>();
3146
3147 cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
3148 if cursor.item().is_none() {
3149 cursor.prev(&());
3150 }
3151
3152 std::iter::from_fn(move || {
3153 let excerpt = cursor.item()?;
3154 let multibuffer_start = *cursor.start();
3155 let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
3156 if multibuffer_start.row >= row_range.end {
3157 return None;
3158 }
3159
3160 let mut buffer_start = excerpt.range.context.start;
3161 let mut buffer_end = excerpt.range.context.end;
3162 let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
3163 let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
3164
3165 if row_range.start > multibuffer_start.row {
3166 let buffer_start_point =
3167 excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
3168 buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
3169 }
3170
3171 if row_range.end < multibuffer_end.row {
3172 let buffer_end_point =
3173 excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
3174 buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
3175 }
3176
3177 let buffer_hunks = excerpt
3178 .buffer
3179 .git_diff_hunks_intersecting_range_rev(buffer_start..buffer_end)
3180 .map(move |hunk| {
3181 let start = multibuffer_start.row
3182 + hunk
3183 .buffer_range
3184 .start
3185 .saturating_sub(excerpt_start_point.row);
3186 let end = multibuffer_start.row
3187 + hunk
3188 .buffer_range
3189 .end
3190 .min(excerpt_end_point.row + 1)
3191 .saturating_sub(excerpt_start_point.row);
3192
3193 DiffHunk {
3194 buffer_range: start..end,
3195 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3196 }
3197 });
3198
3199 cursor.prev(&());
3200
3201 Some(buffer_hunks)
3202 })
3203 .flatten()
3204 }
3205
3206 pub fn git_diff_hunks_in_range(
3207 &self,
3208 row_range: Range<u32>,
3209 ) -> impl Iterator<Item = DiffHunk<u32>> + '_ {
3210 let mut cursor = self.excerpts.cursor::<Point>();
3211
3212 cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
3213
3214 std::iter::from_fn(move || {
3215 let excerpt = cursor.item()?;
3216 let multibuffer_start = *cursor.start();
3217 let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
3218 if multibuffer_start.row >= row_range.end {
3219 return None;
3220 }
3221
3222 let mut buffer_start = excerpt.range.context.start;
3223 let mut buffer_end = excerpt.range.context.end;
3224 let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
3225 let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
3226
3227 if row_range.start > multibuffer_start.row {
3228 let buffer_start_point =
3229 excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
3230 buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
3231 }
3232
3233 if row_range.end < multibuffer_end.row {
3234 let buffer_end_point =
3235 excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
3236 buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
3237 }
3238
3239 let buffer_hunks = excerpt
3240 .buffer
3241 .git_diff_hunks_intersecting_range(buffer_start..buffer_end)
3242 .map(move |hunk| {
3243 let start = multibuffer_start.row
3244 + hunk
3245 .buffer_range
3246 .start
3247 .saturating_sub(excerpt_start_point.row);
3248 let end = multibuffer_start.row
3249 + hunk
3250 .buffer_range
3251 .end
3252 .min(excerpt_end_point.row + 1)
3253 .saturating_sub(excerpt_start_point.row);
3254
3255 DiffHunk {
3256 buffer_range: start..end,
3257 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3258 }
3259 });
3260
3261 cursor.next(&());
3262
3263 Some(buffer_hunks)
3264 })
3265 .flatten()
3266 }
3267
3268 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
3269 let range = range.start.to_offset(self)..range.end.to_offset(self);
3270 let excerpt = self.excerpt_containing(range.clone())?;
3271
3272 let ancestor_buffer_range = excerpt
3273 .buffer()
3274 .range_for_syntax_ancestor(excerpt.map_range_to_buffer(range))?;
3275
3276 Some(excerpt.map_range_from_buffer(ancestor_buffer_range))
3277 }
3278
3279 pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
3280 let (excerpt_id, _, buffer) = self.as_singleton()?;
3281 let outline = buffer.outline(theme)?;
3282 Some(Outline::new(
3283 outline
3284 .items
3285 .into_iter()
3286 .map(|item| OutlineItem {
3287 depth: item.depth,
3288 range: self.anchor_in_excerpt(*excerpt_id, item.range.start)
3289 ..self.anchor_in_excerpt(*excerpt_id, item.range.end),
3290 text: item.text,
3291 highlight_ranges: item.highlight_ranges,
3292 name_ranges: item.name_ranges,
3293 })
3294 .collect(),
3295 ))
3296 }
3297
3298 pub fn symbols_containing<T: ToOffset>(
3299 &self,
3300 offset: T,
3301 theme: Option<&SyntaxTheme>,
3302 ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
3303 let anchor = self.anchor_before(offset);
3304 let excerpt_id = anchor.excerpt_id;
3305 let excerpt = self.excerpt(excerpt_id)?;
3306 Some((
3307 excerpt.buffer_id,
3308 excerpt
3309 .buffer
3310 .symbols_containing(anchor.text_anchor, theme)
3311 .into_iter()
3312 .flatten()
3313 .map(|item| OutlineItem {
3314 depth: item.depth,
3315 range: self.anchor_in_excerpt(excerpt_id, item.range.start)
3316 ..self.anchor_in_excerpt(excerpt_id, item.range.end),
3317 text: item.text,
3318 highlight_ranges: item.highlight_ranges,
3319 name_ranges: item.name_ranges,
3320 })
3321 .collect(),
3322 ))
3323 }
3324
3325 fn excerpt_locator_for_id(&self, id: ExcerptId) -> &Locator {
3326 if id == ExcerptId::min() {
3327 Locator::min_ref()
3328 } else if id == ExcerptId::max() {
3329 Locator::max_ref()
3330 } else {
3331 let mut cursor = self.excerpt_ids.cursor::<ExcerptId>();
3332 cursor.seek(&id, Bias::Left, &());
3333 if let Some(entry) = cursor.item() {
3334 if entry.id == id {
3335 return &entry.locator;
3336 }
3337 }
3338 panic!("invalid excerpt id {:?}", id)
3339 }
3340 }
3341
3342 pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<BufferId> {
3343 Some(self.excerpt(excerpt_id)?.buffer_id)
3344 }
3345
3346 pub fn buffer_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<&BufferSnapshot> {
3347 Some(&self.excerpt(excerpt_id)?.buffer)
3348 }
3349
3350 fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
3351 let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
3352 let locator = self.excerpt_locator_for_id(excerpt_id);
3353 cursor.seek(&Some(locator), Bias::Left, &());
3354 if let Some(excerpt) = cursor.item() {
3355 if excerpt.id == excerpt_id {
3356 return Some(excerpt);
3357 }
3358 }
3359 None
3360 }
3361
3362 /// Returns the excerpt containing range and its offset start within the multibuffer or none if `range` spans multiple excerpts
3363 pub fn excerpt_containing<T: ToOffset>(&self, range: Range<T>) -> Option<MultiBufferExcerpt> {
3364 let range = range.start.to_offset(self)..range.end.to_offset(self);
3365
3366 let mut cursor = self.excerpts.cursor::<usize>();
3367 cursor.seek(&range.start, Bias::Right, &());
3368 let start_excerpt = cursor.item()?;
3369
3370 if range.start == range.end {
3371 return Some(MultiBufferExcerpt::new(start_excerpt, *cursor.start()));
3372 }
3373
3374 cursor.seek(&range.end, Bias::Right, &());
3375 let end_excerpt = cursor.item()?;
3376
3377 if start_excerpt.id != end_excerpt.id {
3378 None
3379 } else {
3380 Some(MultiBufferExcerpt::new(start_excerpt, *cursor.start()))
3381 }
3382 }
3383
3384 pub fn remote_selections_in_range<'a>(
3385 &'a self,
3386 range: &'a Range<Anchor>,
3387 ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
3388 let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
3389 let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
3390 let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
3391 cursor.seek(start_locator, Bias::Left, &());
3392 cursor
3393 .take_while(move |excerpt| excerpt.locator <= *end_locator)
3394 .flat_map(move |excerpt| {
3395 let mut query_range = excerpt.range.context.start..excerpt.range.context.end;
3396 if excerpt.id == range.start.excerpt_id {
3397 query_range.start = range.start.text_anchor;
3398 }
3399 if excerpt.id == range.end.excerpt_id {
3400 query_range.end = range.end.text_anchor;
3401 }
3402
3403 excerpt
3404 .buffer
3405 .remote_selections_in_range(query_range)
3406 .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
3407 selections.map(move |selection| {
3408 let mut start = Anchor {
3409 buffer_id: Some(excerpt.buffer_id),
3410 excerpt_id: excerpt.id,
3411 text_anchor: selection.start,
3412 };
3413 let mut end = Anchor {
3414 buffer_id: Some(excerpt.buffer_id),
3415 excerpt_id: excerpt.id,
3416 text_anchor: selection.end,
3417 };
3418 if range.start.cmp(&start, self).is_gt() {
3419 start = range.start;
3420 }
3421 if range.end.cmp(&end, self).is_lt() {
3422 end = range.end;
3423 }
3424
3425 (
3426 replica_id,
3427 line_mode,
3428 cursor_shape,
3429 Selection {
3430 id: selection.id,
3431 start,
3432 end,
3433 reversed: selection.reversed,
3434 goal: selection.goal,
3435 },
3436 )
3437 })
3438 })
3439 })
3440 }
3441}
3442
3443#[cfg(any(test, feature = "test-support"))]
3444impl MultiBufferSnapshot {
3445 pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
3446 let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
3447 let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
3448 start..end
3449 }
3450}
3451
3452impl History {
3453 fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {
3454 self.transaction_depth += 1;
3455 if self.transaction_depth == 1 {
3456 let id = self.next_transaction_id.tick();
3457 self.undo_stack.push(Transaction {
3458 id,
3459 buffer_transactions: Default::default(),
3460 first_edit_at: now,
3461 last_edit_at: now,
3462 suppress_grouping: false,
3463 });
3464 Some(id)
3465 } else {
3466 None
3467 }
3468 }
3469
3470 fn end_transaction(
3471 &mut self,
3472 now: Instant,
3473 buffer_transactions: HashMap<BufferId, TransactionId>,
3474 ) -> bool {
3475 assert_ne!(self.transaction_depth, 0);
3476 self.transaction_depth -= 1;
3477 if self.transaction_depth == 0 {
3478 if buffer_transactions.is_empty() {
3479 self.undo_stack.pop();
3480 false
3481 } else {
3482 self.redo_stack.clear();
3483 let transaction = self.undo_stack.last_mut().unwrap();
3484 transaction.last_edit_at = now;
3485 for (buffer_id, transaction_id) in buffer_transactions {
3486 transaction
3487 .buffer_transactions
3488 .entry(buffer_id)
3489 .or_insert(transaction_id);
3490 }
3491 true
3492 }
3493 } else {
3494 false
3495 }
3496 }
3497
3498 fn push_transaction<'a, T>(
3499 &mut self,
3500 buffer_transactions: T,
3501 now: Instant,
3502 cx: &mut ModelContext<MultiBuffer>,
3503 ) where
3504 T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
3505 {
3506 assert_eq!(self.transaction_depth, 0);
3507 let transaction = Transaction {
3508 id: self.next_transaction_id.tick(),
3509 buffer_transactions: buffer_transactions
3510 .into_iter()
3511 .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
3512 .collect(),
3513 first_edit_at: now,
3514 last_edit_at: now,
3515 suppress_grouping: false,
3516 };
3517 if !transaction.buffer_transactions.is_empty() {
3518 self.undo_stack.push(transaction);
3519 self.redo_stack.clear();
3520 }
3521 }
3522
3523 fn finalize_last_transaction(&mut self) {
3524 if let Some(transaction) = self.undo_stack.last_mut() {
3525 transaction.suppress_grouping = true;
3526 }
3527 }
3528
3529 fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {
3530 if let Some(ix) = self
3531 .undo_stack
3532 .iter()
3533 .rposition(|transaction| transaction.id == transaction_id)
3534 {
3535 Some(self.undo_stack.remove(ix))
3536 } else if let Some(ix) = self
3537 .redo_stack
3538 .iter()
3539 .rposition(|transaction| transaction.id == transaction_id)
3540 {
3541 Some(self.redo_stack.remove(ix))
3542 } else {
3543 None
3544 }
3545 }
3546
3547 fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {
3548 self.undo_stack
3549 .iter_mut()
3550 .find(|transaction| transaction.id == transaction_id)
3551 .or_else(|| {
3552 self.redo_stack
3553 .iter_mut()
3554 .find(|transaction| transaction.id == transaction_id)
3555 })
3556 }
3557
3558 fn pop_undo(&mut self) -> Option<&mut Transaction> {
3559 assert_eq!(self.transaction_depth, 0);
3560 if let Some(transaction) = self.undo_stack.pop() {
3561 self.redo_stack.push(transaction);
3562 self.redo_stack.last_mut()
3563 } else {
3564 None
3565 }
3566 }
3567
3568 fn pop_redo(&mut self) -> Option<&mut Transaction> {
3569 assert_eq!(self.transaction_depth, 0);
3570 if let Some(transaction) = self.redo_stack.pop() {
3571 self.undo_stack.push(transaction);
3572 self.undo_stack.last_mut()
3573 } else {
3574 None
3575 }
3576 }
3577
3578 fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {
3579 let ix = self
3580 .undo_stack
3581 .iter()
3582 .rposition(|transaction| transaction.id == transaction_id)?;
3583 let transaction = self.undo_stack.remove(ix);
3584 self.redo_stack.push(transaction);
3585 self.redo_stack.last()
3586 }
3587
3588 fn group(&mut self) -> Option<TransactionId> {
3589 let mut count = 0;
3590 let mut transactions = self.undo_stack.iter();
3591 if let Some(mut transaction) = transactions.next_back() {
3592 while let Some(prev_transaction) = transactions.next_back() {
3593 if !prev_transaction.suppress_grouping
3594 && transaction.first_edit_at - prev_transaction.last_edit_at
3595 <= self.group_interval
3596 {
3597 transaction = prev_transaction;
3598 count += 1;
3599 } else {
3600 break;
3601 }
3602 }
3603 }
3604 self.group_trailing(count)
3605 }
3606
3607 fn group_until(&mut self, transaction_id: TransactionId) {
3608 let mut count = 0;
3609 for transaction in self.undo_stack.iter().rev() {
3610 if transaction.id == transaction_id {
3611 self.group_trailing(count);
3612 break;
3613 } else if transaction.suppress_grouping {
3614 break;
3615 } else {
3616 count += 1;
3617 }
3618 }
3619 }
3620
3621 fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {
3622 let new_len = self.undo_stack.len() - n;
3623 let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);
3624 if let Some(last_transaction) = transactions_to_keep.last_mut() {
3625 if let Some(transaction) = transactions_to_merge.last() {
3626 last_transaction.last_edit_at = transaction.last_edit_at;
3627 }
3628 for to_merge in transactions_to_merge {
3629 for (buffer_id, transaction_id) in &to_merge.buffer_transactions {
3630 last_transaction
3631 .buffer_transactions
3632 .entry(*buffer_id)
3633 .or_insert(*transaction_id);
3634 }
3635 }
3636 }
3637
3638 self.undo_stack.truncate(new_len);
3639 self.undo_stack.last().map(|t| t.id)
3640 }
3641}
3642
3643impl Excerpt {
3644 fn new(
3645 id: ExcerptId,
3646 locator: Locator,
3647 buffer_id: BufferId,
3648 buffer: BufferSnapshot,
3649 range: ExcerptRange<text::Anchor>,
3650 has_trailing_newline: bool,
3651 ) -> Self {
3652 Excerpt {
3653 id,
3654 locator,
3655 max_buffer_row: range.context.end.to_point(&buffer).row,
3656 text_summary: buffer
3657 .text_summary_for_range::<TextSummary, _>(range.context.to_offset(&buffer)),
3658 buffer_id,
3659 buffer,
3660 range,
3661 has_trailing_newline,
3662 }
3663 }
3664
3665 fn chunks_in_range(&self, range: Range<usize>, language_aware: bool) -> ExcerptChunks {
3666 let content_start = self.range.context.start.to_offset(&self.buffer);
3667 let chunks_start = content_start + range.start;
3668 let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
3669
3670 let footer_height = if self.has_trailing_newline
3671 && range.start <= self.text_summary.len
3672 && range.end > self.text_summary.len
3673 {
3674 1
3675 } else {
3676 0
3677 };
3678
3679 let content_chunks = self.buffer.chunks(chunks_start..chunks_end, language_aware);
3680
3681 ExcerptChunks {
3682 content_chunks,
3683 footer_height,
3684 }
3685 }
3686
3687 fn bytes_in_range(&self, range: Range<usize>) -> ExcerptBytes {
3688 let content_start = self.range.context.start.to_offset(&self.buffer);
3689 let bytes_start = content_start + range.start;
3690 let bytes_end = content_start + cmp::min(range.end, self.text_summary.len);
3691 let footer_height = if self.has_trailing_newline
3692 && range.start <= self.text_summary.len
3693 && range.end > self.text_summary.len
3694 {
3695 1
3696 } else {
3697 0
3698 };
3699 let content_bytes = self.buffer.bytes_in_range(bytes_start..bytes_end);
3700
3701 ExcerptBytes {
3702 content_bytes,
3703 footer_height,
3704 }
3705 }
3706
3707 fn reversed_bytes_in_range(&self, range: Range<usize>) -> ExcerptBytes {
3708 let content_start = self.range.context.start.to_offset(&self.buffer);
3709 let bytes_start = content_start + range.start;
3710 let bytes_end = content_start + cmp::min(range.end, self.text_summary.len);
3711 let footer_height = if self.has_trailing_newline
3712 && range.start <= self.text_summary.len
3713 && range.end > self.text_summary.len
3714 {
3715 1
3716 } else {
3717 0
3718 };
3719 let content_bytes = self.buffer.reversed_bytes_in_range(bytes_start..bytes_end);
3720
3721 ExcerptBytes {
3722 content_bytes,
3723 footer_height,
3724 }
3725 }
3726
3727 fn clip_anchor(&self, text_anchor: text::Anchor) -> text::Anchor {
3728 if text_anchor
3729 .cmp(&self.range.context.start, &self.buffer)
3730 .is_lt()
3731 {
3732 self.range.context.start
3733 } else if text_anchor
3734 .cmp(&self.range.context.end, &self.buffer)
3735 .is_gt()
3736 {
3737 self.range.context.end
3738 } else {
3739 text_anchor
3740 }
3741 }
3742
3743 fn contains(&self, anchor: &Anchor) -> bool {
3744 Some(self.buffer_id) == anchor.buffer_id
3745 && self
3746 .range
3747 .context
3748 .start
3749 .cmp(&anchor.text_anchor, &self.buffer)
3750 .is_le()
3751 && self
3752 .range
3753 .context
3754 .end
3755 .cmp(&anchor.text_anchor, &self.buffer)
3756 .is_ge()
3757 }
3758
3759 /// The [`Excerpt`]'s start offset in its [`Buffer`]
3760 fn buffer_start_offset(&self) -> usize {
3761 self.range.context.start.to_offset(&self.buffer)
3762 }
3763
3764 /// The [`Excerpt`]'s end offset in its [`Buffer`]
3765 fn buffer_end_offset(&self) -> usize {
3766 self.buffer_start_offset() + self.text_summary.len
3767 }
3768}
3769
3770impl<'a> MultiBufferExcerpt<'a> {
3771 fn new(excerpt: &'a Excerpt, excerpt_offset: usize) -> Self {
3772 MultiBufferExcerpt {
3773 excerpt,
3774 excerpt_offset,
3775 }
3776 }
3777
3778 pub fn buffer(&self) -> &'a BufferSnapshot {
3779 &self.excerpt.buffer
3780 }
3781
3782 /// Maps an offset within the [`MultiBuffer`] to an offset within the [`Buffer`]
3783 pub fn map_offset_to_buffer(&self, offset: usize) -> usize {
3784 self.excerpt.buffer_start_offset() + offset.saturating_sub(self.excerpt_offset)
3785 }
3786
3787 /// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`]
3788 pub fn map_range_to_buffer(&self, range: Range<usize>) -> Range<usize> {
3789 self.map_offset_to_buffer(range.start)..self.map_offset_to_buffer(range.end)
3790 }
3791
3792 /// Map an offset within the [`Buffer`] to an offset within the [`MultiBuffer`]
3793 pub fn map_offset_from_buffer(&self, buffer_offset: usize) -> usize {
3794 let mut buffer_offset_in_excerpt =
3795 buffer_offset.saturating_sub(self.excerpt.buffer_start_offset());
3796 buffer_offset_in_excerpt =
3797 cmp::min(buffer_offset_in_excerpt, self.excerpt.text_summary.len);
3798
3799 self.excerpt_offset + buffer_offset_in_excerpt
3800 }
3801
3802 /// Map a range within the [`Buffer`] to a range within the [`MultiBuffer`]
3803 pub fn map_range_from_buffer(&self, buffer_range: Range<usize>) -> Range<usize> {
3804 self.map_offset_from_buffer(buffer_range.start)
3805 ..self.map_offset_from_buffer(buffer_range.end)
3806 }
3807
3808 /// Returns true if the entirety of the given range is in the buffer's excerpt
3809 pub fn contains_buffer_range(&self, range: Range<usize>) -> bool {
3810 range.start >= self.excerpt.buffer_start_offset()
3811 && range.end <= self.excerpt.buffer_end_offset()
3812 }
3813}
3814
3815impl ExcerptId {
3816 pub fn min() -> Self {
3817 Self(0)
3818 }
3819
3820 pub fn max() -> Self {
3821 Self(usize::MAX)
3822 }
3823
3824 pub fn to_proto(&self) -> u64 {
3825 self.0 as _
3826 }
3827
3828 pub fn from_proto(proto: u64) -> Self {
3829 Self(proto as _)
3830 }
3831
3832 pub fn cmp(&self, other: &Self, snapshot: &MultiBufferSnapshot) -> cmp::Ordering {
3833 let a = snapshot.excerpt_locator_for_id(*self);
3834 let b = snapshot.excerpt_locator_for_id(*other);
3835 a.cmp(b).then_with(|| self.0.cmp(&other.0))
3836 }
3837}
3838
3839impl Into<usize> for ExcerptId {
3840 fn into(self) -> usize {
3841 self.0
3842 }
3843}
3844
3845impl fmt::Debug for Excerpt {
3846 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3847 f.debug_struct("Excerpt")
3848 .field("id", &self.id)
3849 .field("locator", &self.locator)
3850 .field("buffer_id", &self.buffer_id)
3851 .field("range", &self.range)
3852 .field("text_summary", &self.text_summary)
3853 .field("has_trailing_newline", &self.has_trailing_newline)
3854 .finish()
3855 }
3856}
3857
3858impl sum_tree::Item for Excerpt {
3859 type Summary = ExcerptSummary;
3860
3861 fn summary(&self) -> Self::Summary {
3862 let mut text = self.text_summary.clone();
3863 if self.has_trailing_newline {
3864 text += TextSummary::from("\n");
3865 }
3866 ExcerptSummary {
3867 excerpt_id: self.id,
3868 excerpt_locator: self.locator.clone(),
3869 max_buffer_row: self.max_buffer_row,
3870 text,
3871 }
3872 }
3873}
3874
3875impl sum_tree::Item for ExcerptIdMapping {
3876 type Summary = ExcerptId;
3877
3878 fn summary(&self) -> Self::Summary {
3879 self.id
3880 }
3881}
3882
3883impl sum_tree::KeyedItem for ExcerptIdMapping {
3884 type Key = ExcerptId;
3885
3886 fn key(&self) -> Self::Key {
3887 self.id
3888 }
3889}
3890
3891impl sum_tree::Summary for ExcerptId {
3892 type Context = ();
3893
3894 fn add_summary(&mut self, other: &Self, _: &()) {
3895 *self = *other;
3896 }
3897}
3898
3899impl sum_tree::Summary for ExcerptSummary {
3900 type Context = ();
3901
3902 fn add_summary(&mut self, summary: &Self, _: &()) {
3903 debug_assert!(summary.excerpt_locator > self.excerpt_locator);
3904 self.excerpt_locator = summary.excerpt_locator.clone();
3905 self.text.add_summary(&summary.text, &());
3906 self.max_buffer_row = cmp::max(self.max_buffer_row, summary.max_buffer_row);
3907 }
3908}
3909
3910impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for TextSummary {
3911 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3912 *self += &summary.text;
3913 }
3914}
3915
3916impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for usize {
3917 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3918 *self += summary.text.len;
3919 }
3920}
3921
3922impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, ExcerptSummary> for usize {
3923 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
3924 Ord::cmp(self, &cursor_location.text.len)
3925 }
3926}
3927
3928impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, Option<&'a Locator>> for Locator {
3929 fn cmp(&self, cursor_location: &Option<&'a Locator>, _: &()) -> cmp::Ordering {
3930 Ord::cmp(&Some(self), cursor_location)
3931 }
3932}
3933
3934impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, ExcerptSummary> for Locator {
3935 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
3936 Ord::cmp(self, &cursor_location.excerpt_locator)
3937 }
3938}
3939
3940impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for OffsetUtf16 {
3941 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3942 *self += summary.text.len_utf16;
3943 }
3944}
3945
3946impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Point {
3947 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3948 *self += summary.text.lines;
3949 }
3950}
3951
3952impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for PointUtf16 {
3953 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3954 *self += summary.text.lines_utf16()
3955 }
3956}
3957
3958impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<&'a Locator> {
3959 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3960 *self = Some(&summary.excerpt_locator);
3961 }
3962}
3963
3964impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<ExcerptId> {
3965 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3966 *self = Some(summary.excerpt_id);
3967 }
3968}
3969
3970impl<'a> MultiBufferRows<'a> {
3971 pub fn seek(&mut self, row: u32) {
3972 self.buffer_row_range = 0..0;
3973
3974 self.excerpts
3975 .seek_forward(&Point::new(row, 0), Bias::Right, &());
3976 if self.excerpts.item().is_none() {
3977 self.excerpts.prev(&());
3978
3979 if self.excerpts.item().is_none() && row == 0 {
3980 self.buffer_row_range = 0..1;
3981 return;
3982 }
3983 }
3984
3985 if let Some(excerpt) = self.excerpts.item() {
3986 let overshoot = row - self.excerpts.start().row;
3987 let excerpt_start = excerpt.range.context.start.to_point(&excerpt.buffer).row;
3988 self.buffer_row_range.start = excerpt_start + overshoot;
3989 self.buffer_row_range.end = excerpt_start + excerpt.text_summary.lines.row + 1;
3990 }
3991 }
3992}
3993
3994impl<'a> Iterator for MultiBufferRows<'a> {
3995 type Item = Option<u32>;
3996
3997 fn next(&mut self) -> Option<Self::Item> {
3998 loop {
3999 if !self.buffer_row_range.is_empty() {
4000 let row = Some(self.buffer_row_range.start);
4001 self.buffer_row_range.start += 1;
4002 return Some(row);
4003 }
4004 self.excerpts.item()?;
4005 self.excerpts.next(&());
4006 let excerpt = self.excerpts.item()?;
4007 self.buffer_row_range.start = excerpt.range.context.start.to_point(&excerpt.buffer).row;
4008 self.buffer_row_range.end =
4009 self.buffer_row_range.start + excerpt.text_summary.lines.row + 1;
4010 }
4011 }
4012}
4013
4014impl<'a> MultiBufferChunks<'a> {
4015 pub fn offset(&self) -> usize {
4016 self.range.start
4017 }
4018
4019 pub fn seek(&mut self, offset: usize) {
4020 self.range.start = offset;
4021 self.excerpts.seek(&offset, Bias::Right, &());
4022 if let Some(excerpt) = self.excerpts.item() {
4023 self.excerpt_chunks = Some(excerpt.chunks_in_range(
4024 self.range.start - self.excerpts.start()..self.range.end - self.excerpts.start(),
4025 self.language_aware,
4026 ));
4027 } else {
4028 self.excerpt_chunks = None;
4029 }
4030 }
4031}
4032
4033impl<'a> Iterator for MultiBufferChunks<'a> {
4034 type Item = Chunk<'a>;
4035
4036 fn next(&mut self) -> Option<Self::Item> {
4037 if self.range.is_empty() {
4038 None
4039 } else if let Some(chunk) = self.excerpt_chunks.as_mut()?.next() {
4040 self.range.start += chunk.text.len();
4041 Some(chunk)
4042 } else {
4043 self.excerpts.next(&());
4044 let excerpt = self.excerpts.item()?;
4045 self.excerpt_chunks = Some(excerpt.chunks_in_range(
4046 0..self.range.end - self.excerpts.start(),
4047 self.language_aware,
4048 ));
4049 self.next()
4050 }
4051 }
4052}
4053
4054impl<'a> MultiBufferBytes<'a> {
4055 fn consume(&mut self, len: usize) {
4056 self.range.start += len;
4057 self.chunk = &self.chunk[len..];
4058
4059 if !self.range.is_empty() && self.chunk.is_empty() {
4060 if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
4061 self.chunk = chunk;
4062 } else {
4063 self.excerpts.next(&());
4064 if let Some(excerpt) = self.excerpts.item() {
4065 let mut excerpt_bytes =
4066 excerpt.bytes_in_range(0..self.range.end - self.excerpts.start());
4067 self.chunk = excerpt_bytes.next().unwrap();
4068 self.excerpt_bytes = Some(excerpt_bytes);
4069 }
4070 }
4071 }
4072 }
4073}
4074
4075impl<'a> Iterator for MultiBufferBytes<'a> {
4076 type Item = &'a [u8];
4077
4078 fn next(&mut self) -> Option<Self::Item> {
4079 let chunk = self.chunk;
4080 if chunk.is_empty() {
4081 None
4082 } else {
4083 self.consume(chunk.len());
4084 Some(chunk)
4085 }
4086 }
4087}
4088
4089impl<'a> io::Read for MultiBufferBytes<'a> {
4090 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
4091 let len = cmp::min(buf.len(), self.chunk.len());
4092 buf[..len].copy_from_slice(&self.chunk[..len]);
4093 if len > 0 {
4094 self.consume(len);
4095 }
4096 Ok(len)
4097 }
4098}
4099
4100impl<'a> ReversedMultiBufferBytes<'a> {
4101 fn consume(&mut self, len: usize) {
4102 self.range.end -= len;
4103 self.chunk = &self.chunk[..self.chunk.len() - len];
4104
4105 if !self.range.is_empty() && self.chunk.is_empty() {
4106 if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
4107 self.chunk = chunk;
4108 } else {
4109 self.excerpts.next(&());
4110 if let Some(excerpt) = self.excerpts.item() {
4111 let mut excerpt_bytes =
4112 excerpt.bytes_in_range(0..self.range.end - self.excerpts.start());
4113 self.chunk = excerpt_bytes.next().unwrap();
4114 self.excerpt_bytes = Some(excerpt_bytes);
4115 }
4116 }
4117 }
4118 }
4119}
4120
4121impl<'a> io::Read for ReversedMultiBufferBytes<'a> {
4122 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
4123 let len = cmp::min(buf.len(), self.chunk.len());
4124 buf[..len].copy_from_slice(&self.chunk[..len]);
4125 buf[..len].reverse();
4126 if len > 0 {
4127 self.consume(len);
4128 }
4129 Ok(len)
4130 }
4131}
4132impl<'a> Iterator for ExcerptBytes<'a> {
4133 type Item = &'a [u8];
4134
4135 fn next(&mut self) -> Option<Self::Item> {
4136 if let Some(chunk) = self.content_bytes.next() {
4137 if !chunk.is_empty() {
4138 return Some(chunk);
4139 }
4140 }
4141
4142 if self.footer_height > 0 {
4143 let result = &NEWLINES[..self.footer_height];
4144 self.footer_height = 0;
4145 return Some(result);
4146 }
4147
4148 None
4149 }
4150}
4151
4152impl<'a> Iterator for ExcerptChunks<'a> {
4153 type Item = Chunk<'a>;
4154
4155 fn next(&mut self) -> Option<Self::Item> {
4156 if let Some(chunk) = self.content_chunks.next() {
4157 return Some(chunk);
4158 }
4159
4160 if self.footer_height > 0 {
4161 let text = unsafe { str::from_utf8_unchecked(&NEWLINES[..self.footer_height]) };
4162 self.footer_height = 0;
4163 return Some(Chunk {
4164 text,
4165 ..Default::default()
4166 });
4167 }
4168
4169 None
4170 }
4171}
4172
4173impl ToOffset for Point {
4174 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4175 snapshot.point_to_offset(*self)
4176 }
4177}
4178
4179impl ToOffset for usize {
4180 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4181 assert!(*self <= snapshot.len(), "offset is out of range");
4182 *self
4183 }
4184}
4185
4186impl ToOffset for OffsetUtf16 {
4187 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4188 snapshot.offset_utf16_to_offset(*self)
4189 }
4190}
4191
4192impl ToOffset for PointUtf16 {
4193 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4194 snapshot.point_utf16_to_offset(*self)
4195 }
4196}
4197
4198impl ToOffsetUtf16 for OffsetUtf16 {
4199 fn to_offset_utf16(&self, _snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
4200 *self
4201 }
4202}
4203
4204impl ToOffsetUtf16 for usize {
4205 fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
4206 snapshot.offset_to_offset_utf16(*self)
4207 }
4208}
4209
4210impl ToPoint for usize {
4211 fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {
4212 snapshot.offset_to_point(*self)
4213 }
4214}
4215
4216impl ToPoint for Point {
4217 fn to_point<'a>(&self, _: &MultiBufferSnapshot) -> Point {
4218 *self
4219 }
4220}
4221
4222impl ToPointUtf16 for usize {
4223 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
4224 snapshot.offset_to_point_utf16(*self)
4225 }
4226}
4227
4228impl ToPointUtf16 for Point {
4229 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
4230 snapshot.point_to_point_utf16(*self)
4231 }
4232}
4233
4234impl ToPointUtf16 for PointUtf16 {
4235 fn to_point_utf16<'a>(&self, _: &MultiBufferSnapshot) -> PointUtf16 {
4236 *self
4237 }
4238}
4239
4240fn build_excerpt_ranges<T>(
4241 buffer: &BufferSnapshot,
4242 ranges: &[Range<T>],
4243 context_line_count: u32,
4244) -> (Vec<ExcerptRange<Point>>, Vec<usize>)
4245where
4246 T: text::ToPoint,
4247{
4248 let max_point = buffer.max_point();
4249 let mut range_counts = Vec::new();
4250 let mut excerpt_ranges = Vec::new();
4251 let mut range_iter = ranges
4252 .iter()
4253 .map(|range| range.start.to_point(buffer)..range.end.to_point(buffer))
4254 .peekable();
4255 while let Some(range) = range_iter.next() {
4256 let excerpt_start = Point::new(range.start.row.saturating_sub(context_line_count), 0);
4257 let mut excerpt_end = Point::new(range.end.row + 1 + context_line_count, 0).min(max_point);
4258 let mut ranges_in_excerpt = 1;
4259
4260 while let Some(next_range) = range_iter.peek() {
4261 if next_range.start.row <= excerpt_end.row + context_line_count {
4262 excerpt_end =
4263 Point::new(next_range.end.row + 1 + context_line_count, 0).min(max_point);
4264 ranges_in_excerpt += 1;
4265 range_iter.next();
4266 } else {
4267 break;
4268 }
4269 }
4270
4271 excerpt_ranges.push(ExcerptRange {
4272 context: excerpt_start..excerpt_end,
4273 primary: Some(range),
4274 });
4275 range_counts.push(ranges_in_excerpt);
4276 }
4277
4278 (excerpt_ranges, range_counts)
4279}
4280
4281#[cfg(test)]
4282mod tests {
4283 use super::*;
4284 use futures::StreamExt;
4285 use gpui::{AppContext, Context, TestAppContext};
4286 use language::{Buffer, Rope};
4287 use parking_lot::RwLock;
4288 use rand::prelude::*;
4289 use settings::SettingsStore;
4290 use std::env;
4291 use util::test::sample_text;
4292
4293 #[gpui::test]
4294 fn test_singleton(cx: &mut AppContext) {
4295 let buffer = cx.new_model(|cx| {
4296 Buffer::new(
4297 0,
4298 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4299 sample_text(6, 6, 'a'),
4300 )
4301 });
4302 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4303
4304 let snapshot = multibuffer.read(cx).snapshot(cx);
4305 assert_eq!(snapshot.text(), buffer.read(cx).text());
4306
4307 assert_eq!(
4308 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4309 (0..buffer.read(cx).row_count())
4310 .map(Some)
4311 .collect::<Vec<_>>()
4312 );
4313
4314 buffer.update(cx, |buffer, cx| buffer.edit([(1..3, "XXX\n")], None, cx));
4315 let snapshot = multibuffer.read(cx).snapshot(cx);
4316
4317 assert_eq!(snapshot.text(), buffer.read(cx).text());
4318 assert_eq!(
4319 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4320 (0..buffer.read(cx).row_count())
4321 .map(Some)
4322 .collect::<Vec<_>>()
4323 );
4324 }
4325
4326 #[gpui::test]
4327 fn test_remote(cx: &mut AppContext) {
4328 let host_buffer =
4329 cx.new_model(|cx| Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "a"));
4330 let guest_buffer = cx.new_model(|cx| {
4331 let state = host_buffer.read(cx).to_proto();
4332 let ops = cx
4333 .background_executor()
4334 .block(host_buffer.read(cx).serialize_ops(None, cx));
4335 let mut buffer = Buffer::from_proto(1, Capability::ReadWrite, state, None).unwrap();
4336 buffer
4337 .apply_ops(
4338 ops.into_iter()
4339 .map(|op| language::proto::deserialize_operation(op).unwrap()),
4340 cx,
4341 )
4342 .unwrap();
4343 buffer
4344 });
4345 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(guest_buffer.clone(), cx));
4346 let snapshot = multibuffer.read(cx).snapshot(cx);
4347 assert_eq!(snapshot.text(), "a");
4348
4349 guest_buffer.update(cx, |buffer, cx| buffer.edit([(1..1, "b")], None, cx));
4350 let snapshot = multibuffer.read(cx).snapshot(cx);
4351 assert_eq!(snapshot.text(), "ab");
4352
4353 guest_buffer.update(cx, |buffer, cx| buffer.edit([(2..2, "c")], None, cx));
4354 let snapshot = multibuffer.read(cx).snapshot(cx);
4355 assert_eq!(snapshot.text(), "abc");
4356 }
4357
4358 #[gpui::test]
4359 fn test_excerpt_boundaries_and_clipping(cx: &mut AppContext) {
4360 let buffer_1 = cx.new_model(|cx| {
4361 Buffer::new(
4362 0,
4363 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4364 sample_text(6, 6, 'a'),
4365 )
4366 });
4367 let buffer_2 = cx.new_model(|cx| {
4368 Buffer::new(
4369 0,
4370 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4371 sample_text(6, 6, 'g'),
4372 )
4373 });
4374 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4375
4376 let events = Arc::new(RwLock::new(Vec::<Event>::new()));
4377 multibuffer.update(cx, |_, cx| {
4378 let events = events.clone();
4379 cx.subscribe(&multibuffer, move |_, _, event, _| {
4380 if let Event::Edited { .. } = event {
4381 events.write().push(event.clone())
4382 }
4383 })
4384 .detach();
4385 });
4386
4387 let subscription = multibuffer.update(cx, |multibuffer, cx| {
4388 let subscription = multibuffer.subscribe();
4389 multibuffer.push_excerpts(
4390 buffer_1.clone(),
4391 [ExcerptRange {
4392 context: Point::new(1, 2)..Point::new(2, 5),
4393 primary: None,
4394 }],
4395 cx,
4396 );
4397 assert_eq!(
4398 subscription.consume().into_inner(),
4399 [Edit {
4400 old: 0..0,
4401 new: 0..10
4402 }]
4403 );
4404
4405 multibuffer.push_excerpts(
4406 buffer_1.clone(),
4407 [ExcerptRange {
4408 context: Point::new(3, 3)..Point::new(4, 4),
4409 primary: None,
4410 }],
4411 cx,
4412 );
4413 multibuffer.push_excerpts(
4414 buffer_2.clone(),
4415 [ExcerptRange {
4416 context: Point::new(3, 1)..Point::new(3, 3),
4417 primary: None,
4418 }],
4419 cx,
4420 );
4421 assert_eq!(
4422 subscription.consume().into_inner(),
4423 [Edit {
4424 old: 10..10,
4425 new: 10..22
4426 }]
4427 );
4428
4429 subscription
4430 });
4431
4432 // Adding excerpts emits an edited event.
4433 assert_eq!(
4434 events.read().as_slice(),
4435 &[
4436 Event::Edited {
4437 singleton_buffer_edited: false
4438 },
4439 Event::Edited {
4440 singleton_buffer_edited: false
4441 },
4442 Event::Edited {
4443 singleton_buffer_edited: false
4444 }
4445 ]
4446 );
4447
4448 let snapshot = multibuffer.read(cx).snapshot(cx);
4449 assert_eq!(
4450 snapshot.text(),
4451 concat!(
4452 "bbbb\n", // Preserve newlines
4453 "ccccc\n", //
4454 "ddd\n", //
4455 "eeee\n", //
4456 "jj" //
4457 )
4458 );
4459 assert_eq!(
4460 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4461 [Some(1), Some(2), Some(3), Some(4), Some(3)]
4462 );
4463 assert_eq!(
4464 snapshot.buffer_rows(2).collect::<Vec<_>>(),
4465 [Some(3), Some(4), Some(3)]
4466 );
4467 assert_eq!(snapshot.buffer_rows(4).collect::<Vec<_>>(), [Some(3)]);
4468 assert_eq!(snapshot.buffer_rows(5).collect::<Vec<_>>(), []);
4469
4470 assert_eq!(
4471 boundaries_in_range(Point::new(0, 0)..Point::new(4, 2), &snapshot),
4472 &[
4473 (0, "bbbb\nccccc".to_string(), true),
4474 (2, "ddd\neeee".to_string(), false),
4475 (4, "jj".to_string(), true),
4476 ]
4477 );
4478 assert_eq!(
4479 boundaries_in_range(Point::new(0, 0)..Point::new(2, 0), &snapshot),
4480 &[(0, "bbbb\nccccc".to_string(), true)]
4481 );
4482 assert_eq!(
4483 boundaries_in_range(Point::new(1, 0)..Point::new(1, 5), &snapshot),
4484 &[]
4485 );
4486 assert_eq!(
4487 boundaries_in_range(Point::new(1, 0)..Point::new(2, 0), &snapshot),
4488 &[]
4489 );
4490 assert_eq!(
4491 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
4492 &[(2, "ddd\neeee".to_string(), false)]
4493 );
4494 assert_eq!(
4495 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
4496 &[(2, "ddd\neeee".to_string(), false)]
4497 );
4498 assert_eq!(
4499 boundaries_in_range(Point::new(2, 0)..Point::new(3, 0), &snapshot),
4500 &[(2, "ddd\neeee".to_string(), false)]
4501 );
4502 assert_eq!(
4503 boundaries_in_range(Point::new(4, 0)..Point::new(4, 2), &snapshot),
4504 &[(4, "jj".to_string(), true)]
4505 );
4506 assert_eq!(
4507 boundaries_in_range(Point::new(4, 2)..Point::new(4, 2), &snapshot),
4508 &[]
4509 );
4510
4511 buffer_1.update(cx, |buffer, cx| {
4512 let text = "\n";
4513 buffer.edit(
4514 [
4515 (Point::new(0, 0)..Point::new(0, 0), text),
4516 (Point::new(2, 1)..Point::new(2, 3), text),
4517 ],
4518 None,
4519 cx,
4520 );
4521 });
4522
4523 let snapshot = multibuffer.read(cx).snapshot(cx);
4524 assert_eq!(
4525 snapshot.text(),
4526 concat!(
4527 "bbbb\n", // Preserve newlines
4528 "c\n", //
4529 "cc\n", //
4530 "ddd\n", //
4531 "eeee\n", //
4532 "jj" //
4533 )
4534 );
4535
4536 assert_eq!(
4537 subscription.consume().into_inner(),
4538 [Edit {
4539 old: 6..8,
4540 new: 6..7
4541 }]
4542 );
4543
4544 let snapshot = multibuffer.read(cx).snapshot(cx);
4545 assert_eq!(
4546 snapshot.clip_point(Point::new(0, 5), Bias::Left),
4547 Point::new(0, 4)
4548 );
4549 assert_eq!(
4550 snapshot.clip_point(Point::new(0, 5), Bias::Right),
4551 Point::new(0, 4)
4552 );
4553 assert_eq!(
4554 snapshot.clip_point(Point::new(5, 1), Bias::Right),
4555 Point::new(5, 1)
4556 );
4557 assert_eq!(
4558 snapshot.clip_point(Point::new(5, 2), Bias::Right),
4559 Point::new(5, 2)
4560 );
4561 assert_eq!(
4562 snapshot.clip_point(Point::new(5, 3), Bias::Right),
4563 Point::new(5, 2)
4564 );
4565
4566 let snapshot = multibuffer.update(cx, |multibuffer, cx| {
4567 let (buffer_2_excerpt_id, _) =
4568 multibuffer.excerpts_for_buffer(&buffer_2, cx)[0].clone();
4569 multibuffer.remove_excerpts([buffer_2_excerpt_id], cx);
4570 multibuffer.snapshot(cx)
4571 });
4572
4573 assert_eq!(
4574 snapshot.text(),
4575 concat!(
4576 "bbbb\n", // Preserve newlines
4577 "c\n", //
4578 "cc\n", //
4579 "ddd\n", //
4580 "eeee", //
4581 )
4582 );
4583
4584 fn boundaries_in_range(
4585 range: Range<Point>,
4586 snapshot: &MultiBufferSnapshot,
4587 ) -> Vec<(u32, String, bool)> {
4588 snapshot
4589 .excerpt_boundaries_in_range(range)
4590 .map(|boundary| {
4591 (
4592 boundary.row,
4593 boundary
4594 .buffer
4595 .text_for_range(boundary.range.context)
4596 .collect::<String>(),
4597 boundary.starts_new_buffer,
4598 )
4599 })
4600 .collect::<Vec<_>>()
4601 }
4602 }
4603
4604 #[gpui::test]
4605 fn test_excerpt_events(cx: &mut AppContext) {
4606 let buffer_1 = cx.new_model(|cx| {
4607 Buffer::new(
4608 0,
4609 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4610 sample_text(10, 3, 'a'),
4611 )
4612 });
4613 let buffer_2 = cx.new_model(|cx| {
4614 Buffer::new(
4615 0,
4616 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4617 sample_text(10, 3, 'm'),
4618 )
4619 });
4620
4621 let leader_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4622 let follower_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4623 let follower_edit_event_count = Arc::new(RwLock::new(0));
4624
4625 follower_multibuffer.update(cx, |_, cx| {
4626 let follower_edit_event_count = follower_edit_event_count.clone();
4627 cx.subscribe(
4628 &leader_multibuffer,
4629 move |follower, _, event, cx| match event.clone() {
4630 Event::ExcerptsAdded {
4631 buffer,
4632 predecessor,
4633 excerpts,
4634 } => follower.insert_excerpts_with_ids_after(predecessor, buffer, excerpts, cx),
4635 Event::ExcerptsRemoved { ids } => follower.remove_excerpts(ids, cx),
4636 Event::Edited { .. } => {
4637 *follower_edit_event_count.write() += 1;
4638 }
4639 _ => {}
4640 },
4641 )
4642 .detach();
4643 });
4644
4645 leader_multibuffer.update(cx, |leader, cx| {
4646 leader.push_excerpts(
4647 buffer_1.clone(),
4648 [
4649 ExcerptRange {
4650 context: 0..8,
4651 primary: None,
4652 },
4653 ExcerptRange {
4654 context: 12..16,
4655 primary: None,
4656 },
4657 ],
4658 cx,
4659 );
4660 leader.insert_excerpts_after(
4661 leader.excerpt_ids()[0],
4662 buffer_2.clone(),
4663 [
4664 ExcerptRange {
4665 context: 0..5,
4666 primary: None,
4667 },
4668 ExcerptRange {
4669 context: 10..15,
4670 primary: None,
4671 },
4672 ],
4673 cx,
4674 )
4675 });
4676 assert_eq!(
4677 leader_multibuffer.read(cx).snapshot(cx).text(),
4678 follower_multibuffer.read(cx).snapshot(cx).text(),
4679 );
4680 assert_eq!(*follower_edit_event_count.read(), 2);
4681
4682 leader_multibuffer.update(cx, |leader, cx| {
4683 let excerpt_ids = leader.excerpt_ids();
4684 leader.remove_excerpts([excerpt_ids[1], excerpt_ids[3]], cx);
4685 });
4686 assert_eq!(
4687 leader_multibuffer.read(cx).snapshot(cx).text(),
4688 follower_multibuffer.read(cx).snapshot(cx).text(),
4689 );
4690 assert_eq!(*follower_edit_event_count.read(), 3);
4691
4692 // Removing an empty set of excerpts is a noop.
4693 leader_multibuffer.update(cx, |leader, cx| {
4694 leader.remove_excerpts([], cx);
4695 });
4696 assert_eq!(
4697 leader_multibuffer.read(cx).snapshot(cx).text(),
4698 follower_multibuffer.read(cx).snapshot(cx).text(),
4699 );
4700 assert_eq!(*follower_edit_event_count.read(), 3);
4701
4702 // Adding an empty set of excerpts is a noop.
4703 leader_multibuffer.update(cx, |leader, cx| {
4704 leader.push_excerpts::<usize>(buffer_2.clone(), [], cx);
4705 });
4706 assert_eq!(
4707 leader_multibuffer.read(cx).snapshot(cx).text(),
4708 follower_multibuffer.read(cx).snapshot(cx).text(),
4709 );
4710 assert_eq!(*follower_edit_event_count.read(), 3);
4711
4712 leader_multibuffer.update(cx, |leader, cx| {
4713 leader.clear(cx);
4714 });
4715 assert_eq!(
4716 leader_multibuffer.read(cx).snapshot(cx).text(),
4717 follower_multibuffer.read(cx).snapshot(cx).text(),
4718 );
4719 assert_eq!(*follower_edit_event_count.read(), 4);
4720 }
4721
4722 #[gpui::test]
4723 fn test_push_excerpts_with_context_lines(cx: &mut AppContext) {
4724 let buffer = cx.new_model(|cx| {
4725 Buffer::new(
4726 0,
4727 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4728 sample_text(20, 3, 'a'),
4729 )
4730 });
4731 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4732 let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
4733 multibuffer.push_excerpts_with_context_lines(
4734 buffer.clone(),
4735 vec![
4736 Point::new(3, 2)..Point::new(4, 2),
4737 Point::new(7, 1)..Point::new(7, 3),
4738 Point::new(15, 0)..Point::new(15, 0),
4739 ],
4740 2,
4741 cx,
4742 )
4743 });
4744
4745 let snapshot = multibuffer.read(cx).snapshot(cx);
4746 assert_eq!(
4747 snapshot.text(),
4748 "bbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\n\nnnn\nooo\nppp\nqqq\nrrr\n"
4749 );
4750
4751 assert_eq!(
4752 anchor_ranges
4753 .iter()
4754 .map(|range| range.to_point(&snapshot))
4755 .collect::<Vec<_>>(),
4756 vec![
4757 Point::new(2, 2)..Point::new(3, 2),
4758 Point::new(6, 1)..Point::new(6, 3),
4759 Point::new(12, 0)..Point::new(12, 0)
4760 ]
4761 );
4762 }
4763
4764 #[gpui::test]
4765 async fn test_stream_excerpts_with_context_lines(cx: &mut TestAppContext) {
4766 let buffer = cx.new_model(|cx| {
4767 Buffer::new(
4768 0,
4769 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4770 sample_text(20, 3, 'a'),
4771 )
4772 });
4773 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4774 let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
4775 let snapshot = buffer.read(cx);
4776 let ranges = vec![
4777 snapshot.anchor_before(Point::new(3, 2))..snapshot.anchor_before(Point::new(4, 2)),
4778 snapshot.anchor_before(Point::new(7, 1))..snapshot.anchor_before(Point::new(7, 3)),
4779 snapshot.anchor_before(Point::new(15, 0))
4780 ..snapshot.anchor_before(Point::new(15, 0)),
4781 ];
4782 multibuffer.stream_excerpts_with_context_lines(buffer.clone(), ranges, 2, cx)
4783 });
4784
4785 let anchor_ranges = anchor_ranges.collect::<Vec<_>>().await;
4786
4787 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
4788 assert_eq!(
4789 snapshot.text(),
4790 "bbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\n\nnnn\nooo\nppp\nqqq\nrrr\n"
4791 );
4792
4793 assert_eq!(
4794 anchor_ranges
4795 .iter()
4796 .map(|range| range.to_point(&snapshot))
4797 .collect::<Vec<_>>(),
4798 vec![
4799 Point::new(2, 2)..Point::new(3, 2),
4800 Point::new(6, 1)..Point::new(6, 3),
4801 Point::new(12, 0)..Point::new(12, 0)
4802 ]
4803 );
4804 }
4805
4806 #[gpui::test]
4807 fn test_empty_multibuffer(cx: &mut AppContext) {
4808 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4809
4810 let snapshot = multibuffer.read(cx).snapshot(cx);
4811 assert_eq!(snapshot.text(), "");
4812 assert_eq!(snapshot.buffer_rows(0).collect::<Vec<_>>(), &[Some(0)]);
4813 assert_eq!(snapshot.buffer_rows(1).collect::<Vec<_>>(), &[]);
4814 }
4815
4816 #[gpui::test]
4817 fn test_singleton_multibuffer_anchors(cx: &mut AppContext) {
4818 let buffer = cx.new_model(|cx| {
4819 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4820 });
4821 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4822 let old_snapshot = multibuffer.read(cx).snapshot(cx);
4823 buffer.update(cx, |buffer, cx| {
4824 buffer.edit([(0..0, "X")], None, cx);
4825 buffer.edit([(5..5, "Y")], None, cx);
4826 });
4827 let new_snapshot = multibuffer.read(cx).snapshot(cx);
4828
4829 assert_eq!(old_snapshot.text(), "abcd");
4830 assert_eq!(new_snapshot.text(), "XabcdY");
4831
4832 assert_eq!(old_snapshot.anchor_before(0).to_offset(&new_snapshot), 0);
4833 assert_eq!(old_snapshot.anchor_after(0).to_offset(&new_snapshot), 1);
4834 assert_eq!(old_snapshot.anchor_before(4).to_offset(&new_snapshot), 5);
4835 assert_eq!(old_snapshot.anchor_after(4).to_offset(&new_snapshot), 6);
4836 }
4837
4838 #[gpui::test]
4839 fn test_multibuffer_anchors(cx: &mut AppContext) {
4840 let buffer_1 = cx.new_model(|cx| {
4841 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4842 });
4843 let buffer_2 = cx.new_model(|cx| {
4844 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "efghi")
4845 });
4846 let multibuffer = cx.new_model(|cx| {
4847 let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
4848 multibuffer.push_excerpts(
4849 buffer_1.clone(),
4850 [ExcerptRange {
4851 context: 0..4,
4852 primary: None,
4853 }],
4854 cx,
4855 );
4856 multibuffer.push_excerpts(
4857 buffer_2.clone(),
4858 [ExcerptRange {
4859 context: 0..5,
4860 primary: None,
4861 }],
4862 cx,
4863 );
4864 multibuffer
4865 });
4866 let old_snapshot = multibuffer.read(cx).snapshot(cx);
4867
4868 assert_eq!(old_snapshot.anchor_before(0).to_offset(&old_snapshot), 0);
4869 assert_eq!(old_snapshot.anchor_after(0).to_offset(&old_snapshot), 0);
4870 assert_eq!(Anchor::min().to_offset(&old_snapshot), 0);
4871 assert_eq!(Anchor::min().to_offset(&old_snapshot), 0);
4872 assert_eq!(Anchor::max().to_offset(&old_snapshot), 10);
4873 assert_eq!(Anchor::max().to_offset(&old_snapshot), 10);
4874
4875 buffer_1.update(cx, |buffer, cx| {
4876 buffer.edit([(0..0, "W")], None, cx);
4877 buffer.edit([(5..5, "X")], None, cx);
4878 });
4879 buffer_2.update(cx, |buffer, cx| {
4880 buffer.edit([(0..0, "Y")], None, cx);
4881 buffer.edit([(6..6, "Z")], None, cx);
4882 });
4883 let new_snapshot = multibuffer.read(cx).snapshot(cx);
4884
4885 assert_eq!(old_snapshot.text(), "abcd\nefghi");
4886 assert_eq!(new_snapshot.text(), "WabcdX\nYefghiZ");
4887
4888 assert_eq!(old_snapshot.anchor_before(0).to_offset(&new_snapshot), 0);
4889 assert_eq!(old_snapshot.anchor_after(0).to_offset(&new_snapshot), 1);
4890 assert_eq!(old_snapshot.anchor_before(1).to_offset(&new_snapshot), 2);
4891 assert_eq!(old_snapshot.anchor_after(1).to_offset(&new_snapshot), 2);
4892 assert_eq!(old_snapshot.anchor_before(2).to_offset(&new_snapshot), 3);
4893 assert_eq!(old_snapshot.anchor_after(2).to_offset(&new_snapshot), 3);
4894 assert_eq!(old_snapshot.anchor_before(5).to_offset(&new_snapshot), 7);
4895 assert_eq!(old_snapshot.anchor_after(5).to_offset(&new_snapshot), 8);
4896 assert_eq!(old_snapshot.anchor_before(10).to_offset(&new_snapshot), 13);
4897 assert_eq!(old_snapshot.anchor_after(10).to_offset(&new_snapshot), 14);
4898 }
4899
4900 #[gpui::test]
4901 fn test_resolving_anchors_after_replacing_their_excerpts(cx: &mut AppContext) {
4902 let buffer_1 = cx.new_model(|cx| {
4903 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4904 });
4905 let buffer_2 = cx.new_model(|cx| {
4906 Buffer::new(
4907 0,
4908 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4909 "ABCDEFGHIJKLMNOP",
4910 )
4911 });
4912 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4913
4914 // Create an insertion id in buffer 1 that doesn't exist in buffer 2.
4915 // Add an excerpt from buffer 1 that spans this new insertion.
4916 buffer_1.update(cx, |buffer, cx| buffer.edit([(4..4, "123")], None, cx));
4917 let excerpt_id_1 = multibuffer.update(cx, |multibuffer, cx| {
4918 multibuffer
4919 .push_excerpts(
4920 buffer_1.clone(),
4921 [ExcerptRange {
4922 context: 0..7,
4923 primary: None,
4924 }],
4925 cx,
4926 )
4927 .pop()
4928 .unwrap()
4929 });
4930
4931 let snapshot_1 = multibuffer.read(cx).snapshot(cx);
4932 assert_eq!(snapshot_1.text(), "abcd123");
4933
4934 // Replace the buffer 1 excerpt with new excerpts from buffer 2.
4935 let (excerpt_id_2, excerpt_id_3) = multibuffer.update(cx, |multibuffer, cx| {
4936 multibuffer.remove_excerpts([excerpt_id_1], cx);
4937 let mut ids = multibuffer
4938 .push_excerpts(
4939 buffer_2.clone(),
4940 [
4941 ExcerptRange {
4942 context: 0..4,
4943 primary: None,
4944 },
4945 ExcerptRange {
4946 context: 6..10,
4947 primary: None,
4948 },
4949 ExcerptRange {
4950 context: 12..16,
4951 primary: None,
4952 },
4953 ],
4954 cx,
4955 )
4956 .into_iter();
4957 (ids.next().unwrap(), ids.next().unwrap())
4958 });
4959 let snapshot_2 = multibuffer.read(cx).snapshot(cx);
4960 assert_eq!(snapshot_2.text(), "ABCD\nGHIJ\nMNOP");
4961
4962 // The old excerpt id doesn't get reused.
4963 assert_ne!(excerpt_id_2, excerpt_id_1);
4964
4965 // Resolve some anchors from the previous snapshot in the new snapshot.
4966 // The current excerpts are from a different buffer, so we don't attempt to
4967 // resolve the old text anchor in the new buffer.
4968 assert_eq!(
4969 snapshot_2.summary_for_anchor::<usize>(&snapshot_1.anchor_before(2)),
4970 0
4971 );
4972 assert_eq!(
4973 snapshot_2.summaries_for_anchors::<usize, _>(&[
4974 snapshot_1.anchor_before(2),
4975 snapshot_1.anchor_after(3)
4976 ]),
4977 vec![0, 0]
4978 );
4979
4980 // Refresh anchors from the old snapshot. The return value indicates that both
4981 // anchors lost their original excerpt.
4982 let refresh =
4983 snapshot_2.refresh_anchors(&[snapshot_1.anchor_before(2), snapshot_1.anchor_after(3)]);
4984 assert_eq!(
4985 refresh,
4986 &[
4987 (0, snapshot_2.anchor_before(0), false),
4988 (1, snapshot_2.anchor_after(0), false),
4989 ]
4990 );
4991
4992 // Replace the middle excerpt with a smaller excerpt in buffer 2,
4993 // that intersects the old excerpt.
4994 let excerpt_id_5 = multibuffer.update(cx, |multibuffer, cx| {
4995 multibuffer.remove_excerpts([excerpt_id_3], cx);
4996 multibuffer
4997 .insert_excerpts_after(
4998 excerpt_id_2,
4999 buffer_2.clone(),
5000 [ExcerptRange {
5001 context: 5..8,
5002 primary: None,
5003 }],
5004 cx,
5005 )
5006 .pop()
5007 .unwrap()
5008 });
5009
5010 let snapshot_3 = multibuffer.read(cx).snapshot(cx);
5011 assert_eq!(snapshot_3.text(), "ABCD\nFGH\nMNOP");
5012 assert_ne!(excerpt_id_5, excerpt_id_3);
5013
5014 // Resolve some anchors from the previous snapshot in the new snapshot.
5015 // The third anchor can't be resolved, since its excerpt has been removed,
5016 // so it resolves to the same position as its predecessor.
5017 let anchors = [
5018 snapshot_2.anchor_before(0),
5019 snapshot_2.anchor_after(2),
5020 snapshot_2.anchor_after(6),
5021 snapshot_2.anchor_after(14),
5022 ];
5023 assert_eq!(
5024 snapshot_3.summaries_for_anchors::<usize, _>(&anchors),
5025 &[0, 2, 9, 13]
5026 );
5027
5028 let new_anchors = snapshot_3.refresh_anchors(&anchors);
5029 assert_eq!(
5030 new_anchors.iter().map(|a| (a.0, a.2)).collect::<Vec<_>>(),
5031 &[(0, true), (1, true), (2, true), (3, true)]
5032 );
5033 assert_eq!(
5034 snapshot_3.summaries_for_anchors::<usize, _>(new_anchors.iter().map(|a| &a.1)),
5035 &[0, 2, 7, 13]
5036 );
5037 }
5038
5039 #[gpui::test(iterations = 100)]
5040 fn test_random_multibuffer(cx: &mut AppContext, mut rng: StdRng) {
5041 let operations = env::var("OPERATIONS")
5042 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
5043 .unwrap_or(10);
5044
5045 let mut buffers: Vec<Model<Buffer>> = Vec::new();
5046 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
5047 let mut excerpt_ids = Vec::<ExcerptId>::new();
5048 let mut expected_excerpts = Vec::<(Model<Buffer>, Range<text::Anchor>)>::new();
5049 let mut anchors = Vec::new();
5050 let mut old_versions = Vec::new();
5051
5052 for _ in 0..operations {
5053 match rng.gen_range(0..100) {
5054 0..=19 if !buffers.is_empty() => {
5055 let buffer = buffers.choose(&mut rng).unwrap();
5056 buffer.update(cx, |buf, cx| buf.randomly_edit(&mut rng, 5, cx));
5057 }
5058 20..=29 if !expected_excerpts.is_empty() => {
5059 let mut ids_to_remove = vec![];
5060 for _ in 0..rng.gen_range(1..=3) {
5061 if expected_excerpts.is_empty() {
5062 break;
5063 }
5064
5065 let ix = rng.gen_range(0..expected_excerpts.len());
5066 ids_to_remove.push(excerpt_ids.remove(ix));
5067 let (buffer, range) = expected_excerpts.remove(ix);
5068 let buffer = buffer.read(cx);
5069 log::info!(
5070 "Removing excerpt {}: {:?}",
5071 ix,
5072 buffer
5073 .text_for_range(range.to_offset(buffer))
5074 .collect::<String>(),
5075 );
5076 }
5077 let snapshot = multibuffer.read(cx).read(cx);
5078 ids_to_remove.sort_unstable_by(|a, b| a.cmp(&b, &snapshot));
5079 drop(snapshot);
5080 multibuffer.update(cx, |multibuffer, cx| {
5081 multibuffer.remove_excerpts(ids_to_remove, cx)
5082 });
5083 }
5084 30..=39 if !expected_excerpts.is_empty() => {
5085 let multibuffer = multibuffer.read(cx).read(cx);
5086 let offset =
5087 multibuffer.clip_offset(rng.gen_range(0..=multibuffer.len()), Bias::Left);
5088 let bias = if rng.gen() { Bias::Left } else { Bias::Right };
5089 log::info!("Creating anchor at {} with bias {:?}", offset, bias);
5090 anchors.push(multibuffer.anchor_at(offset, bias));
5091 anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
5092 }
5093 40..=44 if !anchors.is_empty() => {
5094 let multibuffer = multibuffer.read(cx).read(cx);
5095 let prev_len = anchors.len();
5096 anchors = multibuffer
5097 .refresh_anchors(&anchors)
5098 .into_iter()
5099 .map(|a| a.1)
5100 .collect();
5101
5102 // Ensure the newly-refreshed anchors point to a valid excerpt and don't
5103 // overshoot its boundaries.
5104 assert_eq!(anchors.len(), prev_len);
5105 for anchor in &anchors {
5106 if anchor.excerpt_id == ExcerptId::min()
5107 || anchor.excerpt_id == ExcerptId::max()
5108 {
5109 continue;
5110 }
5111
5112 let excerpt = multibuffer.excerpt(anchor.excerpt_id).unwrap();
5113 assert_eq!(excerpt.id, anchor.excerpt_id);
5114 assert!(excerpt.contains(anchor));
5115 }
5116 }
5117 _ => {
5118 let buffer_handle = if buffers.is_empty() || rng.gen_bool(0.4) {
5119 let base_text = util::RandomCharIter::new(&mut rng)
5120 .take(10)
5121 .collect::<String>();
5122 buffers.push(cx.new_model(|cx| {
5123 Buffer::new(
5124 0,
5125 BufferId::new(cx.entity_id().as_u64()).unwrap(),
5126 base_text,
5127 )
5128 }));
5129 buffers.last().unwrap()
5130 } else {
5131 buffers.choose(&mut rng).unwrap()
5132 };
5133
5134 let buffer = buffer_handle.read(cx);
5135 let end_ix = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
5136 let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
5137 let anchor_range = buffer.anchor_before(start_ix)..buffer.anchor_after(end_ix);
5138 let prev_excerpt_ix = rng.gen_range(0..=expected_excerpts.len());
5139 let prev_excerpt_id = excerpt_ids
5140 .get(prev_excerpt_ix)
5141 .cloned()
5142 .unwrap_or_else(ExcerptId::max);
5143 let excerpt_ix = (prev_excerpt_ix + 1).min(expected_excerpts.len());
5144
5145 log::info!(
5146 "Inserting excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
5147 excerpt_ix,
5148 expected_excerpts.len(),
5149 buffer_handle.read(cx).remote_id(),
5150 buffer.text(),
5151 start_ix..end_ix,
5152 &buffer.text()[start_ix..end_ix]
5153 );
5154
5155 let excerpt_id = multibuffer.update(cx, |multibuffer, cx| {
5156 multibuffer
5157 .insert_excerpts_after(
5158 prev_excerpt_id,
5159 buffer_handle.clone(),
5160 [ExcerptRange {
5161 context: start_ix..end_ix,
5162 primary: None,
5163 }],
5164 cx,
5165 )
5166 .pop()
5167 .unwrap()
5168 });
5169
5170 excerpt_ids.insert(excerpt_ix, excerpt_id);
5171 expected_excerpts.insert(excerpt_ix, (buffer_handle.clone(), anchor_range));
5172 }
5173 }
5174
5175 if rng.gen_bool(0.3) {
5176 multibuffer.update(cx, |multibuffer, cx| {
5177 old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
5178 })
5179 }
5180
5181 let snapshot = multibuffer.read(cx).snapshot(cx);
5182
5183 let mut excerpt_starts = Vec::new();
5184 let mut expected_text = String::new();
5185 let mut expected_buffer_rows = Vec::new();
5186 for (buffer, range) in &expected_excerpts {
5187 let buffer = buffer.read(cx);
5188 let buffer_range = range.to_offset(buffer);
5189
5190 excerpt_starts.push(TextSummary::from(expected_text.as_str()));
5191 expected_text.extend(buffer.text_for_range(buffer_range.clone()));
5192 expected_text.push('\n');
5193
5194 let buffer_row_range = buffer.offset_to_point(buffer_range.start).row
5195 ..=buffer.offset_to_point(buffer_range.end).row;
5196 for row in buffer_row_range {
5197 expected_buffer_rows.push(Some(row));
5198 }
5199 }
5200 // Remove final trailing newline.
5201 if !expected_excerpts.is_empty() {
5202 expected_text.pop();
5203 }
5204
5205 // Always report one buffer row
5206 if expected_buffer_rows.is_empty() {
5207 expected_buffer_rows.push(Some(0));
5208 }
5209
5210 assert_eq!(snapshot.text(), expected_text);
5211 log::info!("MultiBuffer text: {:?}", expected_text);
5212
5213 assert_eq!(
5214 snapshot.buffer_rows(0).collect::<Vec<_>>(),
5215 expected_buffer_rows,
5216 );
5217
5218 for _ in 0..5 {
5219 let start_row = rng.gen_range(0..=expected_buffer_rows.len());
5220 assert_eq!(
5221 snapshot.buffer_rows(start_row as u32).collect::<Vec<_>>(),
5222 &expected_buffer_rows[start_row..],
5223 "buffer_rows({})",
5224 start_row
5225 );
5226 }
5227
5228 assert_eq!(
5229 snapshot.max_buffer_row(),
5230 expected_buffer_rows.into_iter().flatten().max().unwrap()
5231 );
5232
5233 let mut excerpt_starts = excerpt_starts.into_iter();
5234 for (buffer, range) in &expected_excerpts {
5235 let buffer = buffer.read(cx);
5236 let buffer_id = buffer.remote_id();
5237 let buffer_range = range.to_offset(buffer);
5238 let buffer_start_point = buffer.offset_to_point(buffer_range.start);
5239 let buffer_start_point_utf16 =
5240 buffer.text_summary_for_range::<PointUtf16, _>(0..buffer_range.start);
5241
5242 let excerpt_start = excerpt_starts.next().unwrap();
5243 let mut offset = excerpt_start.len;
5244 let mut buffer_offset = buffer_range.start;
5245 let mut point = excerpt_start.lines;
5246 let mut buffer_point = buffer_start_point;
5247 let mut point_utf16 = excerpt_start.lines_utf16();
5248 let mut buffer_point_utf16 = buffer_start_point_utf16;
5249 for ch in buffer
5250 .snapshot()
5251 .chunks(buffer_range.clone(), false)
5252 .flat_map(|c| c.text.chars())
5253 {
5254 for _ in 0..ch.len_utf8() {
5255 let left_offset = snapshot.clip_offset(offset, Bias::Left);
5256 let right_offset = snapshot.clip_offset(offset, Bias::Right);
5257 let buffer_left_offset = buffer.clip_offset(buffer_offset, Bias::Left);
5258 let buffer_right_offset = buffer.clip_offset(buffer_offset, Bias::Right);
5259 assert_eq!(
5260 left_offset,
5261 excerpt_start.len + (buffer_left_offset - buffer_range.start),
5262 "clip_offset({:?}, Left). buffer: {:?}, buffer offset: {:?}",
5263 offset,
5264 buffer_id,
5265 buffer_offset,
5266 );
5267 assert_eq!(
5268 right_offset,
5269 excerpt_start.len + (buffer_right_offset - buffer_range.start),
5270 "clip_offset({:?}, Right). buffer: {:?}, buffer offset: {:?}",
5271 offset,
5272 buffer_id,
5273 buffer_offset,
5274 );
5275
5276 let left_point = snapshot.clip_point(point, Bias::Left);
5277 let right_point = snapshot.clip_point(point, Bias::Right);
5278 let buffer_left_point = buffer.clip_point(buffer_point, Bias::Left);
5279 let buffer_right_point = buffer.clip_point(buffer_point, Bias::Right);
5280 assert_eq!(
5281 left_point,
5282 excerpt_start.lines + (buffer_left_point - buffer_start_point),
5283 "clip_point({:?}, Left). buffer: {:?}, buffer point: {:?}",
5284 point,
5285 buffer_id,
5286 buffer_point,
5287 );
5288 assert_eq!(
5289 right_point,
5290 excerpt_start.lines + (buffer_right_point - buffer_start_point),
5291 "clip_point({:?}, Right). buffer: {:?}, buffer point: {:?}",
5292 point,
5293 buffer_id,
5294 buffer_point,
5295 );
5296
5297 assert_eq!(
5298 snapshot.point_to_offset(left_point),
5299 left_offset,
5300 "point_to_offset({:?})",
5301 left_point,
5302 );
5303 assert_eq!(
5304 snapshot.offset_to_point(left_offset),
5305 left_point,
5306 "offset_to_point({:?})",
5307 left_offset,
5308 );
5309
5310 offset += 1;
5311 buffer_offset += 1;
5312 if ch == '\n' {
5313 point += Point::new(1, 0);
5314 buffer_point += Point::new(1, 0);
5315 } else {
5316 point += Point::new(0, 1);
5317 buffer_point += Point::new(0, 1);
5318 }
5319 }
5320
5321 for _ in 0..ch.len_utf16() {
5322 let left_point_utf16 =
5323 snapshot.clip_point_utf16(Unclipped(point_utf16), Bias::Left);
5324 let right_point_utf16 =
5325 snapshot.clip_point_utf16(Unclipped(point_utf16), Bias::Right);
5326 let buffer_left_point_utf16 =
5327 buffer.clip_point_utf16(Unclipped(buffer_point_utf16), Bias::Left);
5328 let buffer_right_point_utf16 =
5329 buffer.clip_point_utf16(Unclipped(buffer_point_utf16), Bias::Right);
5330 assert_eq!(
5331 left_point_utf16,
5332 excerpt_start.lines_utf16()
5333 + (buffer_left_point_utf16 - buffer_start_point_utf16),
5334 "clip_point_utf16({:?}, Left). buffer: {:?}, buffer point_utf16: {:?}",
5335 point_utf16,
5336 buffer_id,
5337 buffer_point_utf16,
5338 );
5339 assert_eq!(
5340 right_point_utf16,
5341 excerpt_start.lines_utf16()
5342 + (buffer_right_point_utf16 - buffer_start_point_utf16),
5343 "clip_point_utf16({:?}, Right). buffer: {:?}, buffer point_utf16: {:?}",
5344 point_utf16,
5345 buffer_id,
5346 buffer_point_utf16,
5347 );
5348
5349 if ch == '\n' {
5350 point_utf16 += PointUtf16::new(1, 0);
5351 buffer_point_utf16 += PointUtf16::new(1, 0);
5352 } else {
5353 point_utf16 += PointUtf16::new(0, 1);
5354 buffer_point_utf16 += PointUtf16::new(0, 1);
5355 }
5356 }
5357 }
5358 }
5359
5360 for (row, line) in expected_text.split('\n').enumerate() {
5361 assert_eq!(
5362 snapshot.line_len(row as u32),
5363 line.len() as u32,
5364 "line_len({}).",
5365 row
5366 );
5367 }
5368
5369 let text_rope = Rope::from(expected_text.as_str());
5370 for _ in 0..10 {
5371 let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
5372 let start_ix = text_rope.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
5373
5374 let text_for_range = snapshot
5375 .text_for_range(start_ix..end_ix)
5376 .collect::<String>();
5377 assert_eq!(
5378 text_for_range,
5379 &expected_text[start_ix..end_ix],
5380 "incorrect text for range {:?}",
5381 start_ix..end_ix
5382 );
5383
5384 let excerpted_buffer_ranges = multibuffer
5385 .read(cx)
5386 .range_to_buffer_ranges(start_ix..end_ix, cx);
5387 let excerpted_buffers_text = excerpted_buffer_ranges
5388 .iter()
5389 .map(|(buffer, buffer_range, _)| {
5390 buffer
5391 .read(cx)
5392 .text_for_range(buffer_range.clone())
5393 .collect::<String>()
5394 })
5395 .collect::<Vec<_>>()
5396 .join("\n");
5397 assert_eq!(excerpted_buffers_text, text_for_range);
5398 if !expected_excerpts.is_empty() {
5399 assert!(!excerpted_buffer_ranges.is_empty());
5400 }
5401
5402 let expected_summary = TextSummary::from(&expected_text[start_ix..end_ix]);
5403 assert_eq!(
5404 snapshot.text_summary_for_range::<TextSummary, _>(start_ix..end_ix),
5405 expected_summary,
5406 "incorrect summary for range {:?}",
5407 start_ix..end_ix
5408 );
5409 }
5410
5411 // Anchor resolution
5412 let summaries = snapshot.summaries_for_anchors::<usize, _>(&anchors);
5413 assert_eq!(anchors.len(), summaries.len());
5414 for (anchor, resolved_offset) in anchors.iter().zip(summaries) {
5415 assert!(resolved_offset <= snapshot.len());
5416 assert_eq!(
5417 snapshot.summary_for_anchor::<usize>(anchor),
5418 resolved_offset
5419 );
5420 }
5421
5422 for _ in 0..10 {
5423 let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
5424 assert_eq!(
5425 snapshot.reversed_chars_at(end_ix).collect::<String>(),
5426 expected_text[..end_ix].chars().rev().collect::<String>(),
5427 );
5428 }
5429
5430 for _ in 0..10 {
5431 let end_ix = rng.gen_range(0..=text_rope.len());
5432 let start_ix = rng.gen_range(0..=end_ix);
5433 assert_eq!(
5434 snapshot
5435 .bytes_in_range(start_ix..end_ix)
5436 .flatten()
5437 .copied()
5438 .collect::<Vec<_>>(),
5439 expected_text.as_bytes()[start_ix..end_ix].to_vec(),
5440 "bytes_in_range({:?})",
5441 start_ix..end_ix,
5442 );
5443 }
5444 }
5445
5446 let snapshot = multibuffer.read(cx).snapshot(cx);
5447 for (old_snapshot, subscription) in old_versions {
5448 let edits = subscription.consume().into_inner();
5449
5450 log::info!(
5451 "applying subscription edits to old text: {:?}: {:?}",
5452 old_snapshot.text(),
5453 edits,
5454 );
5455
5456 let mut text = old_snapshot.text();
5457 for edit in edits {
5458 let new_text: String = snapshot.text_for_range(edit.new.clone()).collect();
5459 text.replace_range(edit.new.start..edit.new.start + edit.old.len(), &new_text);
5460 }
5461 assert_eq!(text.to_string(), snapshot.text());
5462 }
5463 }
5464
5465 #[gpui::test]
5466 fn test_history(cx: &mut AppContext) {
5467 let test_settings = SettingsStore::test(cx);
5468 cx.set_global(test_settings);
5469
5470 let buffer_1 = cx.new_model(|cx| {
5471 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "1234")
5472 });
5473 let buffer_2 = cx.new_model(|cx| {
5474 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "5678")
5475 });
5476 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
5477 let group_interval = multibuffer.read(cx).history.group_interval;
5478 multibuffer.update(cx, |multibuffer, cx| {
5479 multibuffer.push_excerpts(
5480 buffer_1.clone(),
5481 [ExcerptRange {
5482 context: 0..buffer_1.read(cx).len(),
5483 primary: None,
5484 }],
5485 cx,
5486 );
5487 multibuffer.push_excerpts(
5488 buffer_2.clone(),
5489 [ExcerptRange {
5490 context: 0..buffer_2.read(cx).len(),
5491 primary: None,
5492 }],
5493 cx,
5494 );
5495 });
5496
5497 let mut now = Instant::now();
5498
5499 multibuffer.update(cx, |multibuffer, cx| {
5500 let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();
5501 multibuffer.edit(
5502 [
5503 (Point::new(0, 0)..Point::new(0, 0), "A"),
5504 (Point::new(1, 0)..Point::new(1, 0), "A"),
5505 ],
5506 None,
5507 cx,
5508 );
5509 multibuffer.edit(
5510 [
5511 (Point::new(0, 1)..Point::new(0, 1), "B"),
5512 (Point::new(1, 1)..Point::new(1, 1), "B"),
5513 ],
5514 None,
5515 cx,
5516 );
5517 multibuffer.end_transaction_at(now, cx);
5518 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5519
5520 // Edit buffer 1 through the multibuffer
5521 now += 2 * group_interval;
5522 multibuffer.start_transaction_at(now, cx);
5523 multibuffer.edit([(2..2, "C")], None, cx);
5524 multibuffer.end_transaction_at(now, cx);
5525 assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
5526
5527 // Edit buffer 1 independently
5528 buffer_1.update(cx, |buffer_1, cx| {
5529 buffer_1.start_transaction_at(now);
5530 buffer_1.edit([(3..3, "D")], None, cx);
5531 buffer_1.end_transaction_at(now, cx);
5532
5533 now += 2 * group_interval;
5534 buffer_1.start_transaction_at(now);
5535 buffer_1.edit([(4..4, "E")], None, cx);
5536 buffer_1.end_transaction_at(now, cx);
5537 });
5538 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
5539
5540 // An undo in the multibuffer undoes the multibuffer transaction
5541 // and also any individual buffer edits that have occurred since
5542 // that transaction.
5543 multibuffer.undo(cx);
5544 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5545
5546 multibuffer.undo(cx);
5547 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5548
5549 multibuffer.redo(cx);
5550 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5551
5552 multibuffer.redo(cx);
5553 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
5554
5555 // Undo buffer 2 independently.
5556 buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));
5557 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");
5558
5559 // An undo in the multibuffer undoes the components of the
5560 // the last multibuffer transaction that are not already undone.
5561 multibuffer.undo(cx);
5562 assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");
5563
5564 multibuffer.undo(cx);
5565 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5566
5567 multibuffer.redo(cx);
5568 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5569
5570 buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));
5571 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
5572
5573 // Redo stack gets cleared after an edit.
5574 now += 2 * group_interval;
5575 multibuffer.start_transaction_at(now, cx);
5576 multibuffer.edit([(0..0, "X")], None, cx);
5577 multibuffer.end_transaction_at(now, cx);
5578 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5579 multibuffer.redo(cx);
5580 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5581 multibuffer.undo(cx);
5582 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
5583 multibuffer.undo(cx);
5584 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5585
5586 // Transactions can be grouped manually.
5587 multibuffer.redo(cx);
5588 multibuffer.redo(cx);
5589 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5590 multibuffer.group_until_transaction(transaction_1, cx);
5591 multibuffer.undo(cx);
5592 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5593 multibuffer.redo(cx);
5594 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5595 });
5596 }
5597}