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