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