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            let mut tab_edits_iter = tab_edits.iter().peekable();
 308            new_transforms = old_cursor.slice(
 309                &tab_edits_iter.peek().unwrap().old_lines.start,
 310                Bias::Right,
 311                &(),
 312            );
 313
 314            while let Some(edit) = tab_edits_iter.next() {
 315                if edit.new_lines.start > TabPoint::from(new_transforms.summary().input.lines) {
 316                    let summary = new_tab_snapshot.text_summary_for_range(
 317                        TabPoint::from(new_transforms.summary().input.lines)..edit.new_lines.start,
 318                    );
 319                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 320                }
 321
 322                if !edit.new_lines.is_empty() {
 323                    new_transforms.push_or_extend(Transform::isomorphic(
 324                        new_tab_snapshot.text_summary_for_range(edit.new_lines.clone()),
 325                    ));
 326                }
 327
 328                old_cursor.seek_forward(&edit.old_lines.end, Bias::Right, &());
 329                if let Some(next_edit) = tab_edits_iter.peek() {
 330                    if next_edit.old_lines.start > old_cursor.end(&()) {
 331                        if old_cursor.end(&()) > edit.old_lines.end {
 332                            let summary = self
 333                                .tab_snapshot
 334                                .text_summary_for_range(edit.old_lines.end..old_cursor.end(&()));
 335                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 336                        }
 337                        old_cursor.next(&());
 338                        new_transforms.push_tree(
 339                            old_cursor.slice(&next_edit.old_lines.start, Bias::Right, &()),
 340                            &(),
 341                        );
 342                    }
 343                } else {
 344                    if old_cursor.end(&()) > edit.old_lines.end {
 345                        let summary = self
 346                            .tab_snapshot
 347                            .text_summary_for_range(edit.old_lines.end..old_cursor.end(&()));
 348                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 349                    }
 350                    old_cursor.next(&());
 351                    new_transforms.push_tree(old_cursor.suffix(&()), &());
 352                }
 353            }
 354        }
 355
 356        let old_snapshot = mem::replace(
 357            self,
 358            Snapshot {
 359                tab_snapshot: new_tab_snapshot,
 360                transforms: new_transforms,
 361                interpolated: true,
 362            },
 363        );
 364        self.check_invariants();
 365        old_snapshot.compute_edits(tab_edits, self)
 366    }
 367
 368    async fn update(
 369        &mut self,
 370        new_tab_snapshot: TabSnapshot,
 371        tab_edits: &[TabEdit],
 372        wrap_width: f32,
 373        line_wrapper: &mut LineWrapper,
 374    ) -> Patch {
 375        #[derive(Debug)]
 376        struct RowEdit {
 377            old_rows: Range<u32>,
 378            new_rows: Range<u32>,
 379        }
 380
 381        let mut tab_edits_iter = tab_edits.into_iter().peekable();
 382        let mut row_edits = Vec::new();
 383        while let Some(edit) = tab_edits_iter.next() {
 384            let mut row_edit = RowEdit {
 385                old_rows: edit.old_lines.start.row()..edit.old_lines.end.row() + 1,
 386                new_rows: edit.new_lines.start.row()..edit.new_lines.end.row() + 1,
 387            };
 388
 389            while let Some(next_edit) = tab_edits_iter.peek() {
 390                if next_edit.old_lines.start.row() <= row_edit.old_rows.end {
 391                    row_edit.old_rows.end = next_edit.old_lines.end.row() + 1;
 392                    row_edit.new_rows.end = next_edit.new_lines.end.row() + 1;
 393                    tab_edits_iter.next();
 394                } else {
 395                    break;
 396                }
 397            }
 398
 399            row_edits.push(row_edit);
 400        }
 401
 402        let mut new_transforms;
 403        if row_edits.is_empty() {
 404            new_transforms = self.transforms.clone();
 405        } else {
 406            let mut row_edits = row_edits.into_iter().peekable();
 407            let mut old_cursor = self.transforms.cursor::<TabPoint>();
 408
 409            new_transforms = old_cursor.slice(
 410                &TabPoint::new(row_edits.peek().unwrap().old_rows.start, 0),
 411                Bias::Right,
 412                &(),
 413            );
 414
 415            while let Some(edit) = row_edits.next() {
 416                if edit.new_rows.start > new_transforms.summary().input.lines.row {
 417                    let summary = new_tab_snapshot.text_summary_for_range(
 418                        TabPoint::new(new_transforms.summary().input.lines.row, 0)
 419                            ..TabPoint::new(edit.new_rows.start, 0),
 420                    );
 421                    new_transforms.push_or_extend(Transform::isomorphic(summary));
 422                }
 423
 424                let mut line = String::new();
 425                let mut remaining = None;
 426                let mut chunks = new_tab_snapshot.chunks(
 427                    TabPoint::new(edit.new_rows.start, 0)..new_tab_snapshot.max_point(),
 428                    false,
 429                );
 430                let mut edit_transforms = Vec::<Transform>::new();
 431                for _ in edit.new_rows.start..edit.new_rows.end {
 432                    while let Some(chunk) =
 433                        remaining.take().or_else(|| chunks.next().map(|c| c.text))
 434                    {
 435                        if let Some(ix) = chunk.find('\n') {
 436                            line.push_str(&chunk[..ix + 1]);
 437                            remaining = Some(&chunk[ix + 1..]);
 438                            break;
 439                        } else {
 440                            line.push_str(chunk)
 441                        }
 442                    }
 443
 444                    if line.is_empty() {
 445                        break;
 446                    }
 447
 448                    let mut prev_boundary_ix = 0;
 449                    for boundary in line_wrapper.wrap_line(&line, wrap_width) {
 450                        let wrapped = &line[prev_boundary_ix..boundary.ix];
 451                        push_isomorphic(&mut edit_transforms, TextSummary::from(wrapped));
 452                        edit_transforms.push(Transform::wrap(boundary.next_indent));
 453                        prev_boundary_ix = boundary.ix;
 454                    }
 455
 456                    if prev_boundary_ix < line.len() {
 457                        push_isomorphic(
 458                            &mut edit_transforms,
 459                            TextSummary::from(&line[prev_boundary_ix..]),
 460                        );
 461                    }
 462
 463                    line.clear();
 464                    yield_now().await;
 465                }
 466
 467                let mut edit_transforms = edit_transforms.into_iter();
 468                if let Some(transform) = edit_transforms.next() {
 469                    new_transforms.push_or_extend(transform);
 470                }
 471                new_transforms.extend(edit_transforms, &());
 472
 473                old_cursor.seek_forward(&TabPoint::new(edit.old_rows.end, 0), Bias::Right, &());
 474                if let Some(next_edit) = row_edits.peek() {
 475                    if next_edit.old_rows.start > old_cursor.end(&()).row() {
 476                        if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) {
 477                            let summary = self.tab_snapshot.text_summary_for_range(
 478                                TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()),
 479                            );
 480                            new_transforms.push_or_extend(Transform::isomorphic(summary));
 481                        }
 482                        old_cursor.next(&());
 483                        new_transforms.push_tree(
 484                            old_cursor.slice(
 485                                &TabPoint::new(next_edit.old_rows.start, 0),
 486                                Bias::Right,
 487                                &(),
 488                            ),
 489                            &(),
 490                        );
 491                    }
 492                } else {
 493                    if old_cursor.end(&()) > TabPoint::new(edit.old_rows.end, 0) {
 494                        let summary = self.tab_snapshot.text_summary_for_range(
 495                            TabPoint::new(edit.old_rows.end, 0)..old_cursor.end(&()),
 496                        );
 497                        new_transforms.push_or_extend(Transform::isomorphic(summary));
 498                    }
 499                    old_cursor.next(&());
 500                    new_transforms.push_tree(old_cursor.suffix(&()), &());
 501                }
 502            }
 503        }
 504
 505        let old_snapshot = mem::replace(
 506            self,
 507            Snapshot {
 508                tab_snapshot: new_tab_snapshot,
 509                transforms: new_transforms,
 510                interpolated: false,
 511            },
 512        );
 513        self.check_invariants();
 514        old_snapshot.compute_edits(tab_edits, self)
 515    }
 516
 517    fn compute_edits(&self, tab_edits: &[TabEdit], new_snapshot: &Snapshot) -> Patch {
 518        let mut wrap_edits = Vec::new();
 519        let mut old_cursor = self.transforms.cursor::<TransformSummary>();
 520        let mut new_cursor = new_snapshot.transforms.cursor::<TransformSummary>();
 521        for mut tab_edit in tab_edits.iter().cloned() {
 522            tab_edit.old_lines.start.0.column = 0;
 523            tab_edit.old_lines.end.0 += Point::new(1, 0);
 524            tab_edit.new_lines.start.0.column = 0;
 525            tab_edit.new_lines.end.0 += Point::new(1, 0);
 526
 527            old_cursor.seek(&tab_edit.old_lines.start, Bias::Right, &());
 528            let mut old_start = old_cursor.start().output.lines;
 529            old_start += tab_edit.old_lines.start.0 - old_cursor.start().input.lines;
 530
 531            old_cursor.seek(&tab_edit.old_lines.end, Bias::Right, &());
 532            let mut old_end = old_cursor.start().output.lines;
 533            old_end += tab_edit.old_lines.end.0 - old_cursor.start().input.lines;
 534
 535            new_cursor.seek(&tab_edit.new_lines.start, Bias::Right, &());
 536            let mut new_start = new_cursor.start().output.lines;
 537            new_start += tab_edit.new_lines.start.0 - new_cursor.start().input.lines;
 538
 539            new_cursor.seek(&tab_edit.new_lines.end, Bias::Right, &());
 540            let mut new_end = new_cursor.start().output.lines;
 541            new_end += tab_edit.new_lines.end.0 - new_cursor.start().input.lines;
 542
 543            wrap_edits.push(Edit {
 544                old: old_start.row..old_end.row,
 545                new: new_start.row..new_end.row,
 546            });
 547        }
 548
 549        consolidate_wrap_edits(&mut wrap_edits);
 550        unsafe { Patch::new_unchecked(wrap_edits) }
 551    }
 552
 553    pub fn text_chunks(&self, wrap_row: u32) -> impl Iterator<Item = &str> {
 554        self.chunks(wrap_row..self.max_point().row() + 1, false)
 555            .map(|h| h.text)
 556    }
 557
 558    pub fn chunks(&self, rows: Range<u32>, highlights: bool) -> Chunks {
 559        let output_start = WrapPoint::new(rows.start, 0);
 560        let output_end = WrapPoint::new(rows.end, 0);
 561        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>();
 562        transforms.seek(&output_start, Bias::Right, &());
 563        let mut input_start = TabPoint(transforms.start().1 .0);
 564        if transforms.item().map_or(false, |t| t.is_isomorphic()) {
 565            input_start.0 += output_start.0 - transforms.start().0 .0;
 566        }
 567        let input_end = self
 568            .to_tab_point(output_end)
 569            .min(self.tab_snapshot.max_point());
 570        Chunks {
 571            input_chunks: self.tab_snapshot.chunks(input_start..input_end, highlights),
 572            input_chunk: Default::default(),
 573            output_position: output_start,
 574            max_output_row: rows.end,
 575            transforms,
 576        }
 577    }
 578
 579    pub fn text_summary(&self) -> TextSummary {
 580        self.transforms.summary().output
 581    }
 582
 583    pub fn max_point(&self) -> WrapPoint {
 584        WrapPoint(self.transforms.summary().output.lines)
 585    }
 586
 587    pub fn line_len(&self, row: u32) -> u32 {
 588        let mut len = 0;
 589        for chunk in self.text_chunks(row) {
 590            if let Some(newline_ix) = chunk.find('\n') {
 591                len += newline_ix;
 592                break;
 593            } else {
 594                len += chunk.len();
 595            }
 596        }
 597        len as u32
 598    }
 599
 600    pub fn soft_wrap_indent(&self, row: u32) -> Option<u32> {
 601        let mut cursor = self.transforms.cursor::<WrapPoint>();
 602        cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Right, &());
 603        cursor.item().and_then(|transform| {
 604            if transform.is_isomorphic() {
 605                None
 606            } else {
 607                Some(transform.summary.output.lines.column)
 608            }
 609        })
 610    }
 611
 612    pub fn longest_row(&self) -> u32 {
 613        self.transforms.summary().output.longest_row
 614    }
 615
 616    pub fn buffer_rows(&self, start_row: u32) -> BufferRows {
 617        let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>();
 618        transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
 619        let mut input_row = transforms.start().1.row();
 620        if transforms.item().map_or(false, |t| t.is_isomorphic()) {
 621            input_row += start_row - transforms.start().0.row();
 622        }
 623        let soft_wrapped = transforms.item().map_or(false, |t| !t.is_isomorphic());
 624        let mut input_buffer_rows = self.tab_snapshot.buffer_rows(input_row);
 625        let input_buffer_row = input_buffer_rows.next().unwrap();
 626        BufferRows {
 627            transforms,
 628            input_buffer_row,
 629            input_buffer_rows,
 630            output_row: start_row,
 631            soft_wrapped,
 632            max_output_row: self.max_point().row(),
 633        }
 634    }
 635
 636    pub fn to_tab_point(&self, point: WrapPoint) -> TabPoint {
 637        let mut cursor = self.transforms.cursor::<(WrapPoint, TabPoint)>();
 638        cursor.seek(&point, Bias::Right, &());
 639        let mut tab_point = cursor.start().1 .0;
 640        if cursor.item().map_or(false, |t| t.is_isomorphic()) {
 641            tab_point += point.0 - cursor.start().0 .0;
 642        }
 643        TabPoint(tab_point)
 644    }
 645
 646    pub fn to_point(&self, point: WrapPoint, bias: Bias) -> Point {
 647        self.tab_snapshot.to_point(self.to_tab_point(point), bias)
 648    }
 649
 650    pub fn from_point(&self, point: Point, bias: Bias) -> WrapPoint {
 651        self.from_tab_point(self.tab_snapshot.from_point(point, bias))
 652    }
 653
 654    pub fn from_tab_point(&self, point: TabPoint) -> WrapPoint {
 655        let mut cursor = self.transforms.cursor::<(TabPoint, WrapPoint)>();
 656        cursor.seek(&point, Bias::Right, &());
 657        WrapPoint(cursor.start().1 .0 + (point.0 - cursor.start().0 .0))
 658    }
 659
 660    pub fn clip_point(&self, mut point: WrapPoint, bias: Bias) -> WrapPoint {
 661        if bias == Bias::Left {
 662            let mut cursor = self.transforms.cursor::<WrapPoint>();
 663            cursor.seek(&point, Bias::Right, &());
 664            if cursor.item().map_or(false, |t| !t.is_isomorphic()) {
 665                point = *cursor.start();
 666                *point.column_mut() -= 1;
 667            }
 668        }
 669
 670        self.from_tab_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias))
 671    }
 672
 673    fn check_invariants(&self) {
 674        #[cfg(test)]
 675        {
 676            assert_eq!(
 677                TabPoint::from(self.transforms.summary().input.lines),
 678                self.tab_snapshot.max_point()
 679            );
 680
 681            {
 682                let mut transforms = self.transforms.cursor::<()>().peekable();
 683                while let Some(transform) = transforms.next() {
 684                    if let Some(next_transform) = transforms.peek() {
 685                        assert!(transform.is_isomorphic() != next_transform.is_isomorphic());
 686                    }
 687                }
 688            }
 689
 690            let mut expected_buffer_rows = Vec::new();
 691            let mut buffer_row = 0;
 692            let mut prev_tab_row = 0;
 693            for display_row in 0..=self.max_point().row() {
 694                let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
 695                let soft_wrapped;
 696                if tab_point.row() == prev_tab_row {
 697                    soft_wrapped = display_row != 0;
 698                } else {
 699                    let fold_point = self.tab_snapshot.to_fold_point(tab_point, Bias::Left).0;
 700                    let buffer_point = fold_point.to_buffer_point(&self.tab_snapshot.fold_snapshot);
 701                    buffer_row = buffer_point.row;
 702                    prev_tab_row = tab_point.row();
 703                    soft_wrapped = false;
 704                }
 705                expected_buffer_rows.push(if soft_wrapped { None } else { Some(buffer_row) });
 706            }
 707
 708            for start_display_row in 0..expected_buffer_rows.len() {
 709                assert_eq!(
 710                    self.buffer_rows(start_display_row as u32)
 711                        .collect::<Vec<_>>(),
 712                    &expected_buffer_rows[start_display_row..],
 713                    "invalid buffer_rows({}..)",
 714                    start_display_row
 715                );
 716            }
 717        }
 718    }
 719}
 720
 721impl<'a> Iterator for Chunks<'a> {
 722    type Item = Chunk<'a>;
 723
 724    fn next(&mut self) -> Option<Self::Item> {
 725        if self.output_position.row() >= self.max_output_row {
 726            return None;
 727        }
 728
 729        let transform = self.transforms.item()?;
 730        if let Some(display_text) = transform.display_text {
 731            let mut start_ix = 0;
 732            let mut end_ix = display_text.len();
 733            let mut summary = transform.summary.output.lines;
 734
 735            if self.output_position > self.transforms.start().0 {
 736                // Exclude newline starting prior to the desired row.
 737                start_ix = 1;
 738                summary.row = 0;
 739            } else if self.output_position.row() + 1 >= self.max_output_row {
 740                // Exclude soft indentation ending after the desired row.
 741                end_ix = 1;
 742                summary.column = 0;
 743            }
 744
 745            self.output_position.0 += summary;
 746            self.transforms.next(&());
 747            return Some(Chunk {
 748                text: &display_text[start_ix..end_ix],
 749                ..self.input_chunk
 750            });
 751        }
 752
 753        if self.input_chunk.text.is_empty() {
 754            self.input_chunk = self.input_chunks.next().unwrap();
 755        }
 756
 757        let mut input_len = 0;
 758        let transform_end = self.transforms.end(&()).0;
 759        for c in self.input_chunk.text.chars() {
 760            let char_len = c.len_utf8();
 761            input_len += char_len;
 762            if c == '\n' {
 763                *self.output_position.row_mut() += 1;
 764                *self.output_position.column_mut() = 0;
 765            } else {
 766                *self.output_position.column_mut() += char_len as u32;
 767            }
 768
 769            if self.output_position >= transform_end {
 770                self.transforms.next(&());
 771                break;
 772            }
 773        }
 774
 775        let (prefix, suffix) = self.input_chunk.text.split_at(input_len);
 776        self.input_chunk.text = suffix;
 777        Some(Chunk {
 778            text: prefix,
 779            ..self.input_chunk
 780        })
 781    }
 782}
 783
 784impl<'a> Iterator for BufferRows<'a> {
 785    type Item = Option<u32>;
 786
 787    fn next(&mut self) -> Option<Self::Item> {
 788        if self.output_row > self.max_output_row {
 789            return None;
 790        }
 791
 792        let buffer_row = self.input_buffer_row;
 793        let soft_wrapped = self.soft_wrapped;
 794
 795        self.output_row += 1;
 796        self.transforms
 797            .seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left, &());
 798        if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
 799            self.input_buffer_row = self.input_buffer_rows.next().unwrap();
 800            self.soft_wrapped = false;
 801        } else {
 802            self.soft_wrapped = true;
 803        }
 804
 805        Some(if soft_wrapped { None } else { Some(buffer_row) })
 806    }
 807}
 808
 809impl Transform {
 810    fn isomorphic(summary: TextSummary) -> Self {
 811        #[cfg(test)]
 812        assert!(!summary.lines.is_zero());
 813
 814        Self {
 815            summary: TransformSummary {
 816                input: summary.clone(),
 817                output: summary,
 818            },
 819            display_text: None,
 820        }
 821    }
 822
 823    fn wrap(indent: u32) -> Self {
 824        lazy_static! {
 825            static ref WRAP_TEXT: String = {
 826                let mut wrap_text = String::new();
 827                wrap_text.push('\n');
 828                wrap_text.extend((0..LineWrapper::MAX_INDENT as usize).map(|_| ' '));
 829                wrap_text
 830            };
 831        }
 832
 833        Self {
 834            summary: TransformSummary {
 835                input: TextSummary::default(),
 836                output: TextSummary {
 837                    lines: Point::new(1, indent),
 838                    first_line_chars: 0,
 839                    last_line_chars: indent,
 840                    longest_row: 1,
 841                    longest_row_chars: indent,
 842                },
 843            },
 844            display_text: Some(&WRAP_TEXT[..1 + indent as usize]),
 845        }
 846    }
 847
 848    fn is_isomorphic(&self) -> bool {
 849        self.display_text.is_none()
 850    }
 851}
 852
 853impl sum_tree::Item for Transform {
 854    type Summary = TransformSummary;
 855
 856    fn summary(&self) -> Self::Summary {
 857        self.summary.clone()
 858    }
 859}
 860
 861fn push_isomorphic(transforms: &mut Vec<Transform>, summary: TextSummary) {
 862    if let Some(last_transform) = transforms.last_mut() {
 863        if last_transform.is_isomorphic() {
 864            last_transform.summary.input += &summary;
 865            last_transform.summary.output += &summary;
 866            return;
 867        }
 868    }
 869    transforms.push(Transform::isomorphic(summary));
 870}
 871
 872trait SumTreeExt {
 873    fn push_or_extend(&mut self, transform: Transform);
 874}
 875
 876impl SumTreeExt for SumTree<Transform> {
 877    fn push_or_extend(&mut self, transform: Transform) {
 878        let mut transform = Some(transform);
 879        self.update_last(
 880            |last_transform| {
 881                if last_transform.is_isomorphic() && transform.as_ref().unwrap().is_isomorphic() {
 882                    let transform = transform.take().unwrap();
 883                    last_transform.summary.input += &transform.summary.input;
 884                    last_transform.summary.output += &transform.summary.output;
 885                }
 886            },
 887            &(),
 888        );
 889
 890        if let Some(transform) = transform {
 891            self.push(transform, &());
 892        }
 893    }
 894}
 895
 896impl WrapPoint {
 897    pub fn new(row: u32, column: u32) -> Self {
 898        Self(super::Point::new(row, column))
 899    }
 900
 901    pub fn row(self) -> u32 {
 902        self.0.row
 903    }
 904
 905    pub fn row_mut(&mut self) -> &mut u32 {
 906        &mut self.0.row
 907    }
 908
 909    pub fn column_mut(&mut self) -> &mut u32 {
 910        &mut self.0.column
 911    }
 912}
 913
 914impl sum_tree::Summary for TransformSummary {
 915    type Context = ();
 916
 917    fn add_summary(&mut self, other: &Self, _: &()) {
 918        self.input += &other.input;
 919        self.output += &other.output;
 920    }
 921}
 922
 923impl<'a> sum_tree::Dimension<'a, TransformSummary> for TabPoint {
 924    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 925        self.0 += summary.input.lines;
 926    }
 927}
 928
 929impl<'a> sum_tree::SeekTarget<'a, TransformSummary, TransformSummary> for TabPoint {
 930    fn cmp(&self, cursor_location: &TransformSummary, _: &()) -> std::cmp::Ordering {
 931        Ord::cmp(&self.0, &cursor_location.input.lines)
 932    }
 933}
 934
 935impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
 936    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 937        self.0 += summary.output.lines;
 938    }
 939}
 940
 941fn consolidate_wrap_edits(edits: &mut Vec<Edit>) {
 942    let mut i = 1;
 943    while i < edits.len() {
 944        let edit = edits[i].clone();
 945        let prev_edit = &mut edits[i - 1];
 946        if prev_edit.old.end >= edit.old.start {
 947            prev_edit.old.end = edit.old.end;
 948            prev_edit.new.end = edit.new.end;
 949            edits.remove(i);
 950            continue;
 951        }
 952        i += 1;
 953    }
 954}
 955
 956#[cfg(test)]
 957mod tests {
 958    use super::*;
 959    use crate::{
 960        display_map::{fold_map::FoldMap, tab_map::TabMap},
 961        test::Observer,
 962    };
 963    use buffer::Rope;
 964    use language::{Buffer, RandomCharIter};
 965    use rand::prelude::*;
 966    use std::{cmp, env};
 967
 968    #[gpui::test(iterations = 100)]
 969    async fn test_random_wraps(mut cx: gpui::TestAppContext, mut rng: StdRng) {
 970        cx.foreground().set_block_on_ticks(0..=50);
 971        cx.foreground().forbid_parking();
 972        let operations = env::var("OPERATIONS")
 973            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
 974            .unwrap_or(10);
 975
 976        let font_cache = cx.font_cache().clone();
 977        let font_system = cx.platform().fonts();
 978        let mut wrap_width = if rng.gen_bool(0.1) {
 979            None
 980        } else {
 981            Some(rng.gen_range(0.0..=1000.0))
 982        };
 983        let tab_size = rng.gen_range(1..=4);
 984        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
 985        let font_id = font_cache
 986            .select_font(family_id, &Default::default())
 987            .unwrap();
 988        let font_size = 14.0;
 989
 990        log::info!("Tab size: {}", tab_size);
 991        log::info!("Wrap width: {:?}", wrap_width);
 992
 993        let buffer = cx.add_model(|cx| {
 994            let len = rng.gen_range(0..10);
 995            let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
 996            Buffer::new(0, text, cx)
 997        });
 998        let (mut fold_map, folds_snapshot) = cx.read(|cx| FoldMap::new(buffer.clone(), cx));
 999        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
1000        log::info!(
1001            "Unwrapped text (no folds): {:?}",
1002            buffer.read_with(&cx, |buf, _| buf.text())
1003        );
1004        log::info!(
1005            "Unwrapped text (unexpanded tabs): {:?}",
1006            folds_snapshot.text()
1007        );
1008        log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
1009
1010        let mut line_wrapper = LineWrapper::new(font_id, font_size, font_system);
1011        let unwrapped_text = tabs_snapshot.text();
1012        let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper);
1013
1014        let (wrap_map, initial_snapshot) =
1015            cx.update(|cx| WrapMap::new(tabs_snapshot.clone(), font_id, font_size, wrap_width, cx));
1016        let (_observer, notifications) = Observer::new(&wrap_map, &mut cx);
1017
1018        if wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
1019            notifications.recv().await.unwrap();
1020        }
1021
1022        let actual_text = initial_snapshot.text();
1023        assert_eq!(
1024            actual_text, expected_text,
1025            "unwrapped text is: {:?}",
1026            unwrapped_text
1027        );
1028        log::info!("Wrapped text: {:?}", actual_text);
1029
1030        let mut edits = Vec::new();
1031        for _i in 0..operations {
1032            match rng.gen_range(0..=100) {
1033                0..=19 => {
1034                    wrap_width = if rng.gen_bool(0.2) {
1035                        None
1036                    } else {
1037                        Some(rng.gen_range(0.0..=1000.0))
1038                    };
1039                    log::info!("Setting wrap width to {:?}", wrap_width);
1040                    wrap_map.update(&mut cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1041                }
1042                20..=39 => {
1043                    for (folds_snapshot, fold_edits) in
1044                        cx.read(|cx| fold_map.randomly_mutate(&mut rng, cx))
1045                    {
1046                        let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1047                        let (mut snapshot, wrap_edits) = wrap_map
1048                            .update(&mut cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
1049                        snapshot.check_invariants();
1050                        snapshot.verify_chunks(&mut rng);
1051                        edits.push((snapshot, wrap_edits));
1052                    }
1053                }
1054                _ => {
1055                    buffer.update(&mut cx, |buffer, _| buffer.randomly_mutate(&mut rng));
1056                }
1057            }
1058
1059            log::info!(
1060                "Unwrapped text (no folds): {:?}",
1061                buffer.read_with(&cx, |buf, _| buf.text())
1062            );
1063            let (folds_snapshot, fold_edits) = cx.read(|cx| fold_map.read(cx));
1064            log::info!(
1065                "Unwrapped text (unexpanded tabs): {:?}",
1066                folds_snapshot.text()
1067            );
1068            let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1069            log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
1070
1071            let unwrapped_text = tabs_snapshot.text();
1072            let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper);
1073            let (mut snapshot, wrap_edits) = wrap_map.update(&mut cx, |map, cx| {
1074                map.sync(tabs_snapshot.clone(), tab_edits, cx)
1075            });
1076            snapshot.check_invariants();
1077            snapshot.verify_chunks(&mut rng);
1078            edits.push((snapshot, wrap_edits));
1079
1080            if wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) && rng.gen_bool(0.4) {
1081                log::info!("Waiting for wrapping to finish");
1082                while wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
1083                    notifications.recv().await.unwrap();
1084                }
1085            }
1086
1087            if !wrap_map.read_with(&cx, |map, _| map.is_rewrapping()) {
1088                let (mut wrapped_snapshot, wrap_edits) =
1089                    wrap_map.update(&mut cx, |map, cx| map.sync(tabs_snapshot, Vec::new(), cx));
1090                let actual_text = wrapped_snapshot.text();
1091                log::info!("Wrapping finished: {:?}", actual_text);
1092                wrapped_snapshot.check_invariants();
1093                wrapped_snapshot.verify_chunks(&mut rng);
1094                edits.push((wrapped_snapshot, wrap_edits));
1095                assert_eq!(
1096                    actual_text, expected_text,
1097                    "unwrapped text is: {:?}",
1098                    unwrapped_text
1099                );
1100            }
1101        }
1102
1103        let mut initial_text = Rope::from(initial_snapshot.text().as_str());
1104        for (snapshot, patch) in edits {
1105            let snapshot_text = Rope::from(snapshot.text().as_str());
1106            for edit in &patch {
1107                let old_start = initial_text.point_to_offset(Point::new(edit.new.start, 0));
1108                let old_end = initial_text.point_to_offset(cmp::min(
1109                    Point::new(edit.new.start + edit.old.len() as u32, 0),
1110                    initial_text.max_point(),
1111                ));
1112                let new_start = snapshot_text.point_to_offset(Point::new(edit.new.start, 0));
1113                let new_end = snapshot_text.point_to_offset(cmp::min(
1114                    Point::new(edit.new.end, 0),
1115                    snapshot_text.max_point(),
1116                ));
1117                let new_text = snapshot_text
1118                    .chunks_in_range(new_start..new_end)
1119                    .collect::<String>();
1120
1121                initial_text.replace(old_start..old_end, &new_text);
1122            }
1123            assert_eq!(initial_text.to_string(), snapshot_text.to_string());
1124        }
1125    }
1126
1127    fn wrap_text(
1128        unwrapped_text: &str,
1129        wrap_width: Option<f32>,
1130        line_wrapper: &mut LineWrapper,
1131    ) -> String {
1132        if let Some(wrap_width) = wrap_width {
1133            let mut wrapped_text = String::new();
1134            for (row, line) in unwrapped_text.split('\n').enumerate() {
1135                if row > 0 {
1136                    wrapped_text.push('\n')
1137                }
1138
1139                let mut prev_ix = 0;
1140                for boundary in line_wrapper.wrap_line(line, wrap_width) {
1141                    wrapped_text.push_str(&line[prev_ix..boundary.ix]);
1142                    wrapped_text.push('\n');
1143                    wrapped_text.push_str(&" ".repeat(boundary.next_indent as usize));
1144                    prev_ix = boundary.ix;
1145                }
1146                wrapped_text.push_str(&line[prev_ix..]);
1147            }
1148            wrapped_text
1149        } else {
1150            unwrapped_text.to_string()
1151        }
1152    }
1153
1154    impl Snapshot {
1155        pub fn text(&self) -> String {
1156            self.text_chunks(0).collect()
1157        }
1158
1159        fn verify_chunks(&mut self, rng: &mut impl Rng) {
1160            for _ in 0..5 {
1161                let mut end_row = rng.gen_range(0..=self.max_point().row());
1162                let start_row = rng.gen_range(0..=end_row);
1163                end_row += 1;
1164
1165                let mut expected_text = self.text_chunks(start_row).collect::<String>();
1166                if expected_text.ends_with("\n") {
1167                    expected_text.push('\n');
1168                }
1169                let mut expected_text = expected_text
1170                    .lines()
1171                    .take((end_row - start_row) as usize)
1172                    .collect::<Vec<_>>()
1173                    .join("\n");
1174                if end_row <= self.max_point().row() {
1175                    expected_text.push('\n');
1176                }
1177
1178                let actual_text = self
1179                    .chunks(start_row..end_row, false)
1180                    .map(|c| c.text)
1181                    .collect::<String>();
1182                assert_eq!(
1183                    expected_text,
1184                    actual_text,
1185                    "chunks != highlighted_chunks for rows {:?}",
1186                    start_row..end_row
1187                );
1188            }
1189        }
1190    }
1191}