1use super::wrap_map::{self, WrapEdit, WrapPoint, WrapSnapshot};
   2use gpui::{AppContext, ElementBox, ModelHandle};
   3use language::{Buffer, Chunk};
   4use parking_lot::Mutex;
   5use std::{
   6    cmp::{self, Ordering},
   7    collections::{HashMap, HashSet},
   8    fmt::Debug,
   9    ops::{Deref, Range},
  10    sync::{
  11        atomic::{AtomicUsize, Ordering::SeqCst},
  12        Arc,
  13    },
  14};
  15use sum_tree::SumTree;
  16use text::{Anchor, Bias, Edit, Point, ToOffset, ToPoint as _};
  17use theme::SyntaxTheme;
  18
  19const NEWLINES: &'static [u8] = &[b'\n'; u8::MAX as usize];
  20
  21pub struct BlockMap {
  22    buffer: ModelHandle<Buffer>,
  23    next_block_id: AtomicUsize,
  24    wrap_snapshot: Mutex<WrapSnapshot>,
  25    blocks: Vec<Arc<Block>>,
  26    transforms: Mutex<SumTree<Transform>>,
  27}
  28
  29pub struct BlockMapWriter<'a>(&'a mut BlockMap);
  30
  31pub struct BlockSnapshot {
  32    wrap_snapshot: WrapSnapshot,
  33    transforms: SumTree<Transform>,
  34}
  35
  36#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
  37pub struct BlockId(usize);
  38
  39#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  40pub struct BlockPoint(pub super::Point);
  41
  42#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  43struct BlockRow(u32);
  44
  45#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
  46struct WrapRow(u32);
  47
  48pub struct Block {
  49    id: BlockId,
  50    position: Anchor,
  51    height: u8,
  52    render: Mutex<Arc<dyn Fn(&BlockContext) -> ElementBox>>,
  53    disposition: BlockDisposition,
  54}
  55
  56#[derive(Clone)]
  57pub struct BlockProperties<P>
  58where
  59    P: Clone,
  60{
  61    pub position: P,
  62    pub height: u8,
  63    pub render: Arc<dyn Fn(&BlockContext) -> ElementBox>,
  64    pub disposition: BlockDisposition,
  65}
  66
  67pub struct BlockContext<'a> {
  68    pub cx: &'a AppContext,
  69    pub anchor_x: f32,
  70}
  71
  72#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
  73pub enum BlockDisposition {
  74    Above,
  75    Below,
  76}
  77
  78#[derive(Clone, Debug)]
  79struct Transform {
  80    summary: TransformSummary,
  81    block: Option<AlignedBlock>,
  82}
  83
  84#[derive(Clone, Debug)]
  85pub struct AlignedBlock {
  86    block: Arc<Block>,
  87    column: u32,
  88}
  89
  90#[derive(Clone, Debug, Default)]
  91struct TransformSummary {
  92    input_rows: u32,
  93    output_rows: u32,
  94}
  95
  96pub struct BlockChunks<'a> {
  97    transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
  98    input_chunks: wrap_map::WrapChunks<'a>,
  99    input_chunk: Chunk<'a>,
 100    output_row: u32,
 101    max_output_row: u32,
 102}
 103
 104pub struct BlockBufferRows<'a> {
 105    transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
 106    input_buffer_rows: wrap_map::WrapBufferRows<'a>,
 107    output_row: u32,
 108    started: bool,
 109}
 110
 111impl BlockMap {
 112    pub fn new(buffer: ModelHandle<Buffer>, wrap_snapshot: WrapSnapshot) -> Self {
 113        Self {
 114            buffer,
 115            next_block_id: AtomicUsize::new(0),
 116            blocks: Vec::new(),
 117            transforms: Mutex::new(SumTree::from_item(
 118                Transform::isomorphic(wrap_snapshot.text_summary().lines.row + 1),
 119                &(),
 120            )),
 121            wrap_snapshot: Mutex::new(wrap_snapshot),
 122        }
 123    }
 124
 125    pub fn read(
 126        &self,
 127        wrap_snapshot: WrapSnapshot,
 128        edits: Vec<WrapEdit>,
 129        cx: &AppContext,
 130    ) -> BlockSnapshot {
 131        self.sync(&wrap_snapshot, edits, cx);
 132        *self.wrap_snapshot.lock() = wrap_snapshot.clone();
 133        BlockSnapshot {
 134            wrap_snapshot,
 135            transforms: self.transforms.lock().clone(),
 136        }
 137    }
 138
 139    pub fn write(
 140        &mut self,
 141        wrap_snapshot: WrapSnapshot,
 142        edits: Vec<WrapEdit>,
 143        cx: &AppContext,
 144    ) -> BlockMapWriter {
 145        self.sync(&wrap_snapshot, edits, cx);
 146        *self.wrap_snapshot.lock() = wrap_snapshot;
 147        BlockMapWriter(self)
 148    }
 149
 150    fn sync(&self, wrap_snapshot: &WrapSnapshot, edits: Vec<WrapEdit>, cx: &AppContext) {
 151        if edits.is_empty() {
 152            return;
 153        }
 154
 155        let buffer = self.buffer.read(cx);
 156        let mut transforms = self.transforms.lock();
 157        let mut new_transforms = SumTree::new();
 158        let old_row_count = transforms.summary().input_rows;
 159        let new_row_count = wrap_snapshot.max_point().row() + 1;
 160        let mut cursor = transforms.cursor::<WrapRow>();
 161        let mut last_block_ix = 0;
 162        let mut blocks_in_edit = Vec::new();
 163        let mut edits = edits.into_iter().peekable();
 164
 165        while let Some(edit) = edits.next() {
 166            // Preserve any old transforms that precede this edit.
 167            let old_start = WrapRow(edit.old.start);
 168            let new_start = WrapRow(edit.new.start);
 169            new_transforms.push_tree(cursor.slice(&old_start, Bias::Left, &()), &());
 170            if let Some(transform) = cursor.item() {
 171                if transform.is_isomorphic() && old_start == cursor.end(&()) {
 172                    new_transforms.push(transform.clone(), &());
 173                    cursor.next(&());
 174                    while let Some(transform) = cursor.item() {
 175                        if transform
 176                            .block
 177                            .as_ref()
 178                            .map_or(false, |b| b.disposition.is_below())
 179                        {
 180                            new_transforms.push(transform.clone(), &());
 181                            cursor.next(&());
 182                        } else {
 183                            break;
 184                        }
 185                    }
 186                }
 187            }
 188
 189            // Preserve any portion of an old transform that precedes this edit.
 190            let extent_before_edit = old_start.0 - cursor.start().0;
 191            push_isomorphic(&mut new_transforms, extent_before_edit);
 192
 193            // Skip over any old transforms that intersect this edit.
 194            let mut old_end = WrapRow(edit.old.end);
 195            let mut new_end = WrapRow(edit.new.end);
 196            cursor.seek(&old_end, Bias::Left, &());
 197            cursor.next(&());
 198            if old_end == *cursor.start() {
 199                while let Some(transform) = cursor.item() {
 200                    if transform
 201                        .block
 202                        .as_ref()
 203                        .map_or(false, |b| b.disposition.is_below())
 204                    {
 205                        cursor.next(&());
 206                    } else {
 207                        break;
 208                    }
 209                }
 210            }
 211
 212            // Combine this edit with any subsequent edits that intersect the same transform.
 213            while let Some(next_edit) = edits.peek() {
 214                if next_edit.old.start <= cursor.start().0 {
 215                    old_end = WrapRow(next_edit.old.end);
 216                    new_end = WrapRow(next_edit.new.end);
 217                    cursor.seek(&old_end, Bias::Left, &());
 218                    cursor.next(&());
 219                    if old_end == *cursor.start() {
 220                        while let Some(transform) = cursor.item() {
 221                            if transform
 222                                .block
 223                                .as_ref()
 224                                .map_or(false, |b| b.disposition.is_below())
 225                            {
 226                                cursor.next(&());
 227                            } else {
 228                                break;
 229                            }
 230                        }
 231                    }
 232                    edits.next();
 233                } else {
 234                    break;
 235                }
 236            }
 237
 238            // Find the blocks within this edited region.
 239            let new_start = wrap_snapshot.to_point(WrapPoint::new(new_start.0, 0), Bias::Left);
 240            let start_anchor = buffer.anchor_before(new_start);
 241            let start_block_ix = match self.blocks[last_block_ix..].binary_search_by(|probe| {
 242                probe
 243                    .position
 244                    .cmp(&start_anchor, buffer)
 245                    .unwrap()
 246                    .then(Ordering::Greater)
 247            }) {
 248                Ok(ix) | Err(ix) => last_block_ix + ix,
 249            };
 250            let end_block_ix = if new_end.0 > wrap_snapshot.max_point().row() {
 251                self.blocks.len()
 252            } else {
 253                let new_end = wrap_snapshot.to_point(WrapPoint::new(new_end.0, 0), Bias::Left);
 254                let end_anchor = buffer.anchor_before(new_end);
 255                match self.blocks[start_block_ix..].binary_search_by(|probe| {
 256                    probe
 257                        .position
 258                        .cmp(&end_anchor, buffer)
 259                        .unwrap()
 260                        .then(Ordering::Greater)
 261                }) {
 262                    Ok(ix) | Err(ix) => start_block_ix + ix,
 263                }
 264            };
 265            last_block_ix = end_block_ix;
 266            blocks_in_edit.clear();
 267            blocks_in_edit.extend(
 268                self.blocks[start_block_ix..end_block_ix]
 269                    .iter()
 270                    .map(|block| {
 271                        let mut position = block.position.to_point(buffer);
 272                        let column = wrap_snapshot.from_point(position, Bias::Left).column();
 273                        match block.disposition {
 274                            BlockDisposition::Above => position.column = 0,
 275                            BlockDisposition::Below => {
 276                                position.column = buffer.line_len(position.row)
 277                            }
 278                        }
 279                        let position = wrap_snapshot.from_point(position, Bias::Left);
 280                        (position.row(), column, block)
 281                    }),
 282            );
 283            blocks_in_edit
 284                .sort_unstable_by_key(|(row, _, block)| (*row, block.disposition, block.id));
 285
 286            // For each of these blocks, insert a new isomorphic transform preceding the block,
 287            // and then insert the block itself.
 288            for (block_row, column, block) in blocks_in_edit.iter().copied() {
 289                let insertion_row = match block.disposition {
 290                    BlockDisposition::Above => block_row,
 291                    BlockDisposition::Below => block_row + 1,
 292                };
 293                let extent_before_block = insertion_row - new_transforms.summary().input_rows;
 294                push_isomorphic(&mut new_transforms, extent_before_block);
 295                new_transforms.push(Transform::block(block.clone(), column), &());
 296            }
 297
 298            old_end = WrapRow(old_end.0.min(old_row_count));
 299            new_end = WrapRow(new_end.0.min(new_row_count));
 300
 301            // Insert an isomorphic transform after the final block.
 302            let extent_after_last_block = new_end.0 - new_transforms.summary().input_rows;
 303            push_isomorphic(&mut new_transforms, extent_after_last_block);
 304
 305            // Preserve any portion of the old transform after this edit.
 306            let extent_after_edit = cursor.start().0 - old_end.0;
 307            push_isomorphic(&mut new_transforms, extent_after_edit);
 308        }
 309
 310        new_transforms.push_tree(cursor.suffix(&()), &());
 311        debug_assert_eq!(
 312            new_transforms.summary().input_rows,
 313            wrap_snapshot.max_point().row() + 1
 314        );
 315
 316        drop(cursor);
 317        *transforms = new_transforms;
 318    }
 319
 320    pub fn replace<F>(&mut self, mut element_builders: HashMap<BlockId, F>)
 321    where
 322        F: 'static + Fn(&BlockContext) -> ElementBox,
 323    {
 324        for block in &self.blocks {
 325            if let Some(build_element) = element_builders.remove(&block.id) {
 326                *block.render.lock() = Arc::new(build_element);
 327            }
 328        }
 329    }
 330}
 331
 332fn push_isomorphic(tree: &mut SumTree<Transform>, rows: u32) {
 333    if rows == 0 {
 334        return;
 335    }
 336
 337    let mut extent = Some(rows);
 338    tree.update_last(
 339        |last_transform| {
 340            if last_transform.is_isomorphic() {
 341                let extent = extent.take().unwrap();
 342                last_transform.summary.input_rows += extent;
 343                last_transform.summary.output_rows += extent;
 344            }
 345        },
 346        &(),
 347    );
 348    if let Some(extent) = extent {
 349        tree.push(Transform::isomorphic(extent), &());
 350    }
 351}
 352
 353impl BlockPoint {
 354    pub fn new(row: u32, column: u32) -> Self {
 355        Self(Point::new(row, column))
 356    }
 357}
 358
 359impl Deref for BlockPoint {
 360    type Target = Point;
 361
 362    fn deref(&self) -> &Self::Target {
 363        &self.0
 364    }
 365}
 366
 367impl std::ops::DerefMut for BlockPoint {
 368    fn deref_mut(&mut self) -> &mut Self::Target {
 369        &mut self.0
 370    }
 371}
 372
 373impl<'a> BlockMapWriter<'a> {
 374    pub fn insert<P>(
 375        &mut self,
 376        blocks: impl IntoIterator<Item = BlockProperties<P>>,
 377        cx: &AppContext,
 378    ) -> Vec<BlockId>
 379    where
 380        P: ToOffset + Clone,
 381    {
 382        let buffer = self.0.buffer.read(cx);
 383        let mut ids = Vec::new();
 384        let mut edits = Vec::<Edit<u32>>::new();
 385        let wrap_snapshot = &*self.0.wrap_snapshot.lock();
 386
 387        for block in blocks {
 388            let id = BlockId(self.0.next_block_id.fetch_add(1, SeqCst));
 389            ids.push(id);
 390
 391            let position = buffer.anchor_after(block.position);
 392            let point = position.to_point(buffer);
 393            let start_row = wrap_snapshot
 394                .from_point(Point::new(point.row, 0), Bias::Left)
 395                .row();
 396            let end_row = if point.row == buffer.max_point().row {
 397                wrap_snapshot.max_point().row() + 1
 398            } else {
 399                wrap_snapshot
 400                    .from_point(Point::new(point.row + 1, 0), Bias::Left)
 401                    .row()
 402            };
 403
 404            let block_ix = match self
 405                .0
 406                .blocks
 407                .binary_search_by(|probe| probe.position.cmp(&position, buffer).unwrap())
 408            {
 409                Ok(ix) | Err(ix) => ix,
 410            };
 411            self.0.blocks.insert(
 412                block_ix,
 413                Arc::new(Block {
 414                    id,
 415                    position,
 416                    height: block.height,
 417                    render: Mutex::new(block.render),
 418                    disposition: block.disposition,
 419                }),
 420            );
 421
 422            if let Err(edit_ix) = edits.binary_search_by_key(&start_row, |edit| edit.old.start) {
 423                edits.insert(
 424                    edit_ix,
 425                    Edit {
 426                        old: start_row..end_row,
 427                        new: start_row..end_row,
 428                    },
 429                );
 430            }
 431        }
 432
 433        self.0.sync(wrap_snapshot, edits, cx);
 434        ids
 435    }
 436
 437    pub fn remove(&mut self, block_ids: HashSet<BlockId>, cx: &AppContext) {
 438        let buffer = self.0.buffer.read(cx);
 439        let wrap_snapshot = &*self.0.wrap_snapshot.lock();
 440        let mut edits = Vec::new();
 441        let mut last_block_buffer_row = None;
 442        self.0.blocks.retain(|block| {
 443            if block_ids.contains(&block.id) {
 444                let buffer_row = block.position.to_point(buffer).row;
 445                if last_block_buffer_row != Some(buffer_row) {
 446                    last_block_buffer_row = Some(buffer_row);
 447                    let start_row = wrap_snapshot
 448                        .from_point(Point::new(buffer_row, 0), Bias::Left)
 449                        .row();
 450                    let end_row = wrap_snapshot
 451                        .from_point(
 452                            Point::new(buffer_row, buffer.line_len(buffer_row)),
 453                            Bias::Left,
 454                        )
 455                        .row()
 456                        + 1;
 457                    edits.push(Edit {
 458                        old: start_row..end_row,
 459                        new: start_row..end_row,
 460                    })
 461                }
 462                false
 463            } else {
 464                true
 465            }
 466        });
 467        self.0.sync(wrap_snapshot, edits, cx);
 468    }
 469}
 470
 471impl BlockSnapshot {
 472    #[cfg(test)]
 473    fn text(&mut self) -> String {
 474        self.chunks(0..self.transforms.summary().output_rows, None)
 475            .map(|chunk| chunk.text)
 476            .collect()
 477    }
 478
 479    pub fn chunks<'a>(
 480        &'a self,
 481        rows: Range<u32>,
 482        theme: Option<&'a SyntaxTheme>,
 483    ) -> BlockChunks<'a> {
 484        let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
 485        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 486        let input_end = {
 487            cursor.seek(&BlockRow(rows.end), Bias::Right, &());
 488            let overshoot = if cursor
 489                .item()
 490                .map_or(false, |transform| transform.is_isomorphic())
 491            {
 492                rows.end - cursor.start().0 .0
 493            } else {
 494                0
 495            };
 496            cursor.start().1 .0 + overshoot
 497        };
 498        let input_start = {
 499            cursor.seek(&BlockRow(rows.start), Bias::Right, &());
 500            let overshoot = if cursor
 501                .item()
 502                .map_or(false, |transform| transform.is_isomorphic())
 503            {
 504                rows.start - cursor.start().0 .0
 505            } else {
 506                0
 507            };
 508            cursor.start().1 .0 + overshoot
 509        };
 510        BlockChunks {
 511            input_chunks: self.wrap_snapshot.chunks(input_start..input_end, theme),
 512            input_chunk: Default::default(),
 513            transforms: cursor,
 514            output_row: rows.start,
 515            max_output_row,
 516        }
 517    }
 518
 519    pub fn buffer_rows<'a>(&'a self, start_row: u32) -> BlockBufferRows<'a> {
 520        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 521        cursor.seek(&BlockRow(start_row), Bias::Right, &());
 522        let (output_start, input_start) = cursor.start();
 523        let overshoot = if cursor.item().map_or(false, |t| t.is_isomorphic()) {
 524            start_row - output_start.0
 525        } else {
 526            0
 527        };
 528        let input_start_row = input_start.0 + overshoot;
 529        BlockBufferRows {
 530            transforms: cursor,
 531            input_buffer_rows: self.wrap_snapshot.buffer_rows(input_start_row),
 532            output_row: start_row,
 533            started: false,
 534        }
 535    }
 536
 537    pub fn blocks_in_range<'a>(
 538        &'a self,
 539        rows: Range<u32>,
 540    ) -> impl Iterator<Item = (u32, &'a AlignedBlock)> {
 541        let mut cursor = self.transforms.cursor::<BlockRow>();
 542        cursor.seek(&BlockRow(rows.start), Bias::Right, &());
 543        std::iter::from_fn(move || {
 544            while let Some(transform) = cursor.item() {
 545                let start_row = cursor.start().0;
 546                if start_row >= rows.end {
 547                    break;
 548                }
 549                if let Some(block) = &transform.block {
 550                    cursor.next(&());
 551                    return Some((start_row, block));
 552                } else {
 553                    cursor.next(&());
 554                }
 555            }
 556            None
 557        })
 558    }
 559
 560    pub fn max_point(&self) -> BlockPoint {
 561        let row = self.transforms.summary().output_rows - 1;
 562        BlockPoint::new(row, self.line_len(row))
 563    }
 564
 565    pub fn longest_row(&self) -> u32 {
 566        let input_row = self.wrap_snapshot.longest_row();
 567        self.to_block_point(WrapPoint::new(input_row, 0)).row
 568    }
 569
 570    pub fn line_len(&self, row: u32) -> u32 {
 571        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 572        cursor.seek(&BlockRow(row), Bias::Right, &());
 573        if let Some(transform) = cursor.item() {
 574            let (output_start, input_start) = cursor.start();
 575            let overshoot = row - output_start.0;
 576            if transform.block.is_some() {
 577                0
 578            } else {
 579                self.wrap_snapshot.line_len(input_start.0 + overshoot)
 580            }
 581        } else {
 582            panic!("row out of range");
 583        }
 584    }
 585
 586    pub fn is_block_line(&self, row: u32) -> bool {
 587        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 588        cursor.seek(&BlockRow(row), Bias::Right, &());
 589        cursor.item().map_or(false, |t| t.block.is_some())
 590    }
 591
 592    pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
 593        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 594        cursor.seek(&BlockRow(point.row), Bias::Right, &());
 595
 596        let max_input_row = WrapRow(self.transforms.summary().input_rows);
 597        let search_left =
 598            (bias == Bias::Left && cursor.start().1 .0 > 0) || cursor.end(&()).1 == max_input_row;
 599
 600        loop {
 601            if let Some(transform) = cursor.item() {
 602                if transform.is_isomorphic() {
 603                    let (output_start_row, input_start_row) = cursor.start();
 604                    let (output_end_row, input_end_row) = cursor.end(&());
 605
 606                    if point.row >= output_end_row.0 {
 607                        return BlockPoint::new(
 608                            output_end_row.0 - 1,
 609                            self.wrap_snapshot.line_len(input_end_row.0 - 1),
 610                        );
 611                    }
 612
 613                    let output_start = Point::new(output_start_row.0, 0);
 614                    if point.0 > output_start {
 615                        let output_overshoot = point.0 - output_start;
 616                        let input_start = Point::new(input_start_row.0, 0);
 617                        let input_point = self
 618                            .wrap_snapshot
 619                            .clip_point(WrapPoint(input_start + output_overshoot), bias);
 620                        let input_overshoot = input_point.0 - input_start;
 621                        return BlockPoint(output_start + input_overshoot);
 622                    } else {
 623                        return BlockPoint(output_start);
 624                    }
 625                } else if search_left {
 626                    cursor.prev(&());
 627                } else {
 628                    cursor.next(&());
 629                }
 630            } else {
 631                return self.max_point();
 632            }
 633        }
 634    }
 635
 636    pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
 637        let mut cursor = self.transforms.cursor::<(WrapRow, BlockRow)>();
 638        cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
 639        if let Some(transform) = cursor.item() {
 640            debug_assert!(transform.is_isomorphic());
 641        } else {
 642            return self.max_point();
 643        }
 644
 645        let (input_start_row, output_start_row) = cursor.start();
 646        let input_start = Point::new(input_start_row.0, 0);
 647        let output_start = Point::new(output_start_row.0, 0);
 648        let input_overshoot = wrap_point.0 - input_start;
 649        BlockPoint(output_start + input_overshoot)
 650    }
 651
 652    pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
 653        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
 654        cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
 655        if let Some(transform) = cursor.item() {
 656            match transform.block.as_ref().map(|b| b.disposition) {
 657                Some(BlockDisposition::Above) => WrapPoint::new(cursor.start().1 .0, 0),
 658                Some(BlockDisposition::Below) => {
 659                    let wrap_row = cursor.start().1 .0 - 1;
 660                    WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
 661                }
 662                None => {
 663                    let overshoot = block_point.row - cursor.start().0 .0;
 664                    let wrap_row = cursor.start().1 .0 + overshoot;
 665                    WrapPoint::new(wrap_row, block_point.column)
 666                }
 667            }
 668        } else {
 669            self.wrap_snapshot.max_point()
 670        }
 671    }
 672}
 673
 674impl Transform {
 675    fn isomorphic(rows: u32) -> Self {
 676        Self {
 677            summary: TransformSummary {
 678                input_rows: rows,
 679                output_rows: rows,
 680            },
 681            block: None,
 682        }
 683    }
 684
 685    fn block(block: Arc<Block>, column: u32) -> Self {
 686        Self {
 687            summary: TransformSummary {
 688                input_rows: 0,
 689                output_rows: block.height as u32,
 690            },
 691            block: Some(AlignedBlock { block, column }),
 692        }
 693    }
 694
 695    fn is_isomorphic(&self) -> bool {
 696        self.block.is_none()
 697    }
 698}
 699
 700impl<'a> Iterator for BlockChunks<'a> {
 701    type Item = Chunk<'a>;
 702
 703    fn next(&mut self) -> Option<Self::Item> {
 704        if self.output_row >= self.max_output_row {
 705            return None;
 706        }
 707
 708        let transform = self.transforms.item()?;
 709        if transform.block.is_some() {
 710            let block_start = self.transforms.start().0 .0;
 711            let mut block_end = self.transforms.end(&()).0 .0;
 712            self.transforms.next(&());
 713            if self.transforms.item().is_none() {
 714                block_end -= 1;
 715            }
 716
 717            let start_in_block = self.output_row - block_start;
 718            let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
 719            let line_count = end_in_block - start_in_block;
 720            self.output_row += line_count;
 721
 722            return Some(Chunk {
 723                text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..line_count as usize]) },
 724                highlight_style: None,
 725                diagnostic: None,
 726            });
 727        }
 728
 729        if self.input_chunk.text.is_empty() {
 730            if let Some(input_chunk) = self.input_chunks.next() {
 731                self.input_chunk = input_chunk;
 732            } else {
 733                self.output_row += 1;
 734                if self.output_row < self.max_output_row {
 735                    self.transforms.next(&());
 736                    return Some(Chunk {
 737                        text: "\n",
 738                        ..Default::default()
 739                    });
 740                } else {
 741                    return None;
 742                }
 743            }
 744        }
 745
 746        let transform_end = self.transforms.end(&()).0 .0;
 747        let (prefix_rows, prefix_bytes) =
 748            offset_for_row(self.input_chunk.text, transform_end - self.output_row);
 749        self.output_row += prefix_rows;
 750        let (prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
 751        self.input_chunk.text = suffix;
 752        if self.output_row == transform_end {
 753            self.transforms.next(&());
 754        }
 755
 756        Some(Chunk {
 757            text: prefix,
 758            ..self.input_chunk
 759        })
 760    }
 761}
 762
 763impl<'a> Iterator for BlockBufferRows<'a> {
 764    type Item = Option<u32>;
 765
 766    fn next(&mut self) -> Option<Self::Item> {
 767        if self.started {
 768            self.output_row += 1;
 769        } else {
 770            self.started = true;
 771        }
 772
 773        if self.output_row >= self.transforms.end(&()).0 .0 {
 774            self.transforms.next(&());
 775        }
 776
 777        let transform = self.transforms.item()?;
 778        if transform.block.is_some() {
 779            Some(None)
 780        } else {
 781            Some(self.input_buffer_rows.next().unwrap())
 782        }
 783    }
 784}
 785
 786impl sum_tree::Item for Transform {
 787    type Summary = TransformSummary;
 788
 789    fn summary(&self) -> Self::Summary {
 790        self.summary.clone()
 791    }
 792}
 793
 794impl sum_tree::Summary for TransformSummary {
 795    type Context = ();
 796
 797    fn add_summary(&mut self, summary: &Self, _: &()) {
 798        self.input_rows += summary.input_rows;
 799        self.output_rows += summary.output_rows;
 800    }
 801}
 802
 803impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
 804    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 805        self.0 += summary.input_rows;
 806    }
 807}
 808
 809impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
 810    fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
 811        self.0 += summary.output_rows;
 812    }
 813}
 814
 815impl BlockDisposition {
 816    fn is_below(&self) -> bool {
 817        matches!(self, BlockDisposition::Below)
 818    }
 819}
 820
 821impl AlignedBlock {
 822    pub fn height(&self) -> u32 {
 823        self.height as u32
 824    }
 825
 826    pub fn column(&self) -> u32 {
 827        self.column
 828    }
 829
 830    pub fn render(&self, cx: &BlockContext) -> ElementBox {
 831        self.render.lock()(cx)
 832    }
 833
 834    pub fn position(&self) -> &Anchor {
 835        &self.block.position
 836    }
 837}
 838
 839impl Deref for AlignedBlock {
 840    type Target = Block;
 841
 842    fn deref(&self) -> &Self::Target {
 843        self.block.as_ref()
 844    }
 845}
 846
 847impl Debug for Block {
 848    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 849        f.debug_struct("Block")
 850            .field("id", &self.id)
 851            .field("position", &self.position)
 852            .field("disposition", &self.disposition)
 853            .finish()
 854    }
 855}
 856
 857// Count the number of bytes prior to a target point. If the string doesn't contain the target
 858// point, return its total extent. Otherwise return the target point itself.
 859fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
 860    let mut row = 0;
 861    let mut offset = 0;
 862    for (ix, line) in s.split('\n').enumerate() {
 863        if ix > 0 {
 864            row += 1;
 865            offset += 1;
 866        }
 867        if row >= target {
 868            break;
 869        }
 870        offset += line.len() as usize;
 871    }
 872    (row, offset)
 873}
 874
 875#[cfg(test)]
 876mod tests {
 877    use super::*;
 878    use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
 879    use gpui::{elements::Empty, Element};
 880    use language::Buffer;
 881    use rand::prelude::*;
 882    use std::env;
 883    use text::RandomCharIter;
 884
 885    #[gpui::test]
 886    fn test_offset_for_row() {
 887        assert_eq!(offset_for_row("", 0), (0, 0));
 888        assert_eq!(offset_for_row("", 1), (0, 0));
 889        assert_eq!(offset_for_row("abcd", 0), (0, 0));
 890        assert_eq!(offset_for_row("abcd", 1), (0, 4));
 891        assert_eq!(offset_for_row("\n", 0), (0, 0));
 892        assert_eq!(offset_for_row("\n", 1), (1, 1));
 893        assert_eq!(offset_for_row("abc\ndef\nghi", 0), (0, 0));
 894        assert_eq!(offset_for_row("abc\ndef\nghi", 1), (1, 4));
 895        assert_eq!(offset_for_row("abc\ndef\nghi", 2), (2, 8));
 896        assert_eq!(offset_for_row("abc\ndef\nghi", 3), (2, 11));
 897    }
 898
 899    #[gpui::test]
 900    fn test_basic_blocks(cx: &mut gpui::MutableAppContext) {
 901        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
 902        let font_id = cx
 903            .font_cache()
 904            .select_font(family_id, &Default::default())
 905            .unwrap();
 906
 907        let text = "aaa\nbbb\nccc\nddd";
 908
 909        let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
 910        let (fold_map, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot());
 911        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
 912        let (wrap_map, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, None, cx);
 913        let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot.clone());
 914
 915        let mut writer = block_map.write(wraps_snapshot.clone(), vec![], cx);
 916        writer.insert(
 917            vec![
 918                BlockProperties {
 919                    position: Point::new(1, 0),
 920                    height: 1,
 921                    disposition: BlockDisposition::Above,
 922                    render: Arc::new(|_| Empty::new().named("block 1")),
 923                },
 924                BlockProperties {
 925                    position: Point::new(1, 2),
 926                    height: 2,
 927                    disposition: BlockDisposition::Above,
 928                    render: Arc::new(|_| Empty::new().named("block 2")),
 929                },
 930                BlockProperties {
 931                    position: Point::new(3, 3),
 932                    height: 3,
 933                    disposition: BlockDisposition::Below,
 934                    render: Arc::new(|_| Empty::new().named("block 3")),
 935                },
 936            ],
 937            cx,
 938        );
 939
 940        let mut snapshot = block_map.read(wraps_snapshot, vec![], cx);
 941        assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
 942
 943        let blocks = snapshot
 944            .blocks_in_range(0..8)
 945            .map(|(start_row, block)| {
 946                (
 947                    start_row..start_row + block.height(),
 948                    block.column(),
 949                    block
 950                        .render(&BlockContext { cx, anchor_x: 0. })
 951                        .name()
 952                        .unwrap()
 953                        .to_string(),
 954                )
 955            })
 956            .collect::<Vec<_>>();
 957        assert_eq!(
 958            blocks,
 959            &[
 960                (1..2, 0, "block 1".to_string()),
 961                (2..4, 2, "block 2".to_string()),
 962                (7..10, 3, "block 3".to_string()),
 963            ]
 964        );
 965
 966        assert_eq!(
 967            snapshot.to_block_point(WrapPoint::new(0, 3)),
 968            BlockPoint::new(0, 3)
 969        );
 970        assert_eq!(
 971            snapshot.to_block_point(WrapPoint::new(1, 0)),
 972            BlockPoint::new(4, 0)
 973        );
 974        assert_eq!(
 975            snapshot.to_block_point(WrapPoint::new(3, 3)),
 976            BlockPoint::new(6, 3)
 977        );
 978
 979        assert_eq!(
 980            snapshot.to_wrap_point(BlockPoint::new(0, 3)),
 981            WrapPoint::new(0, 3)
 982        );
 983        assert_eq!(
 984            snapshot.to_wrap_point(BlockPoint::new(1, 0)),
 985            WrapPoint::new(1, 0)
 986        );
 987        assert_eq!(
 988            snapshot.to_wrap_point(BlockPoint::new(3, 0)),
 989            WrapPoint::new(1, 0)
 990        );
 991        assert_eq!(
 992            snapshot.to_wrap_point(BlockPoint::new(7, 0)),
 993            WrapPoint::new(3, 3)
 994        );
 995
 996        assert_eq!(
 997            snapshot.clip_point(BlockPoint::new(1, 0), Bias::Left),
 998            BlockPoint::new(0, 3)
 999        );
1000        assert_eq!(
1001            snapshot.clip_point(BlockPoint::new(1, 0), Bias::Right),
1002            BlockPoint::new(4, 0)
1003        );
1004        assert_eq!(
1005            snapshot.clip_point(BlockPoint::new(1, 1), Bias::Left),
1006            BlockPoint::new(0, 3)
1007        );
1008        assert_eq!(
1009            snapshot.clip_point(BlockPoint::new(1, 1), Bias::Right),
1010            BlockPoint::new(4, 0)
1011        );
1012        assert_eq!(
1013            snapshot.clip_point(BlockPoint::new(4, 0), Bias::Left),
1014            BlockPoint::new(4, 0)
1015        );
1016        assert_eq!(
1017            snapshot.clip_point(BlockPoint::new(4, 0), Bias::Right),
1018            BlockPoint::new(4, 0)
1019        );
1020        assert_eq!(
1021            snapshot.clip_point(BlockPoint::new(6, 3), Bias::Left),
1022            BlockPoint::new(6, 3)
1023        );
1024        assert_eq!(
1025            snapshot.clip_point(BlockPoint::new(6, 3), Bias::Right),
1026            BlockPoint::new(6, 3)
1027        );
1028        assert_eq!(
1029            snapshot.clip_point(BlockPoint::new(7, 0), Bias::Left),
1030            BlockPoint::new(6, 3)
1031        );
1032        assert_eq!(
1033            snapshot.clip_point(BlockPoint::new(7, 0), Bias::Right),
1034            BlockPoint::new(6, 3)
1035        );
1036
1037        assert_eq!(
1038            snapshot.buffer_rows(0).collect::<Vec<_>>(),
1039            &[
1040                Some(0),
1041                None,
1042                None,
1043                None,
1044                Some(1),
1045                Some(2),
1046                Some(3),
1047                None,
1048                None,
1049                None
1050            ]
1051        );
1052
1053        // Insert a line break, separating two block decorations into separate
1054        // lines.
1055        let (buffer_snapshot, buffer_edits) = buffer.update(cx, |buffer, cx| {
1056            let v0 = buffer.version();
1057            buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx);
1058            (buffer.snapshot(), buffer.edits_since(&v0).collect())
1059        });
1060
1061        let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot, buffer_edits);
1062        let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1063        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1064            wrap_map.sync(tabs_snapshot, tab_edits, cx)
1065        });
1066        let mut snapshot = block_map.read(wraps_snapshot, wrap_edits, cx);
1067        assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
1068    }
1069
1070    #[gpui::test]
1071    fn test_blocks_on_wrapped_lines(cx: &mut gpui::MutableAppContext) {
1072        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
1073        let font_id = cx
1074            .font_cache()
1075            .select_font(family_id, &Default::default())
1076            .unwrap();
1077
1078        let text = "one two three\nfour five six\nseven eight";
1079
1080        let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
1081        let (_, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot());
1082        let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
1083        let (_, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, Some(60.), cx);
1084        let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot.clone());
1085
1086        let mut writer = block_map.write(wraps_snapshot.clone(), vec![], cx);
1087        writer.insert(
1088            vec![
1089                BlockProperties {
1090                    position: Point::new(1, 12),
1091                    disposition: BlockDisposition::Above,
1092                    render: Arc::new(|_| Empty::new().named("block 1")),
1093                    height: 1,
1094                },
1095                BlockProperties {
1096                    position: Point::new(1, 1),
1097                    disposition: BlockDisposition::Below,
1098                    render: Arc::new(|_| Empty::new().named("block 2")),
1099                    height: 1,
1100                },
1101            ],
1102            cx,
1103        );
1104
1105        // Blocks with an 'above' disposition go above their corresponding buffer line.
1106        // Blocks with a 'below' disposition go below their corresponding buffer line.
1107        let mut snapshot = block_map.read(wraps_snapshot, vec![], cx);
1108        assert_eq!(
1109            snapshot.text(),
1110            "one two \nthree\n\nfour five \nsix\n\nseven \neight"
1111        );
1112    }
1113
1114    #[gpui::test(iterations = 100)]
1115    fn test_random_blocks(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
1116        let operations = env::var("OPERATIONS")
1117            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1118            .unwrap_or(10);
1119
1120        let wrap_width = if rng.gen_bool(0.2) {
1121            None
1122        } else {
1123            Some(rng.gen_range(0.0..=100.0))
1124        };
1125        let tab_size = 1;
1126        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
1127        let font_id = cx
1128            .font_cache()
1129            .select_font(family_id, &Default::default())
1130            .unwrap();
1131        let font_size = 14.0;
1132
1133        log::info!("Wrap width: {:?}", wrap_width);
1134
1135        let buffer = cx.add_model(|cx| {
1136            let len = rng.gen_range(0..10);
1137            let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
1138            log::info!("initial buffer text: {:?}", text);
1139            Buffer::new(0, text, cx)
1140        });
1141        let mut buffer_snapshot = buffer.read(cx).snapshot();
1142        let (fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
1143        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
1144        let (wrap_map, wraps_snapshot) =
1145            WrapMap::new(tabs_snapshot, font_id, font_size, wrap_width, cx);
1146        let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot);
1147        let mut expected_blocks = Vec::new();
1148
1149        for _ in 0..operations {
1150            let mut buffer_edits = Vec::new();
1151            match rng.gen_range(0..=100) {
1152                0..=19 => {
1153                    let wrap_width = if rng.gen_bool(0.2) {
1154                        None
1155                    } else {
1156                        Some(rng.gen_range(0.0..=100.0))
1157                    };
1158                    log::info!("Setting wrap width to {:?}", wrap_width);
1159                    wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
1160                }
1161                20..=39 => {
1162                    let block_count = rng.gen_range(1..=1);
1163                    let block_properties = (0..block_count)
1164                        .map(|_| {
1165                            let buffer = buffer.read(cx);
1166                            let position = buffer.anchor_after(
1167                                buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Left),
1168                            );
1169
1170                            let disposition = if rng.gen() {
1171                                BlockDisposition::Above
1172                            } else {
1173                                BlockDisposition::Below
1174                            };
1175                            let height = rng.gen_range(1..5);
1176                            log::info!(
1177                                "inserting block {:?} {:?} with height {}",
1178                                disposition,
1179                                position.to_point(buffer),
1180                                height
1181                            );
1182                            BlockProperties {
1183                                position,
1184                                height,
1185                                disposition,
1186                                render: Arc::new(|_| Empty::new().boxed()),
1187                            }
1188                        })
1189                        .collect::<Vec<_>>();
1190
1191                    let (folds_snapshot, fold_edits) =
1192                        fold_map.read(buffer_snapshot.clone(), vec![]);
1193                    let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1194                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1195                        wrap_map.sync(tabs_snapshot, tab_edits, cx)
1196                    });
1197                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, cx);
1198                    let block_ids = block_map.insert(block_properties.clone(), cx);
1199                    for (block_id, props) in block_ids.into_iter().zip(block_properties) {
1200                        expected_blocks.push((block_id, props));
1201                    }
1202                }
1203                40..=59 if !expected_blocks.is_empty() => {
1204                    let block_count = rng.gen_range(1..=4.min(expected_blocks.len()));
1205                    let block_ids_to_remove = (0..block_count)
1206                        .map(|_| {
1207                            expected_blocks
1208                                .remove(rng.gen_range(0..expected_blocks.len()))
1209                                .0
1210                        })
1211                        .collect();
1212
1213                    let (folds_snapshot, fold_edits) =
1214                        fold_map.read(buffer_snapshot.clone(), vec![]);
1215                    let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1216                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1217                        wrap_map.sync(tabs_snapshot, tab_edits, cx)
1218                    });
1219                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, cx);
1220                    block_map.remove(block_ids_to_remove, cx);
1221                }
1222                _ => {
1223                    buffer.update(cx, |buffer, cx| {
1224                        let v0 = buffer.version();
1225                        let edit_count = rng.gen_range(1..=5);
1226                        buffer.randomly_edit(&mut rng, edit_count, cx);
1227                        log::info!("buffer text: {:?}", buffer.text());
1228                        buffer_edits.extend(buffer.edits_since(&v0));
1229                        buffer_snapshot = buffer.snapshot();
1230                    });
1231                }
1232            }
1233
1234            let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
1235            let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
1236            let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
1237                wrap_map.sync(tabs_snapshot, tab_edits, cx)
1238            });
1239            let mut blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, cx);
1240            assert_eq!(
1241                blocks_snapshot.transforms.summary().input_rows,
1242                wraps_snapshot.max_point().row() + 1
1243            );
1244            log::info!("blocks text: {:?}", blocks_snapshot.text());
1245
1246            let buffer = buffer.read(cx);
1247            let mut sorted_blocks = expected_blocks
1248                .iter()
1249                .cloned()
1250                .map(|(id, block)| {
1251                    let mut position = block.position.to_point(buffer);
1252                    let column = wraps_snapshot.from_point(position, Bias::Left).column();
1253                    match block.disposition {
1254                        BlockDisposition::Above => {
1255                            position.column = 0;
1256                        }
1257                        BlockDisposition::Below => {
1258                            position.column = buffer.line_len(position.row);
1259                        }
1260                    };
1261                    let row = wraps_snapshot.from_point(position, Bias::Left).row();
1262                    (
1263                        id,
1264                        BlockProperties {
1265                            position: BlockPoint::new(row, column),
1266                            height: block.height,
1267                            disposition: block.disposition,
1268                            render: block.render.clone(),
1269                        },
1270                    )
1271                })
1272                .collect::<Vec<_>>();
1273            sorted_blocks
1274                .sort_unstable_by_key(|(id, block)| (block.position.row, block.disposition, *id));
1275            let mut sorted_blocks = sorted_blocks.into_iter().peekable();
1276
1277            let mut expected_buffer_rows = Vec::new();
1278            let mut expected_text = String::new();
1279            let input_text = wraps_snapshot.text();
1280            for (row, input_line) in input_text.split('\n').enumerate() {
1281                let row = row as u32;
1282                if row > 0 {
1283                    expected_text.push('\n');
1284                }
1285
1286                let buffer_row = wraps_snapshot
1287                    .to_point(WrapPoint::new(row, 0), Bias::Left)
1288                    .row;
1289
1290                while let Some((_, block)) = sorted_blocks.peek() {
1291                    if block.position.row == row && block.disposition == BlockDisposition::Above {
1292                        let text = "\n".repeat(block.height as usize);
1293                        expected_text.push_str(&text);
1294                        for _ in 0..block.height {
1295                            expected_buffer_rows.push(None);
1296                        }
1297                        sorted_blocks.next();
1298                    } else {
1299                        break;
1300                    }
1301                }
1302
1303                let soft_wrapped = wraps_snapshot.to_tab_point(WrapPoint::new(row, 0)).column() > 0;
1304                expected_buffer_rows.push(if soft_wrapped { None } else { Some(buffer_row) });
1305                expected_text.push_str(input_line);
1306
1307                while let Some((_, block)) = sorted_blocks.peek() {
1308                    if block.position.row == row && block.disposition == BlockDisposition::Below {
1309                        let text = "\n".repeat(block.height as usize);
1310                        expected_text.push_str(&text);
1311                        for _ in 0..block.height {
1312                            expected_buffer_rows.push(None);
1313                        }
1314                        sorted_blocks.next();
1315                    } else {
1316                        break;
1317                    }
1318                }
1319            }
1320
1321            let expected_lines = expected_text.split('\n').collect::<Vec<_>>();
1322            let expected_row_count = expected_lines.len();
1323            for start_row in 0..expected_row_count {
1324                let expected_text = expected_lines[start_row..].join("\n");
1325                let actual_text = blocks_snapshot
1326                    .chunks(start_row as u32..expected_row_count as u32, None)
1327                    .map(|chunk| chunk.text)
1328                    .collect::<String>();
1329                assert_eq!(
1330                    actual_text, expected_text,
1331                    "incorrect text starting from row {}",
1332                    start_row
1333                );
1334                assert_eq!(
1335                    blocks_snapshot
1336                        .buffer_rows(start_row as u32)
1337                        .collect::<Vec<_>>(),
1338                    &expected_buffer_rows[start_row..]
1339                );
1340            }
1341
1342            let mut expected_longest_rows = Vec::new();
1343            let mut longest_line_len = -1_isize;
1344            for (row, line) in expected_lines.iter().enumerate() {
1345                let row = row as u32;
1346
1347                assert_eq!(
1348                    blocks_snapshot.line_len(row),
1349                    line.len() as u32,
1350                    "invalid line len for row {}",
1351                    row
1352                );
1353
1354                let line_char_count = line.chars().count() as isize;
1355                match line_char_count.cmp(&longest_line_len) {
1356                    Ordering::Less => {}
1357                    Ordering::Equal => expected_longest_rows.push(row),
1358                    Ordering::Greater => {
1359                        longest_line_len = line_char_count;
1360                        expected_longest_rows.clear();
1361                        expected_longest_rows.push(row);
1362                    }
1363                }
1364            }
1365
1366            let longest_row = blocks_snapshot.longest_row();
1367            assert!(
1368                expected_longest_rows.contains(&longest_row),
1369                "incorrect longest row {}. expected {:?} with length {}",
1370                longest_row,
1371                expected_longest_rows,
1372                longest_line_len,
1373            );
1374
1375            for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
1376                let wrap_point = WrapPoint::new(row, 0);
1377                let block_point = blocks_snapshot.to_block_point(wrap_point);
1378                assert_eq!(blocks_snapshot.to_wrap_point(block_point), wrap_point);
1379            }
1380
1381            let mut block_point = BlockPoint::new(0, 0);
1382            for c in expected_text.chars() {
1383                let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
1384                let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
1385
1386                assert_eq!(
1387                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(left_point)),
1388                    left_point
1389                );
1390                assert_eq!(
1391                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(right_point)),
1392                    right_point
1393                );
1394
1395                if c == '\n' {
1396                    block_point.0 += Point::new(1, 0);
1397                } else {
1398                    block_point.column += c.len_utf8() as u32;
1399                }
1400            }
1401        }
1402    }
1403}