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