Make BlockMap 1d
Co-Authored-By: Nathan Sobo <nathan@zed.dev> Co-Authored-By: Max Brunsfeld <max@zed.dev>
This commit is contained in:
Antonio Scandurra
parent
18354c5e04
commit
d9283efbe6
2 changed files with 327 additions and 366 deletions
|
|
@ -14,7 +14,8 @@ use sum_tree::Bias;
|
|||
use tab_map::TabMap;
|
||||
use wrap_map::WrapMap;
|
||||
|
||||
pub use block_map::{BlockDisposition, BlockProperties, BufferRows, Chunks};
|
||||
pub use block_map::{BlockDisposition, BlockProperties, Chunks};
|
||||
pub use wrap_map::BufferRows;
|
||||
|
||||
pub trait ToDisplayPoint {
|
||||
fn to_display_point(&self, map: &DisplayMapSnapshot) -> DisplayPoint;
|
||||
|
|
@ -173,7 +174,7 @@ impl DisplayMapSnapshot {
|
|||
}
|
||||
|
||||
pub fn buffer_rows(&self, start_row: u32) -> BufferRows {
|
||||
self.blocks_snapshot.buffer_rows(start_row)
|
||||
self.wraps_snapshot.buffer_rows(start_row)
|
||||
}
|
||||
|
||||
pub fn buffer_row_count(&self) -> u32 {
|
||||
|
|
|
|||
|
|
@ -37,6 +37,12 @@ pub struct BlockId(usize);
|
|||
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
|
||||
pub struct BlockPoint(pub super::Point);
|
||||
|
||||
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
|
||||
struct BlockRow(u32);
|
||||
|
||||
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
|
||||
struct WrapRow(u32);
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Block {
|
||||
id: BlockId,
|
||||
|
|
@ -72,17 +78,18 @@ struct Transform {
|
|||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
struct TransformSummary {
|
||||
input: Point,
|
||||
output: Point,
|
||||
input_rows: u32,
|
||||
output_rows: u32,
|
||||
}
|
||||
|
||||
pub struct Chunks<'a> {
|
||||
transforms: sum_tree::Cursor<'a, Transform, (BlockPoint, WrapPoint)>,
|
||||
transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>,
|
||||
input_chunks: wrap_map::Chunks<'a>,
|
||||
input_chunk: Chunk<'a>,
|
||||
block_chunks: Option<BlockChunks<'a>>,
|
||||
output_position: BlockPoint,
|
||||
max_output_position: BlockPoint,
|
||||
output_row: u32,
|
||||
max_output_row: u32,
|
||||
max_input_row: u32,
|
||||
}
|
||||
|
||||
struct BlockChunks<'a> {
|
||||
|
|
@ -93,16 +100,6 @@ struct BlockChunks<'a> {
|
|||
offset: usize,
|
||||
}
|
||||
|
||||
pub struct BufferRows<'a> {
|
||||
transforms: sum_tree::Cursor<'a, Transform, (BlockPoint, WrapPoint)>,
|
||||
input_buffer_rows: wrap_map::BufferRows<'a>,
|
||||
input_buffer_row: Option<(u32, bool)>,
|
||||
input_row: u32,
|
||||
output_row: u32,
|
||||
max_output_row: u32,
|
||||
in_block: bool,
|
||||
}
|
||||
|
||||
impl BlockMap {
|
||||
pub fn new(buffer: ModelHandle<Buffer>, wrap_snapshot: WrapSnapshot) -> Self {
|
||||
Self {
|
||||
|
|
@ -110,7 +107,7 @@ impl BlockMap {
|
|||
next_block_id: AtomicUsize::new(0),
|
||||
blocks: Vec::new(),
|
||||
transforms: Mutex::new(SumTree::from_item(
|
||||
Transform::isomorphic(wrap_snapshot.text_summary().lines),
|
||||
Transform::isomorphic(wrap_snapshot.text_summary().lines.row + 1),
|
||||
&(),
|
||||
)),
|
||||
wrap_snapshot: Mutex::new(wrap_snapshot),
|
||||
|
|
@ -150,36 +147,80 @@ impl BlockMap {
|
|||
let buffer = self.buffer.read(cx);
|
||||
let mut transforms = self.transforms.lock();
|
||||
let mut new_transforms = SumTree::new();
|
||||
let old_max_point = WrapPoint(transforms.summary().input);
|
||||
let new_max_point = wrap_snapshot.max_point();
|
||||
let mut cursor = transforms.cursor::<WrapPoint>();
|
||||
let old_row_count = transforms.summary().input_rows;
|
||||
let new_row_count = wrap_snapshot.max_point().row() + 1;
|
||||
let mut cursor = transforms.cursor::<WrapRow>();
|
||||
let mut last_block_ix = 0;
|
||||
let mut blocks_in_edit = Vec::new();
|
||||
let mut edits = edits.into_iter().peekable();
|
||||
|
||||
while let Some(edit) = edits.next() {
|
||||
// Preserve any old transforms that precede this edit.
|
||||
let old_start = WrapPoint::new(edit.old.start, 0);
|
||||
let new_start = WrapPoint::new(edit.new.start, 0);
|
||||
let old_start = WrapRow(edit.old.start);
|
||||
let new_start = WrapRow(edit.new.start);
|
||||
new_transforms.push_tree(cursor.slice(&old_start, Bias::Left, &()), &());
|
||||
if let Some(transform) = cursor.item() {
|
||||
if transform.is_isomorphic() && old_start == cursor.end(&()) {
|
||||
new_transforms.push(transform.clone(), &());
|
||||
cursor.next(&());
|
||||
while let Some(transform) = cursor.item() {
|
||||
if transform
|
||||
.block
|
||||
.as_ref()
|
||||
.map_or(false, |b| b.disposition.is_below())
|
||||
{
|
||||
new_transforms.push(transform.clone(), &());
|
||||
cursor.next(&());
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Preserve any portion of an old transform that precedes this edit.
|
||||
let extent_before_edit = old_start.0 - cursor.start().0;
|
||||
push_isomorphic(&mut new_transforms, extent_before_edit);
|
||||
|
||||
// Skip over any old transforms that intersect this edit.
|
||||
let mut old_end = WrapPoint::new(edit.old.end, 0);
|
||||
let mut new_end = WrapPoint::new(edit.new.end, 0);
|
||||
let mut old_end = WrapRow(edit.old.end);
|
||||
let mut new_end = WrapRow(edit.new.end);
|
||||
cursor.seek(&old_end, Bias::Left, &());
|
||||
cursor.next(&());
|
||||
if old_end == *cursor.start() {
|
||||
while let Some(transform) = cursor.item() {
|
||||
if transform
|
||||
.block
|
||||
.as_ref()
|
||||
.map_or(false, |b| b.disposition.is_below())
|
||||
{
|
||||
cursor.next(&());
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Combine this edit with any subsequent edits that intersect the same transform.
|
||||
while let Some(next_edit) = edits.peek() {
|
||||
if next_edit.old.start <= cursor.start().row() {
|
||||
old_end = WrapPoint::new(next_edit.old.end, 0);
|
||||
new_end = WrapPoint::new(next_edit.new.end, 0);
|
||||
if next_edit.old.start <= cursor.start().0 {
|
||||
old_end = WrapRow(next_edit.old.end);
|
||||
new_end = WrapRow(next_edit.new.end);
|
||||
cursor.seek(&old_end, Bias::Left, &());
|
||||
cursor.next(&());
|
||||
if old_end == *cursor.start() {
|
||||
while let Some(transform) = cursor.item() {
|
||||
if transform
|
||||
.block
|
||||
.as_ref()
|
||||
.map_or(false, |b| b.disposition.is_below())
|
||||
{
|
||||
cursor.next(&());
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
edits.next();
|
||||
} else {
|
||||
break;
|
||||
|
|
@ -187,7 +228,7 @@ impl BlockMap {
|
|||
}
|
||||
|
||||
// Find the blocks within this edited region.
|
||||
let new_start = wrap_snapshot.to_point(new_start, Bias::Left);
|
||||
let new_start = wrap_snapshot.to_point(WrapPoint::new(new_start.0, 0), Bias::Left);
|
||||
let start_anchor = buffer.anchor_before(new_start);
|
||||
let start_block_ix = match self.blocks[last_block_ix..].binary_search_by(|probe| {
|
||||
probe
|
||||
|
|
@ -198,10 +239,10 @@ impl BlockMap {
|
|||
}) {
|
||||
Ok(ix) | Err(ix) => last_block_ix + ix,
|
||||
};
|
||||
let end_block_ix = if new_end.row() > wrap_snapshot.max_point().row() {
|
||||
let end_block_ix = if new_end.0 > wrap_snapshot.max_point().row() {
|
||||
self.blocks.len()
|
||||
} else {
|
||||
let new_end = wrap_snapshot.to_point(new_end, Bias::Left);
|
||||
let new_end = wrap_snapshot.to_point(WrapPoint::new(new_end.0, 0), Bias::Left);
|
||||
let end_anchor = buffer.anchor_before(new_end);
|
||||
match self.blocks[start_block_ix..].binary_search_by(|probe| {
|
||||
probe
|
||||
|
|
@ -235,27 +276,20 @@ impl BlockMap {
|
|||
// For each of these blocks, insert a new isomorphic transform preceding the block,
|
||||
// and then insert the block itself.
|
||||
for (block_row, block) in blocks_in_edit.iter().copied() {
|
||||
let block_insertion_point = match block.disposition {
|
||||
BlockDisposition::Above => Point::new(block_row, 0),
|
||||
BlockDisposition::Below => {
|
||||
Point::new(block_row, wrap_snapshot.line_len(block_row))
|
||||
}
|
||||
let insertion_row = match block.disposition {
|
||||
BlockDisposition::Above => block_row,
|
||||
BlockDisposition::Below => block_row + 1,
|
||||
};
|
||||
|
||||
let extent_before_block = block_insertion_point - new_transforms.summary().input;
|
||||
let extent_before_block = insertion_row - new_transforms.summary().input_rows;
|
||||
push_isomorphic(&mut new_transforms, extent_before_block);
|
||||
if block.disposition == BlockDisposition::Below {
|
||||
ensure_last_is_isomorphic_or_below_block(&mut new_transforms);
|
||||
}
|
||||
|
||||
new_transforms.push(Transform::block(block.clone()), &());
|
||||
}
|
||||
|
||||
old_end = old_end.min(old_max_point);
|
||||
new_end = new_end.min(new_max_point);
|
||||
old_end = WrapRow(old_end.0.min(old_row_count));
|
||||
new_end = WrapRow(new_end.0.min(new_row_count));
|
||||
|
||||
// Insert an isomorphic transform after the final block.
|
||||
let extent_after_last_block = new_end.0 - new_transforms.summary().input;
|
||||
let extent_after_last_block = new_end.0 - new_transforms.summary().input_rows;
|
||||
push_isomorphic(&mut new_transforms, extent_after_last_block);
|
||||
|
||||
// Preserve any portion of the old transform after this edit.
|
||||
|
|
@ -264,37 +298,28 @@ impl BlockMap {
|
|||
}
|
||||
|
||||
new_transforms.push_tree(cursor.suffix(&()), &());
|
||||
ensure_last_is_isomorphic_or_below_block(&mut new_transforms);
|
||||
debug_assert_eq!(new_transforms.summary().input, wrap_snapshot.max_point().0);
|
||||
debug_assert_eq!(
|
||||
new_transforms.summary().input_rows,
|
||||
wrap_snapshot.max_point().row() + 1
|
||||
);
|
||||
|
||||
drop(cursor);
|
||||
*transforms = new_transforms;
|
||||
}
|
||||
}
|
||||
|
||||
fn ensure_last_is_isomorphic_or_below_block(tree: &mut SumTree<Transform>) {
|
||||
if tree.last().map_or(true, |transform| {
|
||||
transform
|
||||
.block
|
||||
.as_ref()
|
||||
.map_or(false, |block| block.disposition.is_above())
|
||||
}) {
|
||||
tree.push(Transform::isomorphic(Point::zero()), &())
|
||||
}
|
||||
}
|
||||
|
||||
fn push_isomorphic(tree: &mut SumTree<Transform>, extent: Point) {
|
||||
if extent.is_zero() {
|
||||
fn push_isomorphic(tree: &mut SumTree<Transform>, rows: u32) {
|
||||
if rows == 0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut extent = Some(extent);
|
||||
let mut extent = Some(rows);
|
||||
tree.update_last(
|
||||
|last_transform| {
|
||||
if last_transform.is_isomorphic() {
|
||||
let extent = extent.take().unwrap();
|
||||
last_transform.summary.input += &extent;
|
||||
last_transform.summary.output += &extent;
|
||||
last_transform.summary.input_rows += extent;
|
||||
last_transform.summary.output_rows += extent;
|
||||
}
|
||||
},
|
||||
&(),
|
||||
|
|
@ -363,19 +388,12 @@ impl<'a> BlockMapWriter<'a> {
|
|||
{
|
||||
Ok(ix) | Err(ix) => ix,
|
||||
};
|
||||
let mut text = block.text.into();
|
||||
if block.disposition.is_above() {
|
||||
text.push("\n");
|
||||
} else {
|
||||
text.push_front("\n");
|
||||
}
|
||||
|
||||
self.0.blocks.insert(
|
||||
block_ix,
|
||||
Arc::new(Block {
|
||||
id,
|
||||
position,
|
||||
text,
|
||||
text: block.text.into(),
|
||||
runs: block.runs,
|
||||
disposition: block.disposition,
|
||||
}),
|
||||
|
|
@ -433,20 +451,28 @@ impl<'a> BlockMapWriter<'a> {
|
|||
impl BlockSnapshot {
|
||||
#[cfg(test)]
|
||||
fn text(&mut self) -> String {
|
||||
self.chunks(0..self.max_point().0.row + 1, false)
|
||||
self.chunks(0..self.transforms.summary().output_rows, false)
|
||||
.map(|chunk| chunk.text)
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn chunks(&self, rows: Range<u32>, highlights: bool) -> Chunks {
|
||||
let max_output_position = self.max_point().min(BlockPoint::new(rows.end, 0));
|
||||
let mut cursor = self.transforms.cursor::<(BlockPoint, WrapPoint)>();
|
||||
let output_position = BlockPoint::new(rows.start, 0);
|
||||
cursor.seek(&output_position, Bias::Right, &());
|
||||
let max_input_row = self.transforms.summary().input_rows;
|
||||
let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);
|
||||
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
|
||||
let output_row = rows.start;
|
||||
cursor.seek(&BlockRow(output_row), Bias::Right, &());
|
||||
let (input_start, output_start) = cursor.start();
|
||||
let row_overshoot = rows.start - output_start.0.row;
|
||||
let input_start_row = input_start.0.row + row_overshoot;
|
||||
let input_end_row = self.to_wrap_point(BlockPoint::new(rows.end, 0)).row();
|
||||
let overshoot = rows.start - output_start.0;
|
||||
let output_end_row = max_output_row.saturating_sub(1);
|
||||
let input_start_row = input_start.0 + overshoot;
|
||||
let input_end_row = self
|
||||
.to_wrap_point(BlockPoint::new(
|
||||
output_end_row,
|
||||
self.wrap_snapshot.line_len(output_end_row),
|
||||
))
|
||||
.row()
|
||||
+ 1;
|
||||
let input_chunks = self
|
||||
.wrap_snapshot
|
||||
.chunks(input_start_row..input_end_row, highlights);
|
||||
|
|
@ -455,112 +481,103 @@ impl BlockSnapshot {
|
|||
input_chunk: Default::default(),
|
||||
block_chunks: None,
|
||||
transforms: cursor,
|
||||
output_position,
|
||||
max_output_position,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn buffer_rows(&self, start_row: u32) -> BufferRows {
|
||||
let mut transforms = self.transforms.cursor::<(BlockPoint, WrapPoint)>();
|
||||
transforms.seek(&BlockPoint::new(start_row, 0), Bias::Left, &());
|
||||
let mut input_row = transforms.start().1.row();
|
||||
let transform = transforms.item().unwrap();
|
||||
let in_block;
|
||||
if transform.is_isomorphic() {
|
||||
input_row += start_row - transforms.start().0.row;
|
||||
in_block = false;
|
||||
} else {
|
||||
in_block = true;
|
||||
}
|
||||
let mut input_buffer_rows = self.wrap_snapshot.buffer_rows(input_row);
|
||||
let input_buffer_row = input_buffer_rows.next().unwrap();
|
||||
BufferRows {
|
||||
transforms,
|
||||
input_buffer_row: Some(input_buffer_row),
|
||||
input_buffer_rows,
|
||||
input_row,
|
||||
output_row: start_row,
|
||||
max_output_row: self.max_point().row,
|
||||
in_block,
|
||||
output_row,
|
||||
max_output_row,
|
||||
max_input_row,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn max_point(&self) -> BlockPoint {
|
||||
BlockPoint(self.transforms.summary().output)
|
||||
todo!()
|
||||
}
|
||||
|
||||
pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
|
||||
let mut cursor = self.transforms.cursor::<(BlockPoint, WrapPoint)>();
|
||||
cursor.seek(&point, Bias::Right, &());
|
||||
if let Some(transform) = cursor.prev_item() {
|
||||
if transform.is_isomorphic() && point == cursor.start().0 {
|
||||
return point;
|
||||
}
|
||||
}
|
||||
if let Some(transform) = cursor.item() {
|
||||
if transform.is_isomorphic() {
|
||||
let (output_start, input_start) = cursor.start();
|
||||
let output_overshoot = point.0 - output_start.0;
|
||||
let input_point = self
|
||||
.wrap_snapshot
|
||||
.clip_point(WrapPoint(input_start.0 + output_overshoot), bias);
|
||||
let input_overshoot = input_point.0 - input_start.0;
|
||||
BlockPoint(output_start.0 + input_overshoot)
|
||||
} else {
|
||||
if bias == Bias::Left && cursor.start().1 .0 > Point::zero()
|
||||
|| cursor.end(&()).1 == self.wrap_snapshot.max_point()
|
||||
{
|
||||
loop {
|
||||
cursor.prev(&());
|
||||
let transform = cursor.item().unwrap();
|
||||
if transform.is_isomorphic() {
|
||||
return BlockPoint(cursor.end(&()).0 .0);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
loop {
|
||||
cursor.next(&());
|
||||
let transform = cursor.item().unwrap();
|
||||
if transform.is_isomorphic() {
|
||||
return BlockPoint(cursor.start().0 .0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
self.max_point()
|
||||
}
|
||||
todo!()
|
||||
// let mut cursor = self.transforms.cursor::<(BlockPoint, WrapPoint)>();
|
||||
// cursor.seek(&point, Bias::Right, &());
|
||||
// if let Some(transform) = cursor.prev_item() {
|
||||
// if transform.is_isomorphic() && point == cursor.start().0 {
|
||||
// return point;
|
||||
// }
|
||||
// }
|
||||
// if let Some(transform) = cursor.item() {
|
||||
// if transform.is_isomorphic() {
|
||||
// let (output_start, input_start) = cursor.start();
|
||||
// let output_overshoot = point.0 - output_start.0;
|
||||
// let input_point = self
|
||||
// .wrap_snapshot
|
||||
// .clip_point(WrapPoint(input_start.0 + output_overshoot), bias);
|
||||
// let input_overshoot = input_point.0 - input_start.0;
|
||||
// BlockPoint(output_start.0 + input_overshoot)
|
||||
// } else {
|
||||
// if bias == Bias::Left && cursor.start().1 .0 > Point::zero()
|
||||
// || cursor.end(&()).1 == self.wrap_snapshot.max_point()
|
||||
// {
|
||||
// loop {
|
||||
// cursor.prev(&());
|
||||
// let transform = cursor.item().unwrap();
|
||||
// if transform.is_isomorphic() {
|
||||
// return BlockPoint(cursor.end(&()).0 .0);
|
||||
// }
|
||||
// }
|
||||
// } else {
|
||||
// loop {
|
||||
// cursor.next(&());
|
||||
// let transform = cursor.item().unwrap();
|
||||
// if transform.is_isomorphic() {
|
||||
// return BlockPoint(cursor.start().0 .0);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// } else {
|
||||
// self.max_point()
|
||||
// }
|
||||
}
|
||||
|
||||
pub fn to_block_point(&self, wrap_point: WrapPoint, bias: Bias) -> BlockPoint {
|
||||
let mut cursor = self.transforms.cursor::<(WrapPoint, BlockPoint)>();
|
||||
cursor.seek(&wrap_point, bias, &());
|
||||
while let Some(item) = cursor.item() {
|
||||
if item.is_isomorphic() {
|
||||
break;
|
||||
}
|
||||
cursor.next(&());
|
||||
}
|
||||
let (input_start, output_start) = cursor.start();
|
||||
let input_overshoot = wrap_point.0 - input_start.0;
|
||||
BlockPoint(output_start.0 + input_overshoot)
|
||||
todo!()
|
||||
// let mut cursor = self.transforms.cursor::<(WrapPoint, BlockPoint)>();
|
||||
// cursor.seek(&wrap_point, bias, &());
|
||||
// while let Some(item) = cursor.item() {
|
||||
// if item.is_isomorphic() {
|
||||
// break;
|
||||
// }
|
||||
// cursor.next(&());
|
||||
// }
|
||||
// let (input_start, output_start) = cursor.start();
|
||||
// let input_overshoot = wrap_point.0 - input_start.0;
|
||||
// BlockPoint(output_start.0 + input_overshoot)
|
||||
}
|
||||
|
||||
pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
|
||||
let mut cursor = self.transforms.cursor::<(BlockPoint, WrapPoint)>();
|
||||
cursor.seek(&block_point, Bias::Right, &());
|
||||
let (output_start, input_start) = cursor.start();
|
||||
let output_overshoot = block_point.0 - output_start.0;
|
||||
WrapPoint(input_start.0 + output_overshoot)
|
||||
let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>();
|
||||
cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
|
||||
if let Some(transform) = cursor.item() {
|
||||
match transform.block.as_ref().map(|b| b.disposition) {
|
||||
Some(BlockDisposition::Above) => WrapPoint::new(cursor.start().1 .0, 0),
|
||||
Some(BlockDisposition::Below) => {
|
||||
let wrap_row = cursor.start().1 .0 - 1;
|
||||
WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
|
||||
}
|
||||
None => {
|
||||
let overshoot = block_point.row - cursor.start().0 .0;
|
||||
let wrap_row = cursor.start().1 .0 + overshoot;
|
||||
WrapPoint::new(wrap_row, block_point.column)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
self.wrap_snapshot.max_point()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Transform {
|
||||
fn isomorphic(lines: Point) -> Self {
|
||||
fn isomorphic(rows: u32) -> Self {
|
||||
Self {
|
||||
summary: TransformSummary {
|
||||
input: lines,
|
||||
output: lines,
|
||||
input_rows: rows,
|
||||
output_rows: rows,
|
||||
},
|
||||
block: None,
|
||||
}
|
||||
|
|
@ -569,8 +586,8 @@ impl Transform {
|
|||
fn block(block: Arc<Block>) -> Self {
|
||||
Self {
|
||||
summary: TransformSummary {
|
||||
input: Default::default(),
|
||||
output: block.text.summary().lines,
|
||||
input_rows: 0,
|
||||
output_rows: block.text.summary().lines.row + 1,
|
||||
},
|
||||
block: Some(block),
|
||||
}
|
||||
|
|
@ -585,16 +602,25 @@ impl<'a> Iterator for Chunks<'a> {
|
|||
type Item = Chunk<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.output_position >= self.max_output_position {
|
||||
if self.output_row >= self.max_output_row {
|
||||
return None;
|
||||
}
|
||||
|
||||
if let Some(block_chunks) = self.block_chunks.as_mut() {
|
||||
if let Some(block_chunk) = block_chunks.next() {
|
||||
self.output_position.0 += Point::from_str(block_chunk.text);
|
||||
self.output_row += block_chunk.text.matches('\n').count() as u32;
|
||||
return Some(block_chunk);
|
||||
} else {
|
||||
self.block_chunks.take();
|
||||
self.output_row += 1;
|
||||
if self.output_row < self.max_output_row {
|
||||
return Some(Chunk {
|
||||
text: "\n",
|
||||
..Default::default()
|
||||
});
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -602,31 +628,37 @@ impl<'a> Iterator for Chunks<'a> {
|
|||
if let Some(block) = transform.block.as_ref() {
|
||||
let block_start = self.transforms.start().0 .0;
|
||||
let block_end = self.transforms.end(&()).0 .0;
|
||||
let start_in_block = self.output_position.0 - block_start;
|
||||
let end_in_block = cmp::min(self.max_output_position.0, block_end) - block_start;
|
||||
let start_in_block = self.output_row - block_start;
|
||||
let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
|
||||
self.transforms.next(&());
|
||||
let mut block_chunks = BlockChunks::new(block, start_in_block..end_in_block);
|
||||
if let Some(block_chunk) = block_chunks.next() {
|
||||
self.output_position.0 += Point::from_str(block_chunk.text);
|
||||
return Some(block_chunk);
|
||||
}
|
||||
self.block_chunks = Some(BlockChunks::new(block, start_in_block..end_in_block));
|
||||
return self.next();
|
||||
}
|
||||
|
||||
if self.input_chunk.text.is_empty() {
|
||||
if let Some(input_chunk) = self.input_chunks.next() {
|
||||
self.input_chunk = input_chunk;
|
||||
} else {
|
||||
self.output_row += 1;
|
||||
if self.output_row < self.max_output_row {
|
||||
self.transforms.next(&());
|
||||
return Some(Chunk {
|
||||
text: "\n",
|
||||
..Default::default()
|
||||
});
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let transform_end = self.transforms.end(&()).0 .0;
|
||||
let (prefix_lines, prefix_bytes) = offset_for_point(
|
||||
self.input_chunk.text,
|
||||
transform_end - self.output_position.0,
|
||||
);
|
||||
self.output_position.0 += prefix_lines;
|
||||
let (prefix_rows, prefix_bytes) =
|
||||
offset_for_row(self.input_chunk.text, transform_end - self.output_row);
|
||||
self.output_row += prefix_rows;
|
||||
let (prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
|
||||
self.input_chunk.text = suffix;
|
||||
if self.output_position.0 == transform_end {
|
||||
if self.output_row == transform_end {
|
||||
self.transforms.next(&());
|
||||
}
|
||||
|
||||
|
|
@ -638,9 +670,9 @@ impl<'a> Iterator for Chunks<'a> {
|
|||
}
|
||||
|
||||
impl<'a> BlockChunks<'a> {
|
||||
fn new(block: &'a Block, point_range: Range<Point>) -> Self {
|
||||
let offset_range = block.text.point_to_offset(point_range.start)
|
||||
..block.text.point_to_offset(point_range.end);
|
||||
fn new(block: &'a Block, rows: Range<u32>) -> Self {
|
||||
let offset_range = block.text.point_to_offset(Point::new(rows.start, 0))
|
||||
..block.text.point_to_offset(Point::new(rows.end, 0));
|
||||
|
||||
let mut runs = block.runs.iter().peekable();
|
||||
let mut run_start = 0;
|
||||
|
|
@ -701,78 +733,6 @@ impl<'a> Iterator for BlockChunks<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a> Iterator for BufferRows<'a> {
|
||||
type Item = (u32, bool);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.output_row > self.max_output_row {
|
||||
return None;
|
||||
}
|
||||
|
||||
let (buffer_row, is_wrapped) = self.input_buffer_row.unwrap();
|
||||
let in_block = self.in_block;
|
||||
|
||||
// log::info!(
|
||||
// "============== next - (output_row: {}, input_row: {}, buffer_row: {}, in_block: {}) ===============",
|
||||
// self.output_row,
|
||||
// self.input_row,
|
||||
// buffer_row,
|
||||
// in_block
|
||||
// );
|
||||
|
||||
self.output_row += 1;
|
||||
let output_point = BlockPoint::new(self.output_row, 0);
|
||||
let transform_end = self.transforms.end(&()).0;
|
||||
// if output_point > transform_end || output_point == transform_end && in_block {
|
||||
if output_point >= transform_end {
|
||||
// log::info!(" Calling next once");
|
||||
self.transforms.next(&());
|
||||
if self.transforms.end(&()).0 < output_point {
|
||||
// log::info!(" Calling next twice");
|
||||
self.transforms.next(&());
|
||||
}
|
||||
|
||||
if let Some(transform) = self.transforms.item() {
|
||||
self.in_block = !transform.is_isomorphic();
|
||||
}
|
||||
|
||||
// log::info!(
|
||||
// " Advanced to the next transform (block text: {:?}). Output row: {}, Transform starts at: {:?}",
|
||||
// self.transforms.item().and_then(|t| t.block.as_ref()).map(|b| b.text.to_string()),
|
||||
// self.output_row,
|
||||
// self.transforms.start().1
|
||||
// );
|
||||
|
||||
let mut new_input_position = self.transforms.start().1 .0;
|
||||
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
|
||||
new_input_position += Point::new(self.output_row, 0) - self.transforms.start().0 .0;
|
||||
new_input_position = cmp::min(new_input_position, self.transforms.end(&()).1 .0);
|
||||
}
|
||||
|
||||
if new_input_position.row > self.input_row {
|
||||
self.input_row = new_input_position.row;
|
||||
self.input_buffer_row = self.input_buffer_rows.next();
|
||||
// log::info!(
|
||||
// " Advanced the input buffer row. Input row: {}, Input buffer row {:?}",
|
||||
// self.input_row,
|
||||
// self.input_buffer_row
|
||||
// )
|
||||
}
|
||||
} else if self.transforms.item().map_or(true, |t| t.is_isomorphic()) {
|
||||
self.input_row += 1;
|
||||
self.input_buffer_row = self.input_buffer_rows.next();
|
||||
// log::info!(
|
||||
// " Advancing in isomorphic transform (off the end: {}). Input row: {}, Input buffer row {:?}",
|
||||
// self.transforms.item().is_none(),
|
||||
// self.input_row,
|
||||
// self.input_buffer_row
|
||||
// )
|
||||
}
|
||||
|
||||
Some((buffer_row, false))
|
||||
}
|
||||
}
|
||||
|
||||
impl sum_tree::Item for Transform {
|
||||
type Summary = TransformSummary;
|
||||
|
||||
|
|
@ -785,20 +745,20 @@ impl sum_tree::Summary for TransformSummary {
|
|||
type Context = ();
|
||||
|
||||
fn add_summary(&mut self, summary: &Self, _: &()) {
|
||||
self.input += summary.input;
|
||||
self.output += summary.output;
|
||||
self.input_rows += summary.input_rows;
|
||||
self.output_rows += summary.output_rows;
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapPoint {
|
||||
impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
|
||||
fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
|
||||
self.0 += summary.input;
|
||||
self.0 += summary.input_rows;
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockPoint {
|
||||
impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
|
||||
fn add_summary(&mut self, summary: &'a TransformSummary, _: &()) {
|
||||
self.0 += summary.output;
|
||||
self.0 += summary.output_rows;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -814,23 +774,20 @@ impl BlockDisposition {
|
|||
|
||||
// Count the number of bytes prior to a target point. If the string doesn't contain the target
|
||||
// point, return its total extent. Otherwise return the target point itself.
|
||||
fn offset_for_point(s: &str, target: Point) -> (Point, usize) {
|
||||
let mut point = Point::zero();
|
||||
fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
|
||||
let mut row = 0;
|
||||
let mut offset = 0;
|
||||
for (row, line) in s.split('\n').enumerate().take(target.row as usize + 1) {
|
||||
let row = row as u32;
|
||||
if row > 0 {
|
||||
for (ix, line) in s.split('\n').enumerate() {
|
||||
if ix > 0 {
|
||||
row += 1;
|
||||
offset += 1;
|
||||
}
|
||||
point.row = row;
|
||||
point.column = if row == target.row {
|
||||
cmp::min(line.len() as u32, target.column)
|
||||
} else {
|
||||
line.len() as u32
|
||||
};
|
||||
offset += point.column as usize;
|
||||
if row >= target {
|
||||
break;
|
||||
}
|
||||
offset += line.len() as usize;
|
||||
}
|
||||
(point, offset)
|
||||
(row, offset)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -842,6 +799,20 @@ mod tests {
|
|||
use rand::prelude::*;
|
||||
use std::env;
|
||||
|
||||
#[gpui::test]
|
||||
fn test_offset_for_row() {
|
||||
assert_eq!(offset_for_row("", 0), (0, 0));
|
||||
assert_eq!(offset_for_row("", 1), (0, 0));
|
||||
assert_eq!(offset_for_row("abcd", 0), (0, 0));
|
||||
assert_eq!(offset_for_row("abcd", 1), (0, 4));
|
||||
assert_eq!(offset_for_row("\n", 0), (0, 0));
|
||||
assert_eq!(offset_for_row("\n", 1), (1, 1));
|
||||
assert_eq!(offset_for_row("abc\ndef\nghi", 0), (0, 0));
|
||||
assert_eq!(offset_for_row("abc\ndef\nghi", 1), (1, 4));
|
||||
assert_eq!(offset_for_row("abc\ndef\nghi", 2), (2, 8));
|
||||
assert_eq!(offset_for_row("abc\ndef\nghi", 3), (2, 11));
|
||||
}
|
||||
|
||||
#[gpui::test]
|
||||
fn test_basic_blocks(cx: &mut gpui::MutableAppContext) {
|
||||
let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
|
||||
|
|
@ -888,63 +859,55 @@ mod tests {
|
|||
snapshot.text(),
|
||||
"aaa\nBLOCK 1\nBLOCK 2\nbbb\nccc\nddd\nBLOCK 3"
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.to_block_point(WrapPoint::new(1, 0), Bias::Right),
|
||||
BlockPoint::new(3, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(1, 0), Bias::Left),
|
||||
BlockPoint::new(1, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(1, 0), Bias::Right),
|
||||
BlockPoint::new(1, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(1, 1), Bias::Left),
|
||||
BlockPoint::new(1, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(1, 1), Bias::Right),
|
||||
BlockPoint::new(3, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(3, 0), Bias::Left),
|
||||
BlockPoint::new(3, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(3, 0), Bias::Right),
|
||||
BlockPoint::new(3, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(5, 3), Bias::Left),
|
||||
BlockPoint::new(5, 3)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(5, 3), Bias::Right),
|
||||
BlockPoint::new(5, 3)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(6, 0), Bias::Left),
|
||||
BlockPoint::new(5, 3)
|
||||
);
|
||||
assert_eq!(
|
||||
snapshot.clip_point(BlockPoint::new(6, 0), Bias::Right),
|
||||
BlockPoint::new(5, 3)
|
||||
);
|
||||
// assert_eq!(
|
||||
// snapshot.to_block_point(WrapPoint::new(1, 0), Bias::Right),
|
||||
// BlockPoint::new(3, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(1, 0), Bias::Left),
|
||||
// BlockPoint::new(1, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(1, 0), Bias::Right),
|
||||
// BlockPoint::new(1, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(1, 1), Bias::Left),
|
||||
// BlockPoint::new(1, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(1, 1), Bias::Right),
|
||||
// BlockPoint::new(3, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(3, 0), Bias::Left),
|
||||
// BlockPoint::new(3, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(3, 0), Bias::Right),
|
||||
// BlockPoint::new(3, 0)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(5, 3), Bias::Left),
|
||||
// BlockPoint::new(5, 3)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(5, 3), Bias::Right),
|
||||
// BlockPoint::new(5, 3)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(6, 0), Bias::Left),
|
||||
// BlockPoint::new(5, 3)
|
||||
// );
|
||||
// assert_eq!(
|
||||
// snapshot.clip_point(BlockPoint::new(6, 0), Bias::Right),
|
||||
// BlockPoint::new(5, 3)
|
||||
// );
|
||||
|
||||
assert_eq!(
|
||||
snapshot.buffer_rows(0).collect::<Vec<_>>(),
|
||||
&[
|
||||
(0, true),
|
||||
(1, false),
|
||||
(1, false),
|
||||
(1, true),
|
||||
(2, true),
|
||||
(3, true),
|
||||
(3, false),
|
||||
]
|
||||
);
|
||||
// assert_eq!(
|
||||
// buffer_rows_from_chunks(snapshot.chunks(0..snapshot.max_point().row + 1, false)),
|
||||
// &[Some(0), None, None, Some(1), Some(2), Some(3), None]
|
||||
// );
|
||||
|
||||
// Insert a line break, separating two block decorations into separate
|
||||
// lines.
|
||||
|
|
@ -985,13 +948,13 @@ mod tests {
|
|||
vec![
|
||||
BlockProperties {
|
||||
position: Point::new(1, 12),
|
||||
text: "BLOCK 1",
|
||||
text: "<BLOCK 1",
|
||||
disposition: BlockDisposition::Above,
|
||||
runs: vec![],
|
||||
},
|
||||
BlockProperties {
|
||||
position: Point::new(1, 1),
|
||||
text: "BLOCK 2",
|
||||
text: ">BLOCK 2",
|
||||
disposition: BlockDisposition::Below,
|
||||
runs: vec![],
|
||||
},
|
||||
|
|
@ -1004,7 +967,7 @@ mod tests {
|
|||
let mut snapshot = block_map.read(wraps_snapshot, vec![], cx);
|
||||
assert_eq!(
|
||||
snapshot.text(),
|
||||
"one two \nthree\nBLOCK 1\nfour five \nsix\nBLOCK 2\nseven \neight"
|
||||
"one two \nthree\n<BLOCK 1\nfour five \nsix\n>BLOCK 2\nseven \neight"
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1012,13 +975,9 @@ mod tests {
|
|||
fn test_random_blocks(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
|
||||
let operations = env::var("OPERATIONS")
|
||||
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
|
||||
.unwrap_or(10);
|
||||
.unwrap_or(1);
|
||||
|
||||
let wrap_width = if rng.gen_bool(0.2) {
|
||||
None
|
||||
} else {
|
||||
Some(rng.gen_range(0.0..=100.0))
|
||||
};
|
||||
let wrap_width = None;
|
||||
let tab_size = 1;
|
||||
let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
|
||||
let font_id = cx
|
||||
|
|
@ -1044,15 +1003,15 @@ mod tests {
|
|||
|
||||
for _ in 0..operations {
|
||||
match rng.gen_range(0..=100) {
|
||||
0..=19 => {
|
||||
let wrap_width = if rng.gen_bool(0.2) {
|
||||
None
|
||||
} else {
|
||||
Some(rng.gen_range(0.0..=100.0))
|
||||
};
|
||||
log::info!("Setting wrap width to {:?}", wrap_width);
|
||||
wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
|
||||
}
|
||||
// 0..=19 => {
|
||||
// let wrap_width = if rng.gen_bool(0.2) {
|
||||
// None
|
||||
// } else {
|
||||
// Some(rng.gen_range(0.0..=100.0))
|
||||
// };
|
||||
// log::info!("Setting wrap width to {:?}", wrap_width);
|
||||
// wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
|
||||
// }
|
||||
20..=39 => {
|
||||
let block_count = rng.gen_range(1..=1);
|
||||
let block_properties = (0..block_count)
|
||||
|
|
@ -1134,8 +1093,8 @@ mod tests {
|
|||
});
|
||||
let mut blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, cx);
|
||||
assert_eq!(
|
||||
blocks_snapshot.transforms.summary().input,
|
||||
wraps_snapshot.max_point().0
|
||||
blocks_snapshot.transforms.summary().input_rows,
|
||||
wraps_snapshot.max_point().row() + 1
|
||||
);
|
||||
log::info!("blocks text: {:?}", blocks_snapshot.text());
|
||||
|
||||
|
|
@ -1188,7 +1147,7 @@ mod tests {
|
|||
expected_text.push_str(&text);
|
||||
expected_text.push('\n');
|
||||
for _ in text.split('\n') {
|
||||
expected_buffer_rows.push((buffer_row, false));
|
||||
expected_buffer_rows.push(None);
|
||||
}
|
||||
sorted_blocks.next();
|
||||
} else {
|
||||
|
|
@ -1197,7 +1156,7 @@ mod tests {
|
|||
}
|
||||
|
||||
let soft_wrapped = wraps_snapshot.to_tab_point(WrapPoint::new(row, 0)).column() > 0;
|
||||
expected_buffer_rows.push((buffer_row, false));
|
||||
expected_buffer_rows.push(if soft_wrapped { None } else { Some(buffer_row) });
|
||||
expected_text.push_str(input_line);
|
||||
|
||||
while let Some((_, block)) = sorted_blocks.peek() {
|
||||
|
|
@ -1206,7 +1165,7 @@ mod tests {
|
|||
expected_text.push('\n');
|
||||
expected_text.push_str(&text);
|
||||
for _ in text.split('\n') {
|
||||
expected_buffer_rows.push((buffer_row, false));
|
||||
expected_buffer_rows.push(None);
|
||||
}
|
||||
sorted_blocks.next();
|
||||
} else {
|
||||
|
|
@ -1216,16 +1175,17 @@ mod tests {
|
|||
}
|
||||
|
||||
assert_eq!(blocks_snapshot.text(), expected_text);
|
||||
for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
|
||||
let wrap_point = WrapPoint::new(row, 0);
|
||||
let block_point = blocks_snapshot.to_block_point(wrap_point, Bias::Right);
|
||||
assert_eq!(blocks_snapshot.to_wrap_point(block_point), wrap_point);
|
||||
}
|
||||
|
||||
assert_eq!(
|
||||
blocks_snapshot.buffer_rows(0).collect::<Vec<_>>(),
|
||||
expected_buffer_rows
|
||||
);
|
||||
// for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
|
||||
// let wrap_point = WrapPoint::new(row, 0);
|
||||
// let block_point = blocks_snapshot.to_block_point(wrap_point, Bias::Right);
|
||||
// assert_eq!(blocks_snapshot.to_wrap_point(block_point), wrap_point);
|
||||
// }
|
||||
// assert_eq!(
|
||||
// buffer_rows_from_chunks(
|
||||
// blocks_snapshot.chunks(0..blocks_snapshot.max_point().row + 1, false)
|
||||
// ),
|
||||
// expected_buffer_rows
|
||||
// );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue