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