1use super::{
2 Highlights,
3 fold_map::{Chunk, FoldRows},
4 tab_map::{self, TabEdit, TabPoint, TabSnapshot},
5};
6use gpui::{App, AppContext as _, Context, Entity, Font, LineWrapper, Pixels, Task};
7use language::Point;
8use multi_buffer::{MultiBufferSnapshot, RowInfo};
9use smol::future::yield_now;
10use std::sync::LazyLock;
11use std::{cmp, collections::VecDeque, mem, ops::Range, time::Duration};
12use sum_tree::{Bias, Cursor, Dimensions, SumTree};
13use text::Patch;
14
15pub use super::tab_map::TextSummary;
16pub type WrapEdit = text::Edit<u32>;
17
18/// Handles soft wrapping of text.
19///
20/// See the [`display_map` module documentation](crate::display_map) for more information.
21pub struct WrapMap {
22 snapshot: WrapSnapshot,
23 pending_edits: VecDeque<(TabSnapshot, Vec<TabEdit>)>,
24 interpolated_edits: Patch<u32>,
25 edits_since_sync: Patch<u32>,
26 wrap_width: Option<Pixels>,
27 background_task: Option<Task<()>>,
28 font_with_size: (Font, Pixels),
29}
30
31#[derive(Clone)]
32pub struct WrapSnapshot {
33 pub(super) tab_snapshot: TabSnapshot,
34 // FIXME
35 pub(crate) transforms: SumTree<Transform>,
36 interpolated: bool,
37}
38
39// FIXME
40#[derive(Clone, Debug, Default, Eq, PartialEq)]
41pub(crate) struct Transform {
42 summary: TransformSummary,
43 display_text: Option<&'static str>,
44}
45
46// FIXME
47#[derive(Clone, Debug, Default, Eq, PartialEq)]
48pub(crate) struct TransformSummary {
49 input: TextSummary,
50 output: TextSummary,
51}
52
53#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
54pub struct WrapPoint(pub Point);
55
56pub struct WrapChunks<'a> {
57 input_chunks: tab_map::TabChunks<'a>,
58 input_chunk: Chunk<'a>,
59 output_position: WrapPoint,
60 max_output_row: u32,
61 transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
62 snapshot: &'a WrapSnapshot,
63}
64
65#[derive(Clone)]
66pub struct WrapRows<'a> {
67 input_buffer_rows: FoldRows<'a>,
68 input_buffer_row: RowInfo,
69 output_row: u32,
70 soft_wrapped: bool,
71 max_output_row: u32,
72 transforms: Cursor<'a, 'static, Transform, Dimensions<WrapPoint, TabPoint>>,
73}
74
75impl WrapRows<'_> {
76 pub(crate) fn seek(&mut self, start_row: u32) {
77 self.transforms
78 .seek(&WrapPoint::new(start_row, 0), Bias::Left);
79 let mut input_row = self.transforms.start().1.row();
80 if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
81 input_row += start_row - self.transforms.start().0.row();
82 }
83 self.soft_wrapped = self.transforms.item().is_some_and(|t| !t.is_isomorphic());
84 self.input_buffer_rows.seek(input_row);
85 self.input_buffer_row = self.input_buffer_rows.next().unwrap();
86 self.output_row = start_row;
87 }
88}
89
90impl WrapMap {
91 pub fn new(
92 tab_snapshot: TabSnapshot,
93 font: Font,
94 font_size: Pixels,
95 wrap_width: Option<Pixels>,
96 cx: &mut App,
97 ) -> (Entity<Self>, WrapSnapshot) {
98 let handle = cx.new(|cx| {
99 let mut this = Self {
100 font_with_size: (font, font_size),
101 wrap_width: None,
102 pending_edits: Default::default(),
103 interpolated_edits: Default::default(),
104 edits_since_sync: Default::default(),
105 snapshot: WrapSnapshot::new(tab_snapshot),
106 background_task: None,
107 };
108 this.set_wrap_width(wrap_width, cx);
109 mem::take(&mut this.edits_since_sync);
110 this
111 });
112 let snapshot = handle.read(cx).snapshot.clone();
113 (handle, snapshot)
114 }
115
116 #[cfg(test)]
117 pub fn is_rewrapping(&self) -> bool {
118 self.background_task.is_some()
119 }
120
121 pub fn sync(
122 &mut self,
123 tab_snapshot: TabSnapshot,
124 edits: Vec<TabEdit>,
125 cx: &mut Context<Self>,
126 ) -> (WrapSnapshot, Patch<u32>) {
127 if self.wrap_width.is_some() {
128 self.pending_edits.push_back((tab_snapshot, edits));
129 self.flush_edits(cx);
130 } else {
131 self.edits_since_sync = self
132 .edits_since_sync
133 .compose(self.snapshot.interpolate(tab_snapshot, &edits));
134 self.snapshot.interpolated = false;
135 }
136
137 (self.snapshot.clone(), mem::take(&mut self.edits_since_sync))
138 }
139
140 pub fn set_font_with_size(
141 &mut self,
142 font: Font,
143 font_size: Pixels,
144 cx: &mut Context<Self>,
145 ) -> bool {
146 let font_with_size = (font, font_size);
147
148 if font_with_size == self.font_with_size {
149 false
150 } else {
151 self.font_with_size = font_with_size;
152 self.rewrap(cx);
153 true
154 }
155 }
156
157 pub fn set_wrap_width(&mut self, wrap_width: Option<Pixels>, cx: &mut Context<Self>) -> bool {
158 if wrap_width == self.wrap_width {
159 return false;
160 }
161
162 self.wrap_width = wrap_width;
163 self.rewrap(cx);
164 true
165 }
166
167 fn rewrap(&mut self, cx: &mut Context<Self>) {
168 self.background_task.take();
169 self.interpolated_edits.clear();
170 self.pending_edits.clear();
171
172 if let Some(wrap_width) = self.wrap_width {
173 let mut new_snapshot = self.snapshot.clone();
174
175 let text_system = cx.text_system().clone();
176 let (font, font_size) = self.font_with_size.clone();
177 let task = cx.background_spawn(async move {
178 let mut line_wrapper = text_system.line_wrapper(font, font_size);
179 let tab_snapshot = new_snapshot.tab_snapshot.clone();
180 let range = TabPoint::zero()..tab_snapshot.max_point();
181 let edits = new_snapshot
182 .update(
183 tab_snapshot,
184 &[TabEdit {
185 old: range.clone(),
186 new: range.clone(),
187 }],
188 wrap_width,
189 &mut line_wrapper,
190 )
191 .await;
192 (new_snapshot, edits)
193 });
194
195 match cx
196 .background_executor()
197 .block_with_timeout(Duration::from_millis(5), task)
198 {
199 Ok((snapshot, edits)) => {
200 self.snapshot = snapshot;
201 self.edits_since_sync = self.edits_since_sync.compose(&edits);
202 }
203 Err(wrap_task) => {
204 self.background_task = Some(cx.spawn(async move |this, cx| {
205 let (snapshot, edits) = wrap_task.await;
206 this.update(cx, |this, cx| {
207 this.snapshot = snapshot;
208 this.edits_since_sync = this
209 .edits_since_sync
210 .compose(mem::take(&mut this.interpolated_edits).invert())
211 .compose(&edits);
212 this.background_task = None;
213 this.flush_edits(cx);
214 cx.notify();
215 })
216 .ok();
217 }));
218 }
219 }
220 } else {
221 let old_rows = self.snapshot.transforms.summary().output.lines.row + 1;
222 self.snapshot.transforms = SumTree::default();
223 let summary = self.snapshot.tab_snapshot.text_summary();
224 if !summary.lines.is_zero() {
225 self.snapshot
226 .transforms
227 .push(Transform::isomorphic(summary), ());
228 }
229 let new_rows = self.snapshot.transforms.summary().output.lines.row + 1;
230 self.snapshot.interpolated = false;
231 self.edits_since_sync = self.edits_since_sync.compose(Patch::new(vec![WrapEdit {
232 old: 0..old_rows,
233 new: 0..new_rows,
234 }]));
235 }
236 }
237
238 fn flush_edits(&mut self, cx: &mut Context<Self>) {
239 if !self.snapshot.interpolated {
240 let mut to_remove_len = 0;
241 for (tab_snapshot, _) in &self.pending_edits {
242 if tab_snapshot.version <= self.snapshot.tab_snapshot.version {
243 to_remove_len += 1;
244 } else {
245 break;
246 }
247 }
248 self.pending_edits.drain(..to_remove_len);
249 }
250
251 if self.pending_edits.is_empty() {
252 return;
253 }
254
255 if let Some(wrap_width) = self.wrap_width
256 && self.background_task.is_none()
257 {
258 let pending_edits = self.pending_edits.clone();
259 let mut snapshot = self.snapshot.clone();
260 let text_system = cx.text_system().clone();
261 let (font, font_size) = self.font_with_size.clone();
262 let update_task = cx.background_spawn(async move {
263 let mut edits = Patch::default();
264 let mut line_wrapper = text_system.line_wrapper(font, font_size);
265 for (tab_snapshot, tab_edits) in pending_edits {
266 let wrap_edits = snapshot
267 .update(tab_snapshot, &tab_edits, wrap_width, &mut line_wrapper)
268 .await;
269 edits = edits.compose(&wrap_edits);
270 }
271 (snapshot, edits)
272 });
273
274 match cx
275 .background_executor()
276 .block_with_timeout(Duration::from_millis(1), update_task)
277 {
278 Ok((snapshot, output_edits)) => {
279 self.snapshot = snapshot;
280 self.edits_since_sync = self.edits_since_sync.compose(&output_edits);
281 }
282 Err(update_task) => {
283 self.background_task = Some(cx.spawn(async move |this, cx| {
284 let (snapshot, edits) = update_task.await;
285 this.update(cx, |this, cx| {
286 this.snapshot = snapshot;
287 this.edits_since_sync = this
288 .edits_since_sync
289 .compose(mem::take(&mut this.interpolated_edits).invert())
290 .compose(&edits);
291 this.background_task = None;
292 this.flush_edits(cx);
293 cx.notify();
294 })
295 .ok();
296 }));
297 }
298 }
299 }
300
301 let was_interpolated = self.snapshot.interpolated;
302 let mut to_remove_len = 0;
303 for (tab_snapshot, edits) in &self.pending_edits {
304 if tab_snapshot.version <= self.snapshot.tab_snapshot.version {
305 to_remove_len += 1;
306 } else {
307 let interpolated_edits = self.snapshot.interpolate(tab_snapshot.clone(), edits);
308 self.edits_since_sync = self.edits_since_sync.compose(&interpolated_edits);
309 self.interpolated_edits = self.interpolated_edits.compose(&interpolated_edits);
310 }
311 }
312
313 if !was_interpolated {
314 self.pending_edits.drain(..to_remove_len);
315 }
316 }
317}
318
319impl WrapSnapshot {
320 fn new(tab_snapshot: TabSnapshot) -> Self {
321 let mut transforms = SumTree::default();
322 let extent = tab_snapshot.text_summary();
323 if !extent.lines.is_zero() {
324 transforms.push(Transform::isomorphic(extent), ());
325 }
326 Self {
327 transforms,
328 tab_snapshot,
329 interpolated: true,
330 }
331 }
332
333 pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
334 self.tab_snapshot.buffer_snapshot()
335 }
336
337 fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, tab_edits: &[TabEdit]) -> Patch<u32> {
338 let mut new_transforms;
339 if tab_edits.is_empty() {
340 new_transforms = self.transforms.clone();
341 } else {
342 let mut old_cursor = self.transforms.cursor::<TabPoint>(());
343
344 let mut tab_edits_iter = tab_edits.iter().peekable();
345 new_transforms =
346 old_cursor.slice(&tab_edits_iter.peek().unwrap().old.start, Bias::Right);
347
348 while let Some(edit) = tab_edits_iter.next() {
349 if edit.new.start > TabPoint::from(new_transforms.summary().input.lines) {
350 let summary = new_tab_snapshot.text_summary_for_range(
351 TabPoint::from(new_transforms.summary().input.lines)..edit.new.start,
352 );
353 new_transforms.push_or_extend(Transform::isomorphic(summary));
354 }
355
356 if !edit.new.is_empty() {
357 new_transforms.push_or_extend(Transform::isomorphic(
358 new_tab_snapshot.text_summary_for_range(edit.new.clone()),
359 ));
360 }
361
362 old_cursor.seek_forward(&edit.old.end, Bias::Right);
363 if let Some(next_edit) = tab_edits_iter.peek() {
364 if next_edit.old.start > old_cursor.end() {
365 if old_cursor.end() > edit.old.end {
366 let summary = self
367 .tab_snapshot
368 .text_summary_for_range(edit.old.end..old_cursor.end());
369 new_transforms.push_or_extend(Transform::isomorphic(summary));
370 }
371
372 old_cursor.next();
373 new_transforms
374 .append(old_cursor.slice(&next_edit.old.start, Bias::Right), ());
375 }
376 } else {
377 if old_cursor.end() > edit.old.end {
378 let summary = self
379 .tab_snapshot
380 .text_summary_for_range(edit.old.end..old_cursor.end());
381 new_transforms.push_or_extend(Transform::isomorphic(summary));
382 }
383 old_cursor.next();
384 new_transforms.append(old_cursor.suffix(), ());
385 }
386 }
387 }
388
389 let old_snapshot = mem::replace(
390 self,
391 WrapSnapshot {
392 tab_snapshot: new_tab_snapshot,
393 transforms: new_transforms,
394 interpolated: true,
395 },
396 );
397 self.check_invariants();
398 old_snapshot.compute_edits(tab_edits, self)
399 }
400
401 async fn update(
402 &mut self,
403 new_tab_snapshot: TabSnapshot,
404 tab_edits: &[TabEdit],
405 wrap_width: Pixels,
406 line_wrapper: &mut LineWrapper,
407 ) -> Patch<u32> {
408 #[derive(Debug)]
409 struct RowEdit {
410 old_rows: Range<u32>,
411 new_rows: Range<u32>,
412 }
413
414 let mut tab_edits_iter = tab_edits.iter().peekable();
415 let mut row_edits = Vec::with_capacity(tab_edits.len());
416 while let Some(edit) = tab_edits_iter.next() {
417 let mut row_edit = RowEdit {
418 old_rows: edit.old.start.row()..edit.old.end.row() + 1,
419 new_rows: edit.new.start.row()..edit.new.end.row() + 1,
420 };
421
422 while let Some(next_edit) = tab_edits_iter.peek() {
423 if next_edit.old.start.row() <= row_edit.old_rows.end {
424 row_edit.old_rows.end = next_edit.old.end.row() + 1;
425 row_edit.new_rows.end = next_edit.new.end.row() + 1;
426 tab_edits_iter.next();
427 } else {
428 break;
429 }
430 }
431
432 row_edits.push(row_edit);
433 }
434
435 let mut new_transforms;
436 if row_edits.is_empty() {
437 new_transforms = self.transforms.clone();
438 } else {
439 let mut row_edits = row_edits.into_iter().peekable();
440 let mut old_cursor = self.transforms.cursor::<TabPoint>(());
441
442 new_transforms = old_cursor.slice(
443 &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
444 Bias::Right,
445 );
446
447 while let Some(edit) = row_edits.next() {
448 if edit.new_rows.start > new_transforms.summary().input.lines.row {
449 let summary = new_tab_snapshot.text_summary_for_range(
450 TabPoint(new_transforms.summary().input.lines)
451 ..TabPoint::new(edit.new_rows.start, 0),
452 );
453 new_transforms.push_or_extend(Transform::isomorphic(summary));
454 }
455
456 let mut line = String::new();
457 let mut line_fragments = Vec::new();
458 let mut remaining = None;
459 let mut chunks = new_tab_snapshot.chunks(
460 TabPoint::new(edit.new_rows.start, 0)..new_tab_snapshot.max_point(),
461 false,
462 Highlights::default(),
463 );
464 let mut edit_transforms = Vec::<Transform>::new();
465 for _ in edit.new_rows.start..edit.new_rows.end {
466 while let Some(chunk) = remaining.take().or_else(|| chunks.next()) {
467 if let Some(ix) = chunk.text.find('\n') {
468 let (prefix, suffix) = chunk.text.split_at(ix + 1);
469 line_fragments.push(gpui::LineFragment::text(prefix));
470 line.push_str(prefix);
471 remaining = Some(Chunk {
472 text: suffix,
473 ..chunk
474 });
475 break;
476 } else {
477 if let Some(width) =
478 chunk.renderer.as_ref().and_then(|r| r.measured_width)
479 {
480 line_fragments
481 .push(gpui::LineFragment::element(width, chunk.text.len()));
482 } else {
483 line_fragments.push(gpui::LineFragment::text(chunk.text));
484 }
485 line.push_str(chunk.text);
486 }
487 }
488
489 if line.is_empty() {
490 break;
491 }
492
493 let mut prev_boundary_ix = 0;
494 for boundary in line_wrapper.wrap_line(&line_fragments, wrap_width) {
495 let wrapped = &line[prev_boundary_ix..boundary.ix];
496 push_isomorphic(&mut edit_transforms, TextSummary::from(wrapped));
497 edit_transforms.push(Transform::wrap(boundary.next_indent));
498 prev_boundary_ix = boundary.ix;
499 }
500
501 if prev_boundary_ix < line.len() {
502 push_isomorphic(
503 &mut edit_transforms,
504 TextSummary::from(&line[prev_boundary_ix..]),
505 );
506 }
507
508 line.clear();
509 line_fragments.clear();
510 yield_now().await;
511 }
512
513 let mut edit_transforms = edit_transforms.into_iter();
514 if let Some(transform) = edit_transforms.next() {
515 new_transforms.push_or_extend(transform);
516 }
517 new_transforms.extend(edit_transforms, ());
518
519 old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right);
520 if let Some(next_edit) = row_edits.peek() {
521 if next_edit.old_rows.start > old_cursor.end().row() {
522 if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
523 let summary = self.tab_snapshot.text_summary_for_range(
524 TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
525 );
526 new_transforms.push_or_extend(Transform::isomorphic(summary));
527 }
528 old_cursor.next();
529 new_transforms.append(
530 old_cursor
531 .slice(&TabPoint::new(next_edit.old_rows.start, 0), Bias::Right),
532 (),
533 );
534 }
535 } else {
536 if old_cursor.end() > TabPoint::new(edit.old_rows.end, 0) {
537 let summary = self.tab_snapshot.text_summary_for_range(
538 TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(),
539 );
540 new_transforms.push_or_extend(Transform::isomorphic(summary));
541 }
542 old_cursor.next();
543 new_transforms.append(old_cursor.suffix(), ());
544 }
545 }
546 }
547
548 let old_snapshot = mem::replace(
549 self,
550 WrapSnapshot {
551 tab_snapshot: new_tab_snapshot,
552 transforms: new_transforms,
553 interpolated: false,
554 },
555 );
556 self.check_invariants();
557 old_snapshot.compute_edits(tab_edits, self)
558 }
559
560 fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &WrapSnapshot) -> Patch<u32> {
561 let mut wrap_edits = Vec::with_capacity(tab_edits.len());
562 let mut old_cursor = self.transforms.cursor::<TransformSummary>(());
563 let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>(());
564 for mut tab_edit in tab_edits.iter().cloned() {
565 tab_edit.old.start.0.column = 0;
566 tab_edit.old.end.0 += Point::new(1, 0);
567 tab_edit.new.start.0.column = 0;
568 tab_edit.new.end.0 += Point::new(1, 0);
569
570 old_cursor.seek(&tab_edit.old.start, Bias::Right);
571 let mut old_start = old_cursor.start().output.lines;
572 old_start += tab_edit.old.start.0 - old_cursor.start().input.lines;
573
574 // todo(lw): Should these be seek_forward?
575 old_cursor.seek(&tab_edit.old.end, Bias::Right);
576 let mut old_end = old_cursor.start().output.lines;
577 old_end += tab_edit.old.end.0 - old_cursor.start().input.lines;
578
579 // todo(lw): Should these be seek_forward?
580 new_cursor.seek(&tab_edit.new.start, Bias::Right);
581 let mut new_start = new_cursor.start().output.lines;
582 new_start += tab_edit.new.start.0 - new_cursor.start().input.lines;
583
584 // todo(lw): Should these be seek_forward?
585 new_cursor.seek(&tab_edit.new.end, Bias::Right);
586 let mut new_end = new_cursor.start().output.lines;
587 new_end += tab_edit.new.end.0 - new_cursor.start().input.lines;
588
589 wrap_edits.push(WrapEdit {
590 old: old_start.row..old_end.row,
591 new: new_start.row..new_end.row,
592 });
593 }
594
595 wrap_edits = consolidate_wrap_edits(wrap_edits);
596 Patch::new(wrap_edits)
597 }
598
599 pub(crate) fn chunks<'a>(
600 &'a self,
601 rows: Range<u32>,
602 language_aware: bool,
603 highlights: Highlights<'a>,
604 ) -> WrapChunks<'a> {
605 let output_start = WrapPoint::new(rows.start, 0);
606 let output_end = WrapPoint::new(rows.end, 0);
607 let mut transforms = self
608 .transforms
609 .cursor::<Dimensions<WrapPoint, TabPoint>>(());
610 transforms.seek(&output_start, Bias::Right);
611 let mut input_start = TabPoint(transforms.start().1.0);
612 if transforms.item().is_some_and(|t| t.is_isomorphic()) {
613 input_start.0 += output_start.0 - transforms.start().0.0;
614 }
615 let input_end = self
616 .to_tab_point(output_end)
617 .min(self.tab_snapshot.max_point());
618 WrapChunks {
619 input_chunks: self.tab_snapshot.chunks(
620 input_start..input_end,
621 language_aware,
622 highlights,
623 ),
624 input_chunk: Default::default(),
625 output_position: output_start,
626 max_output_row: rows.end,
627 transforms,
628 snapshot: self,
629 }
630 }
631
632 pub fn max_point(&self) -> WrapPoint {
633 WrapPoint(self.transforms.summary().output.lines)
634 }
635
636 pub fn line_len(&self, row: u32) -> u32 {
637 let (start, _, item) = self.transforms.find::<Dimensions<WrapPoint, TabPoint>, _>(
638 (),
639 &WrapPoint::new(row + 1, 0),
640 Bias::Left,
641 );
642 if item.is_some_and(|transform| transform.is_isomorphic()) {
643 let overshoot = row - start.0.row();
644 let tab_row = start.1.row() + overshoot;
645 let tab_line_len = self.tab_snapshot.line_len(tab_row);
646 if overshoot == 0 {
647 start.0.column() + (tab_line_len - start.1.column())
648 } else {
649 tab_line_len
650 }
651 } else {
652 start.0.column()
653 }
654 }
655
656 pub fn text_summary_for_range(&self, rows: Range<u32>) -> TextSummary {
657 let mut summary = TextSummary::default();
658
659 let start = WrapPoint::new(rows.start, 0);
660 let end = WrapPoint::new(rows.end, 0);
661
662 let mut cursor = self
663 .transforms
664 .cursor::<Dimensions<WrapPoint, TabPoint>>(());
665 cursor.seek(&start, Bias::Right);
666 if let Some(transform) = cursor.item() {
667 let start_in_transform = start.0 - cursor.start().0.0;
668 let end_in_transform = cmp::min(end, cursor.end().0).0 - cursor.start().0.0;
669 if transform.is_isomorphic() {
670 let tab_start = TabPoint(cursor.start().1.0 + start_in_transform);
671 let tab_end = TabPoint(cursor.start().1.0 + end_in_transform);
672 summary += &self.tab_snapshot.text_summary_for_range(tab_start..tab_end);
673 } else {
674 debug_assert_eq!(start_in_transform.row, end_in_transform.row);
675 let indent_len = end_in_transform.column - start_in_transform.column;
676 summary += &TextSummary {
677 lines: Point::new(0, indent_len),
678 first_line_chars: indent_len,
679 last_line_chars: indent_len,
680 longest_row: 0,
681 longest_row_chars: indent_len,
682 };
683 }
684
685 cursor.next();
686 }
687
688 if rows.end > cursor.start().0.row() {
689 summary += &cursor
690 .summary::<_, TransformSummary>(&WrapPoint::new(rows.end, 0), Bias::Right)
691 .output;
692
693 if let Some(transform) = cursor.item() {
694 let end_in_transform = end.0 - cursor.start().0.0;
695 if transform.is_isomorphic() {
696 let char_start = cursor.start().1;
697 let char_end = TabPoint(char_start.0 + end_in_transform);
698 summary += &self
699 .tab_snapshot
700 .text_summary_for_range(char_start..char_end);
701 } else {
702 debug_assert_eq!(end_in_transform, Point::new(1, 0));
703 summary += &TextSummary {
704 lines: Point::new(1, 0),
705 first_line_chars: 0,
706 last_line_chars: 0,
707 longest_row: 0,
708 longest_row_chars: 0,
709 };
710 }
711 }
712 }
713
714 summary
715 }
716
717 pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
718 let (.., item) =
719 self.transforms
720 .find::<WrapPoint, _>((), &WrapPoint::new(row + 1, 0), Bias::Right);
721 item.and_then(|transform| {
722 if transform.is_isomorphic() {
723 None
724 } else {
725 Some(transform.summary.output.lines.column)
726 }
727 })
728 }
729
730 pub fn longest_row(&self) -> u32 {
731 self.transforms.summary().output.longest_row
732 }
733
734 pub fn row_infos(&self, start_row: u32) -> WrapRows<'_> {
735 let mut transforms = self
736 .transforms
737 .cursor::<Dimensions<WrapPoint, TabPoint>>(());
738 transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left);
739 let mut input_row = transforms.start().1.row();
740 if transforms.item().is_some_and(|t| t.is_isomorphic()) {
741 input_row += start_row - transforms.start().0.row();
742 }
743 let soft_wrapped = transforms.item().is_some_and(|t| !t.is_isomorphic());
744 let mut input_buffer_rows = self.tab_snapshot.rows(input_row);
745 let input_buffer_row = input_buffer_rows.next().unwrap();
746 WrapRows {
747 transforms,
748 input_buffer_row,
749 input_buffer_rows,
750 output_row: start_row,
751 soft_wrapped,
752 max_output_row: self.max_point().row(),
753 }
754 }
755
756 pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
757 let (start, _, item) =
758 self.transforms
759 .find::<Dimensions<WrapPoint, TabPoint>, _>((), &point, Bias::Right);
760 let mut tab_point = start.1.0;
761 if item.is_some_and(|t| t.is_isomorphic()) {
762 tab_point += point.0 - start.0.0;
763 }
764 TabPoint(tab_point)
765 }
766
767 pub fn to_point(&self, point: WrapPoint, bias: Bias) -> Point {
768 self.tab_snapshot.to_point(self.to_tab_point(point), bias)
769 }
770
771 pub fn make_wrap_point(&self, point: Point, bias: Bias) -> WrapPoint {
772 self.tab_point_to_wrap_point(self.tab_snapshot.make_tab_point(point, bias))
773 }
774
775 pub fn tab_point_to_wrap_point(&self, point: TabPoint) -> WrapPoint {
776 let (start, ..) =
777 self.transforms
778 .find::<Dimensions<TabPoint, WrapPoint>, _>((), &point, Bias::Right);
779 WrapPoint(start.1.0 + (point.0 - start.0.0))
780 }
781
782 pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
783 if bias == Bias::Left {
784 let (start, _, item) = self
785 .transforms
786 .find::<WrapPoint, _>((), &point, Bias::Right);
787 if item.is_some_and(|t| !t.is_isomorphic()) {
788 point = start;
789 *point.column_mut() -= 1;
790 }
791 }
792
793 self.tab_point_to_wrap_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias))
794 }
795
796 pub fn prev_row_boundary(&self, mut point: WrapPoint) -> u32 {
797 if self.transforms.is_empty() {
798 return 0;
799 }
800
801 *point.column_mut() = 0;
802
803 let mut cursor = self
804 .transforms
805 .cursor::<Dimensions<WrapPoint, TabPoint>>(());
806 cursor.seek(&point, Bias::Right);
807 if cursor.item().is_none() {
808 cursor.prev();
809 }
810
811 while let Some(transform) = cursor.item() {
812 if transform.is_isomorphic() && cursor.start().1.column() == 0 {
813 return cmp::min(cursor.end().0.row(), point.row());
814 } else {
815 cursor.prev();
816 }
817 }
818
819 unreachable!()
820 }
821
822 pub fn next_row_boundary(&self, mut point: WrapPoint) -> Option<u32> {
823 point.0 += Point::new(1, 0);
824
825 let mut cursor = self
826 .transforms
827 .cursor::<Dimensions<WrapPoint, TabPoint>>(());
828 cursor.seek(&point, Bias::Right);
829 while let Some(transform) = cursor.item() {
830 if transform.is_isomorphic() && cursor.start().1.column() == 0 {
831 return Some(cmp::max(cursor.start().0.row(), point.row()));
832 } else {
833 cursor.next();
834 }
835 }
836
837 None
838 }
839
840 #[cfg(test)]
841 pub fn text(&self) -> String {
842 self.text_chunks(0).collect()
843 }
844
845 #[cfg(test)]
846 pub fn text_chunks(&self, wrap_row: u32) -> impl Iterator<Item = &str> {
847 self.chunks(
848 wrap_row..self.max_point().row() + 1,
849 false,
850 Highlights::default(),
851 )
852 .map(|h| h.text)
853 }
854
855 fn check_invariants(&self) {
856 #[cfg(test)]
857 {
858 assert_eq!(
859 TabPoint::from(self.transforms.summary().input.lines),
860 self.tab_snapshot.max_point()
861 );
862
863 {
864 let mut transforms = self.transforms.cursor::<()>(()).peekable();
865 while let Some(transform) = transforms.next() {
866 if let Some(next_transform) = transforms.peek() {
867 assert!(transform.is_isomorphic() != next_transform.is_isomorphic());
868 }
869 }
870 }
871
872 let text = language::Rope::from(self.text().as_str());
873 let mut input_buffer_rows = self.tab_snapshot.rows(0);
874 let mut expected_buffer_rows = Vec::new();
875 let mut prev_tab_row = 0;
876 for display_row in 0..=self.max_point().row() {
877 let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
878 if tab_point.row() == prev_tab_row && display_row != 0 {
879 expected_buffer_rows.push(None);
880 } else {
881 expected_buffer_rows.push(input_buffer_rows.next().unwrap().buffer_row);
882 }
883
884 prev_tab_row = tab_point.row();
885 assert_eq!(self.line_len(display_row), text.line_len(display_row));
886 }
887
888 for start_display_row in 0..expected_buffer_rows.len() {
889 assert_eq!(
890 self.row_infos(start_display_row as u32)
891 .map(|row_info| row_info.buffer_row)
892 .collect::<Vec<_>>(),
893 &expected_buffer_rows[start_display_row..],
894 "invalid buffer_rows({}..)",
895 start_display_row
896 );
897 }
898 }
899 }
900}
901
902impl WrapChunks<'_> {
903 pub(crate) fn seek(&mut self, rows: Range<u32>) {
904 let output_start = WrapPoint::new(rows.start, 0);
905 let output_end = WrapPoint::new(rows.end, 0);
906 self.transforms.seek(&output_start, Bias::Right);
907 let mut input_start = TabPoint(self.transforms.start().1.0);
908 if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
909 input_start.0 += output_start.0 - self.transforms.start().0.0;
910 }
911 let input_end = self
912 .snapshot
913 .to_tab_point(output_end)
914 .min(self.snapshot.tab_snapshot.max_point());
915 self.input_chunks.seek(input_start..input_end);
916 self.input_chunk = Chunk::default();
917 self.output_position = output_start;
918 self.max_output_row = rows.end;
919 }
920}
921
922impl<'a> Iterator for WrapChunks<'a> {
923 type Item = Chunk<'a>;
924
925 fn next(&mut self) -> Option<Self::Item> {
926 if self.output_position.row() >= self.max_output_row {
927 return None;
928 }
929
930 let transform = self.transforms.item()?;
931 if let Some(display_text) = transform.display_text {
932 let mut start_ix = 0;
933 let mut end_ix = display_text.len();
934 let mut summary = transform.summary.output.lines;
935
936 if self.output_position > self.transforms.start().0 {
937 // Exclude newline starting prior to the desired row.
938 start_ix = 1;
939 summary.row = 0;
940 } else if self.output_position.row() + 1 >= self.max_output_row {
941 // Exclude soft indentation ending after the desired row.
942 end_ix = 1;
943 summary.column = 0;
944 }
945
946 self.output_position.0 += summary;
947 self.transforms.next();
948 return Some(Chunk {
949 text: &display_text[start_ix..end_ix],
950 ..Default::default()
951 });
952 }
953
954 if self.input_chunk.text.is_empty() {
955 self.input_chunk = self.input_chunks.next().unwrap();
956 }
957
958 let mut input_len = 0;
959 let transform_end = self.transforms.end().0;
960 for c in self.input_chunk.text.chars() {
961 let char_len = c.len_utf8();
962 input_len += char_len;
963 if c == '\n' {
964 *self.output_position.row_mut() += 1;
965 *self.output_position.column_mut() = 0;
966 } else {
967 *self.output_position.column_mut() += char_len as u32;
968 }
969
970 if self.output_position >= transform_end {
971 self.transforms.next();
972 break;
973 }
974 }
975
976 let (prefix, suffix) = self.input_chunk.text.split_at(input_len);
977
978 let mask = 1u128.unbounded_shl(input_len as u32).wrapping_sub(1);
979 let chars = self.input_chunk.chars & mask;
980 let tabs = self.input_chunk.tabs & mask;
981 self.input_chunk.tabs = self.input_chunk.tabs.unbounded_shr(input_len as u32);
982 self.input_chunk.chars = self.input_chunk.chars.unbounded_shr(input_len as u32);
983
984 self.input_chunk.text = suffix;
985 Some(Chunk {
986 text: prefix,
987 chars,
988 tabs,
989 ..self.input_chunk.clone()
990 })
991 }
992}
993
994impl Iterator for WrapRows<'_> {
995 type Item = RowInfo;
996
997 fn next(&mut self) -> Option<Self::Item> {
998 if self.output_row > self.max_output_row {
999 return None;
1000 }
1001
1002 let buffer_row = self.input_buffer_row;
1003 let soft_wrapped = self.soft_wrapped;
1004 let diff_status = self.input_buffer_row.diff_status;
1005
1006 self.output_row += 1;
1007 self.transforms
1008 .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left);
1009 if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
1010 self.input_buffer_row = self.input_buffer_rows.next().unwrap();
1011 self.soft_wrapped = false;
1012 } else {
1013 self.soft_wrapped = true;
1014 }
1015
1016 Some(if soft_wrapped {
1017 RowInfo {
1018 buffer_id: None,
1019 buffer_row: None,
1020 multibuffer_row: None,
1021 diff_status,
1022 expand_info: None,
1023 }
1024 } else {
1025 buffer_row
1026 })
1027 }
1028}
1029
1030impl Transform {
1031 fn isomorphic(summary: TextSummary) -> Self {
1032 #[cfg(test)]
1033 assert!(!summary.lines.is_zero());
1034
1035 Self {
1036 summary: TransformSummary {
1037 input: summary.clone(),
1038 output: summary,
1039 },
1040 display_text: None,
1041 }
1042 }
1043
1044 fn wrap(indent: u32) -> Self {
1045 static WRAP_TEXT: LazyLock<String> = LazyLock::new(|| {
1046 let mut wrap_text = String::new();
1047 wrap_text.push('\n');
1048 wrap_text.extend((0..LineWrapper::MAX_INDENT as usize).map(|_| ' '));
1049 wrap_text
1050 });
1051
1052 Self {
1053 summary: TransformSummary {
1054 input: TextSummary::default(),
1055 output: TextSummary {
1056 lines: Point::new(1, indent),
1057 first_line_chars: 0,
1058 last_line_chars: indent,
1059 longest_row: 1,
1060 longest_row_chars: indent,
1061 },
1062 },
1063 display_text: Some(&WRAP_TEXT[..1 + indent as usize]),
1064 }
1065 }
1066
1067 fn is_isomorphic(&self) -> bool {
1068 self.display_text.is_none()
1069 }
1070}
1071
1072impl sum_tree::Item for Transform {
1073 type Summary = TransformSummary;
1074
1075 fn summary(&self, _cx: ()) -> Self::Summary {
1076 self.summary.clone()
1077 }
1078}
1079
1080fn push_isomorphic(transforms: &mut Vec<Transform>, summary: TextSummary) {
1081 if let Some(last_transform) = transforms.last_mut()
1082 && last_transform.is_isomorphic()
1083 {
1084 last_transform.summary.input += &summary;
1085 last_transform.summary.output += &summary;
1086 return;
1087 }
1088 transforms.push(Transform::isomorphic(summary));
1089}
1090
1091trait SumTreeExt {
1092 fn push_or_extend(&mut self, transform: Transform);
1093}
1094
1095impl SumTreeExt for SumTree<Transform> {
1096 fn push_or_extend(&mut self, transform: Transform) {
1097 let mut transform = Some(transform);
1098 self.update_last(
1099 |last_transform| {
1100 if last_transform.is_isomorphic() && transform.as_ref().unwrap().is_isomorphic() {
1101 let transform = transform.take().unwrap();
1102 last_transform.summary.input += &transform.summary.input;
1103 last_transform.summary.output += &transform.summary.output;
1104 }
1105 },
1106 (),
1107 );
1108
1109 if let Some(transform) = transform {
1110 self.push(transform, ());
1111 }
1112 }
1113}
1114
1115impl WrapPoint {
1116 pub fn new(row: u32, column: u32) -> Self {
1117 Self(Point::new(row, column))
1118 }
1119
1120 pub fn row(self) -> u32 {
1121 self.0.row
1122 }
1123
1124 pub fn row_mut(&mut self) -> &mut u32 {
1125 &mut self.0.row
1126 }
1127
1128 pub fn column(self) -> u32 {
1129 self.0.column
1130 }
1131
1132 pub fn column_mut(&mut self) -> &mut u32 {
1133 &mut self.0.column
1134 }
1135}
1136
1137impl sum_tree::ContextLessSummary for TransformSummary {
1138 fn zero() -> Self {
1139 Default::default()
1140 }
1141
1142 fn add_summary(&mut self, other: &Self) {
1143 self.input += &other.input;
1144 self.output += &other.output;
1145 }
1146}
1147
1148impl<'a> sum_tree::Dimension<'a, TransformSummary> for TabPoint {
1149 fn zero(_cx: ()) -> Self {
1150 Default::default()
1151 }
1152
1153 fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
1154 self.0 += summary.input.lines;
1155 }
1156}
1157
1158impl sum_tree::SeekTarget<'_, TransformSummary, TransformSummary> for TabPoint {
1159 fn cmp(&self, cursor_location: &TransformSummary, _: ()) -> std::cmp::Ordering {
1160 Ord::cmp(&self.0, &cursor_location.input.lines)
1161 }
1162}
1163
1164impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
1165 fn zero(_cx: ()) -> Self {
1166 Default::default()
1167 }
1168
1169 fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
1170 self.0 += summary.output.lines;
1171 }
1172}
1173
1174fn consolidate_wrap_edits(edits: Vec<WrapEdit>) -> Vec<WrapEdit> {
1175 let _old_alloc_ptr = edits.as_ptr();
1176 let mut wrap_edits = edits.into_iter();
1177
1178 if let Some(mut first_edit) = wrap_edits.next() {
1179 // This code relies on reusing allocations from the Vec<_> - at the time of writing .flatten() prevents them.
1180 #[allow(clippy::filter_map_identity)]
1181 let mut v: Vec<_> = wrap_edits
1182 .scan(&mut first_edit, |prev_edit, edit| {
1183 if prev_edit.old.end >= edit.old.start {
1184 prev_edit.old.end = edit.old.end;
1185 prev_edit.new.end = edit.new.end;
1186 Some(None) // Skip this edit, it's merged
1187 } else {
1188 let prev = std::mem::replace(*prev_edit, edit);
1189 Some(Some(prev)) // Yield the previous edit
1190 }
1191 })
1192 .filter_map(|x| x)
1193 .collect();
1194 v.push(first_edit.clone());
1195 debug_assert_eq!(v.as_ptr(), _old_alloc_ptr, "Wrap edits were reallocated");
1196 v
1197 } else {
1198 vec![]
1199 }
1200}
1201
1202#[cfg(test)]
1203mod tests {
1204 use super::*;
1205 use crate::{
1206 MultiBuffer,
1207 display_map::{fold_map::FoldMap, inlay_map::InlayMap, tab_map::TabMap},
1208 test::test_font,
1209 };
1210 use gpui::{LineFragment, px, test::observe};
1211 use rand::prelude::*;
1212 use settings::SettingsStore;
1213 use smol::stream::StreamExt;
1214 use std::{cmp, env, num::NonZeroU32};
1215 use text::Rope;
1216 use theme::LoadThemes;
1217
1218 #[gpui::test(iterations = 100)]
1219 async fn test_random_wraps(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
1220 // todo this test is flaky
1221 init_test(cx);
1222
1223 cx.background_executor.set_block_on_ticks(0..=50);
1224 let operations = env::var("OPERATIONS")
1225 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1226 .unwrap_or(10);
1227
1228 let text_system = cx.read(|cx| cx.text_system().clone());
1229 let mut wrap_width = if rng.random_bool(0.1) {
1230 None
1231 } else {
1232 Some(px(rng.random_range(0.0..=1000.0)))
1233 };
1234 let tab_size = NonZeroU32::new(rng.random_range(1..=4)).unwrap();
1235
1236 let font = test_font();
1237 let _font_id = text_system.resolve_font(&font);
1238 let font_size = px(14.0);
1239
1240 log::info!("Tab size: {}", tab_size);
1241 log::info!("Wrap width: {:?}", wrap_width);
1242
1243 let buffer = cx.update(|cx| {
1244 if rng.random() {
1245 MultiBuffer::build_random(&mut rng, cx)
1246 } else {
1247 let len = rng.random_range(0..10);
1248 let text = util::RandomCharIter::new(&mut rng)
1249 .take(len)
1250 .collect::<String>();
1251 MultiBuffer::build_simple(&text, cx)
1252 }
1253 });
1254 let mut buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
1255 log::info!("Buffer text: {:?}", buffer_snapshot.text());
1256 let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
1257 log::info!("InlayMap text: {:?}", inlay_snapshot.text());
1258 let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot.clone());
1259 log::info!("FoldMap text: {:?}", fold_snapshot.text());
1260 let (mut tab_map, _) = TabMap::new(fold_snapshot.clone(), tab_size);
1261 let tabs_snapshot = tab_map.set_max_expansion_column(32);
1262 log::info!("TabMap text: {:?}", tabs_snapshot.text());
1263
1264 let mut line_wrapper = text_system.line_wrapper(font.clone(), font_size);
1265 let expected_text = wrap_text(&tabs_snapshot, wrap_width, &mut line_wrapper);
1266
1267 let (wrap_map, _) =
1268 cx.update(|cx| WrapMap::new(tabs_snapshot.clone(), font, font_size, wrap_width, cx));
1269 let mut notifications = observe(&wrap_map, cx);
1270
1271 if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1272 notifications.next().await.unwrap();
1273 }
1274
1275 let (initial_snapshot, _) = wrap_map.update(cx, |map, cx| {
1276 assert!(!map.is_rewrapping());
1277 map.sync(tabs_snapshot.clone(), Vec::new(), cx)
1278 });
1279
1280 let actual_text = initial_snapshot.text();
1281 assert_eq!(
1282 actual_text,
1283 expected_text,
1284 "unwrapped text is: {:?}",
1285 tabs_snapshot.text()
1286 );
1287 log::info!("Wrapped text: {:?}", actual_text);
1288
1289 let mut next_inlay_id = 0;
1290 let mut edits = Vec::new();
1291 for _i in 0..operations {
1292 log::info!("{} ==============================================", _i);
1293
1294 let mut buffer_edits = Vec::new();
1295 match rng.random_range(0..=100) {
1296 0..=19 => {
1297 wrap_width = if rng.random_bool(0.2) {
1298 None
1299 } else {
1300 Some(px(rng.random_range(0.0..=1000.0)))
1301 };
1302 log::info!("Setting wrap width to {:?}", wrap_width);
1303 wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1304 }
1305 20..=39 => {
1306 for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
1307 let (tabs_snapshot, tab_edits) =
1308 tab_map.sync(fold_snapshot, fold_edits, tab_size);
1309 let (mut snapshot, wrap_edits) =
1310 wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
1311 snapshot.check_invariants();
1312 snapshot.verify_chunks(&mut rng);
1313 edits.push((snapshot, wrap_edits));
1314 }
1315 }
1316 40..=59 => {
1317 let (inlay_snapshot, inlay_edits) =
1318 inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
1319 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1320 let (tabs_snapshot, tab_edits) =
1321 tab_map.sync(fold_snapshot, fold_edits, tab_size);
1322 let (mut snapshot, wrap_edits) =
1323 wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
1324 snapshot.check_invariants();
1325 snapshot.verify_chunks(&mut rng);
1326 edits.push((snapshot, wrap_edits));
1327 }
1328 _ => {
1329 buffer.update(cx, |buffer, cx| {
1330 let subscription = buffer.subscribe();
1331 let edit_count = rng.random_range(1..=5);
1332 buffer.randomly_mutate(&mut rng, edit_count, cx);
1333 buffer_snapshot = buffer.snapshot(cx);
1334 buffer_edits.extend(subscription.consume());
1335 });
1336 }
1337 }
1338
1339 log::info!("Buffer text: {:?}", buffer_snapshot.text());
1340 let (inlay_snapshot, inlay_edits) =
1341 inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
1342 log::info!("InlayMap text: {:?}", inlay_snapshot.text());
1343 let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
1344 log::info!("FoldMap text: {:?}", fold_snapshot.text());
1345 let (tabs_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
1346 log::info!("TabMap text: {:?}", tabs_snapshot.text());
1347
1348 let expected_text = wrap_text(&tabs_snapshot, wrap_width, &mut line_wrapper);
1349 let (mut snapshot, wrap_edits) =
1350 wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot.clone(), tab_edits, cx));
1351 snapshot.check_invariants();
1352 snapshot.verify_chunks(&mut rng);
1353 edits.push((snapshot, wrap_edits));
1354
1355 if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) && rng.random_bool(0.4) {
1356 log::info!("Waiting for wrapping to finish");
1357 while wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1358 notifications.next().await.unwrap();
1359 }
1360 wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
1361 }
1362
1363 if !wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1364 let (mut wrapped_snapshot, wrap_edits) = wrap_map.update(cx, |map, cx| {
1365 map.sync(tabs_snapshot.clone(), Vec::new(), cx)
1366 });
1367 let actual_text = wrapped_snapshot.text();
1368 let actual_longest_row = wrapped_snapshot.longest_row();
1369 log::info!("Wrapping finished: {:?}", actual_text);
1370 wrapped_snapshot.check_invariants();
1371 wrapped_snapshot.verify_chunks(&mut rng);
1372 edits.push((wrapped_snapshot.clone(), wrap_edits));
1373 assert_eq!(
1374 actual_text,
1375 expected_text,
1376 "unwrapped text is: {:?}",
1377 tabs_snapshot.text()
1378 );
1379
1380 let mut summary = TextSummary::default();
1381 for (ix, item) in wrapped_snapshot
1382 .transforms
1383 .items(())
1384 .into_iter()
1385 .enumerate()
1386 {
1387 summary += &item.summary.output;
1388 log::info!("{} summary: {:?}", ix, item.summary.output,);
1389 }
1390
1391 if tab_size.get() == 1
1392 || !wrapped_snapshot
1393 .tab_snapshot
1394 .fold_snapshot
1395 .text()
1396 .contains('\t')
1397 {
1398 let mut expected_longest_rows = Vec::new();
1399 let mut longest_line_len = -1;
1400 for (row, line) in expected_text.split('\n').enumerate() {
1401 let line_char_count = line.chars().count() as isize;
1402 if line_char_count > longest_line_len {
1403 expected_longest_rows.clear();
1404 longest_line_len = line_char_count;
1405 }
1406 if line_char_count >= longest_line_len {
1407 expected_longest_rows.push(row as u32);
1408 }
1409 }
1410
1411 assert!(
1412 expected_longest_rows.contains(&actual_longest_row),
1413 "incorrect longest row {}. expected {:?} with length {}",
1414 actual_longest_row,
1415 expected_longest_rows,
1416 longest_line_len,
1417 )
1418 }
1419 }
1420 }
1421
1422 let mut initial_text = Rope::from(initial_snapshot.text().as_str());
1423 for (snapshot, patch) in edits {
1424 let snapshot_text = Rope::from(snapshot.text().as_str());
1425 for edit in &patch {
1426 let old_start = initial_text.point_to_offset(Point::new(edit.new.start, 0));
1427 let old_end = initial_text.point_to_offset(cmp::min(
1428 Point::new(edit.new.start + edit.old.len() as u32, 0),
1429 initial_text.max_point(),
1430 ));
1431 let new_start = snapshot_text.point_to_offset(Point::new(edit.new.start, 0));
1432 let new_end = snapshot_text.point_to_offset(cmp::min(
1433 Point::new(edit.new.end, 0),
1434 snapshot_text.max_point(),
1435 ));
1436 let new_text = snapshot_text
1437 .chunks_in_range(new_start..new_end)
1438 .collect::<String>();
1439
1440 initial_text.replace(old_start..old_end, &new_text);
1441 }
1442 assert_eq!(initial_text.to_string(), snapshot_text.to_string());
1443 }
1444
1445 if wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1446 log::info!("Waiting for wrapping to finish");
1447 while wrap_map.read_with(cx, |map, _| map.is_rewrapping()) {
1448 notifications.next().await.unwrap();
1449 }
1450 }
1451 wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
1452 }
1453
1454 fn init_test(cx: &mut gpui::TestAppContext) {
1455 cx.update(|cx| {
1456 let settings = SettingsStore::test(cx);
1457 cx.set_global(settings);
1458 theme::init(LoadThemes::JustBase, cx);
1459 });
1460 }
1461
1462 fn wrap_text(
1463 tab_snapshot: &TabSnapshot,
1464 wrap_width: Option<Pixels>,
1465 line_wrapper: &mut LineWrapper,
1466 ) -> String {
1467 if let Some(wrap_width) = wrap_width {
1468 let mut wrapped_text = String::new();
1469 for (row, line) in tab_snapshot.text().split('\n').enumerate() {
1470 if row > 0 {
1471 wrapped_text.push('\n');
1472 }
1473
1474 let mut prev_ix = 0;
1475 for boundary in line_wrapper.wrap_line(&[LineFragment::text(line)], wrap_width) {
1476 wrapped_text.push_str(&line[prev_ix..boundary.ix]);
1477 wrapped_text.push('\n');
1478 wrapped_text.push_str(&" ".repeat(boundary.next_indent as usize));
1479 prev_ix = boundary.ix;
1480 }
1481 wrapped_text.push_str(&line[prev_ix..]);
1482 }
1483
1484 wrapped_text
1485 } else {
1486 tab_snapshot.text()
1487 }
1488 }
1489
1490 impl WrapSnapshot {
1491 fn verify_chunks(&mut self, rng: &mut impl Rng) {
1492 for _ in 0..5 {
1493 let mut end_row = rng.random_range(0..=self.max_point().row());
1494 let start_row = rng.random_range(0..=end_row);
1495 end_row += 1;
1496
1497 let mut expected_text = self.text_chunks(start_row).collect::<String>();
1498 if expected_text.ends_with('\n') {
1499 expected_text.push('\n');
1500 }
1501 let mut expected_text = expected_text
1502 .lines()
1503 .take((end_row - start_row) as usize)
1504 .collect::<Vec<_>>()
1505 .join("\n");
1506 if end_row <= self.max_point().row() {
1507 expected_text.push('\n');
1508 }
1509
1510 let actual_text = self
1511 .chunks(start_row..end_row, true, Highlights::default())
1512 .map(|c| c.text)
1513 .collect::<String>();
1514 assert_eq!(
1515 expected_text,
1516 actual_text,
1517 "chunks != highlighted_chunks for rows {:?}",
1518 start_row..end_row
1519 );
1520 }
1521 }
1522 }
1523}