1use super::{
   2    fold_map,
   3    tab_map::{self, Edit as TabEdit, Snapshot as TabSnapshot, TabPoint, TextSummary},
   4};
   5use crate::{editor::Point, settings::HighlightId, util::Bias, Settings};
   6use gpui::{
   7    sum_tree::{self, Cursor, SumTree},
   8    text_layout::LineWrapper,
   9    Entity, ModelContext, Task,
  10};
  11use lazy_static::lazy_static;
  12use postage::{prelude::Stream, watch};
  13use smol::future::yield_now;
  14use std::{collections::VecDeque, ops::Range, time::Duration};
  15
  16pub struct WrapMap {
  17    snapshot: Snapshot,
  18    pending_edits: VecDeque<(TabSnapshot, Vec<TabEdit>)>,
  19    wrap_width: Option<f32>,
  20    background_task: Option<Task<()>>,
  21    _watch_settings: Task<()>,
  22    settings: watch::Receiver<Settings>,
  23}
  24
  25impl Entity for WrapMap {
  26    type Event = ();
  27}
  28
  29#[derive(Clone)]
  30pub struct Snapshot {
  31    tab_snapshot: TabSnapshot,
  32    transforms: SumTree<Transform>,
  33    interpolated: bool,
  34}
  35
  36#[derive(Clone, Debug, Default, Eq, PartialEq)]
  37struct Transform {
  38    summary: TransformSummary,
  39    display_text: Option<&'static str>,
  40}
  41
  42#[derive(Clone, Debug, Default, Eq, PartialEq)]
  43struct TransformSummary {
  44    input: TextSummary,
  45    output: TextSummary,
  46}
  47
  48#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  49pub struct WrapPoint(super::Point);
  50
  51pub struct Chunks<'a> {
  52    input_chunks: tab_map::Chunks<'a>,
  53    input_chunk: &'a str,
  54    output_position: WrapPoint,
  55    transforms: Cursor<'a, Transform, WrapPoint, TabPoint>,
  56}
  57
  58pub struct HighlightedChunks<'a> {
  59    input_chunks: tab_map::HighlightedChunks<'a>,
  60    input_chunk: &'a str,
  61    style_id: HighlightId,
  62    output_position: WrapPoint,
  63    max_output_row: u32,
  64    transforms: Cursor<'a, Transform, WrapPoint, TabPoint>,
  65}
  66
  67pub struct BufferRows<'a> {
  68    input_buffer_rows: fold_map::BufferRows<'a>,
  69    input_buffer_row: u32,
  70    output_row: u32,
  71    soft_wrapped: bool,
  72    max_output_row: u32,
  73    transforms: Cursor<'a, Transform, WrapPoint, TabPoint>,
  74}
  75
  76impl WrapMap {
  77    pub fn new(
  78        tab_snapshot: TabSnapshot,
  79        settings: watch::Receiver<Settings>,
  80        wrap_width: Option<f32>,
  81        cx: &mut ModelContext<Self>,
  82    ) -> Self {
  83        let _watch_settings = cx.spawn_weak({
  84            let mut prev_font = (
  85                settings.borrow().buffer_font_size,
  86                settings.borrow().buffer_font_family,
  87            );
  88            let mut settings = settings.clone();
  89            move |this, mut cx| async move {
  90                while let Some(settings) = settings.recv().await {
  91                    if let Some(this) = this.upgrade(&cx) {
  92                        let font = (settings.buffer_font_size, settings.buffer_font_family);
  93                        if font != prev_font {
  94                            prev_font = font;
  95                            this.update(&mut cx, |this, cx| this.rewrap(cx));
  96                        }
  97                    }
  98                }
  99            }
 100        });
 101
 102        let mut this = Self {
 103            wrap_width: None,
 104            pending_edits: Default::default(),
 105            snapshot: Snapshot::new(tab_snapshot),
 106            settings,
 107            background_task: None,
 108            _watch_settings,
 109        };
 110        this.set_wrap_width(wrap_width, cx);
 111
 112        this
 113    }
 114
 115    #[cfg(test)]
 116    pub fn is_rewrapping(&self) -> bool {
 117        self.background_task.is_some()
 118    }
 119
 120    pub fn sync(
 121        &mut self,
 122        tab_snapshot: TabSnapshot,
 123        edits: Vec<TabEdit>,
 124        cx: &mut ModelContext<Self>,
 125    ) -> Snapshot {
 126        self.pending_edits.push_back((tab_snapshot, edits));
 127        self.flush_edits(cx);
 128        self.snapshot.clone()
 129    }
 130
 131    pub fn set_wrap_width(&mut self, wrap_width: Option<f32>, cx: &mut ModelContext<Self>) -> bool {
 132        if wrap_width == self.wrap_width {
 133            return false;
 134        }
 135
 136        self.wrap_width = wrap_width;
 137        self.rewrap(cx);
 138        true
 139    }
 140
 141    fn rewrap(&mut self, cx: &mut ModelContext<Self>) {
 142        self.background_task.take();
 143
 144        if let Some(wrap_width) = self.wrap_width {
 145            let mut new_snapshot = self.snapshot.clone();
 146            let font_cache = cx.font_cache().clone();
 147            let settings = self.settings.clone();
 148            let task = cx.background().spawn(async move {
 149                let mut line_wrapper = {
 150                    let settings = settings.borrow();
 151                    let font_id = font_cache
 152                        .select_font(settings.buffer_font_family, &Default::default())
 153                        .unwrap();
 154                    font_cache.line_wrapper(font_id, settings.buffer_font_size)
 155                };
 156                let tab_snapshot = new_snapshot.tab_snapshot.clone();
 157                let range = TabPoint::zero()..tab_snapshot.max_point();
 158                new_snapshot
 159                    .update(
 160                        tab_snapshot,
 161                        &[TabEdit {
 162                            old_lines: range.clone(),
 163                            new_lines: range.clone(),
 164                        }],
 165                        wrap_width,
 166                        &mut line_wrapper,
 167                    )
 168                    .await;
 169                new_snapshot
 170            });
 171
 172            match cx
 173                .background()
 174                .block_with_timeout(Duration::from_millis(5), task)
 175            {
 176                Ok(snapshot) => {
 177                    self.snapshot = snapshot;
 178                    cx.notify();
 179                }
 180                Err(wrap_task) => {
 181                    self.background_task = Some(cx.spawn(|this, mut cx| async move {
 182                        let snapshot = wrap_task.await;
 183                        this.update(&mut cx, |this, cx| {
 184                            this.snapshot = snapshot;
 185                            this.background_task = None;
 186                            this.flush_edits(cx);
 187                            cx.notify();
 188                        });
 189                    }));
 190                }
 191            }
 192        } else {
 193            self.snapshot.transforms = SumTree::new();
 194            let summary = self.snapshot.tab_snapshot.text_summary();
 195            if !summary.lines.is_zero() {
 196                self.snapshot
 197                    .transforms
 198                    .push(Transform::isomorphic(summary), &());
 199            }
 200        }
 201    }
 202
 203    fn flush_edits(&mut self, cx: &mut ModelContext<Self>) {
 204        if !self.snapshot.interpolated {
 205            let mut to_remove_len = 0;
 206            for (tab_snapshot, _) in &self.pending_edits {
 207                if tab_snapshot.version() <= self.snapshot.tab_snapshot.version() {
 208                    to_remove_len += 1;
 209                } else {
 210                    break;
 211                }
 212            }
 213            self.pending_edits.drain(..to_remove_len);
 214        }
 215
 216        if self.pending_edits.is_empty() {
 217            return;
 218        }
 219
 220        if let Some(wrap_width) = self.wrap_width {
 221            if self.background_task.is_none() {
 222                let pending_edits = self.pending_edits.clone();
 223                let mut snapshot = self.snapshot.clone();
 224                let font_cache = cx.font_cache().clone();
 225                let settings = self.settings.clone();
 226                let update_task = cx.background().spawn(async move {
 227                    let mut line_wrapper = {
 228                        let settings = settings.borrow();
 229                        let font_id = font_cache
 230                            .select_font(settings.buffer_font_family, &Default::default())
 231                            .unwrap();
 232                        font_cache.line_wrapper(font_id, settings.buffer_font_size)
 233                    };
 234
 235                    for (tab_snapshot, edits) in pending_edits {
 236                        snapshot
 237                            .update(tab_snapshot, &edits, wrap_width, &mut line_wrapper)
 238                            .await;
 239                    }
 240                    snapshot
 241                });
 242
 243                match cx
 244                    .background()
 245                    .block_with_timeout(Duration::from_millis(1), update_task)
 246                {
 247                    Ok(snapshot) => {
 248                        self.snapshot = snapshot;
 249                    }
 250                    Err(update_task) => {
 251                        self.background_task = Some(cx.spawn(|this, mut cx| async move {
 252                            let snapshot = update_task.await;
 253                            this.update(&mut cx, |this, cx| {
 254                                this.snapshot = snapshot;
 255                                this.background_task = None;
 256                                this.flush_edits(cx);
 257                                cx.notify();
 258                            });
 259                        }));
 260                    }
 261                }
 262            }
 263        }
 264
 265        let was_interpolated = self.snapshot.interpolated;
 266        let mut to_remove_len = 0;
 267        for (tab_snapshot, edits) in &self.pending_edits {
 268            if tab_snapshot.version() <= self.snapshot.tab_snapshot.version() {
 269                to_remove_len += 1;
 270            } else {
 271                self.snapshot.interpolate(tab_snapshot.clone(), &edits);
 272            }
 273        }
 274
 275        if !was_interpolated {
 276            self.pending_edits.drain(..to_remove_len);
 277        }
 278    }
 279}
 280
 281impl Snapshot {
 282    fn new(tab_snapshot: TabSnapshot) -> Self {
 283        let mut transforms = SumTree::new();
 284        let extent = tab_snapshot.text_summary();
 285        if !extent.lines.is_zero() {
 286            transforms.push(Transform::isomorphic(extent), &());
 287        }
 288        Self {
 289            transforms,
 290            tab_snapshot,
 291            interpolated: true,
 292        }
 293    }
 294
 295    fn interpolate(&mut self, new_tab_snapshot: TabSnapshot, edits: &[TabEdit]) {
 296        let mut new_transforms;
 297        if edits.is_empty() {
 298            new_transforms = self.transforms.clone();
 299        } else {
 300            let mut old_cursor = self.transforms.cursor::<TabPoint, ()>();
 301            let mut edits = edits.into_iter().peekable();
 302            new_transforms =
 303                old_cursor.slice(&edits.peek().unwrap().old_lines.start, Bias::Right, &());
 304
 305            while let Some(edit) = edits.next() {
 306                if edit.new_lines.start > TabPoint::from(new_transforms.summary().input.lines) {
 307                    let summary = new_tab_snapshot.text_summary_for_range(
 308                        TabPoint::from(new_transforms.summary().input.lines)..edit.new_lines.start,
 309                    );
 310                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 311                }
 312
 313                if !edit.new_lines.is_empty() {
 314                    new_transforms.push_or_extend(Transform::isomorphic(
 315                        new_tab_snapshot.text_summary_for_range(edit.new_lines.clone()),
 316                    ));
 317                }
 318
 319                old_cursor.seek_forward(&edit.old_lines.end, Bias::Right, &());
 320                if let Some(next_edit) = edits.peek() {
 321                    if next_edit.old_lines.start > old_cursor.seek_end(&()) {
 322                        if old_cursor.seek_end(&()) > edit.old_lines.end {
 323                            let summary = self.tab_snapshot.text_summary_for_range(
 324                                edit.old_lines.end..old_cursor.seek_end(&()),
 325                            );
 326                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 327                        }
 328                        old_cursor.next(&());
 329                        new_transforms.push_tree(
 330                            old_cursor.slice(&next_edit.old_lines.start, Bias::Right, &()),
 331                            &(),
 332                        );
 333                    }
 334                } else {
 335                    if old_cursor.seek_end(&()) > edit.old_lines.end {
 336                        let summary = self
 337                            .tab_snapshot
 338                            .text_summary_for_range(edit.old_lines.end..old_cursor.seek_end(&()));
 339                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 340                    }
 341                    old_cursor.next(&());
 342                    new_transforms.push_tree(old_cursor.suffix(&()), &());
 343                }
 344            }
 345        }
 346
 347        self.transforms = new_transforms;
 348        self.tab_snapshot = new_tab_snapshot;
 349        self.interpolated = true;
 350        self.check_invariants();
 351    }
 352
 353    async fn update(
 354        &mut self,
 355        new_tab_snapshot: TabSnapshot,
 356        edits: &[TabEdit],
 357        wrap_width: f32,
 358        line_wrapper: &mut LineWrapper,
 359    ) {
 360        #[derive(Debug)]
 361        struct RowEdit {
 362            old_rows: Range<u32>,
 363            new_rows: Range<u32>,
 364        }
 365
 366        let mut edits = edits.into_iter().peekable();
 367        let mut row_edits = Vec::new();
 368        while let Some(edit) = edits.next() {
 369            let mut row_edit = RowEdit {
 370                old_rows: edit.old_lines.start.row()..edit.old_lines.end.row() + 1,
 371                new_rows: edit.new_lines.start.row()..edit.new_lines.end.row() + 1,
 372            };
 373
 374            while let Some(next_edit) = edits.peek() {
 375                if next_edit.old_lines.start.row() <= row_edit.old_rows.end {
 376                    row_edit.old_rows.end = next_edit.old_lines.end.row() + 1;
 377                    row_edit.new_rows.end = next_edit.new_lines.end.row() + 1;
 378                    edits.next();
 379                } else {
 380                    break;
 381                }
 382            }
 383
 384            row_edits.push(row_edit);
 385        }
 386
 387        let mut new_transforms;
 388        if row_edits.is_empty() {
 389            new_transforms = self.transforms.clone();
 390        } else {
 391            let mut row_edits = row_edits.into_iter().peekable();
 392            let mut old_cursor = self.transforms.cursor::<TabPoint, ()>();
 393
 394            new_transforms = old_cursor.slice(
 395                &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
 396                Bias::Right,
 397                &(),
 398            );
 399
 400            while let Some(edit) = row_edits.next() {
 401                if edit.new_rows.start > new_transforms.summary().input.lines.row {
 402                    let summary = new_tab_snapshot.text_summary_for_range(
 403                        TabPoint::new(new_transforms.summary().input.lines.row, 0)
 404                            ..TabPoint::new(edit.new_rows.start, 0),
 405                    );
 406                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 407                }
 408
 409                let mut line = String::new();
 410                let mut remaining = None;
 411                let mut chunks = new_tab_snapshot.chunks_at(TabPoint::new(edit.new_rows.start, 0));
 412                let mut edit_transforms = Vec::<Transform>::new();
 413                for _ in edit.new_rows.start..edit.new_rows.end {
 414                    while let Some(chunk) = remaining.take().or_else(|| chunks.next()) {
 415                        if let Some(ix) = chunk.find('\n') {
 416                            line.push_str(&chunk[..ix + 1]);
 417                            remaining = Some(&chunk[ix + 1..]);
 418                            break;
 419                        } else {
 420                            line.push_str(chunk)
 421                        }
 422                    }
 423
 424                    if line.is_empty() {
 425                        break;
 426                    }
 427
 428                    let mut prev_boundary_ix = 0;
 429                    for boundary in line_wrapper.wrap_line(&line, wrap_width) {
 430                        let wrapped = &line[prev_boundary_ix..boundary.ix];
 431                        push_isomorphic(&mut edit_transforms, TextSummary::from(wrapped));
 432                        edit_transforms.push(Transform::wrap(boundary.next_indent));
 433                        prev_boundary_ix = boundary.ix;
 434                    }
 435
 436                    if prev_boundary_ix < line.len() {
 437                        push_isomorphic(
 438                            &mut edit_transforms,
 439                            TextSummary::from(&line[prev_boundary_ix..]),
 440                        );
 441                    }
 442
 443                    line.clear();
 444                    yield_now().await;
 445                }
 446
 447                let mut edit_transforms = edit_transforms.into_iter();
 448                if let Some(transform) = edit_transforms.next() {
 449                    new_transforms.push_or_extend(transform);
 450                }
 451                new_transforms.extend(edit_transforms, &());
 452
 453                old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right, &());
 454                if let Some(next_edit) = row_edits.peek() {
 455                    if next_edit.old_rows.start > old_cursor.seek_end(&()).row() {
 456                        if old_cursor.seek_end(&()) > TabPoint::new(edit.old_rows.end, 0) {
 457                            let summary = self.tab_snapshot.text_summary_for_range(
 458                                TabPoint::new(edit.old_rows.end, 0)..old_cursor.seek_end(&()),
 459                            );
 460                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 461                        }
 462                        old_cursor.next(&());
 463                        new_transforms.push_tree(
 464                            old_cursor.slice(
 465                                &TabPoint::new(next_edit.old_rows.start, 0),
 466                                Bias::Right,
 467                                &(),
 468                            ),
 469                            &(),
 470                        );
 471                    }
 472                } else {
 473                    if old_cursor.seek_end(&()) > TabPoint::new(edit.old_rows.end, 0) {
 474                        let summary = self.tab_snapshot.text_summary_for_range(
 475                            TabPoint::new(edit.old_rows.end, 0)..old_cursor.seek_end(&()),
 476                        );
 477                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 478                    }
 479                    old_cursor.next(&());
 480                    new_transforms.push_tree(old_cursor.suffix(&()), &());
 481                }
 482            }
 483        }
 484
 485        self.transforms = new_transforms;
 486        self.tab_snapshot = new_tab_snapshot;
 487        self.interpolated = false;
 488        self.check_invariants();
 489    }
 490
 491    pub fn chunks_at(&self, wrap_row: u32) -> Chunks {
 492        let point = WrapPoint::new(wrap_row, 0);
 493        let mut transforms = self.transforms.cursor::<WrapPoint, TabPoint>();
 494        transforms.seek(&point, Bias::Right, &());
 495        let mut input_position = TabPoint(transforms.sum_start().0);
 496        if transforms.item().map_or(false, |t| t.is_isomorphic()) {
 497            input_position.0 += point.0 - transforms.seek_start().0;
 498        }
 499        let input_chunks = self.tab_snapshot.chunks_at(input_position);
 500        Chunks {
 501            input_chunks,
 502            transforms,
 503            output_position: point,
 504            input_chunk: "",
 505        }
 506    }
 507
 508    pub fn highlighted_chunks_for_rows(&mut self, rows: Range<u32>) -> HighlightedChunks {
 509        let output_start = WrapPoint::new(rows.start, 0);
 510        let output_end = WrapPoint::new(rows.end, 0);
 511        let mut transforms = self.transforms.cursor::<WrapPoint, TabPoint>();
 512        transforms.seek(&output_start, Bias::Right, &());
 513        let mut input_start = TabPoint(transforms.sum_start().0);
 514        if transforms.item().map_or(false, |t| t.is_isomorphic()) {
 515            input_start.0 += output_start.0 - transforms.seek_start().0;
 516        }
 517        let input_end = self
 518            .to_tab_point(output_end)
 519            .min(self.tab_snapshot.max_point());
 520        HighlightedChunks {
 521            input_chunks: self.tab_snapshot.highlighted_chunks(input_start..input_end),
 522            input_chunk: "",
 523            style_id: HighlightId::default(),
 524            output_position: output_start,
 525            max_output_row: rows.end,
 526            transforms,
 527        }
 528    }
 529
 530    pub fn max_point(&self) -> WrapPoint {
 531        self.to_wrap_point(self.tab_snapshot.max_point())
 532    }
 533
 534    pub fn line_len(&self, row: u32) -> u32 {
 535        let mut len = 0;
 536        for chunk in self.chunks_at(row) {
 537            if let Some(newline_ix) = chunk.find('\n') {
 538                len += newline_ix;
 539                break;
 540            } else {
 541                len += chunk.len();
 542            }
 543        }
 544        len as u32
 545    }
 546
 547    pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
 548        let mut cursor = self.transforms.cursor::<_, ()>();
 549        cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right, &());
 550        cursor.item().and_then(|transform| {
 551            if transform.is_isomorphic() {
 552                None
 553            } else {
 554                Some(transform.summary.output.lines.column)
 555            }
 556        })
 557    }
 558
 559    pub fn longest_row(&self) -> u32 {
 560        self.transforms.summary().output.longest_row
 561    }
 562
 563    pub fn buffer_rows(&self, start_row: u32) -> BufferRows {
 564        let mut transforms = self.transforms.cursor::<WrapPoint, TabPoint>();
 565        transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
 566        let mut input_row = transforms.sum_start().row();
 567        if transforms.item().map_or(false, |t| t.is_isomorphic()) {
 568            input_row += start_row - transforms.seek_start().row();
 569        }
 570        let soft_wrapped = transforms.item().map_or(false, |t| !t.is_isomorphic());
 571        let mut input_buffer_rows = self.tab_snapshot.buffer_rows(input_row);
 572        let input_buffer_row = input_buffer_rows.next().unwrap();
 573        BufferRows {
 574            transforms,
 575            input_buffer_row,
 576            input_buffer_rows,
 577            output_row: start_row,
 578            soft_wrapped,
 579            max_output_row: self.max_point().row(),
 580        }
 581    }
 582
 583    pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
 584        let mut cursor = self.transforms.cursor::<WrapPoint, TabPoint>();
 585        cursor.seek(&point, Bias::Right, &());
 586        let mut tab_point = cursor.sum_start().0;
 587        if cursor.item().map_or(false, |t| t.is_isomorphic()) {
 588            tab_point += point.0 - cursor.seek_start().0;
 589        }
 590        TabPoint(tab_point)
 591    }
 592
 593    pub fn to_wrap_point(&self, point: TabPoint) -> WrapPoint {
 594        let mut cursor = self.transforms.cursor::<TabPoint, WrapPoint>();
 595        cursor.seek(&point, Bias::Right, &());
 596        WrapPoint(cursor.sum_start().0 + (point.0 - cursor.seek_start().0))
 597    }
 598
 599    pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
 600        if bias == Bias::Left {
 601            let mut cursor = self.transforms.cursor::<WrapPoint, ()>();
 602            cursor.seek(&point, Bias::Right, &());
 603            if cursor.item().map_or(false, |t| !t.is_isomorphic()) {
 604                point = *cursor.seek_start();
 605                *point.column_mut() -= 1;
 606            }
 607        }
 608
 609        self.to_wrap_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias))
 610    }
 611
 612    fn check_invariants(&self) {
 613        #[cfg(test)]
 614        {
 615            assert_eq!(
 616                TabPoint::from(self.transforms.summary().input.lines),
 617                self.tab_snapshot.max_point()
 618            );
 619
 620            {
 621                let mut transforms = self.transforms.cursor::<(), ()>().peekable();
 622                while let Some(transform) = transforms.next() {
 623                    if let Some(next_transform) = transforms.peek() {
 624                        assert!(transform.is_isomorphic() != next_transform.is_isomorphic());
 625                    }
 626                }
 627            }
 628
 629            let mut expected_buffer_rows = Vec::new();
 630            let mut buffer_row = 0;
 631            let mut prev_tab_row = 0;
 632            for display_row in 0..=self.max_point().row() {
 633                let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
 634                let soft_wrapped;
 635                if tab_point.row() == prev_tab_row {
 636                    soft_wrapped = display_row != 0;
 637                } else {
 638                    let fold_point = self.tab_snapshot.to_fold_point(tab_point, Bias::Left).0;
 639                    let buffer_point = fold_point.to_buffer_point(&self.tab_snapshot.fold_snapshot);
 640                    buffer_row = buffer_point.row;
 641                    prev_tab_row = tab_point.row();
 642                    soft_wrapped = false;
 643                }
 644                expected_buffer_rows.push((buffer_row, soft_wrapped));
 645            }
 646
 647            for start_display_row in 0..expected_buffer_rows.len() {
 648                assert_eq!(
 649                    self.buffer_rows(start_display_row as u32)
 650                        .collect::<Vec<_>>(),
 651                    &expected_buffer_rows[start_display_row..],
 652                    "invalid buffer_rows({}..)",
 653                    start_display_row
 654                );
 655            }
 656        }
 657    }
 658}
 659
 660impl<'a> Iterator for Chunks<'a> {
 661    type Item = &'a str;
 662
 663    fn next(&mut self) -> Option<Self::Item> {
 664        let transform = self.transforms.item()?;
 665        if let Some(display_text) = transform.display_text {
 666            if self.output_position > *self.transforms.seek_start() {
 667                self.output_position.0.column += transform.summary.output.lines.column;
 668                self.transforms.next(&());
 669                return Some(&display_text[1..]);
 670            } else {
 671                self.output_position.0 += transform.summary.output.lines;
 672                self.transforms.next(&());
 673                return Some(display_text);
 674            }
 675        }
 676
 677        if self.input_chunk.is_empty() {
 678            self.input_chunk = self.input_chunks.next().unwrap();
 679        }
 680
 681        let mut input_len = 0;
 682        let transform_end = self.transforms.seek_end(&());
 683        for c in self.input_chunk.chars() {
 684            let char_len = c.len_utf8();
 685            input_len += char_len;
 686            if c == '\n' {
 687                *self.output_position.row_mut() += 1;
 688                *self.output_position.column_mut() = 0;
 689            } else {
 690                *self.output_position.column_mut() += char_len as u32;
 691            }
 692
 693            if self.output_position >= transform_end {
 694                self.transforms.next(&());
 695                break;
 696            }
 697        }
 698
 699        let (prefix, suffix) = self.input_chunk.split_at(input_len);
 700        self.input_chunk = suffix;
 701        Some(prefix)
 702    }
 703}
 704
 705impl<'a> Iterator for HighlightedChunks<'a> {
 706    type Item = (&'a str, HighlightId);
 707
 708    fn next(&mut self) -> Option<Self::Item> {
 709        if self.output_position.row() >= self.max_output_row {
 710            return None;
 711        }
 712
 713        let transform = self.transforms.item()?;
 714        if let Some(display_text) = transform.display_text {
 715            let mut start_ix = 0;
 716            let mut end_ix = display_text.len();
 717            let mut summary = transform.summary.output.lines;
 718
 719            if self.output_position > *self.transforms.seek_start() {
 720                // Exclude newline starting prior to the desired row.
 721                start_ix = 1;
 722                summary.row = 0;
 723            } else if self.output_position.row() + 1 >= self.max_output_row {
 724                // Exclude soft indentation ending after the desired row.
 725                end_ix = 1;
 726                summary.column = 0;
 727            }
 728
 729            self.output_position.0 += summary;
 730            self.transforms.next(&());
 731            return Some((&display_text[start_ix..end_ix], self.style_id));
 732        }
 733
 734        if self.input_chunk.is_empty() {
 735            let (chunk, style_id) = self.input_chunks.next().unwrap();
 736            self.input_chunk = chunk;
 737            self.style_id = style_id;
 738        }
 739
 740        let mut input_len = 0;
 741        let transform_end = self.transforms.seek_end(&());
 742        for c in self.input_chunk.chars() {
 743            let char_len = c.len_utf8();
 744            input_len += char_len;
 745            if c == '\n' {
 746                *self.output_position.row_mut() += 1;
 747                *self.output_position.column_mut() = 0;
 748            } else {
 749                *self.output_position.column_mut() += char_len as u32;
 750            }
 751
 752            if self.output_position >= transform_end {
 753                self.transforms.next(&());
 754                break;
 755            }
 756        }
 757
 758        let (prefix, suffix) = self.input_chunk.split_at(input_len);
 759        self.input_chunk = suffix;
 760        Some((prefix, self.style_id))
 761    }
 762}
 763
 764impl<'a> Iterator for BufferRows<'a> {
 765    type Item = (u32, bool);
 766
 767    fn next(&mut self) -> Option<Self::Item> {
 768        if self.output_row > self.max_output_row {
 769            return None;
 770        }
 771
 772        let buffer_row = self.input_buffer_row;
 773        let soft_wrapped = self.soft_wrapped;
 774
 775        self.output_row += 1;
 776        self.transforms
 777            .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left, &());
 778        if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
 779            self.input_buffer_row = self.input_buffer_rows.next().unwrap();
 780            self.soft_wrapped = false;
 781        } else {
 782            self.soft_wrapped = true;
 783        }
 784
 785        Some((buffer_row, soft_wrapped))
 786    }
 787}
 788
 789impl Transform {
 790    fn isomorphic(summary: TextSummary) -> Self {
 791        #[cfg(test)]
 792        assert!(!summary.lines.is_zero());
 793
 794        Self {
 795            summary: TransformSummary {
 796                input: summary.clone(),
 797                output: summary,
 798            },
 799            display_text: None,
 800        }
 801    }
 802
 803    fn wrap(indent: u32) -> Self {
 804        lazy_static! {
 805            static ref WRAP_TEXT: String = {
 806                let mut wrap_text = String::new();
 807                wrap_text.push('\n');
 808                wrap_text.extend((0..LineWrapper::MAX_INDENT as usize).map(|_| ' '));
 809                wrap_text
 810            };
 811        }
 812
 813        Self {
 814            summary: TransformSummary {
 815                input: TextSummary::default(),
 816                output: TextSummary {
 817                    lines: Point::new(1, indent),
 818                    first_line_chars: 0,
 819                    last_line_chars: indent,
 820                    longest_row: 1,
 821                    longest_row_chars: indent,
 822                },
 823            },
 824            display_text: Some(&WRAP_TEXT[..1 + indent as usize]),
 825        }
 826    }
 827
 828    fn is_isomorphic(&self) -> bool {
 829        self.display_text.is_none()
 830    }
 831}
 832
 833impl sum_tree::Item for Transform {
 834    type Summary = TransformSummary;
 835
 836    fn summary(&self) -> Self::Summary {
 837        self.summary.clone()
 838    }
 839}
 840
 841fn push_isomorphic(transforms: &mut Vec<Transform>, summary: TextSummary) {
 842    if let Some(last_transform) = transforms.last_mut() {
 843        if last_transform.is_isomorphic() {
 844            last_transform.summary.input += &summary;
 845            last_transform.summary.output += &summary;
 846            return;
 847        }
 848    }
 849    transforms.push(Transform::isomorphic(summary));
 850}
 851
 852trait SumTreeExt {
 853    fn push_or_extend(&mut self, transform: Transform);
 854}
 855
 856impl SumTreeExt for SumTree<Transform> {
 857    fn push_or_extend(&mut self, transform: Transform) {
 858        let mut transform = Some(transform);
 859        self.update_last(
 860            |last_transform| {
 861                if last_transform.is_isomorphic() && transform.as_ref().unwrap().is_isomorphic() {
 862                    let transform = transform.take().unwrap();
 863                    last_transform.summary.input += &transform.summary.input;
 864                    last_transform.summary.output += &transform.summary.output;
 865                }
 866            },
 867            &(),
 868        );
 869
 870        if let Some(transform) = transform {
 871            self.push(transform, &());
 872        }
 873    }
 874}
 875
 876impl WrapPoint {
 877    pub fn new(row: u32, column: u32) -> Self {
 878        Self(super::Point::new(row, column))
 879    }
 880
 881    #[cfg(test)]
 882    pub fn is_zero(&self) -> bool {
 883        self.0.is_zero()
 884    }
 885
 886    pub fn row(self) -> u32 {
 887        self.0.row
 888    }
 889
 890    pub fn column(self) -> u32 {
 891        self.0.column
 892    }
 893
 894    pub fn row_mut(&mut self) -> &mut u32 {
 895        &mut self.0.row
 896    }
 897
 898    pub fn column_mut(&mut self) -> &mut u32 {
 899        &mut self.0.column
 900    }
 901}
 902
 903impl sum_tree::Summary for TransformSummary {
 904    type Context = ();
 905
 906    fn add_summary(&mut self, other: &Self, _: &()) {
 907        self.input += &other.input;
 908        self.output += &other.output;
 909    }
 910}
 911
 912impl<'a> sum_tree::Dimension<'a, TransformSummary> for TabPoint {
 913    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 914        self.0 += summary.input.lines;
 915    }
 916}
 917
 918impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
 919    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 920        self.0 += summary.output.lines;
 921    }
 922}
 923
 924#[cfg(test)]
 925mod tests {
 926    use super::*;
 927    use crate::{
 928        editor::{
 929            display_map::{fold_map::FoldMap, tab_map::TabMap},
 930            Buffer,
 931        },
 932        test::Observer,
 933        util::RandomCharIter,
 934    };
 935    use rand::prelude::*;
 936    use std::env;
 937
 938    #[gpui::test(iterations = 100)]
 939    async fn test_random_wraps(mut cx: gpui::TestAppContext, mut rng: StdRng) {
 940        cx.foreground().set_block_on_ticks(0..=50);
 941        cx.foreground().forbid_parking();
 942        let operations = env::var("OPERATIONS")
 943            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
 944            .unwrap_or(10);
 945
 946        let font_cache = cx.font_cache().clone();
 947        let font_system = cx.platform().fonts();
 948        let mut wrap_width = if rng.gen_bool(0.1) {
 949            None
 950        } else {
 951            Some(rng.gen_range(0.0..=1000.0))
 952        };
 953        let settings = Settings {
 954            tab_size: rng.gen_range(1..=4),
 955            buffer_font_family: font_cache.load_family(&["Helvetica"]).unwrap(),
 956            buffer_font_size: 14.0,
 957            ..cx.read(Settings::test)
 958        };
 959        log::info!("Tab size: {}", settings.tab_size);
 960        log::info!("Wrap width: {:?}", wrap_width);
 961
 962        let buffer = cx.add_model(|cx| {
 963            let len = rng.gen_range(0..10);
 964            let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
 965            Buffer::new(0, text, cx)
 966        });
 967        let (mut fold_map, folds_snapshot) = cx.read(|cx| FoldMap::new(buffer.clone(), cx));
 968        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), settings.tab_size);
 969        log::info!(
 970            "Unwrapped text (no folds): {:?}",
 971            buffer.read_with(&cx, |buf, _| buf.text())
 972        );
 973        log::info!(
 974            "Unwrapped text (unexpanded tabs): {:?}",
 975            folds_snapshot.text()
 976        );
 977        log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
 978
 979        let font_id = font_cache
 980            .select_font(settings.buffer_font_family, &Default::default())
 981            .unwrap();
 982        let mut line_wrapper = LineWrapper::new(font_id, settings.buffer_font_size, font_system);
 983        let unwrapped_text = tabs_snapshot.text();
 984        let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper);
 985
 986        let settings = watch::channel_with(settings).1;
 987        let wrap_map = cx
 988            .add_model(|cx| WrapMap::new(tabs_snapshot.clone(), settings.clone(), wrap_width, cx));
 989        let (_observer, notifications) = Observer::new(&wrap_map, &mut cx);
 990
 991        if wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
 992            notifications.recv().await.unwrap();
 993        }
 994
 995        let snapshot = wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx));
 996        let actual_text = snapshot.text();
 997        assert_eq!(
 998            actual_text, expected_text,
 999            "unwrapped text is: {:?}",
1000            unwrapped_text
1001        );
1002        log::info!("Wrapped text: {:?}", actual_text);
1003
1004        for _i in 0..operations {
1005            match rng.gen_range(0..=100) {
1006                0..=19 => {
1007                    wrap_width = if rng.gen_bool(0.2) {
1008                        None
1009                    } else {
1010                        Some(rng.gen_range(0.0..=1000.0))
1011                    };
1012                    log::info!("Setting wrap width to {:?}", wrap_width);
1013                    wrap_map.update(&mut cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1014                }
1015                20..=39 => {
1016                    for (folds_snapshot, edits) in
1017                        cx.read(|cx| fold_map.randomly_mutate(&mut rng, cx))
1018                    {
1019                        let (tabs_snapshot, edits) = tab_map.sync(folds_snapshot, edits);
1020                        let mut snapshot =
1021                            wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, edits, cx));
1022                        snapshot.check_invariants();
1023                        snapshot.verify_chunks(&mut rng);
1024                    }
1025                }
1026                _ => {
1027                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_mutate(&mut rng, cx));
1028                }
1029            }
1030
1031            log::info!(
1032                "Unwrapped text (no folds): {:?}",
1033                buffer.read_with(&cx, |buf, _| buf.text())
1034            );
1035            let (folds_snapshot, edits) = cx.read(|cx| fold_map.read(cx));
1036            log::info!(
1037                "Unwrapped text (unexpanded tabs): {:?}",
1038                folds_snapshot.text()
1039            );
1040            let (tabs_snapshot, edits) = tab_map.sync(folds_snapshot, edits);
1041            log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
1042
1043            let unwrapped_text = tabs_snapshot.text();
1044            let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper);
1045            let mut snapshot = wrap_map.update(&mut cx, |map, cx| {
1046                map.sync(tabs_snapshot.clone(), edits, cx)
1047            });
1048            snapshot.check_invariants();
1049            snapshot.verify_chunks(&mut rng);
1050
1051            if wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) && rng.gen_bool(0.4) {
1052                log::info!("Waiting for wrapping to finish");
1053                while wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
1054                    notifications.recv().await.unwrap();
1055                }
1056            }
1057
1058            if !wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
1059                let mut wrapped_snapshot =
1060                    wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx));
1061                let actual_text = wrapped_snapshot.text();
1062                log::info!("Wrapping finished: {:?}", actual_text);
1063                wrapped_snapshot.check_invariants();
1064                wrapped_snapshot.verify_chunks(&mut rng);
1065                assert_eq!(
1066                    actual_text, expected_text,
1067                    "unwrapped text is: {:?}",
1068                    unwrapped_text
1069                );
1070            }
1071        }
1072    }
1073
1074    fn wrap_text(
1075        unwrapped_text: &str,
1076        wrap_width: Option<f32>,
1077        line_wrapper: &mut LineWrapper,
1078    ) -> String {
1079        if let Some(wrap_width) = wrap_width {
1080            let mut wrapped_text = String::new();
1081            for (row, line) in unwrapped_text.split('\n').enumerate() {
1082                if row > 0 {
1083                    wrapped_text.push('\n')
1084                }
1085
1086                let mut prev_ix = 0;
1087                for boundary in line_wrapper.wrap_line(line, wrap_width) {
1088                    wrapped_text.push_str(&line[prev_ix..boundary.ix]);
1089                    wrapped_text.push('\n');
1090                    wrapped_text.push_str(&" ".repeat(boundary.next_indent as usize));
1091                    prev_ix = boundary.ix;
1092                }
1093                wrapped_text.push_str(&line[prev_ix..]);
1094            }
1095            wrapped_text
1096        } else {
1097            unwrapped_text.to_string()
1098        }
1099    }
1100
1101    impl Snapshot {
1102        fn text(&self) -> String {
1103            self.chunks_at(0).collect()
1104        }
1105
1106        fn verify_chunks(&mut self, rng: &mut impl Rng) {
1107            for _ in 0..5 {
1108                let mut end_row = rng.gen_range(0..=self.max_point().row());
1109                let start_row = rng.gen_range(0..=end_row);
1110                end_row += 1;
1111
1112                let mut expected_text = self.chunks_at(start_row).collect::<String>();
1113                if expected_text.ends_with("\n") {
1114                    expected_text.push('\n');
1115                }
1116                let mut expected_text = expected_text
1117                    .lines()
1118                    .take((end_row - start_row) as usize)
1119                    .collect::<Vec<_>>()
1120                    .join("\n");
1121                if end_row <= self.max_point().row() {
1122                    expected_text.push('\n');
1123                }
1124
1125                let actual_text = self
1126                    .highlighted_chunks_for_rows(start_row..end_row)
1127                    .map(|c| c.0)
1128                    .collect::<String>();
1129                assert_eq!(
1130                    expected_text,
1131                    actual_text,
1132                    "chunks != highlighted_chunks for rows {:?}",
1133                    start_row..end_row
1134                );
1135            }
1136        }
1137    }
1138}