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 /// Returns an anchor for the given excerpt and text anchor,
2792 /// returns None if the excerpt_id is no longer valid.
2793 pub fn anchor_in_excerpt(
2794 &self,
2795 excerpt_id: ExcerptId,
2796 text_anchor: text::Anchor,
2797 ) -> Option<Anchor> {
2798 let locator = self.excerpt_locator_for_id(excerpt_id);
2799 let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
2800 cursor.seek(locator, Bias::Left, &());
2801 if let Some(excerpt) = cursor.item() {
2802 if excerpt.id == excerpt_id {
2803 let text_anchor = excerpt.clip_anchor(text_anchor);
2804 drop(cursor);
2805 return Some(Anchor {
2806 buffer_id: Some(excerpt.buffer_id),
2807 excerpt_id,
2808 text_anchor,
2809 });
2810 }
2811 }
2812 None
2813 }
2814
2815 pub fn can_resolve(&self, anchor: &Anchor) -> bool {
2816 if anchor.excerpt_id == ExcerptId::min() || anchor.excerpt_id == ExcerptId::max() {
2817 true
2818 } else if let Some(excerpt) = self.excerpt(anchor.excerpt_id) {
2819 excerpt.buffer.can_resolve(&anchor.text_anchor)
2820 } else {
2821 false
2822 }
2823 }
2824
2825 pub fn excerpts(
2826 &self,
2827 ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, ExcerptRange<text::Anchor>)> {
2828 self.excerpts
2829 .iter()
2830 .map(|excerpt| (excerpt.id, &excerpt.buffer, excerpt.range.clone()))
2831 }
2832
2833 fn excerpts_for_range<T: ToOffset>(
2834 &self,
2835 range: Range<T>,
2836 ) -> impl Iterator<Item = (&Excerpt, usize)> + '_ {
2837 let range = range.start.to_offset(self)..range.end.to_offset(self);
2838
2839 let mut cursor = self.excerpts.cursor::<usize>();
2840 cursor.seek(&range.start, Bias::Right, &());
2841 cursor.prev(&());
2842
2843 iter::from_fn(move || {
2844 cursor.next(&());
2845 if cursor.start() < &range.end {
2846 cursor.item().map(|item| (item, *cursor.start()))
2847 } else {
2848 None
2849 }
2850 })
2851 }
2852
2853 pub fn excerpt_boundaries_in_range<R, T>(
2854 &self,
2855 range: R,
2856 ) -> impl Iterator<Item = ExcerptBoundary> + '_
2857 where
2858 R: RangeBounds<T>,
2859 T: ToOffset,
2860 {
2861 let start_offset;
2862 let start = match range.start_bound() {
2863 Bound::Included(start) => {
2864 start_offset = start.to_offset(self);
2865 Bound::Included(start_offset)
2866 }
2867 Bound::Excluded(start) => {
2868 start_offset = start.to_offset(self);
2869 Bound::Excluded(start_offset)
2870 }
2871 Bound::Unbounded => {
2872 start_offset = 0;
2873 Bound::Unbounded
2874 }
2875 };
2876 let end = match range.end_bound() {
2877 Bound::Included(end) => Bound::Included(end.to_offset(self)),
2878 Bound::Excluded(end) => Bound::Excluded(end.to_offset(self)),
2879 Bound::Unbounded => Bound::Unbounded,
2880 };
2881 let bounds = (start, end);
2882
2883 let mut cursor = self.excerpts.cursor::<(usize, Point)>();
2884 cursor.seek(&start_offset, Bias::Right, &());
2885 if cursor.item().is_none() {
2886 cursor.prev(&());
2887 }
2888 if !bounds.contains(&cursor.start().0) {
2889 cursor.next(&());
2890 }
2891
2892 let mut prev_buffer_id = cursor.prev_item().map(|excerpt| excerpt.buffer_id);
2893 std::iter::from_fn(move || {
2894 if self.singleton {
2895 None
2896 } else if bounds.contains(&cursor.start().0) {
2897 let excerpt = cursor.item()?;
2898 let starts_new_buffer = Some(excerpt.buffer_id) != prev_buffer_id;
2899 let boundary = ExcerptBoundary {
2900 id: excerpt.id,
2901 row: cursor.start().1.row,
2902 buffer: excerpt.buffer.clone(),
2903 range: excerpt.range.clone(),
2904 starts_new_buffer,
2905 };
2906
2907 prev_buffer_id = Some(excerpt.buffer_id);
2908 cursor.next(&());
2909 Some(boundary)
2910 } else {
2911 None
2912 }
2913 })
2914 }
2915
2916 pub fn edit_count(&self) -> usize {
2917 self.edit_count
2918 }
2919
2920 pub fn parse_count(&self) -> usize {
2921 self.parse_count
2922 }
2923
2924 /// Returns the smallest enclosing bracket ranges containing the given range or
2925 /// None if no brackets contain range or the range is not contained in a single
2926 /// excerpt
2927 ///
2928 /// Can optionally pass a range_filter to filter the ranges of brackets to consider
2929 pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(
2930 &self,
2931 range: Range<T>,
2932 range_filter: Option<&dyn Fn(Range<usize>, Range<usize>) -> bool>,
2933 ) -> Option<(Range<usize>, Range<usize>)> {
2934 let range = range.start.to_offset(self)..range.end.to_offset(self);
2935 let excerpt = self.excerpt_containing(range.clone())?;
2936
2937 // Filter to ranges contained in the excerpt
2938 let range_filter = |open: Range<usize>, close: Range<usize>| -> bool {
2939 excerpt.contains_buffer_range(open.start..close.end)
2940 && range_filter.map_or(true, |filter| {
2941 filter(
2942 excerpt.map_range_from_buffer(open),
2943 excerpt.map_range_from_buffer(close),
2944 )
2945 })
2946 };
2947
2948 let (open, close) = excerpt.buffer().innermost_enclosing_bracket_ranges(
2949 excerpt.map_range_to_buffer(range),
2950 Some(&range_filter),
2951 )?;
2952
2953 Some((
2954 excerpt.map_range_from_buffer(open),
2955 excerpt.map_range_from_buffer(close),
2956 ))
2957 }
2958
2959 /// Returns enclosing bracket ranges containing the given range or returns None if the range is
2960 /// not contained in a single excerpt
2961 pub fn enclosing_bracket_ranges<T: ToOffset>(
2962 &self,
2963 range: Range<T>,
2964 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
2965 let range = range.start.to_offset(self)..range.end.to_offset(self);
2966 let excerpt = self.excerpt_containing(range.clone())?;
2967
2968 Some(
2969 excerpt
2970 .buffer()
2971 .enclosing_bracket_ranges(excerpt.map_range_to_buffer(range))
2972 .filter_map(move |(open, close)| {
2973 if excerpt.contains_buffer_range(open.start..close.end) {
2974 Some((
2975 excerpt.map_range_from_buffer(open),
2976 excerpt.map_range_from_buffer(close),
2977 ))
2978 } else {
2979 None
2980 }
2981 }),
2982 )
2983 }
2984
2985 /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is
2986 /// not contained in a single excerpt
2987 pub fn bracket_ranges<T: ToOffset>(
2988 &self,
2989 range: Range<T>,
2990 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
2991 let range = range.start.to_offset(self)..range.end.to_offset(self);
2992 let excerpt = self.excerpt_containing(range.clone())?;
2993
2994 Some(
2995 excerpt
2996 .buffer()
2997 .bracket_ranges(excerpt.map_range_to_buffer(range))
2998 .filter_map(move |(start_bracket_range, close_bracket_range)| {
2999 let buffer_range = start_bracket_range.start..close_bracket_range.end;
3000 if excerpt.contains_buffer_range(buffer_range) {
3001 Some((
3002 excerpt.map_range_from_buffer(start_bracket_range),
3003 excerpt.map_range_from_buffer(close_bracket_range),
3004 ))
3005 } else {
3006 None
3007 }
3008 }),
3009 )
3010 }
3011
3012 pub fn redacted_ranges<'a, T: ToOffset>(
3013 &'a self,
3014 range: Range<T>,
3015 redaction_enabled: impl Fn(Option<&Arc<dyn File>>) -> bool + 'a,
3016 ) -> impl Iterator<Item = Range<usize>> + 'a {
3017 let range = range.start.to_offset(self)..range.end.to_offset(self);
3018 self.excerpts_for_range(range.clone())
3019 .filter_map(move |(excerpt, excerpt_offset)| {
3020 redaction_enabled(excerpt.buffer.file()).then(move || {
3021 let excerpt_buffer_start =
3022 excerpt.range.context.start.to_offset(&excerpt.buffer);
3023
3024 excerpt
3025 .buffer
3026 .redacted_ranges(excerpt.range.context.clone())
3027 .map(move |mut redacted_range| {
3028 // Re-base onto the excerpts coordinates in the multibuffer
3029 redacted_range.start =
3030 excerpt_offset + (redacted_range.start - excerpt_buffer_start);
3031 redacted_range.end =
3032 excerpt_offset + (redacted_range.end - excerpt_buffer_start);
3033
3034 redacted_range
3035 })
3036 .skip_while(move |redacted_range| redacted_range.end < range.start)
3037 .take_while(move |redacted_range| redacted_range.start < range.end)
3038 })
3039 })
3040 .flatten()
3041 }
3042
3043 pub fn diagnostics_update_count(&self) -> usize {
3044 self.diagnostics_update_count
3045 }
3046
3047 pub fn git_diff_update_count(&self) -> usize {
3048 self.git_diff_update_count
3049 }
3050
3051 pub fn trailing_excerpt_update_count(&self) -> usize {
3052 self.trailing_excerpt_update_count
3053 }
3054
3055 pub fn file_at<T: ToOffset>(&self, point: T) -> Option<&Arc<dyn File>> {
3056 self.point_to_buffer_offset(point)
3057 .and_then(|(buffer, _)| buffer.file())
3058 }
3059
3060 pub fn language_at<T: ToOffset>(&self, point: T) -> Option<&Arc<Language>> {
3061 self.point_to_buffer_offset(point)
3062 .and_then(|(buffer, offset)| buffer.language_at(offset))
3063 }
3064
3065 pub fn settings_at<'a, T: ToOffset>(
3066 &'a self,
3067 point: T,
3068 cx: &'a AppContext,
3069 ) -> &'a LanguageSettings {
3070 let mut language = None;
3071 let mut file = None;
3072 if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
3073 language = buffer.language_at(offset);
3074 file = buffer.file();
3075 }
3076 language_settings(language, file, cx)
3077 }
3078
3079 pub fn language_scope_at<T: ToOffset>(&self, point: T) -> Option<LanguageScope> {
3080 self.point_to_buffer_offset(point)
3081 .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
3082 }
3083
3084 pub fn language_indent_size_at<T: ToOffset>(
3085 &self,
3086 position: T,
3087 cx: &AppContext,
3088 ) -> Option<IndentSize> {
3089 let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
3090 Some(buffer_snapshot.language_indent_size_at(offset, cx))
3091 }
3092
3093 pub fn is_dirty(&self) -> bool {
3094 self.is_dirty
3095 }
3096
3097 pub fn has_conflict(&self) -> bool {
3098 self.has_conflict
3099 }
3100
3101 pub fn has_diagnostics(&self) -> bool {
3102 self.excerpts
3103 .iter()
3104 .any(|excerpt| excerpt.buffer.has_diagnostics())
3105 }
3106
3107 pub fn diagnostic_group<'a, O>(
3108 &'a self,
3109 group_id: usize,
3110 ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
3111 where
3112 O: text::FromAnchor + 'a,
3113 {
3114 self.as_singleton()
3115 .into_iter()
3116 .flat_map(move |(_, _, buffer)| buffer.diagnostic_group(group_id))
3117 }
3118
3119 pub fn diagnostics_in_range<'a, T, O>(
3120 &'a self,
3121 range: Range<T>,
3122 reversed: bool,
3123 ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
3124 where
3125 T: 'a + ToOffset,
3126 O: 'a + text::FromAnchor + Ord,
3127 {
3128 self.as_singleton()
3129 .into_iter()
3130 .flat_map(move |(_, _, buffer)| {
3131 buffer.diagnostics_in_range(
3132 range.start.to_offset(self)..range.end.to_offset(self),
3133 reversed,
3134 )
3135 })
3136 }
3137
3138 pub fn has_git_diffs(&self) -> bool {
3139 for excerpt in self.excerpts.iter() {
3140 if excerpt.buffer.has_git_diff() {
3141 return true;
3142 }
3143 }
3144 false
3145 }
3146
3147 pub fn git_diff_hunks_in_range_rev(
3148 &self,
3149 row_range: Range<u32>,
3150 ) -> impl Iterator<Item = DiffHunk<u32>> + '_ {
3151 let mut cursor = self.excerpts.cursor::<Point>();
3152
3153 cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
3154 if cursor.item().is_none() {
3155 cursor.prev(&());
3156 }
3157
3158 std::iter::from_fn(move || {
3159 let excerpt = cursor.item()?;
3160 let multibuffer_start = *cursor.start();
3161 let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
3162 if multibuffer_start.row >= row_range.end {
3163 return None;
3164 }
3165
3166 let mut buffer_start = excerpt.range.context.start;
3167 let mut buffer_end = excerpt.range.context.end;
3168 let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
3169 let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
3170
3171 if row_range.start > multibuffer_start.row {
3172 let buffer_start_point =
3173 excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
3174 buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
3175 }
3176
3177 if row_range.end < multibuffer_end.row {
3178 let buffer_end_point =
3179 excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
3180 buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
3181 }
3182
3183 let buffer_hunks = excerpt
3184 .buffer
3185 .git_diff_hunks_intersecting_range_rev(buffer_start..buffer_end)
3186 .map(move |hunk| {
3187 let start = multibuffer_start.row
3188 + hunk
3189 .associated_range
3190 .start
3191 .saturating_sub(excerpt_start_point.row);
3192 let end = multibuffer_start.row
3193 + hunk
3194 .associated_range
3195 .end
3196 .min(excerpt_end_point.row + 1)
3197 .saturating_sub(excerpt_start_point.row);
3198
3199 DiffHunk {
3200 associated_range: start..end,
3201 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3202 buffer_range: hunk.buffer_range.clone(),
3203 buffer_id: hunk.buffer_id,
3204 }
3205 });
3206
3207 cursor.prev(&());
3208
3209 Some(buffer_hunks)
3210 })
3211 .flatten()
3212 }
3213
3214 pub fn git_diff_hunks_in_range(
3215 &self,
3216 row_range: Range<u32>,
3217 ) -> impl Iterator<Item = DiffHunk<u32>> + '_ {
3218 let mut cursor = self.excerpts.cursor::<Point>();
3219
3220 cursor.seek(&Point::new(row_range.start, 0), Bias::Left, &());
3221
3222 std::iter::from_fn(move || {
3223 let excerpt = cursor.item()?;
3224 let multibuffer_start = *cursor.start();
3225 let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
3226 let mut buffer_start = excerpt.range.context.start;
3227 let mut buffer_end = excerpt.range.context.end;
3228
3229 let excerpt_rows = match multibuffer_start.row.cmp(&row_range.end) {
3230 cmp::Ordering::Less => {
3231 let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
3232 let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
3233
3234 if row_range.start > multibuffer_start.row {
3235 let buffer_start_point = excerpt_start_point
3236 + Point::new(row_range.start - multibuffer_start.row, 0);
3237 buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
3238 }
3239
3240 if row_range.end < multibuffer_end.row {
3241 let buffer_end_point = excerpt_start_point
3242 + Point::new(row_range.end - multibuffer_start.row, 0);
3243 buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
3244 }
3245 excerpt_start_point.row..excerpt_end_point.row
3246 }
3247 cmp::Ordering::Equal if row_range.end == 0 => {
3248 buffer_end = buffer_start;
3249 0..0
3250 }
3251 cmp::Ordering::Greater | cmp::Ordering::Equal => return None,
3252 };
3253
3254 let buffer_hunks = excerpt
3255 .buffer
3256 .git_diff_hunks_intersecting_range(buffer_start..buffer_end)
3257 .map(move |hunk| {
3258 let buffer_range = if excerpt_rows.start == 0 && excerpt_rows.end == 0 {
3259 0..1
3260 } else {
3261 let start = multibuffer_start.row
3262 + hunk
3263 .associated_range
3264 .start
3265 .saturating_sub(excerpt_rows.start);
3266 let end = multibuffer_start.row
3267 + hunk
3268 .associated_range
3269 .end
3270 .min(excerpt_rows.end + 1)
3271 .saturating_sub(excerpt_rows.start);
3272 start..end
3273 };
3274 DiffHunk {
3275 associated_range: buffer_range,
3276 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3277 buffer_range: hunk.buffer_range.clone(),
3278 buffer_id: hunk.buffer_id,
3279 }
3280 });
3281
3282 cursor.next(&());
3283
3284 Some(buffer_hunks)
3285 })
3286 .flatten()
3287 }
3288
3289 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
3290 let range = range.start.to_offset(self)..range.end.to_offset(self);
3291 let excerpt = self.excerpt_containing(range.clone())?;
3292
3293 let ancestor_buffer_range = excerpt
3294 .buffer()
3295 .range_for_syntax_ancestor(excerpt.map_range_to_buffer(range))?;
3296
3297 Some(excerpt.map_range_from_buffer(ancestor_buffer_range))
3298 }
3299
3300 pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
3301 let (excerpt_id, _, buffer) = self.as_singleton()?;
3302 let outline = buffer.outline(theme)?;
3303 Some(Outline::new(
3304 outline
3305 .items
3306 .into_iter()
3307 .flat_map(|item| {
3308 Some(OutlineItem {
3309 depth: item.depth,
3310 range: self.anchor_in_excerpt(*excerpt_id, item.range.start)?
3311 ..self.anchor_in_excerpt(*excerpt_id, item.range.end)?,
3312 text: item.text,
3313 highlight_ranges: item.highlight_ranges,
3314 name_ranges: item.name_ranges,
3315 })
3316 })
3317 .collect(),
3318 ))
3319 }
3320
3321 pub fn symbols_containing<T: ToOffset>(
3322 &self,
3323 offset: T,
3324 theme: Option<&SyntaxTheme>,
3325 ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
3326 let anchor = self.anchor_before(offset);
3327 let excerpt_id = anchor.excerpt_id;
3328 let excerpt = self.excerpt(excerpt_id)?;
3329 Some((
3330 excerpt.buffer_id,
3331 excerpt
3332 .buffer
3333 .symbols_containing(anchor.text_anchor, theme)
3334 .into_iter()
3335 .flatten()
3336 .flat_map(|item| {
3337 Some(OutlineItem {
3338 depth: item.depth,
3339 range: self.anchor_in_excerpt(excerpt_id, item.range.start)?
3340 ..self.anchor_in_excerpt(excerpt_id, item.range.end)?,
3341 text: item.text,
3342 highlight_ranges: item.highlight_ranges,
3343 name_ranges: item.name_ranges,
3344 })
3345 })
3346 .collect(),
3347 ))
3348 }
3349
3350 fn excerpt_locator_for_id(&self, id: ExcerptId) -> &Locator {
3351 if id == ExcerptId::min() {
3352 Locator::min_ref()
3353 } else if id == ExcerptId::max() {
3354 Locator::max_ref()
3355 } else {
3356 let mut cursor = self.excerpt_ids.cursor::<ExcerptId>();
3357 cursor.seek(&id, Bias::Left, &());
3358 if let Some(entry) = cursor.item() {
3359 if entry.id == id {
3360 return &entry.locator;
3361 }
3362 }
3363 panic!("invalid excerpt id {:?}", id)
3364 }
3365 }
3366
3367 pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<BufferId> {
3368 Some(self.excerpt(excerpt_id)?.buffer_id)
3369 }
3370
3371 pub fn buffer_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<&BufferSnapshot> {
3372 Some(&self.excerpt(excerpt_id)?.buffer)
3373 }
3374
3375 fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
3376 let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
3377 let locator = self.excerpt_locator_for_id(excerpt_id);
3378 cursor.seek(&Some(locator), Bias::Left, &());
3379 if let Some(excerpt) = cursor.item() {
3380 if excerpt.id == excerpt_id {
3381 return Some(excerpt);
3382 }
3383 }
3384 None
3385 }
3386
3387 /// Returns the excerpt containing range and its offset start within the multibuffer or none if `range` spans multiple excerpts
3388 pub fn excerpt_containing<T: ToOffset>(&self, range: Range<T>) -> Option<MultiBufferExcerpt> {
3389 let range = range.start.to_offset(self)..range.end.to_offset(self);
3390
3391 let mut cursor = self.excerpts.cursor::<usize>();
3392 cursor.seek(&range.start, Bias::Right, &());
3393 let start_excerpt = cursor.item()?;
3394
3395 if range.start == range.end {
3396 return Some(MultiBufferExcerpt::new(start_excerpt, *cursor.start()));
3397 }
3398
3399 cursor.seek(&range.end, Bias::Right, &());
3400 let end_excerpt = cursor.item()?;
3401
3402 if start_excerpt.id != end_excerpt.id {
3403 None
3404 } else {
3405 Some(MultiBufferExcerpt::new(start_excerpt, *cursor.start()))
3406 }
3407 }
3408
3409 pub fn remote_selections_in_range<'a>(
3410 &'a self,
3411 range: &'a Range<Anchor>,
3412 ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
3413 let mut cursor = self.excerpts.cursor::<ExcerptSummary>();
3414 let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
3415 let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
3416 cursor.seek(start_locator, Bias::Left, &());
3417 cursor
3418 .take_while(move |excerpt| excerpt.locator <= *end_locator)
3419 .flat_map(move |excerpt| {
3420 let mut query_range = excerpt.range.context.start..excerpt.range.context.end;
3421 if excerpt.id == range.start.excerpt_id {
3422 query_range.start = range.start.text_anchor;
3423 }
3424 if excerpt.id == range.end.excerpt_id {
3425 query_range.end = range.end.text_anchor;
3426 }
3427
3428 excerpt
3429 .buffer
3430 .remote_selections_in_range(query_range)
3431 .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
3432 selections.map(move |selection| {
3433 let mut start = Anchor {
3434 buffer_id: Some(excerpt.buffer_id),
3435 excerpt_id: excerpt.id,
3436 text_anchor: selection.start,
3437 };
3438 let mut end = Anchor {
3439 buffer_id: Some(excerpt.buffer_id),
3440 excerpt_id: excerpt.id,
3441 text_anchor: selection.end,
3442 };
3443 if range.start.cmp(&start, self).is_gt() {
3444 start = range.start;
3445 }
3446 if range.end.cmp(&end, self).is_lt() {
3447 end = range.end;
3448 }
3449
3450 (
3451 replica_id,
3452 line_mode,
3453 cursor_shape,
3454 Selection {
3455 id: selection.id,
3456 start,
3457 end,
3458 reversed: selection.reversed,
3459 goal: selection.goal,
3460 },
3461 )
3462 })
3463 })
3464 })
3465 }
3466}
3467
3468#[cfg(any(test, feature = "test-support"))]
3469impl MultiBufferSnapshot {
3470 pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
3471 let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
3472 let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
3473 start..end
3474 }
3475}
3476
3477impl History {
3478 fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {
3479 self.transaction_depth += 1;
3480 if self.transaction_depth == 1 {
3481 let id = self.next_transaction_id.tick();
3482 self.undo_stack.push(Transaction {
3483 id,
3484 buffer_transactions: Default::default(),
3485 first_edit_at: now,
3486 last_edit_at: now,
3487 suppress_grouping: false,
3488 });
3489 Some(id)
3490 } else {
3491 None
3492 }
3493 }
3494
3495 fn end_transaction(
3496 &mut self,
3497 now: Instant,
3498 buffer_transactions: HashMap<BufferId, TransactionId>,
3499 ) -> bool {
3500 assert_ne!(self.transaction_depth, 0);
3501 self.transaction_depth -= 1;
3502 if self.transaction_depth == 0 {
3503 if buffer_transactions.is_empty() {
3504 self.undo_stack.pop();
3505 false
3506 } else {
3507 self.redo_stack.clear();
3508 let transaction = self.undo_stack.last_mut().unwrap();
3509 transaction.last_edit_at = now;
3510 for (buffer_id, transaction_id) in buffer_transactions {
3511 transaction
3512 .buffer_transactions
3513 .entry(buffer_id)
3514 .or_insert(transaction_id);
3515 }
3516 true
3517 }
3518 } else {
3519 false
3520 }
3521 }
3522
3523 fn push_transaction<'a, T>(
3524 &mut self,
3525 buffer_transactions: T,
3526 now: Instant,
3527 cx: &mut ModelContext<MultiBuffer>,
3528 ) where
3529 T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
3530 {
3531 assert_eq!(self.transaction_depth, 0);
3532 let transaction = Transaction {
3533 id: self.next_transaction_id.tick(),
3534 buffer_transactions: buffer_transactions
3535 .into_iter()
3536 .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
3537 .collect(),
3538 first_edit_at: now,
3539 last_edit_at: now,
3540 suppress_grouping: false,
3541 };
3542 if !transaction.buffer_transactions.is_empty() {
3543 self.undo_stack.push(transaction);
3544 self.redo_stack.clear();
3545 }
3546 }
3547
3548 fn finalize_last_transaction(&mut self) {
3549 if let Some(transaction) = self.undo_stack.last_mut() {
3550 transaction.suppress_grouping = true;
3551 }
3552 }
3553
3554 fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {
3555 if let Some(ix) = self
3556 .undo_stack
3557 .iter()
3558 .rposition(|transaction| transaction.id == transaction_id)
3559 {
3560 Some(self.undo_stack.remove(ix))
3561 } else if let Some(ix) = self
3562 .redo_stack
3563 .iter()
3564 .rposition(|transaction| transaction.id == transaction_id)
3565 {
3566 Some(self.redo_stack.remove(ix))
3567 } else {
3568 None
3569 }
3570 }
3571
3572 fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {
3573 self.undo_stack
3574 .iter_mut()
3575 .find(|transaction| transaction.id == transaction_id)
3576 .or_else(|| {
3577 self.redo_stack
3578 .iter_mut()
3579 .find(|transaction| transaction.id == transaction_id)
3580 })
3581 }
3582
3583 fn pop_undo(&mut self) -> Option<&mut Transaction> {
3584 assert_eq!(self.transaction_depth, 0);
3585 if let Some(transaction) = self.undo_stack.pop() {
3586 self.redo_stack.push(transaction);
3587 self.redo_stack.last_mut()
3588 } else {
3589 None
3590 }
3591 }
3592
3593 fn pop_redo(&mut self) -> Option<&mut Transaction> {
3594 assert_eq!(self.transaction_depth, 0);
3595 if let Some(transaction) = self.redo_stack.pop() {
3596 self.undo_stack.push(transaction);
3597 self.undo_stack.last_mut()
3598 } else {
3599 None
3600 }
3601 }
3602
3603 fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {
3604 let ix = self
3605 .undo_stack
3606 .iter()
3607 .rposition(|transaction| transaction.id == transaction_id)?;
3608 let transaction = self.undo_stack.remove(ix);
3609 self.redo_stack.push(transaction);
3610 self.redo_stack.last()
3611 }
3612
3613 fn group(&mut self) -> Option<TransactionId> {
3614 let mut count = 0;
3615 let mut transactions = self.undo_stack.iter();
3616 if let Some(mut transaction) = transactions.next_back() {
3617 while let Some(prev_transaction) = transactions.next_back() {
3618 if !prev_transaction.suppress_grouping
3619 && transaction.first_edit_at - prev_transaction.last_edit_at
3620 <= self.group_interval
3621 {
3622 transaction = prev_transaction;
3623 count += 1;
3624 } else {
3625 break;
3626 }
3627 }
3628 }
3629 self.group_trailing(count)
3630 }
3631
3632 fn group_until(&mut self, transaction_id: TransactionId) {
3633 let mut count = 0;
3634 for transaction in self.undo_stack.iter().rev() {
3635 if transaction.id == transaction_id {
3636 self.group_trailing(count);
3637 break;
3638 } else if transaction.suppress_grouping {
3639 break;
3640 } else {
3641 count += 1;
3642 }
3643 }
3644 }
3645
3646 fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {
3647 let new_len = self.undo_stack.len() - n;
3648 let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);
3649 if let Some(last_transaction) = transactions_to_keep.last_mut() {
3650 if let Some(transaction) = transactions_to_merge.last() {
3651 last_transaction.last_edit_at = transaction.last_edit_at;
3652 }
3653 for to_merge in transactions_to_merge {
3654 for (buffer_id, transaction_id) in &to_merge.buffer_transactions {
3655 last_transaction
3656 .buffer_transactions
3657 .entry(*buffer_id)
3658 .or_insert(*transaction_id);
3659 }
3660 }
3661 }
3662
3663 self.undo_stack.truncate(new_len);
3664 self.undo_stack.last().map(|t| t.id)
3665 }
3666}
3667
3668impl Excerpt {
3669 fn new(
3670 id: ExcerptId,
3671 locator: Locator,
3672 buffer_id: BufferId,
3673 buffer: BufferSnapshot,
3674 range: ExcerptRange<text::Anchor>,
3675 has_trailing_newline: bool,
3676 ) -> Self {
3677 Excerpt {
3678 id,
3679 locator,
3680 max_buffer_row: range.context.end.to_point(&buffer).row,
3681 text_summary: buffer
3682 .text_summary_for_range::<TextSummary, _>(range.context.to_offset(&buffer)),
3683 buffer_id,
3684 buffer,
3685 range,
3686 has_trailing_newline,
3687 }
3688 }
3689
3690 fn chunks_in_range(&self, range: Range<usize>, language_aware: bool) -> ExcerptChunks {
3691 let content_start = self.range.context.start.to_offset(&self.buffer);
3692 let chunks_start = content_start + range.start;
3693 let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
3694
3695 let footer_height = if self.has_trailing_newline
3696 && range.start <= self.text_summary.len
3697 && range.end > self.text_summary.len
3698 {
3699 1
3700 } else {
3701 0
3702 };
3703
3704 let content_chunks = self.buffer.chunks(chunks_start..chunks_end, language_aware);
3705
3706 ExcerptChunks {
3707 content_chunks,
3708 footer_height,
3709 }
3710 }
3711
3712 fn bytes_in_range(&self, range: Range<usize>) -> ExcerptBytes {
3713 let content_start = self.range.context.start.to_offset(&self.buffer);
3714 let bytes_start = content_start + range.start;
3715 let bytes_end = content_start + cmp::min(range.end, self.text_summary.len);
3716 let footer_height = if self.has_trailing_newline
3717 && range.start <= self.text_summary.len
3718 && range.end > self.text_summary.len
3719 {
3720 1
3721 } else {
3722 0
3723 };
3724 let content_bytes = self.buffer.bytes_in_range(bytes_start..bytes_end);
3725
3726 ExcerptBytes {
3727 content_bytes,
3728 footer_height,
3729 }
3730 }
3731
3732 fn reversed_bytes_in_range(&self, range: Range<usize>) -> ExcerptBytes {
3733 let content_start = self.range.context.start.to_offset(&self.buffer);
3734 let bytes_start = content_start + range.start;
3735 let bytes_end = content_start + cmp::min(range.end, self.text_summary.len);
3736 let footer_height = if self.has_trailing_newline
3737 && range.start <= self.text_summary.len
3738 && range.end > self.text_summary.len
3739 {
3740 1
3741 } else {
3742 0
3743 };
3744 let content_bytes = self.buffer.reversed_bytes_in_range(bytes_start..bytes_end);
3745
3746 ExcerptBytes {
3747 content_bytes,
3748 footer_height,
3749 }
3750 }
3751
3752 fn clip_anchor(&self, text_anchor: text::Anchor) -> text::Anchor {
3753 if text_anchor
3754 .cmp(&self.range.context.start, &self.buffer)
3755 .is_lt()
3756 {
3757 self.range.context.start
3758 } else if text_anchor
3759 .cmp(&self.range.context.end, &self.buffer)
3760 .is_gt()
3761 {
3762 self.range.context.end
3763 } else {
3764 text_anchor
3765 }
3766 }
3767
3768 fn contains(&self, anchor: &Anchor) -> bool {
3769 Some(self.buffer_id) == anchor.buffer_id
3770 && self
3771 .range
3772 .context
3773 .start
3774 .cmp(&anchor.text_anchor, &self.buffer)
3775 .is_le()
3776 && self
3777 .range
3778 .context
3779 .end
3780 .cmp(&anchor.text_anchor, &self.buffer)
3781 .is_ge()
3782 }
3783
3784 /// The [`Excerpt`]'s start offset in its [`Buffer`]
3785 fn buffer_start_offset(&self) -> usize {
3786 self.range.context.start.to_offset(&self.buffer)
3787 }
3788
3789 /// The [`Excerpt`]'s end offset in its [`Buffer`]
3790 fn buffer_end_offset(&self) -> usize {
3791 self.buffer_start_offset() + self.text_summary.len
3792 }
3793}
3794
3795impl<'a> MultiBufferExcerpt<'a> {
3796 fn new(excerpt: &'a Excerpt, excerpt_offset: usize) -> Self {
3797 MultiBufferExcerpt {
3798 excerpt,
3799 excerpt_offset,
3800 }
3801 }
3802
3803 pub fn buffer(&self) -> &'a BufferSnapshot {
3804 &self.excerpt.buffer
3805 }
3806
3807 /// Maps an offset within the [`MultiBuffer`] to an offset within the [`Buffer`]
3808 pub fn map_offset_to_buffer(&self, offset: usize) -> usize {
3809 self.excerpt.buffer_start_offset() + offset.saturating_sub(self.excerpt_offset)
3810 }
3811
3812 /// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`]
3813 pub fn map_range_to_buffer(&self, range: Range<usize>) -> Range<usize> {
3814 self.map_offset_to_buffer(range.start)..self.map_offset_to_buffer(range.end)
3815 }
3816
3817 /// Map an offset within the [`Buffer`] to an offset within the [`MultiBuffer`]
3818 pub fn map_offset_from_buffer(&self, buffer_offset: usize) -> usize {
3819 let mut buffer_offset_in_excerpt =
3820 buffer_offset.saturating_sub(self.excerpt.buffer_start_offset());
3821 buffer_offset_in_excerpt =
3822 cmp::min(buffer_offset_in_excerpt, self.excerpt.text_summary.len);
3823
3824 self.excerpt_offset + buffer_offset_in_excerpt
3825 }
3826
3827 /// Map a range within the [`Buffer`] to a range within the [`MultiBuffer`]
3828 pub fn map_range_from_buffer(&self, buffer_range: Range<usize>) -> Range<usize> {
3829 self.map_offset_from_buffer(buffer_range.start)
3830 ..self.map_offset_from_buffer(buffer_range.end)
3831 }
3832
3833 /// Returns true if the entirety of the given range is in the buffer's excerpt
3834 pub fn contains_buffer_range(&self, range: Range<usize>) -> bool {
3835 range.start >= self.excerpt.buffer_start_offset()
3836 && range.end <= self.excerpt.buffer_end_offset()
3837 }
3838}
3839
3840impl ExcerptId {
3841 pub fn min() -> Self {
3842 Self(0)
3843 }
3844
3845 pub fn max() -> Self {
3846 Self(usize::MAX)
3847 }
3848
3849 pub fn to_proto(&self) -> u64 {
3850 self.0 as _
3851 }
3852
3853 pub fn from_proto(proto: u64) -> Self {
3854 Self(proto as _)
3855 }
3856
3857 pub fn cmp(&self, other: &Self, snapshot: &MultiBufferSnapshot) -> cmp::Ordering {
3858 let a = snapshot.excerpt_locator_for_id(*self);
3859 let b = snapshot.excerpt_locator_for_id(*other);
3860 a.cmp(b).then_with(|| self.0.cmp(&other.0))
3861 }
3862}
3863
3864impl Into<usize> for ExcerptId {
3865 fn into(self) -> usize {
3866 self.0
3867 }
3868}
3869
3870impl fmt::Debug for Excerpt {
3871 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3872 f.debug_struct("Excerpt")
3873 .field("id", &self.id)
3874 .field("locator", &self.locator)
3875 .field("buffer_id", &self.buffer_id)
3876 .field("range", &self.range)
3877 .field("text_summary", &self.text_summary)
3878 .field("has_trailing_newline", &self.has_trailing_newline)
3879 .finish()
3880 }
3881}
3882
3883impl sum_tree::Item for Excerpt {
3884 type Summary = ExcerptSummary;
3885
3886 fn summary(&self) -> Self::Summary {
3887 let mut text = self.text_summary.clone();
3888 if self.has_trailing_newline {
3889 text += TextSummary::from("\n");
3890 }
3891 ExcerptSummary {
3892 excerpt_id: self.id,
3893 excerpt_locator: self.locator.clone(),
3894 max_buffer_row: self.max_buffer_row,
3895 text,
3896 }
3897 }
3898}
3899
3900impl sum_tree::Item for ExcerptIdMapping {
3901 type Summary = ExcerptId;
3902
3903 fn summary(&self) -> Self::Summary {
3904 self.id
3905 }
3906}
3907
3908impl sum_tree::KeyedItem for ExcerptIdMapping {
3909 type Key = ExcerptId;
3910
3911 fn key(&self) -> Self::Key {
3912 self.id
3913 }
3914}
3915
3916impl sum_tree::Summary for ExcerptId {
3917 type Context = ();
3918
3919 fn add_summary(&mut self, other: &Self, _: &()) {
3920 *self = *other;
3921 }
3922}
3923
3924impl sum_tree::Summary for ExcerptSummary {
3925 type Context = ();
3926
3927 fn add_summary(&mut self, summary: &Self, _: &()) {
3928 debug_assert!(summary.excerpt_locator > self.excerpt_locator);
3929 self.excerpt_locator = summary.excerpt_locator.clone();
3930 self.text.add_summary(&summary.text, &());
3931 self.max_buffer_row = cmp::max(self.max_buffer_row, summary.max_buffer_row);
3932 }
3933}
3934
3935impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for TextSummary {
3936 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3937 *self += &summary.text;
3938 }
3939}
3940
3941impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for usize {
3942 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3943 *self += summary.text.len;
3944 }
3945}
3946
3947impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, ExcerptSummary> for usize {
3948 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
3949 Ord::cmp(self, &cursor_location.text.len)
3950 }
3951}
3952
3953impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, Option<&'a Locator>> for Locator {
3954 fn cmp(&self, cursor_location: &Option<&'a Locator>, _: &()) -> cmp::Ordering {
3955 Ord::cmp(&Some(self), cursor_location)
3956 }
3957}
3958
3959impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, ExcerptSummary> for Locator {
3960 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
3961 Ord::cmp(self, &cursor_location.excerpt_locator)
3962 }
3963}
3964
3965impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for OffsetUtf16 {
3966 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3967 *self += summary.text.len_utf16;
3968 }
3969}
3970
3971impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Point {
3972 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3973 *self += summary.text.lines;
3974 }
3975}
3976
3977impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for PointUtf16 {
3978 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3979 *self += summary.text.lines_utf16()
3980 }
3981}
3982
3983impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<&'a Locator> {
3984 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3985 *self = Some(&summary.excerpt_locator);
3986 }
3987}
3988
3989impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<ExcerptId> {
3990 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
3991 *self = Some(summary.excerpt_id);
3992 }
3993}
3994
3995impl<'a> MultiBufferRows<'a> {
3996 pub fn seek(&mut self, row: u32) {
3997 self.buffer_row_range = 0..0;
3998
3999 self.excerpts
4000 .seek_forward(&Point::new(row, 0), Bias::Right, &());
4001 if self.excerpts.item().is_none() {
4002 self.excerpts.prev(&());
4003
4004 if self.excerpts.item().is_none() && row == 0 {
4005 self.buffer_row_range = 0..1;
4006 return;
4007 }
4008 }
4009
4010 if let Some(excerpt) = self.excerpts.item() {
4011 let overshoot = row - self.excerpts.start().row;
4012 let excerpt_start = excerpt.range.context.start.to_point(&excerpt.buffer).row;
4013 self.buffer_row_range.start = excerpt_start + overshoot;
4014 self.buffer_row_range.end = excerpt_start + excerpt.text_summary.lines.row + 1;
4015 }
4016 }
4017}
4018
4019impl<'a> Iterator for MultiBufferRows<'a> {
4020 type Item = Option<u32>;
4021
4022 fn next(&mut self) -> Option<Self::Item> {
4023 loop {
4024 if !self.buffer_row_range.is_empty() {
4025 let row = Some(self.buffer_row_range.start);
4026 self.buffer_row_range.start += 1;
4027 return Some(row);
4028 }
4029 self.excerpts.item()?;
4030 self.excerpts.next(&());
4031 let excerpt = self.excerpts.item()?;
4032 self.buffer_row_range.start = excerpt.range.context.start.to_point(&excerpt.buffer).row;
4033 self.buffer_row_range.end =
4034 self.buffer_row_range.start + excerpt.text_summary.lines.row + 1;
4035 }
4036 }
4037}
4038
4039impl<'a> MultiBufferChunks<'a> {
4040 pub fn offset(&self) -> usize {
4041 self.range.start
4042 }
4043
4044 pub fn seek(&mut self, offset: usize) {
4045 self.range.start = offset;
4046 self.excerpts.seek(&offset, Bias::Right, &());
4047 if let Some(excerpt) = self.excerpts.item() {
4048 self.excerpt_chunks = Some(excerpt.chunks_in_range(
4049 self.range.start - self.excerpts.start()..self.range.end - self.excerpts.start(),
4050 self.language_aware,
4051 ));
4052 } else {
4053 self.excerpt_chunks = None;
4054 }
4055 }
4056}
4057
4058impl<'a> Iterator for MultiBufferChunks<'a> {
4059 type Item = Chunk<'a>;
4060
4061 fn next(&mut self) -> Option<Self::Item> {
4062 if self.range.is_empty() {
4063 None
4064 } else if let Some(chunk) = self.excerpt_chunks.as_mut()?.next() {
4065 self.range.start += chunk.text.len();
4066 Some(chunk)
4067 } else {
4068 self.excerpts.next(&());
4069 let excerpt = self.excerpts.item()?;
4070 self.excerpt_chunks = Some(excerpt.chunks_in_range(
4071 0..self.range.end - self.excerpts.start(),
4072 self.language_aware,
4073 ));
4074 self.next()
4075 }
4076 }
4077}
4078
4079impl<'a> MultiBufferBytes<'a> {
4080 fn consume(&mut self, len: usize) {
4081 self.range.start += len;
4082 self.chunk = &self.chunk[len..];
4083
4084 if !self.range.is_empty() && self.chunk.is_empty() {
4085 if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
4086 self.chunk = chunk;
4087 } else {
4088 self.excerpts.next(&());
4089 if let Some(excerpt) = self.excerpts.item() {
4090 let mut excerpt_bytes =
4091 excerpt.bytes_in_range(0..self.range.end - self.excerpts.start());
4092 self.chunk = excerpt_bytes.next().unwrap();
4093 self.excerpt_bytes = Some(excerpt_bytes);
4094 }
4095 }
4096 }
4097 }
4098}
4099
4100impl<'a> Iterator for MultiBufferBytes<'a> {
4101 type Item = &'a [u8];
4102
4103 fn next(&mut self) -> Option<Self::Item> {
4104 let chunk = self.chunk;
4105 if chunk.is_empty() {
4106 None
4107 } else {
4108 self.consume(chunk.len());
4109 Some(chunk)
4110 }
4111 }
4112}
4113
4114impl<'a> io::Read for MultiBufferBytes<'a> {
4115 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
4116 let len = cmp::min(buf.len(), self.chunk.len());
4117 buf[..len].copy_from_slice(&self.chunk[..len]);
4118 if len > 0 {
4119 self.consume(len);
4120 }
4121 Ok(len)
4122 }
4123}
4124
4125impl<'a> ReversedMultiBufferBytes<'a> {
4126 fn consume(&mut self, len: usize) {
4127 self.range.end -= len;
4128 self.chunk = &self.chunk[..self.chunk.len() - len];
4129
4130 if !self.range.is_empty() && self.chunk.is_empty() {
4131 if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
4132 self.chunk = chunk;
4133 } else {
4134 self.excerpts.next(&());
4135 if let Some(excerpt) = self.excerpts.item() {
4136 let mut excerpt_bytes =
4137 excerpt.bytes_in_range(0..self.range.end - self.excerpts.start());
4138 self.chunk = excerpt_bytes.next().unwrap();
4139 self.excerpt_bytes = Some(excerpt_bytes);
4140 }
4141 }
4142 }
4143 }
4144}
4145
4146impl<'a> io::Read for ReversedMultiBufferBytes<'a> {
4147 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
4148 let len = cmp::min(buf.len(), self.chunk.len());
4149 buf[..len].copy_from_slice(&self.chunk[..len]);
4150 buf[..len].reverse();
4151 if len > 0 {
4152 self.consume(len);
4153 }
4154 Ok(len)
4155 }
4156}
4157impl<'a> Iterator for ExcerptBytes<'a> {
4158 type Item = &'a [u8];
4159
4160 fn next(&mut self) -> Option<Self::Item> {
4161 if let Some(chunk) = self.content_bytes.next() {
4162 if !chunk.is_empty() {
4163 return Some(chunk);
4164 }
4165 }
4166
4167 if self.footer_height > 0 {
4168 let result = &NEWLINES[..self.footer_height];
4169 self.footer_height = 0;
4170 return Some(result);
4171 }
4172
4173 None
4174 }
4175}
4176
4177impl<'a> Iterator for ExcerptChunks<'a> {
4178 type Item = Chunk<'a>;
4179
4180 fn next(&mut self) -> Option<Self::Item> {
4181 if let Some(chunk) = self.content_chunks.next() {
4182 return Some(chunk);
4183 }
4184
4185 if self.footer_height > 0 {
4186 let text = unsafe { str::from_utf8_unchecked(&NEWLINES[..self.footer_height]) };
4187 self.footer_height = 0;
4188 return Some(Chunk {
4189 text,
4190 ..Default::default()
4191 });
4192 }
4193
4194 None
4195 }
4196}
4197
4198impl ToOffset for Point {
4199 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4200 snapshot.point_to_offset(*self)
4201 }
4202}
4203
4204impl ToOffset for usize {
4205 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4206 assert!(*self <= snapshot.len(), "offset is out of range");
4207 *self
4208 }
4209}
4210
4211impl ToOffset for OffsetUtf16 {
4212 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4213 snapshot.offset_utf16_to_offset(*self)
4214 }
4215}
4216
4217impl ToOffset for PointUtf16 {
4218 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
4219 snapshot.point_utf16_to_offset(*self)
4220 }
4221}
4222
4223impl ToOffsetUtf16 for OffsetUtf16 {
4224 fn to_offset_utf16(&self, _snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
4225 *self
4226 }
4227}
4228
4229impl ToOffsetUtf16 for usize {
4230 fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
4231 snapshot.offset_to_offset_utf16(*self)
4232 }
4233}
4234
4235impl ToPoint for usize {
4236 fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {
4237 snapshot.offset_to_point(*self)
4238 }
4239}
4240
4241impl ToPoint for Point {
4242 fn to_point<'a>(&self, _: &MultiBufferSnapshot) -> Point {
4243 *self
4244 }
4245}
4246
4247impl ToPointUtf16 for usize {
4248 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
4249 snapshot.offset_to_point_utf16(*self)
4250 }
4251}
4252
4253impl ToPointUtf16 for Point {
4254 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
4255 snapshot.point_to_point_utf16(*self)
4256 }
4257}
4258
4259impl ToPointUtf16 for PointUtf16 {
4260 fn to_point_utf16<'a>(&self, _: &MultiBufferSnapshot) -> PointUtf16 {
4261 *self
4262 }
4263}
4264
4265fn build_excerpt_ranges<T>(
4266 buffer: &BufferSnapshot,
4267 ranges: &[Range<T>],
4268 context_line_count: u32,
4269) -> (Vec<ExcerptRange<Point>>, Vec<usize>)
4270where
4271 T: text::ToPoint,
4272{
4273 let max_point = buffer.max_point();
4274 let mut range_counts = Vec::new();
4275 let mut excerpt_ranges = Vec::new();
4276 let mut range_iter = ranges
4277 .iter()
4278 .map(|range| range.start.to_point(buffer)..range.end.to_point(buffer))
4279 .peekable();
4280 while let Some(range) = range_iter.next() {
4281 let excerpt_start = Point::new(range.start.row.saturating_sub(context_line_count), 0);
4282 let mut excerpt_end = Point::new(range.end.row + 1 + context_line_count, 0).min(max_point);
4283 let mut ranges_in_excerpt = 1;
4284
4285 while let Some(next_range) = range_iter.peek() {
4286 if next_range.start.row <= excerpt_end.row + context_line_count {
4287 excerpt_end =
4288 Point::new(next_range.end.row + 1 + context_line_count, 0).min(max_point);
4289 ranges_in_excerpt += 1;
4290 range_iter.next();
4291 } else {
4292 break;
4293 }
4294 }
4295
4296 excerpt_ranges.push(ExcerptRange {
4297 context: excerpt_start..excerpt_end,
4298 primary: Some(range),
4299 });
4300 range_counts.push(ranges_in_excerpt);
4301 }
4302
4303 (excerpt_ranges, range_counts)
4304}
4305
4306#[cfg(test)]
4307mod tests {
4308 use super::*;
4309 use futures::StreamExt;
4310 use gpui::{AppContext, Context, TestAppContext};
4311 use language::{Buffer, Rope};
4312 use parking_lot::RwLock;
4313 use rand::prelude::*;
4314 use settings::SettingsStore;
4315 use std::env;
4316 use util::test::sample_text;
4317
4318 #[gpui::test]
4319 fn test_singleton(cx: &mut AppContext) {
4320 let buffer = cx.new_model(|cx| {
4321 Buffer::new(
4322 0,
4323 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4324 sample_text(6, 6, 'a'),
4325 )
4326 });
4327 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4328
4329 let snapshot = multibuffer.read(cx).snapshot(cx);
4330 assert_eq!(snapshot.text(), buffer.read(cx).text());
4331
4332 assert_eq!(
4333 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4334 (0..buffer.read(cx).row_count())
4335 .map(Some)
4336 .collect::<Vec<_>>()
4337 );
4338
4339 buffer.update(cx, |buffer, cx| buffer.edit([(1..3, "XXX\n")], None, cx));
4340 let snapshot = multibuffer.read(cx).snapshot(cx);
4341
4342 assert_eq!(snapshot.text(), buffer.read(cx).text());
4343 assert_eq!(
4344 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4345 (0..buffer.read(cx).row_count())
4346 .map(Some)
4347 .collect::<Vec<_>>()
4348 );
4349 }
4350
4351 #[gpui::test]
4352 fn test_remote(cx: &mut AppContext) {
4353 let host_buffer =
4354 cx.new_model(|cx| Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "a"));
4355 let guest_buffer = cx.new_model(|cx| {
4356 let state = host_buffer.read(cx).to_proto();
4357 let ops = cx
4358 .background_executor()
4359 .block(host_buffer.read(cx).serialize_ops(None, cx));
4360 let mut buffer = Buffer::from_proto(1, Capability::ReadWrite, state, None).unwrap();
4361 buffer
4362 .apply_ops(
4363 ops.into_iter()
4364 .map(|op| language::proto::deserialize_operation(op).unwrap()),
4365 cx,
4366 )
4367 .unwrap();
4368 buffer
4369 });
4370 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(guest_buffer.clone(), cx));
4371 let snapshot = multibuffer.read(cx).snapshot(cx);
4372 assert_eq!(snapshot.text(), "a");
4373
4374 guest_buffer.update(cx, |buffer, cx| buffer.edit([(1..1, "b")], None, cx));
4375 let snapshot = multibuffer.read(cx).snapshot(cx);
4376 assert_eq!(snapshot.text(), "ab");
4377
4378 guest_buffer.update(cx, |buffer, cx| buffer.edit([(2..2, "c")], None, cx));
4379 let snapshot = multibuffer.read(cx).snapshot(cx);
4380 assert_eq!(snapshot.text(), "abc");
4381 }
4382
4383 #[gpui::test]
4384 fn test_excerpt_boundaries_and_clipping(cx: &mut AppContext) {
4385 let buffer_1 = cx.new_model(|cx| {
4386 Buffer::new(
4387 0,
4388 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4389 sample_text(6, 6, 'a'),
4390 )
4391 });
4392 let buffer_2 = cx.new_model(|cx| {
4393 Buffer::new(
4394 0,
4395 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4396 sample_text(6, 6, 'g'),
4397 )
4398 });
4399 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4400
4401 let events = Arc::new(RwLock::new(Vec::<Event>::new()));
4402 multibuffer.update(cx, |_, cx| {
4403 let events = events.clone();
4404 cx.subscribe(&multibuffer, move |_, _, event, _| {
4405 if let Event::Edited { .. } = event {
4406 events.write().push(event.clone())
4407 }
4408 })
4409 .detach();
4410 });
4411
4412 let subscription = multibuffer.update(cx, |multibuffer, cx| {
4413 let subscription = multibuffer.subscribe();
4414 multibuffer.push_excerpts(
4415 buffer_1.clone(),
4416 [ExcerptRange {
4417 context: Point::new(1, 2)..Point::new(2, 5),
4418 primary: None,
4419 }],
4420 cx,
4421 );
4422 assert_eq!(
4423 subscription.consume().into_inner(),
4424 [Edit {
4425 old: 0..0,
4426 new: 0..10
4427 }]
4428 );
4429
4430 multibuffer.push_excerpts(
4431 buffer_1.clone(),
4432 [ExcerptRange {
4433 context: Point::new(3, 3)..Point::new(4, 4),
4434 primary: None,
4435 }],
4436 cx,
4437 );
4438 multibuffer.push_excerpts(
4439 buffer_2.clone(),
4440 [ExcerptRange {
4441 context: Point::new(3, 1)..Point::new(3, 3),
4442 primary: None,
4443 }],
4444 cx,
4445 );
4446 assert_eq!(
4447 subscription.consume().into_inner(),
4448 [Edit {
4449 old: 10..10,
4450 new: 10..22
4451 }]
4452 );
4453
4454 subscription
4455 });
4456
4457 // Adding excerpts emits an edited event.
4458 assert_eq!(
4459 events.read().as_slice(),
4460 &[
4461 Event::Edited {
4462 singleton_buffer_edited: false
4463 },
4464 Event::Edited {
4465 singleton_buffer_edited: false
4466 },
4467 Event::Edited {
4468 singleton_buffer_edited: false
4469 }
4470 ]
4471 );
4472
4473 let snapshot = multibuffer.read(cx).snapshot(cx);
4474 assert_eq!(
4475 snapshot.text(),
4476 concat!(
4477 "bbbb\n", // Preserve newlines
4478 "ccccc\n", //
4479 "ddd\n", //
4480 "eeee\n", //
4481 "jj" //
4482 )
4483 );
4484 assert_eq!(
4485 snapshot.buffer_rows(0).collect::<Vec<_>>(),
4486 [Some(1), Some(2), Some(3), Some(4), Some(3)]
4487 );
4488 assert_eq!(
4489 snapshot.buffer_rows(2).collect::<Vec<_>>(),
4490 [Some(3), Some(4), Some(3)]
4491 );
4492 assert_eq!(snapshot.buffer_rows(4).collect::<Vec<_>>(), [Some(3)]);
4493 assert_eq!(snapshot.buffer_rows(5).collect::<Vec<_>>(), []);
4494
4495 assert_eq!(
4496 boundaries_in_range(Point::new(0, 0)..Point::new(4, 2), &snapshot),
4497 &[
4498 (0, "bbbb\nccccc".to_string(), true),
4499 (2, "ddd\neeee".to_string(), false),
4500 (4, "jj".to_string(), true),
4501 ]
4502 );
4503 assert_eq!(
4504 boundaries_in_range(Point::new(0, 0)..Point::new(2, 0), &snapshot),
4505 &[(0, "bbbb\nccccc".to_string(), true)]
4506 );
4507 assert_eq!(
4508 boundaries_in_range(Point::new(1, 0)..Point::new(1, 5), &snapshot),
4509 &[]
4510 );
4511 assert_eq!(
4512 boundaries_in_range(Point::new(1, 0)..Point::new(2, 0), &snapshot),
4513 &[]
4514 );
4515 assert_eq!(
4516 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
4517 &[(2, "ddd\neeee".to_string(), false)]
4518 );
4519 assert_eq!(
4520 boundaries_in_range(Point::new(1, 0)..Point::new(4, 0), &snapshot),
4521 &[(2, "ddd\neeee".to_string(), false)]
4522 );
4523 assert_eq!(
4524 boundaries_in_range(Point::new(2, 0)..Point::new(3, 0), &snapshot),
4525 &[(2, "ddd\neeee".to_string(), false)]
4526 );
4527 assert_eq!(
4528 boundaries_in_range(Point::new(4, 0)..Point::new(4, 2), &snapshot),
4529 &[(4, "jj".to_string(), true)]
4530 );
4531 assert_eq!(
4532 boundaries_in_range(Point::new(4, 2)..Point::new(4, 2), &snapshot),
4533 &[]
4534 );
4535
4536 buffer_1.update(cx, |buffer, cx| {
4537 let text = "\n";
4538 buffer.edit(
4539 [
4540 (Point::new(0, 0)..Point::new(0, 0), text),
4541 (Point::new(2, 1)..Point::new(2, 3), text),
4542 ],
4543 None,
4544 cx,
4545 );
4546 });
4547
4548 let snapshot = multibuffer.read(cx).snapshot(cx);
4549 assert_eq!(
4550 snapshot.text(),
4551 concat!(
4552 "bbbb\n", // Preserve newlines
4553 "c\n", //
4554 "cc\n", //
4555 "ddd\n", //
4556 "eeee\n", //
4557 "jj" //
4558 )
4559 );
4560
4561 assert_eq!(
4562 subscription.consume().into_inner(),
4563 [Edit {
4564 old: 6..8,
4565 new: 6..7
4566 }]
4567 );
4568
4569 let snapshot = multibuffer.read(cx).snapshot(cx);
4570 assert_eq!(
4571 snapshot.clip_point(Point::new(0, 5), Bias::Left),
4572 Point::new(0, 4)
4573 );
4574 assert_eq!(
4575 snapshot.clip_point(Point::new(0, 5), Bias::Right),
4576 Point::new(0, 4)
4577 );
4578 assert_eq!(
4579 snapshot.clip_point(Point::new(5, 1), Bias::Right),
4580 Point::new(5, 1)
4581 );
4582 assert_eq!(
4583 snapshot.clip_point(Point::new(5, 2), Bias::Right),
4584 Point::new(5, 2)
4585 );
4586 assert_eq!(
4587 snapshot.clip_point(Point::new(5, 3), Bias::Right),
4588 Point::new(5, 2)
4589 );
4590
4591 let snapshot = multibuffer.update(cx, |multibuffer, cx| {
4592 let (buffer_2_excerpt_id, _) =
4593 multibuffer.excerpts_for_buffer(&buffer_2, cx)[0].clone();
4594 multibuffer.remove_excerpts([buffer_2_excerpt_id], cx);
4595 multibuffer.snapshot(cx)
4596 });
4597
4598 assert_eq!(
4599 snapshot.text(),
4600 concat!(
4601 "bbbb\n", // Preserve newlines
4602 "c\n", //
4603 "cc\n", //
4604 "ddd\n", //
4605 "eeee", //
4606 )
4607 );
4608
4609 fn boundaries_in_range(
4610 range: Range<Point>,
4611 snapshot: &MultiBufferSnapshot,
4612 ) -> Vec<(u32, String, bool)> {
4613 snapshot
4614 .excerpt_boundaries_in_range(range)
4615 .map(|boundary| {
4616 (
4617 boundary.row,
4618 boundary
4619 .buffer
4620 .text_for_range(boundary.range.context)
4621 .collect::<String>(),
4622 boundary.starts_new_buffer,
4623 )
4624 })
4625 .collect::<Vec<_>>()
4626 }
4627 }
4628
4629 #[gpui::test]
4630 fn test_excerpt_events(cx: &mut AppContext) {
4631 let buffer_1 = cx.new_model(|cx| {
4632 Buffer::new(
4633 0,
4634 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4635 sample_text(10, 3, 'a'),
4636 )
4637 });
4638 let buffer_2 = cx.new_model(|cx| {
4639 Buffer::new(
4640 0,
4641 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4642 sample_text(10, 3, 'm'),
4643 )
4644 });
4645
4646 let leader_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4647 let follower_multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4648 let follower_edit_event_count = Arc::new(RwLock::new(0));
4649
4650 follower_multibuffer.update(cx, |_, cx| {
4651 let follower_edit_event_count = follower_edit_event_count.clone();
4652 cx.subscribe(
4653 &leader_multibuffer,
4654 move |follower, _, event, cx| match event.clone() {
4655 Event::ExcerptsAdded {
4656 buffer,
4657 predecessor,
4658 excerpts,
4659 } => follower.insert_excerpts_with_ids_after(predecessor, buffer, excerpts, cx),
4660 Event::ExcerptsRemoved { ids } => follower.remove_excerpts(ids, cx),
4661 Event::Edited { .. } => {
4662 *follower_edit_event_count.write() += 1;
4663 }
4664 _ => {}
4665 },
4666 )
4667 .detach();
4668 });
4669
4670 leader_multibuffer.update(cx, |leader, cx| {
4671 leader.push_excerpts(
4672 buffer_1.clone(),
4673 [
4674 ExcerptRange {
4675 context: 0..8,
4676 primary: None,
4677 },
4678 ExcerptRange {
4679 context: 12..16,
4680 primary: None,
4681 },
4682 ],
4683 cx,
4684 );
4685 leader.insert_excerpts_after(
4686 leader.excerpt_ids()[0],
4687 buffer_2.clone(),
4688 [
4689 ExcerptRange {
4690 context: 0..5,
4691 primary: None,
4692 },
4693 ExcerptRange {
4694 context: 10..15,
4695 primary: None,
4696 },
4697 ],
4698 cx,
4699 )
4700 });
4701 assert_eq!(
4702 leader_multibuffer.read(cx).snapshot(cx).text(),
4703 follower_multibuffer.read(cx).snapshot(cx).text(),
4704 );
4705 assert_eq!(*follower_edit_event_count.read(), 2);
4706
4707 leader_multibuffer.update(cx, |leader, cx| {
4708 let excerpt_ids = leader.excerpt_ids();
4709 leader.remove_excerpts([excerpt_ids[1], excerpt_ids[3]], cx);
4710 });
4711 assert_eq!(
4712 leader_multibuffer.read(cx).snapshot(cx).text(),
4713 follower_multibuffer.read(cx).snapshot(cx).text(),
4714 );
4715 assert_eq!(*follower_edit_event_count.read(), 3);
4716
4717 // Removing an empty set of excerpts is a noop.
4718 leader_multibuffer.update(cx, |leader, cx| {
4719 leader.remove_excerpts([], cx);
4720 });
4721 assert_eq!(
4722 leader_multibuffer.read(cx).snapshot(cx).text(),
4723 follower_multibuffer.read(cx).snapshot(cx).text(),
4724 );
4725 assert_eq!(*follower_edit_event_count.read(), 3);
4726
4727 // Adding an empty set of excerpts is a noop.
4728 leader_multibuffer.update(cx, |leader, cx| {
4729 leader.push_excerpts::<usize>(buffer_2.clone(), [], cx);
4730 });
4731 assert_eq!(
4732 leader_multibuffer.read(cx).snapshot(cx).text(),
4733 follower_multibuffer.read(cx).snapshot(cx).text(),
4734 );
4735 assert_eq!(*follower_edit_event_count.read(), 3);
4736
4737 leader_multibuffer.update(cx, |leader, cx| {
4738 leader.clear(cx);
4739 });
4740 assert_eq!(
4741 leader_multibuffer.read(cx).snapshot(cx).text(),
4742 follower_multibuffer.read(cx).snapshot(cx).text(),
4743 );
4744 assert_eq!(*follower_edit_event_count.read(), 4);
4745 }
4746
4747 #[gpui::test]
4748 fn test_push_excerpts_with_context_lines(cx: &mut AppContext) {
4749 let buffer = cx.new_model(|cx| {
4750 Buffer::new(
4751 0,
4752 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4753 sample_text(20, 3, 'a'),
4754 )
4755 });
4756 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4757 let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
4758 multibuffer.push_excerpts_with_context_lines(
4759 buffer.clone(),
4760 vec![
4761 Point::new(3, 2)..Point::new(4, 2),
4762 Point::new(7, 1)..Point::new(7, 3),
4763 Point::new(15, 0)..Point::new(15, 0),
4764 ],
4765 2,
4766 cx,
4767 )
4768 });
4769
4770 let snapshot = multibuffer.read(cx).snapshot(cx);
4771 assert_eq!(
4772 snapshot.text(),
4773 "bbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\n\nnnn\nooo\nppp\nqqq\nrrr\n"
4774 );
4775
4776 assert_eq!(
4777 anchor_ranges
4778 .iter()
4779 .map(|range| range.to_point(&snapshot))
4780 .collect::<Vec<_>>(),
4781 vec![
4782 Point::new(2, 2)..Point::new(3, 2),
4783 Point::new(6, 1)..Point::new(6, 3),
4784 Point::new(12, 0)..Point::new(12, 0)
4785 ]
4786 );
4787 }
4788
4789 #[gpui::test]
4790 async fn test_stream_excerpts_with_context_lines(cx: &mut TestAppContext) {
4791 let buffer = cx.new_model(|cx| {
4792 Buffer::new(
4793 0,
4794 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4795 sample_text(20, 3, 'a'),
4796 )
4797 });
4798 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4799 let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
4800 let snapshot = buffer.read(cx);
4801 let ranges = vec![
4802 snapshot.anchor_before(Point::new(3, 2))..snapshot.anchor_before(Point::new(4, 2)),
4803 snapshot.anchor_before(Point::new(7, 1))..snapshot.anchor_before(Point::new(7, 3)),
4804 snapshot.anchor_before(Point::new(15, 0))
4805 ..snapshot.anchor_before(Point::new(15, 0)),
4806 ];
4807 multibuffer.stream_excerpts_with_context_lines(buffer.clone(), ranges, 2, cx)
4808 });
4809
4810 let anchor_ranges = anchor_ranges.collect::<Vec<_>>().await;
4811
4812 let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
4813 assert_eq!(
4814 snapshot.text(),
4815 "bbb\nccc\nddd\neee\nfff\nggg\nhhh\niii\njjj\n\nnnn\nooo\nppp\nqqq\nrrr\n"
4816 );
4817
4818 assert_eq!(
4819 anchor_ranges
4820 .iter()
4821 .map(|range| range.to_point(&snapshot))
4822 .collect::<Vec<_>>(),
4823 vec![
4824 Point::new(2, 2)..Point::new(3, 2),
4825 Point::new(6, 1)..Point::new(6, 3),
4826 Point::new(12, 0)..Point::new(12, 0)
4827 ]
4828 );
4829 }
4830
4831 #[gpui::test]
4832 fn test_empty_multibuffer(cx: &mut AppContext) {
4833 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4834
4835 let snapshot = multibuffer.read(cx).snapshot(cx);
4836 assert_eq!(snapshot.text(), "");
4837 assert_eq!(snapshot.buffer_rows(0).collect::<Vec<_>>(), &[Some(0)]);
4838 assert_eq!(snapshot.buffer_rows(1).collect::<Vec<_>>(), &[]);
4839 }
4840
4841 #[gpui::test]
4842 fn test_singleton_multibuffer_anchors(cx: &mut AppContext) {
4843 let buffer = cx.new_model(|cx| {
4844 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4845 });
4846 let multibuffer = cx.new_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
4847 let old_snapshot = multibuffer.read(cx).snapshot(cx);
4848 buffer.update(cx, |buffer, cx| {
4849 buffer.edit([(0..0, "X")], None, cx);
4850 buffer.edit([(5..5, "Y")], None, cx);
4851 });
4852 let new_snapshot = multibuffer.read(cx).snapshot(cx);
4853
4854 assert_eq!(old_snapshot.text(), "abcd");
4855 assert_eq!(new_snapshot.text(), "XabcdY");
4856
4857 assert_eq!(old_snapshot.anchor_before(0).to_offset(&new_snapshot), 0);
4858 assert_eq!(old_snapshot.anchor_after(0).to_offset(&new_snapshot), 1);
4859 assert_eq!(old_snapshot.anchor_before(4).to_offset(&new_snapshot), 5);
4860 assert_eq!(old_snapshot.anchor_after(4).to_offset(&new_snapshot), 6);
4861 }
4862
4863 #[gpui::test]
4864 fn test_multibuffer_anchors(cx: &mut AppContext) {
4865 let buffer_1 = cx.new_model(|cx| {
4866 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4867 });
4868 let buffer_2 = cx.new_model(|cx| {
4869 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "efghi")
4870 });
4871 let multibuffer = cx.new_model(|cx| {
4872 let mut multibuffer = MultiBuffer::new(0, Capability::ReadWrite);
4873 multibuffer.push_excerpts(
4874 buffer_1.clone(),
4875 [ExcerptRange {
4876 context: 0..4,
4877 primary: None,
4878 }],
4879 cx,
4880 );
4881 multibuffer.push_excerpts(
4882 buffer_2.clone(),
4883 [ExcerptRange {
4884 context: 0..5,
4885 primary: None,
4886 }],
4887 cx,
4888 );
4889 multibuffer
4890 });
4891 let old_snapshot = multibuffer.read(cx).snapshot(cx);
4892
4893 assert_eq!(old_snapshot.anchor_before(0).to_offset(&old_snapshot), 0);
4894 assert_eq!(old_snapshot.anchor_after(0).to_offset(&old_snapshot), 0);
4895 assert_eq!(Anchor::min().to_offset(&old_snapshot), 0);
4896 assert_eq!(Anchor::min().to_offset(&old_snapshot), 0);
4897 assert_eq!(Anchor::max().to_offset(&old_snapshot), 10);
4898 assert_eq!(Anchor::max().to_offset(&old_snapshot), 10);
4899
4900 buffer_1.update(cx, |buffer, cx| {
4901 buffer.edit([(0..0, "W")], None, cx);
4902 buffer.edit([(5..5, "X")], None, cx);
4903 });
4904 buffer_2.update(cx, |buffer, cx| {
4905 buffer.edit([(0..0, "Y")], None, cx);
4906 buffer.edit([(6..6, "Z")], None, cx);
4907 });
4908 let new_snapshot = multibuffer.read(cx).snapshot(cx);
4909
4910 assert_eq!(old_snapshot.text(), "abcd\nefghi");
4911 assert_eq!(new_snapshot.text(), "WabcdX\nYefghiZ");
4912
4913 assert_eq!(old_snapshot.anchor_before(0).to_offset(&new_snapshot), 0);
4914 assert_eq!(old_snapshot.anchor_after(0).to_offset(&new_snapshot), 1);
4915 assert_eq!(old_snapshot.anchor_before(1).to_offset(&new_snapshot), 2);
4916 assert_eq!(old_snapshot.anchor_after(1).to_offset(&new_snapshot), 2);
4917 assert_eq!(old_snapshot.anchor_before(2).to_offset(&new_snapshot), 3);
4918 assert_eq!(old_snapshot.anchor_after(2).to_offset(&new_snapshot), 3);
4919 assert_eq!(old_snapshot.anchor_before(5).to_offset(&new_snapshot), 7);
4920 assert_eq!(old_snapshot.anchor_after(5).to_offset(&new_snapshot), 8);
4921 assert_eq!(old_snapshot.anchor_before(10).to_offset(&new_snapshot), 13);
4922 assert_eq!(old_snapshot.anchor_after(10).to_offset(&new_snapshot), 14);
4923 }
4924
4925 #[gpui::test]
4926 fn test_resolving_anchors_after_replacing_their_excerpts(cx: &mut AppContext) {
4927 let buffer_1 = cx.new_model(|cx| {
4928 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "abcd")
4929 });
4930 let buffer_2 = cx.new_model(|cx| {
4931 Buffer::new(
4932 0,
4933 BufferId::new(cx.entity_id().as_u64()).unwrap(),
4934 "ABCDEFGHIJKLMNOP",
4935 )
4936 });
4937 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
4938
4939 // Create an insertion id in buffer 1 that doesn't exist in buffer 2.
4940 // Add an excerpt from buffer 1 that spans this new insertion.
4941 buffer_1.update(cx, |buffer, cx| buffer.edit([(4..4, "123")], None, cx));
4942 let excerpt_id_1 = multibuffer.update(cx, |multibuffer, cx| {
4943 multibuffer
4944 .push_excerpts(
4945 buffer_1.clone(),
4946 [ExcerptRange {
4947 context: 0..7,
4948 primary: None,
4949 }],
4950 cx,
4951 )
4952 .pop()
4953 .unwrap()
4954 });
4955
4956 let snapshot_1 = multibuffer.read(cx).snapshot(cx);
4957 assert_eq!(snapshot_1.text(), "abcd123");
4958
4959 // Replace the buffer 1 excerpt with new excerpts from buffer 2.
4960 let (excerpt_id_2, excerpt_id_3) = multibuffer.update(cx, |multibuffer, cx| {
4961 multibuffer.remove_excerpts([excerpt_id_1], cx);
4962 let mut ids = multibuffer
4963 .push_excerpts(
4964 buffer_2.clone(),
4965 [
4966 ExcerptRange {
4967 context: 0..4,
4968 primary: None,
4969 },
4970 ExcerptRange {
4971 context: 6..10,
4972 primary: None,
4973 },
4974 ExcerptRange {
4975 context: 12..16,
4976 primary: None,
4977 },
4978 ],
4979 cx,
4980 )
4981 .into_iter();
4982 (ids.next().unwrap(), ids.next().unwrap())
4983 });
4984 let snapshot_2 = multibuffer.read(cx).snapshot(cx);
4985 assert_eq!(snapshot_2.text(), "ABCD\nGHIJ\nMNOP");
4986
4987 // The old excerpt id doesn't get reused.
4988 assert_ne!(excerpt_id_2, excerpt_id_1);
4989
4990 // Resolve some anchors from the previous snapshot in the new snapshot.
4991 // The current excerpts are from a different buffer, so we don't attempt to
4992 // resolve the old text anchor in the new buffer.
4993 assert_eq!(
4994 snapshot_2.summary_for_anchor::<usize>(&snapshot_1.anchor_before(2)),
4995 0
4996 );
4997 assert_eq!(
4998 snapshot_2.summaries_for_anchors::<usize, _>(&[
4999 snapshot_1.anchor_before(2),
5000 snapshot_1.anchor_after(3)
5001 ]),
5002 vec![0, 0]
5003 );
5004
5005 // Refresh anchors from the old snapshot. The return value indicates that both
5006 // anchors lost their original excerpt.
5007 let refresh =
5008 snapshot_2.refresh_anchors(&[snapshot_1.anchor_before(2), snapshot_1.anchor_after(3)]);
5009 assert_eq!(
5010 refresh,
5011 &[
5012 (0, snapshot_2.anchor_before(0), false),
5013 (1, snapshot_2.anchor_after(0), false),
5014 ]
5015 );
5016
5017 // Replace the middle excerpt with a smaller excerpt in buffer 2,
5018 // that intersects the old excerpt.
5019 let excerpt_id_5 = multibuffer.update(cx, |multibuffer, cx| {
5020 multibuffer.remove_excerpts([excerpt_id_3], cx);
5021 multibuffer
5022 .insert_excerpts_after(
5023 excerpt_id_2,
5024 buffer_2.clone(),
5025 [ExcerptRange {
5026 context: 5..8,
5027 primary: None,
5028 }],
5029 cx,
5030 )
5031 .pop()
5032 .unwrap()
5033 });
5034
5035 let snapshot_3 = multibuffer.read(cx).snapshot(cx);
5036 assert_eq!(snapshot_3.text(), "ABCD\nFGH\nMNOP");
5037 assert_ne!(excerpt_id_5, excerpt_id_3);
5038
5039 // Resolve some anchors from the previous snapshot in the new snapshot.
5040 // The third anchor can't be resolved, since its excerpt has been removed,
5041 // so it resolves to the same position as its predecessor.
5042 let anchors = [
5043 snapshot_2.anchor_before(0),
5044 snapshot_2.anchor_after(2),
5045 snapshot_2.anchor_after(6),
5046 snapshot_2.anchor_after(14),
5047 ];
5048 assert_eq!(
5049 snapshot_3.summaries_for_anchors::<usize, _>(&anchors),
5050 &[0, 2, 9, 13]
5051 );
5052
5053 let new_anchors = snapshot_3.refresh_anchors(&anchors);
5054 assert_eq!(
5055 new_anchors.iter().map(|a| (a.0, a.2)).collect::<Vec<_>>(),
5056 &[(0, true), (1, true), (2, true), (3, true)]
5057 );
5058 assert_eq!(
5059 snapshot_3.summaries_for_anchors::<usize, _>(new_anchors.iter().map(|a| &a.1)),
5060 &[0, 2, 7, 13]
5061 );
5062 }
5063
5064 #[gpui::test(iterations = 100)]
5065 fn test_random_multibuffer(cx: &mut AppContext, mut rng: StdRng) {
5066 let operations = env::var("OPERATIONS")
5067 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
5068 .unwrap_or(10);
5069
5070 let mut buffers: Vec<Model<Buffer>> = Vec::new();
5071 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
5072 let mut excerpt_ids = Vec::<ExcerptId>::new();
5073 let mut expected_excerpts = Vec::<(Model<Buffer>, Range<text::Anchor>)>::new();
5074 let mut anchors = Vec::new();
5075 let mut old_versions = Vec::new();
5076
5077 for _ in 0..operations {
5078 match rng.gen_range(0..100) {
5079 0..=19 if !buffers.is_empty() => {
5080 let buffer = buffers.choose(&mut rng).unwrap();
5081 buffer.update(cx, |buf, cx| buf.randomly_edit(&mut rng, 5, cx));
5082 }
5083 20..=29 if !expected_excerpts.is_empty() => {
5084 let mut ids_to_remove = vec![];
5085 for _ in 0..rng.gen_range(1..=3) {
5086 if expected_excerpts.is_empty() {
5087 break;
5088 }
5089
5090 let ix = rng.gen_range(0..expected_excerpts.len());
5091 ids_to_remove.push(excerpt_ids.remove(ix));
5092 let (buffer, range) = expected_excerpts.remove(ix);
5093 let buffer = buffer.read(cx);
5094 log::info!(
5095 "Removing excerpt {}: {:?}",
5096 ix,
5097 buffer
5098 .text_for_range(range.to_offset(buffer))
5099 .collect::<String>(),
5100 );
5101 }
5102 let snapshot = multibuffer.read(cx).read(cx);
5103 ids_to_remove.sort_unstable_by(|a, b| a.cmp(&b, &snapshot));
5104 drop(snapshot);
5105 multibuffer.update(cx, |multibuffer, cx| {
5106 multibuffer.remove_excerpts(ids_to_remove, cx)
5107 });
5108 }
5109 30..=39 if !expected_excerpts.is_empty() => {
5110 let multibuffer = multibuffer.read(cx).read(cx);
5111 let offset =
5112 multibuffer.clip_offset(rng.gen_range(0..=multibuffer.len()), Bias::Left);
5113 let bias = if rng.gen() { Bias::Left } else { Bias::Right };
5114 log::info!("Creating anchor at {} with bias {:?}", offset, bias);
5115 anchors.push(multibuffer.anchor_at(offset, bias));
5116 anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
5117 }
5118 40..=44 if !anchors.is_empty() => {
5119 let multibuffer = multibuffer.read(cx).read(cx);
5120 let prev_len = anchors.len();
5121 anchors = multibuffer
5122 .refresh_anchors(&anchors)
5123 .into_iter()
5124 .map(|a| a.1)
5125 .collect();
5126
5127 // Ensure the newly-refreshed anchors point to a valid excerpt and don't
5128 // overshoot its boundaries.
5129 assert_eq!(anchors.len(), prev_len);
5130 for anchor in &anchors {
5131 if anchor.excerpt_id == ExcerptId::min()
5132 || anchor.excerpt_id == ExcerptId::max()
5133 {
5134 continue;
5135 }
5136
5137 let excerpt = multibuffer.excerpt(anchor.excerpt_id).unwrap();
5138 assert_eq!(excerpt.id, anchor.excerpt_id);
5139 assert!(excerpt.contains(anchor));
5140 }
5141 }
5142 _ => {
5143 let buffer_handle = if buffers.is_empty() || rng.gen_bool(0.4) {
5144 let base_text = util::RandomCharIter::new(&mut rng)
5145 .take(10)
5146 .collect::<String>();
5147 buffers.push(cx.new_model(|cx| {
5148 Buffer::new(
5149 0,
5150 BufferId::new(cx.entity_id().as_u64()).unwrap(),
5151 base_text,
5152 )
5153 }));
5154 buffers.last().unwrap()
5155 } else {
5156 buffers.choose(&mut rng).unwrap()
5157 };
5158
5159 let buffer = buffer_handle.read(cx);
5160 let end_ix = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
5161 let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
5162 let anchor_range = buffer.anchor_before(start_ix)..buffer.anchor_after(end_ix);
5163 let prev_excerpt_ix = rng.gen_range(0..=expected_excerpts.len());
5164 let prev_excerpt_id = excerpt_ids
5165 .get(prev_excerpt_ix)
5166 .cloned()
5167 .unwrap_or_else(ExcerptId::max);
5168 let excerpt_ix = (prev_excerpt_ix + 1).min(expected_excerpts.len());
5169
5170 log::info!(
5171 "Inserting excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
5172 excerpt_ix,
5173 expected_excerpts.len(),
5174 buffer_handle.read(cx).remote_id(),
5175 buffer.text(),
5176 start_ix..end_ix,
5177 &buffer.text()[start_ix..end_ix]
5178 );
5179
5180 let excerpt_id = multibuffer.update(cx, |multibuffer, cx| {
5181 multibuffer
5182 .insert_excerpts_after(
5183 prev_excerpt_id,
5184 buffer_handle.clone(),
5185 [ExcerptRange {
5186 context: start_ix..end_ix,
5187 primary: None,
5188 }],
5189 cx,
5190 )
5191 .pop()
5192 .unwrap()
5193 });
5194
5195 excerpt_ids.insert(excerpt_ix, excerpt_id);
5196 expected_excerpts.insert(excerpt_ix, (buffer_handle.clone(), anchor_range));
5197 }
5198 }
5199
5200 if rng.gen_bool(0.3) {
5201 multibuffer.update(cx, |multibuffer, cx| {
5202 old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
5203 })
5204 }
5205
5206 let snapshot = multibuffer.read(cx).snapshot(cx);
5207
5208 let mut excerpt_starts = Vec::new();
5209 let mut expected_text = String::new();
5210 let mut expected_buffer_rows = Vec::new();
5211 for (buffer, range) in &expected_excerpts {
5212 let buffer = buffer.read(cx);
5213 let buffer_range = range.to_offset(buffer);
5214
5215 excerpt_starts.push(TextSummary::from(expected_text.as_str()));
5216 expected_text.extend(buffer.text_for_range(buffer_range.clone()));
5217 expected_text.push('\n');
5218
5219 let buffer_row_range = buffer.offset_to_point(buffer_range.start).row
5220 ..=buffer.offset_to_point(buffer_range.end).row;
5221 for row in buffer_row_range {
5222 expected_buffer_rows.push(Some(row));
5223 }
5224 }
5225 // Remove final trailing newline.
5226 if !expected_excerpts.is_empty() {
5227 expected_text.pop();
5228 }
5229
5230 // Always report one buffer row
5231 if expected_buffer_rows.is_empty() {
5232 expected_buffer_rows.push(Some(0));
5233 }
5234
5235 assert_eq!(snapshot.text(), expected_text);
5236 log::info!("MultiBuffer text: {:?}", expected_text);
5237
5238 assert_eq!(
5239 snapshot.buffer_rows(0).collect::<Vec<_>>(),
5240 expected_buffer_rows,
5241 );
5242
5243 for _ in 0..5 {
5244 let start_row = rng.gen_range(0..=expected_buffer_rows.len());
5245 assert_eq!(
5246 snapshot.buffer_rows(start_row as u32).collect::<Vec<_>>(),
5247 &expected_buffer_rows[start_row..],
5248 "buffer_rows({})",
5249 start_row
5250 );
5251 }
5252
5253 assert_eq!(
5254 snapshot.max_buffer_row(),
5255 expected_buffer_rows.into_iter().flatten().max().unwrap()
5256 );
5257
5258 let mut excerpt_starts = excerpt_starts.into_iter();
5259 for (buffer, range) in &expected_excerpts {
5260 let buffer = buffer.read(cx);
5261 let buffer_id = buffer.remote_id();
5262 let buffer_range = range.to_offset(buffer);
5263 let buffer_start_point = buffer.offset_to_point(buffer_range.start);
5264 let buffer_start_point_utf16 =
5265 buffer.text_summary_for_range::<PointUtf16, _>(0..buffer_range.start);
5266
5267 let excerpt_start = excerpt_starts.next().unwrap();
5268 let mut offset = excerpt_start.len;
5269 let mut buffer_offset = buffer_range.start;
5270 let mut point = excerpt_start.lines;
5271 let mut buffer_point = buffer_start_point;
5272 let mut point_utf16 = excerpt_start.lines_utf16();
5273 let mut buffer_point_utf16 = buffer_start_point_utf16;
5274 for ch in buffer
5275 .snapshot()
5276 .chunks(buffer_range.clone(), false)
5277 .flat_map(|c| c.text.chars())
5278 {
5279 for _ in 0..ch.len_utf8() {
5280 let left_offset = snapshot.clip_offset(offset, Bias::Left);
5281 let right_offset = snapshot.clip_offset(offset, Bias::Right);
5282 let buffer_left_offset = buffer.clip_offset(buffer_offset, Bias::Left);
5283 let buffer_right_offset = buffer.clip_offset(buffer_offset, Bias::Right);
5284 assert_eq!(
5285 left_offset,
5286 excerpt_start.len + (buffer_left_offset - buffer_range.start),
5287 "clip_offset({:?}, Left). buffer: {:?}, buffer offset: {:?}",
5288 offset,
5289 buffer_id,
5290 buffer_offset,
5291 );
5292 assert_eq!(
5293 right_offset,
5294 excerpt_start.len + (buffer_right_offset - buffer_range.start),
5295 "clip_offset({:?}, Right). buffer: {:?}, buffer offset: {:?}",
5296 offset,
5297 buffer_id,
5298 buffer_offset,
5299 );
5300
5301 let left_point = snapshot.clip_point(point, Bias::Left);
5302 let right_point = snapshot.clip_point(point, Bias::Right);
5303 let buffer_left_point = buffer.clip_point(buffer_point, Bias::Left);
5304 let buffer_right_point = buffer.clip_point(buffer_point, Bias::Right);
5305 assert_eq!(
5306 left_point,
5307 excerpt_start.lines + (buffer_left_point - buffer_start_point),
5308 "clip_point({:?}, Left). buffer: {:?}, buffer point: {:?}",
5309 point,
5310 buffer_id,
5311 buffer_point,
5312 );
5313 assert_eq!(
5314 right_point,
5315 excerpt_start.lines + (buffer_right_point - buffer_start_point),
5316 "clip_point({:?}, Right). buffer: {:?}, buffer point: {:?}",
5317 point,
5318 buffer_id,
5319 buffer_point,
5320 );
5321
5322 assert_eq!(
5323 snapshot.point_to_offset(left_point),
5324 left_offset,
5325 "point_to_offset({:?})",
5326 left_point,
5327 );
5328 assert_eq!(
5329 snapshot.offset_to_point(left_offset),
5330 left_point,
5331 "offset_to_point({:?})",
5332 left_offset,
5333 );
5334
5335 offset += 1;
5336 buffer_offset += 1;
5337 if ch == '\n' {
5338 point += Point::new(1, 0);
5339 buffer_point += Point::new(1, 0);
5340 } else {
5341 point += Point::new(0, 1);
5342 buffer_point += Point::new(0, 1);
5343 }
5344 }
5345
5346 for _ in 0..ch.len_utf16() {
5347 let left_point_utf16 =
5348 snapshot.clip_point_utf16(Unclipped(point_utf16), Bias::Left);
5349 let right_point_utf16 =
5350 snapshot.clip_point_utf16(Unclipped(point_utf16), Bias::Right);
5351 let buffer_left_point_utf16 =
5352 buffer.clip_point_utf16(Unclipped(buffer_point_utf16), Bias::Left);
5353 let buffer_right_point_utf16 =
5354 buffer.clip_point_utf16(Unclipped(buffer_point_utf16), Bias::Right);
5355 assert_eq!(
5356 left_point_utf16,
5357 excerpt_start.lines_utf16()
5358 + (buffer_left_point_utf16 - buffer_start_point_utf16),
5359 "clip_point_utf16({:?}, Left). buffer: {:?}, buffer point_utf16: {:?}",
5360 point_utf16,
5361 buffer_id,
5362 buffer_point_utf16,
5363 );
5364 assert_eq!(
5365 right_point_utf16,
5366 excerpt_start.lines_utf16()
5367 + (buffer_right_point_utf16 - buffer_start_point_utf16),
5368 "clip_point_utf16({:?}, Right). buffer: {:?}, buffer point_utf16: {:?}",
5369 point_utf16,
5370 buffer_id,
5371 buffer_point_utf16,
5372 );
5373
5374 if ch == '\n' {
5375 point_utf16 += PointUtf16::new(1, 0);
5376 buffer_point_utf16 += PointUtf16::new(1, 0);
5377 } else {
5378 point_utf16 += PointUtf16::new(0, 1);
5379 buffer_point_utf16 += PointUtf16::new(0, 1);
5380 }
5381 }
5382 }
5383 }
5384
5385 for (row, line) in expected_text.split('\n').enumerate() {
5386 assert_eq!(
5387 snapshot.line_len(row as u32),
5388 line.len() as u32,
5389 "line_len({}).",
5390 row
5391 );
5392 }
5393
5394 let text_rope = Rope::from(expected_text.as_str());
5395 for _ in 0..10 {
5396 let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
5397 let start_ix = text_rope.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
5398
5399 let text_for_range = snapshot
5400 .text_for_range(start_ix..end_ix)
5401 .collect::<String>();
5402 assert_eq!(
5403 text_for_range,
5404 &expected_text[start_ix..end_ix],
5405 "incorrect text for range {:?}",
5406 start_ix..end_ix
5407 );
5408
5409 let excerpted_buffer_ranges = multibuffer
5410 .read(cx)
5411 .range_to_buffer_ranges(start_ix..end_ix, cx);
5412 let excerpted_buffers_text = excerpted_buffer_ranges
5413 .iter()
5414 .map(|(buffer, buffer_range, _)| {
5415 buffer
5416 .read(cx)
5417 .text_for_range(buffer_range.clone())
5418 .collect::<String>()
5419 })
5420 .collect::<Vec<_>>()
5421 .join("\n");
5422 assert_eq!(excerpted_buffers_text, text_for_range);
5423 if !expected_excerpts.is_empty() {
5424 assert!(!excerpted_buffer_ranges.is_empty());
5425 }
5426
5427 let expected_summary = TextSummary::from(&expected_text[start_ix..end_ix]);
5428 assert_eq!(
5429 snapshot.text_summary_for_range::<TextSummary, _>(start_ix..end_ix),
5430 expected_summary,
5431 "incorrect summary for range {:?}",
5432 start_ix..end_ix
5433 );
5434 }
5435
5436 // Anchor resolution
5437 let summaries = snapshot.summaries_for_anchors::<usize, _>(&anchors);
5438 assert_eq!(anchors.len(), summaries.len());
5439 for (anchor, resolved_offset) in anchors.iter().zip(summaries) {
5440 assert!(resolved_offset <= snapshot.len());
5441 assert_eq!(
5442 snapshot.summary_for_anchor::<usize>(anchor),
5443 resolved_offset
5444 );
5445 }
5446
5447 for _ in 0..10 {
5448 let end_ix = text_rope.clip_offset(rng.gen_range(0..=text_rope.len()), Bias::Right);
5449 assert_eq!(
5450 snapshot.reversed_chars_at(end_ix).collect::<String>(),
5451 expected_text[..end_ix].chars().rev().collect::<String>(),
5452 );
5453 }
5454
5455 for _ in 0..10 {
5456 let end_ix = rng.gen_range(0..=text_rope.len());
5457 let start_ix = rng.gen_range(0..=end_ix);
5458 assert_eq!(
5459 snapshot
5460 .bytes_in_range(start_ix..end_ix)
5461 .flatten()
5462 .copied()
5463 .collect::<Vec<_>>(),
5464 expected_text.as_bytes()[start_ix..end_ix].to_vec(),
5465 "bytes_in_range({:?})",
5466 start_ix..end_ix,
5467 );
5468 }
5469 }
5470
5471 let snapshot = multibuffer.read(cx).snapshot(cx);
5472 for (old_snapshot, subscription) in old_versions {
5473 let edits = subscription.consume().into_inner();
5474
5475 log::info!(
5476 "applying subscription edits to old text: {:?}: {:?}",
5477 old_snapshot.text(),
5478 edits,
5479 );
5480
5481 let mut text = old_snapshot.text();
5482 for edit in edits {
5483 let new_text: String = snapshot.text_for_range(edit.new.clone()).collect();
5484 text.replace_range(edit.new.start..edit.new.start + edit.old.len(), &new_text);
5485 }
5486 assert_eq!(text.to_string(), snapshot.text());
5487 }
5488 }
5489
5490 #[gpui::test]
5491 fn test_history(cx: &mut AppContext) {
5492 let test_settings = SettingsStore::test(cx);
5493 cx.set_global(test_settings);
5494
5495 let buffer_1 = cx.new_model(|cx| {
5496 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "1234")
5497 });
5498 let buffer_2 = cx.new_model(|cx| {
5499 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "5678")
5500 });
5501 let multibuffer = cx.new_model(|_| MultiBuffer::new(0, Capability::ReadWrite));
5502 let group_interval = multibuffer.read(cx).history.group_interval;
5503 multibuffer.update(cx, |multibuffer, cx| {
5504 multibuffer.push_excerpts(
5505 buffer_1.clone(),
5506 [ExcerptRange {
5507 context: 0..buffer_1.read(cx).len(),
5508 primary: None,
5509 }],
5510 cx,
5511 );
5512 multibuffer.push_excerpts(
5513 buffer_2.clone(),
5514 [ExcerptRange {
5515 context: 0..buffer_2.read(cx).len(),
5516 primary: None,
5517 }],
5518 cx,
5519 );
5520 });
5521
5522 let mut now = Instant::now();
5523
5524 multibuffer.update(cx, |multibuffer, cx| {
5525 let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();
5526 multibuffer.edit(
5527 [
5528 (Point::new(0, 0)..Point::new(0, 0), "A"),
5529 (Point::new(1, 0)..Point::new(1, 0), "A"),
5530 ],
5531 None,
5532 cx,
5533 );
5534 multibuffer.edit(
5535 [
5536 (Point::new(0, 1)..Point::new(0, 1), "B"),
5537 (Point::new(1, 1)..Point::new(1, 1), "B"),
5538 ],
5539 None,
5540 cx,
5541 );
5542 multibuffer.end_transaction_at(now, cx);
5543 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5544
5545 // Edit buffer 1 through the multibuffer
5546 now += 2 * group_interval;
5547 multibuffer.start_transaction_at(now, cx);
5548 multibuffer.edit([(2..2, "C")], None, cx);
5549 multibuffer.end_transaction_at(now, cx);
5550 assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
5551
5552 // Edit buffer 1 independently
5553 buffer_1.update(cx, |buffer_1, cx| {
5554 buffer_1.start_transaction_at(now);
5555 buffer_1.edit([(3..3, "D")], None, cx);
5556 buffer_1.end_transaction_at(now, cx);
5557
5558 now += 2 * group_interval;
5559 buffer_1.start_transaction_at(now);
5560 buffer_1.edit([(4..4, "E")], None, cx);
5561 buffer_1.end_transaction_at(now, cx);
5562 });
5563 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
5564
5565 // An undo in the multibuffer undoes the multibuffer transaction
5566 // and also any individual buffer edits that have occurred since
5567 // that transaction.
5568 multibuffer.undo(cx);
5569 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5570
5571 multibuffer.undo(cx);
5572 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5573
5574 multibuffer.redo(cx);
5575 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5576
5577 multibuffer.redo(cx);
5578 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
5579
5580 // Undo buffer 2 independently.
5581 buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));
5582 assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");
5583
5584 // An undo in the multibuffer undoes the components of the
5585 // the last multibuffer transaction that are not already undone.
5586 multibuffer.undo(cx);
5587 assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");
5588
5589 multibuffer.undo(cx);
5590 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5591
5592 multibuffer.redo(cx);
5593 assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
5594
5595 buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));
5596 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
5597
5598 // Redo stack gets cleared after an edit.
5599 now += 2 * group_interval;
5600 multibuffer.start_transaction_at(now, cx);
5601 multibuffer.edit([(0..0, "X")], None, cx);
5602 multibuffer.end_transaction_at(now, cx);
5603 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5604 multibuffer.redo(cx);
5605 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5606 multibuffer.undo(cx);
5607 assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
5608 multibuffer.undo(cx);
5609 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5610
5611 // Transactions can be grouped manually.
5612 multibuffer.redo(cx);
5613 multibuffer.redo(cx);
5614 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5615 multibuffer.group_until_transaction(transaction_1, cx);
5616 multibuffer.undo(cx);
5617 assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
5618 multibuffer.redo(cx);
5619 assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
5620 });
5621 }
5622}