Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

multi_buffer: Fix word diff ranges for collapsed hunks (#65829)

Arth Srivastava32558ab9d531
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 5d60d65b229..0787f0078d0 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -3519,18 +3519,29 @@ impl MultiBufferSnapshot {
.then(|| {
let mut word_diffs = Vec::new();
- if self.show_deleted_hunks || is_inverted {
- let hunk_start_offset = if is_inverted {
- Anchor::in_buffer(
- excerpt.path_key_index,
- buffer_snapshot.anchor_after(hunk.diff_base_byte_range.start),
- )
+ let hunk_start_offset = if is_inverted {
+ Anchor::in_buffer(
+ excerpt.path_key_index,
+ buffer_snapshot.anchor_after(hunk.diff_base_byte_range.start),
+ )
+ .to_offset(self)
+ } else {
+ Anchor::in_buffer(excerpt.path_key_index, hunk.buffer_range.start)
.to_offset(self)
- } else {
- Anchor::in_buffer(excerpt.path_key_index, hunk.buffer_range.start)
- .to_offset(self)
- };
+ };
+
+ let hunk_has_deleted_text = !is_inverted && {
+ let mut cursor = self.diff_transforms.cursor::<MultiBufferOffset>(());
+ cursor.seek(&hunk_start_offset, Bias::Right);
+ matches!(
+ cursor.item(),
+ Some(DiffTransform::DeletedHunk { buffer_id, hunk_info, .. })
+ if *buffer_id == buffer_snapshot.remote_id()
+ && hunk_info.hunk_start_anchor == hunk.buffer_range.start
+ )
+ };
+ if hunk_has_deleted_text || is_inverted {
word_diffs.extend(hunk.base_word_diffs.iter().map(|diff| {
hunk_start_offset + diff.start..hunk_start_offset + diff.end
}));
diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rs
index 397cf00be11..e0e20ac88aa 100644
--- a/crates/multi_buffer/src/multi_buffer_tests.rs
+++ b/crates/multi_buffer/src/multi_buffer_tests.rs
@@ -13,11 +13,6 @@ use util::RandomCharIter;
use util::rel_path::rel_path;
use util::test::sample_text;
-#[ctor::ctor(unsafe)]
-fn init_logger() {
- zlog::init_test();
-}
-
#[gpui::test]
fn test_empty_singleton(cx: &mut App) {
let buffer = cx.new(|cx| Buffer::local("", cx));
@@ -3398,2667 +3393,1869 @@ async fn test_diff_hunks_with_multiple_excerpts(cx: &mut TestAppContext) {
assert_line_indents(&snapshot);
}
-/// A naive implementation of a multi-buffer that does not maintain
-/// any derived state, used for comparison in a randomized test.
-#[derive(Default)]
-struct ReferenceMultibuffer {
- excerpts: Vec<ReferenceExcerpt>,
- diffs: HashMap<BufferId, Entity<BufferDiff>>,
- inverted_diffs: HashMap<BufferId, (Entity<BufferDiff>, Entity<language::Buffer>)>,
- expanded_diff_hunks_by_buffer: HashMap<BufferId, Vec<text::Anchor>>,
-}
+#[gpui::test(iterations = 100)]
+async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {
+ let base_text = "a\n".repeat(100);
+ let buf = cx.update(|cx| cx.new(|cx| Buffer::local(base_text, cx)));
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
-#[derive(Clone, Debug)]
-struct ReferenceExcerpt {
- path_key: PathKey,
- path_key_index: PathKeyIndex,
- buffer: Entity<Buffer>,
- range: Range<text::Anchor>,
-}
+ let operations = env::var("OPERATIONS")
+ .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+ .unwrap_or(10);
-#[derive(Clone, Debug)]
-struct ReferenceRegion {
- buffer_id: Option<BufferId>,
- range: Range<usize>,
- buffer_range: Range<Point>,
- // if this is a deleted hunk, the main buffer anchor to which the deleted content is attached
- deleted_hunk_anchor: Option<text::Anchor>,
- status: Option<DiffHunkStatus>,
- excerpt: Option<ReferenceExcerpt>,
-}
+ fn row_ranges(ranges: &Vec<Range<Point>>) -> Vec<Range<u32>> {
+ ranges
+ .iter()
+ .map(|range| range.start.row..range.end.row)
+ .collect()
+ }
-impl ReferenceMultibuffer {
- fn expand_excerpts(
- &mut self,
- excerpts: &HashSet<ExcerptRange<text::Anchor>>,
- line_count: u32,
- cx: &mut App,
- ) {
- use text::AnchorRangeExt as _;
+ for _ in 0..operations {
+ let snapshot = buf.update(cx, |buf, _| buf.snapshot());
+ let num_ranges = rng.random_range(0..=10);
+ let max_row = snapshot.max_point().row;
+ let mut ranges = (0..num_ranges)
+ .map(|_| {
+ let start = rng.random_range(0..max_row);
+ let end = rng.random_range(start + 1..max_row + 1);
+ Point::row_range(start..end)
+ })
+ .collect::<Vec<_>>();
+ ranges.sort_by_key(|range| range.start);
+ log::info!("Setting ranges: {:?}", row_ranges(&ranges));
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ PathKey::for_buffer(&buf, cx),
+ buf.clone(),
+ ranges.clone(),
+ 2,
+ cx,
+ )
+ });
- if line_count == 0 || excerpts.is_empty() {
- return;
- }
+ let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let mut last_end = None;
+ let mut seen_ranges = Vec::default();
- let mut excerpts_by_buffer: HashMap<BufferId, Vec<ExcerptRange<text::Anchor>>> =
- HashMap::default();
- for excerpt in excerpts {
- excerpts_by_buffer
- .entry(excerpt.context.start.buffer_id)
- .or_default()
- .push(excerpt.clone())
- }
+ for info in snapshot.excerpts() {
+ let buffer_snapshot = snapshot
+ .buffer_for_id(info.context.start.buffer_id)
+ .unwrap();
+ let start = info.context.start.to_point(buffer_snapshot);
+ let end = info.context.end.to_point(buffer_snapshot);
+ seen_ranges.push(start..end);
- for (buffer_id, excerpts_to_expand) in excerpts_by_buffer {
- let mut buffer = None;
- let mut buffer_snapshot = None;
- let mut path = None;
- let mut path_key_index = None;
- let mut new_ranges =
- self.excerpts
- .iter()
- .filter(|excerpt| excerpt.range.start.buffer_id == buffer_id)
- .map(|excerpt| {
- let snapshot = excerpt.buffer.read(cx).snapshot();
- let mut range = excerpt.range.to_point(&snapshot);
- if excerpts_to_expand.iter().any(|info| {
- excerpt.range.contains_anchor(info.context.start, &snapshot)
- }) {
- range.start = Point::new(range.start.row.saturating_sub(line_count), 0);
- range.end = snapshot
- .clip_point(Point::new(range.end.row + line_count, 0), Bias::Left);
- range.end.column = snapshot.line_len(range.end.row);
- }
- buffer = Some(excerpt.buffer.clone());
- buffer_snapshot = Some(snapshot);
- path = Some(excerpt.path_key.clone());
- path_key_index = Some(excerpt.path_key_index);
- ExcerptRange::new(range)
- })
- .collect::<Vec<_>>();
+ if let Some(last_end) = last_end.take() {
+ assert!(
+ start > last_end,
+ "multibuffer has out-of-order ranges: {:?}; {:?} <= {:?}",
+ row_ranges(&seen_ranges),
+ start,
+ last_end
+ )
+ }
- new_ranges.sort_by_key(|nr| nr.context.start);
+ ranges.retain(|range| range.start < start || range.end > end);
- self.set_excerpts(
- path.unwrap(),
- path_key_index.unwrap(),
- buffer.unwrap(),
- &buffer_snapshot.unwrap(),
- new_ranges,
- cx,
- );
+ last_end = Some(end)
}
- }
- fn set_excerpts(
- &mut self,
- path_key: PathKey,
- path_key_index: PathKeyIndex,
- buffer: Entity<Buffer>,
- buffer_snapshot: &BufferSnapshot,
- ranges: Vec<ExcerptRange<Point>>,
- cx: &mut App,
- ) {
- self.excerpts.retain(|excerpt| {
- excerpt.path_key != path_key && excerpt.buffer.entity_id() != buffer.entity_id()
- });
-
- let ranges = MultiBuffer::merge_excerpt_ranges(&ranges);
-
- let (Ok(ix) | Err(ix)) = self
- .excerpts
- .binary_search_by(|probe| probe.path_key.cmp(&path_key));
- self.excerpts.splice(
- ix..ix,
- ranges.into_iter().map(|range| ReferenceExcerpt {
- path_key: path_key.clone(),
- path_key_index,
- buffer: buffer.clone(),
- range: buffer_snapshot.anchor_before(range.context.start)
- ..buffer_snapshot.anchor_after(range.context.end),
- }),
+ assert!(
+ ranges.is_empty(),
+ "multibuffer {:?} did not include all ranges: {:?}",
+ row_ranges(&seen_ranges),
+ row_ranges(&ranges)
);
- self.update_expanded_diff_hunks_for_buffer(buffer_snapshot.remote_id(), cx);
}
+}
- fn expand_diff_hunks(&mut self, path_key: PathKey, range: Range<text::Anchor>, cx: &App) {
- let excerpt = self
- .excerpts
- .iter_mut()
- .find(|e| {
- e.path_key == path_key
- && e.range
- .start
- .cmp(&range.start, &e.buffer.read(cx).snapshot())
- .is_le()
- && e.range
- .end
- .cmp(&range.end, &e.buffer.read(cx).snapshot())
- .is_ge()
- })
- .unwrap();
- let buffer = excerpt.buffer.read(cx).snapshot();
- let buffer_id = buffer.remote_id();
+#[gpui::test(iterations = 100)]
+async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
+ let operations = env::var("OPERATIONS")
+ .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+ .unwrap_or(10);
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ let mut buffers: Vec<Entity<Buffer>> = Vec::new();
+ let mut base_texts: HashMap<BufferId, String> = HashMap::default();
+ let mut reference = ReferenceMultibuffer::default();
+ let mut anchors = Vec::new();
+ let mut old_versions = Vec::new();
+ let mut needs_diff_calculation = false;
+ let mut inverted_diff_main_buffers: HashMap<BufferId, Entity<BufferDiff>> = HashMap::default();
+ for _ in 0..operations {
+ match rng.random_range(0..100) {
+ 0..=14 if !buffers.is_empty() => {
+ let buffer = buffers.choose(&mut rng).unwrap();
+ buffer.update(cx, |buf, cx| {
+ let edit_count = rng.random_range(1..5);
+ buf.randomly_edit(&mut rng, edit_count, cx);
+ log::info!("buffer text:\n{}", buf.text());
+ needs_diff_calculation = true;
+ });
+ cx.update(|cx| reference.diffs_updated(cx));
+ }
+ 15..=24 if !reference.excerpts.is_empty() => {
+ multibuffer.update(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ let infos = snapshot.excerpts().collect::<Vec<_>>();
+ let mut excerpts = HashSet::default();
+ for _ in 0..rng.random_range(0..infos.len()) {
+ excerpts.extend(infos.choose(&mut rng).cloned());
+ }
- // Skip inverted excerpts - hunks are always expanded
- if self.inverted_diffs.contains_key(&buffer_id) {
- return;
- }
+ let line_count = rng.random_range(0..5);
- let Some(diff) = self.diffs.get(&buffer_id) else {
- return;
- };
- let excerpt_range = excerpt.range.to_point(&buffer);
- let expanded_diff_hunks = self
- .expanded_diff_hunks_by_buffer
- .entry(buffer_id)
- .or_default();
- for hunk in diff
- .read(cx)
- .snapshot(cx)
- .hunks_intersecting_range(range, &buffer)
- {
- let hunk_range = hunk.buffer_range.to_point(&buffer);
- if hunk_range.start < excerpt_range.start || hunk_range.start > excerpt_range.end {
- continue;
- }
- if let Err(ix) = expanded_diff_hunks
- .binary_search_by(|anchor| anchor.cmp(&hunk.buffer_range.start, &buffer))
- {
- log::info!(
- "expanding diff hunk {:?}. excerpt range: {:?}, buffer {:?}",
- hunk_range,
- excerpt_range,
- buffer.remote_id()
+ let excerpt_ixs = excerpts
+ .iter()
+ .map(|info| {
+ reference
+ .excerpts
+ .iter()
+ .position(|e| e.range == info.context)
+ .unwrap()
+ })
+ .collect::<Vec<_>>();
+ log::info!("Expanding excerpts {excerpt_ixs:?} by {line_count} lines");
+ multibuffer.expand_excerpts(
+ excerpts
+ .iter()
+ .map(|info| snapshot.anchor_in_excerpt(info.context.end).unwrap()),
+ line_count,
+ ExpandExcerptDirection::UpAndDown,
+ cx,
+ );
+
+ reference.expand_excerpts(&excerpts, line_count, cx);
+ });
+ }
+ 25..=34 if !reference.excerpts.is_empty() => {
+ let multibuffer =
+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let offset = multibuffer.clip_offset(
+ MultiBufferOffset(rng.random_range(0..=multibuffer.len().0)),
+ Bias::Left,
);
- expanded_diff_hunks.insert(ix, hunk.buffer_range.start);
- } else {
- log::trace!("hunk {hunk_range:?} already expanded in excerpt");
+ let bias = if rng.random() {
+ Bias::Left
+ } else {
+ Bias::Right
+ };
+ log::info!("Creating anchor at {} with bias {:?}", offset.0, bias);
+ anchors.push(multibuffer.anchor_at(offset, bias));
+ anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
}
- }
- }
-
- fn expected_content(
- &self,
- cx: &App,
- ) -> (
- String,
- Vec<RowInfo>,
- HashSet<MultiBufferRow>,
- Vec<ReferenceRegion>,
- ) {
- use util::maybe;
+ 35..=45 if !reference.excerpts.is_empty() => {
+ multibuffer.update(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ let excerpt_ix = rng.random_range(0..reference.excerpts.len());
+ let excerpt = &reference.excerpts[excerpt_ix];
- let mut text = String::new();
- let mut regions = Vec::<ReferenceRegion>::new();
- let mut excerpt_boundary_rows = HashSet::default();
- for excerpt in &self.excerpts {
- excerpt_boundary_rows.insert(MultiBufferRow(text.matches('\n').count() as u32));
- let buffer = excerpt.buffer.read(cx);
- let buffer_id = buffer.remote_id();
- let buffer_range = excerpt.range.to_offset(buffer);
+ // Skip inverted excerpts - hunks can't be collapsed
+ let buffer_id = excerpt.buffer.read(cx).remote_id();
+ if reference.inverted_diffs.contains_key(&buffer_id) {
+ return;
+ }
- if let Some((diff, main_buffer)) = self.inverted_diffs.get(&buffer_id) {
- let diff_snapshot = diff.read(cx).snapshot(cx);
- let main_buffer_snapshot = main_buffer.read(cx).snapshot();
+ let start = excerpt.range.start;
+ let end = excerpt.range.end;
+ let range = snapshot.anchor_in_excerpt(start).unwrap()
+ ..snapshot.anchor_in_excerpt(end).unwrap();
- let mut offset = buffer_range.start;
- for hunk in diff_snapshot.hunks_intersecting_base_text_range(
- buffer_range.clone(),
- &main_buffer_snapshot.text,
- ) {
- let mut hunk_base_range = hunk.diff_base_byte_range.clone();
+ log::info!(
+ "expanding diff hunks in range {:?} (excerpt index {excerpt_ix:?}, buffer id {:?})",
+ range.to_point(&snapshot),
+ buffer_id,
+ );
+ reference.expand_diff_hunks(excerpt.path_key.clone(), start..end, cx);
+ multibuffer.expand_diff_hunks(vec![range], cx);
+ });
+ }
+ 46..=75 if needs_diff_calculation => {
+ multibuffer.update(cx, |multibuffer, cx| {
+ for buffer in multibuffer.all_buffers() {
+ let snapshot = buffer.read(cx).snapshot();
+ let buffer_id = snapshot.remote_id();
- hunk_base_range.end = hunk_base_range.end.min(buffer_range.end);
- if hunk_base_range.start > buffer_range.end
- || hunk_base_range.start < buffer_range.start
- {
- continue;
- }
+ if let Some(diff) = multibuffer.diff_for(buffer_id) {
+ diff.update(cx, |diff, cx| {
+ log::info!("recalculating diff for buffer {:?}", buffer_id,);
+ diff.recalculate_diff_sync(&snapshot.text, cx);
+ });
+ }
- // Add the text before the hunk
- if hunk_base_range.start >= offset {
- let len = text.len();
- text.extend(buffer.text_for_range(offset..hunk_base_range.start));
- if text.len() > len {
- regions.push(ReferenceRegion {
- buffer_id: Some(buffer_id),
- range: len..text.len(),
- buffer_range: (offset..hunk_base_range.start).to_point(&buffer),
- status: None,
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
+ if let Some(inverted_diff) = inverted_diff_main_buffers.get(&buffer_id) {
+ inverted_diff.update(cx, |diff, cx| {
+ log::info!(
+ "recalculating inverted diff for main buffer {:?}",
+ buffer_id,
+ );
+ diff.recalculate_diff_sync(&snapshot.text, cx);
});
}
}
+ reference.diffs_updated(cx);
+ needs_diff_calculation = false;
+ });
+ }
+ _ => {
+ // Decide if we're creating a new buffer or reusing an existing one
+ let create_new_buffer = buffers.is_empty() || rng.random_bool(0.4);
- // Add the "deleted" region (base text that's not in main)
- if !hunk_base_range.is_empty() {
- let len = text.len();
- text.extend(buffer.text_for_range(hunk_base_range.clone()));
- regions.push(ReferenceRegion {
- buffer_id: Some(buffer_id),
- range: len..text.len(),
- buffer_range: hunk_base_range.to_point(&buffer),
- status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
- });
- }
+ let (excerpt_buffer, diff, inverted_main_buffer) = if create_new_buffer {
+ let create_inverted = rng.random_bool(0.3);
- offset = hunk_base_range.end;
- }
+ if create_inverted {
+ let mut main_buffer_text = util::RandomCharIter::new(&mut rng)
+ .take(256)
+ .collect::<String>();
+ let main_buffer = cx.new(|cx| Buffer::local(main_buffer_text.clone(), cx));
+ text::LineEnding::normalize(&mut main_buffer_text);
+ let main_buffer_id =
+ main_buffer.read_with(cx, |buffer, _| buffer.remote_id());
+ base_texts.insert(main_buffer_id, main_buffer_text.clone());
+ buffers.push(main_buffer.clone());
- // Add remaining buffer text
- let len = text.len();
- text.extend(buffer.text_for_range(offset..buffer_range.end));
- text.push('\n');
- regions.push(ReferenceRegion {
- buffer_id: Some(buffer_id),
- range: len..text.len(),
- buffer_range: (offset..buffer_range.end).to_point(&buffer),
- status: None,
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
- });
- } else {
- let diff = self.diffs.get(&buffer_id).unwrap().read(cx).snapshot(cx);
- let base_buffer = diff.base_text();
+ let diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ &main_buffer_text,
+ &main_buffer.read(cx).text_snapshot(),
+ cx,
+ )
+ });
- let mut offset = buffer_range.start;
- let hunks = diff
- .hunks_intersecting_range(excerpt.range.clone(), buffer)
- .peekable();
+ let base_text_buffer =
+ diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
- for hunk in hunks {
- // Ignore hunks that are outside the excerpt range.
- let mut hunk_range = hunk.buffer_range.to_offset(buffer);
+ // Track for recalculation when main buffer is edited
+ inverted_diff_main_buffers.insert(main_buffer_id, diff.clone());
- hunk_range.end = hunk_range.end.min(buffer_range.end);
- if hunk_range.start > buffer_range.end || hunk_range.start < buffer_range.start
- {
- log::trace!("skipping hunk outside excerpt range");
- continue;
- }
+ (base_text_buffer, diff, Some(main_buffer))
+ } else {
+ let mut base_text = util::RandomCharIter::new(&mut rng)
+ .take(256)
+ .collect::<String>();
- if !self
- .expanded_diff_hunks_by_buffer
- .get(&buffer_id)
- .cloned()
- .into_iter()
- .flatten()
- .any(|expanded_anchor| {
- expanded_anchor
- .cmp(&hunk.buffer_range.start, buffer)
- .is_eq()
- })
- {
- log::trace!("skipping a hunk that's not marked as expanded");
- continue;
- }
+ let buffer_handle = cx.new(|cx| Buffer::local(base_text.clone(), cx));
+ text::LineEnding::normalize(&mut base_text);
+ let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
+ base_texts.insert(buffer_id, base_text.clone());
+ buffers.push(buffer_handle.clone());
- if !hunk.buffer_range.start.is_valid(buffer) {
- log::trace!("skipping hunk with deleted start: {:?}", hunk.range);
- continue;
+ let diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ &base_text,
+ &buffer_handle.read(cx).text_snapshot(),
+ cx,
+ )
+ });
+
+ (buffer_handle, diff, None)
}
+ } else {
+ // Reuse an existing buffer
+ let buffer_handle = buffers.choose(&mut rng).unwrap().clone();
+ let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
- if hunk_range.start >= offset {
- // Add the buffer text before the hunk
- let len = text.len();
- text.extend(buffer.text_for_range(offset..hunk_range.start));
- if text.len() > len {
- regions.push(ReferenceRegion {
- buffer_id: Some(buffer_id),
- range: len..text.len(),
- buffer_range: (offset..hunk_range.start).to_point(&buffer),
- status: None,
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
- });
- }
-
- // Add the deleted text for the hunk.
- if !hunk.diff_base_byte_range.is_empty() {
- let mut base_text = base_buffer
- .text_for_range(hunk.diff_base_byte_range.clone())
- .collect::<String>();
- if !base_text.ends_with('\n') {
- base_text.push('\n');
- }
- let len = text.len();
- text.push_str(&base_text);
- regions.push(ReferenceRegion {
- buffer_id: Some(base_buffer.remote_id()),
- range: len..text.len(),
- buffer_range: hunk.diff_base_byte_range.to_point(&base_buffer),
- status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: Some(hunk.buffer_range.start),
+ if let Some(diff) = inverted_diff_main_buffers.get(&buffer_id) {
+ let base_text_buffer =
+ diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
+ (base_text_buffer, diff.clone(), Some(buffer_handle))
+ } else {
+ // Get existing diff or create new one for regular buffer
+ let diff = multibuffer
+ .read_with(cx, |mb, _| mb.diff_for(buffer_id))
+ .unwrap_or_else(|| {
+ let base_text = base_texts.get(&buffer_id).unwrap();
+ cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ base_text,
+ &buffer_handle.read(cx).text_snapshot(),
+ cx,
+ )
+ })
});
- }
-
- offset = hunk_range.start;
+ (buffer_handle, diff, None)
}
+ };
- // Add the inserted text for the hunk.
- if hunk_range.end > offset {
- let len = text.len();
- text.extend(buffer.text_for_range(offset..hunk_range.end));
- let range = len..text.len();
- let region = ReferenceRegion {
- buffer_id: Some(buffer_id),
- range,
- buffer_range: (offset..hunk_range.end).to_point(&buffer),
- status: Some(DiffHunkStatus::added(hunk.secondary_status)),
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
- };
- offset = hunk_range.end;
- regions.push(region);
- }
- }
+ let excerpt_buffer_snapshot =
+ excerpt_buffer.read_with(cx, |excerpt_buffer, _| excerpt_buffer.snapshot());
+ let mut ranges = reference
+ .excerpts
+ .iter()
+ .filter(|excerpt| excerpt.buffer == excerpt_buffer)
+ .map(|excerpt| excerpt.range.to_point(&excerpt_buffer_snapshot))
+ .collect::<Vec<_>>();
+ mutate_excerpt_ranges(&mut rng, &mut ranges, &excerpt_buffer_snapshot, 1);
+ let ranges = ranges
+ .iter()
+ .cloned()
+ .map(ExcerptRange::new)
+ .collect::<Vec<_>>();
+ let path = cx.update(|cx| PathKey::for_buffer(&excerpt_buffer, cx));
+ let path_key_index = multibuffer.update(cx, |multibuffer, _| {
+ multibuffer.get_or_create_path_key_index(&path)
+ });
- // Add the buffer text for the rest of the excerpt.
- let len = text.len();
- text.extend(buffer.text_for_range(offset..buffer_range.end));
- text.push('\n');
- regions.push(ReferenceRegion {
- buffer_id: Some(buffer_id),
- range: len..text.len(),
- buffer_range: (offset..buffer_range.end).to_point(&buffer),
- status: None,
- excerpt: Some(excerpt.clone()),
- deleted_hunk_anchor: None,
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpt_ranges_for_path(
+ path.clone(),
+ excerpt_buffer.clone(),
+ &excerpt_buffer_snapshot,
+ ranges.clone(),
+ cx,
+ )
});
- }
- }
- // Remove final trailing newline.
- if self.excerpts.is_empty() {
- regions.push(ReferenceRegion {
- buffer_id: None,
- range: 0..1,
- buffer_range: Point::new(0, 0)..Point::new(0, 1),
- status: None,
- excerpt: None,
- deleted_hunk_anchor: None,
- });
- } else {
- text.pop();
- let region = regions.last_mut().unwrap();
- assert!(region.deleted_hunk_anchor.is_none());
- region.range.end -= 1;
- }
+ cx.update(|cx| {
+ reference.set_excerpts(
+ path,
+ path_key_index,
+ excerpt_buffer.clone(),
+ &excerpt_buffer_snapshot,
+ ranges,
+ cx,
+ )
+ });
- // Retrieve the row info using the region that contains
- // the start of each multi-buffer line.
- let mut ix = 0;
- let row_infos = text
- .split('\n')
- .map(|line| {
- let row_info = regions
- .iter()
- .rposition(|region| {
- region.range.contains(&ix) || (ix == text.len() && ix == region.range.end)
- })
- .map_or(RowInfo::default(), |region_ix| {
- let region = regions[region_ix].clone();
- let buffer_row = region.buffer_range.start.row
- + text[region.range.start..ix].matches('\n').count() as u32;
- let main_buffer = region.excerpt.as_ref().map(|e| e.buffer.clone());
- let excerpt_range = region.excerpt.as_ref().map(|e| &e.range);
- let is_excerpt_start = region_ix == 0
- || regions[region_ix - 1].excerpt.as_ref().map(|e| &e.range)
- != excerpt_range
- || regions[region_ix - 1].range.is_empty();
- let mut is_excerpt_end = region_ix == regions.len() - 1
- || regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)
- != excerpt_range;
- let is_start = !text[region.range.start..ix].contains('\n');
- let is_last_region = region_ix == regions.len() - 1;
- let mut is_end = if region.range.end > text.len() {
- !text[ix..].contains('\n')
+ let excerpt_buffer_id =
+ excerpt_buffer.read_with(cx, |buffer, _| buffer.remote_id());
+ multibuffer.update(cx, |multibuffer, cx| {
+ if multibuffer.diff_for(excerpt_buffer_id).is_none() {
+ if let Some(main_buffer) = inverted_main_buffer {
+ reference.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);
+ multibuffer.add_inverted_diff(diff, main_buffer, cx);
} else {
- let remaining_newlines = text[ix..region.range.end.min(text.len())]
- .matches('\n')
- .count();
- remaining_newlines == if is_last_region { 0 } else { 1 }
- };
- if region_ix < regions.len() - 1
- && !text[ix..].contains("\n")
- && (region.status == Some(DiffHunkStatus::added_none())
- || region.status.is_some_and(|s| s.is_deleted()))
- && regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)
- == excerpt_range
- && regions[region_ix + 1].range.start == text.len()
- {
- is_end = true;
- is_excerpt_end = true;
- }
- let multibuffer_row =
- MultiBufferRow(text[..ix].matches('\n').count() as u32);
- let mut expand_direction = None;
- if let Some(buffer) = &main_buffer {
- let needs_expand_up = is_excerpt_start && is_start && buffer_row > 0;
- let needs_expand_down = is_excerpt_end
- && is_end
- && buffer.read(cx).max_point().row > buffer_row;
- expand_direction = if needs_expand_up && needs_expand_down {
- Some(ExpandExcerptDirection::UpAndDown)
- } else if needs_expand_up {
- Some(ExpandExcerptDirection::Up)
- } else if needs_expand_down {
- Some(ExpandExcerptDirection::Down)
- } else {
- None
- };
+ reference.add_diff(diff.clone(), cx);
+ multibuffer.add_diff(diff, cx);
}
- RowInfo {
- buffer_id: region.buffer_id,
- diff_status: region.status,
- buffer_row: Some(buffer_row),
- wrapped_buffer_row: None,
+ }
+ });
+ }
+ }
- multibuffer_row: Some(multibuffer_row),
- expand_info: maybe!({
- let direction = expand_direction?;
- let excerpt = region.excerpt.as_ref()?;
- Some(ExpandInfo {
- direction,
- start_anchor: Anchor::in_buffer(
- excerpt.path_key_index,
- excerpt.range.start,
- ),
- })
- }),
- }
- });
- ix += line.len() + 1;
- row_info
+ if rng.random_bool(0.3) {
+ multibuffer.update(cx, |multibuffer, cx| {
+ old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
})
- .collect();
-
- (text, row_infos, excerpt_boundary_rows, regions)
- }
-
- fn diffs_updated(&mut self, cx: &mut App) {
- let buffer_ids = self.diffs.keys().copied().collect::<Vec<_>>();
- for buffer_id in buffer_ids {
- self.update_expanded_diff_hunks_for_buffer(buffer_id, cx);
}
- }
- fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut App) {
- let buffer_id = diff.read(cx).buffer_id;
- self.diffs.insert(buffer_id, diff);
+ multibuffer.read_with(cx, |multibuffer, cx| {
+ check_multibuffer(multibuffer, &reference, &anchors, cx, &mut rng);
+ });
}
-
- fn add_inverted_diff(
- &mut self,
- diff: Entity<BufferDiff>,
- main_buffer: Entity<language::Buffer>,
- cx: &App,
- ) {
- let base_text_buffer_id = diff.read(cx).base_text(cx).remote_id();
- self.inverted_diffs
- .insert(base_text_buffer_id, (diff, main_buffer));
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ for (old_snapshot, subscription) in old_versions {
+ check_multibuffer_edits(&snapshot, &old_snapshot, subscription);
}
+}
- fn update_expanded_diff_hunks_for_buffer(&mut self, buffer_id: BufferId, cx: &mut App) {
- let excerpts = self
- .excerpts
- .iter()
- .filter(|excerpt| excerpt.buffer.read(cx).remote_id() == buffer_id)
- .collect::<Vec<_>>();
- let Some(buffer) = excerpts.first().map(|excerpt| excerpt.buffer.clone()) else {
- self.expanded_diff_hunks_by_buffer.remove(&buffer_id);
- return;
- };
- let buffer_snapshot = buffer.read(cx).snapshot();
- let Some(diff) = self.diffs.get(&buffer_id) else {
- self.expanded_diff_hunks_by_buffer.remove(&buffer_id);
- return;
- };
- let diff = diff.read(cx).snapshot(cx);
- let hunks = diff
- .hunks_in_row_range(0..u32::MAX, &buffer_snapshot)
- .collect::<Vec<_>>();
- self.expanded_diff_hunks_by_buffer
- .entry(buffer_id)
- .or_default()
- .retain(|hunk_anchor| {
- if !hunk_anchor.is_valid(&buffer_snapshot) {
- return false;
- }
-
- let Ok(ix) = hunks.binary_search_by(|hunk| {
- hunk.buffer_range.start.cmp(hunk_anchor, &buffer_snapshot)
- }) else {
- return false;
- };
- let hunk_range = hunks[ix].buffer_range.to_point(&buffer_snapshot);
- excerpts.iter().any(|excerpt| {
- let excerpt_range = excerpt.range.to_point(&buffer_snapshot);
- hunk_range.start >= excerpt_range.start && hunk_range.start <= excerpt_range.end
- })
- });
- }
+#[gpui::test]
+fn test_history(cx: &mut App) {
+ let test_settings = SettingsStore::test(cx);
+ cx.set_global(test_settings);
- fn anchor_to_offset(&self, anchor: &Anchor, cx: &App) -> Option<MultiBufferOffset> {
- if anchor.diff_base_anchor().is_some() {
- panic!("reference multibuffer cannot yet resolve anchors inside deleted hunks");
- }
- let (anchor, snapshot, path_key) = self.anchor_to_buffer_anchor(anchor, cx)?;
- // TODO(cole) can maybe make this and expected content call a common function instead
- let (text, _, _, regions) = self.expected_content(cx);
+ let group_interval: Duration = Duration::from_millis(1);
+ let buffer_1 = cx.new(|cx| {
+ let mut buf = Buffer::local("1234", cx);
+ buf.set_group_interval(group_interval);
+ buf
+ });
+ let buffer_2 = cx.new(|cx| {
+ let mut buf = Buffer::local("5678", cx);
+ buf.set_group_interval(group_interval);
+ buf
+ });
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ multibuffer.update(cx, |this, cx| {
+ this.set_group_interval(group_interval, cx);
+ });
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::zero()..buffer_1.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ [Point::zero()..buffer_2.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ });
- // Locate the first region that contains or is past the putative location of the buffer anchor
- let ix = regions.partition_point(|region| {
- let excerpt = region
- .excerpt
- .as_ref()
- .expect("should have no buffers in empty reference multibuffer");
- excerpt
- .path_key
- .cmp(&path_key)
- .then_with(|| {
- if excerpt.range.end.cmp(&anchor, &snapshot).is_lt() {
- Ordering::Less
- } else if excerpt.range.start.cmp(&anchor, &snapshot).is_gt() {
- Ordering::Greater
- } else {
- Ordering::Equal
- }
- })
- .then_with(|| {
- if let Some(deleted_hunk_anchor) = region.deleted_hunk_anchor {
- deleted_hunk_anchor.cmp(&anchor, &snapshot)
- } else {
- let point = anchor.to_point(&snapshot);
- assert_eq!(region.buffer_id, Some(snapshot.remote_id()));
- if region.buffer_range.end < point {
- Ordering::Less
- } else if region.buffer_range.start > point {
- Ordering::Greater
- } else {
- Ordering::Equal
- }
- }
- })
- .is_lt()
- });
+ let mut now = Instant::now();
- let Some(region) = regions.get(ix) else {
- return Some(MultiBufferOffset(text.len()));
- };
+ multibuffer.update(cx, |multibuffer, cx| {
+ let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();
+ multibuffer.edit(
+ [
+ (Point::new(0, 0)..Point::new(0, 0), "A"),
+ (Point::new(1, 0)..Point::new(1, 0), "A"),
+ ],
+ None,
+ cx,
+ );
+ multibuffer.edit(
+ [
+ (Point::new(0, 1)..Point::new(0, 1), "B"),
+ (Point::new(1, 1)..Point::new(1, 1), "B"),
+ ],
+ None,
+ cx,
+ );
+ multibuffer.end_transaction_at(now, cx);
+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
- let offset = if region.buffer_id == Some(snapshot.remote_id()) {
- let buffer_offset = anchor.to_offset(&snapshot);
- let buffer_range = region.buffer_range.to_offset(&snapshot);
- assert!(buffer_offset <= buffer_range.end);
- let overshoot = buffer_offset.saturating_sub(buffer_range.start);
- region.range.start + overshoot
- } else {
- region.range.start
- };
- Some(MultiBufferOffset(offset))
- }
+ // Verify edited ranges for transaction 1
+ assert_eq!(
+ multibuffer.edited_ranges_for_transaction(transaction_1, cx),
+ &[
+ MultiBufferOffset(0)..MultiBufferOffset(2),
+ MultiBufferOffset(7)..MultiBufferOffset(9),
+ ]
+ );
- fn anchor_to_buffer_anchor(
- &self,
- anchor: &Anchor,
- cx: &App,
- ) -> Option<(text::Anchor, BufferSnapshot, PathKey)> {
- let (excerpt, anchor) = match anchor {
- Anchor::Min => {
- let excerpt = self.excerpts.first()?;
- (excerpt, excerpt.range.start)
- }
- Anchor::Excerpt(excerpt_anchor) => (
- self.excerpts.iter().find(|excerpt| {
- excerpt.buffer.read(cx).remote_id() == excerpt_anchor.buffer_id()
- })?,
- excerpt_anchor.text_anchor,
- ),
- Anchor::Max => {
- let excerpt = self.excerpts.last()?;
- (excerpt, excerpt.range.end)
- }
- };
+ // Edit buffer 1 through the multibuffer
+ now += 2 * group_interval;
+ multibuffer.start_transaction_at(now, cx);
+ multibuffer.edit(
+ [(MultiBufferOffset(2)..MultiBufferOffset(2), "C")],
+ None,
+ cx,
+ );
+ multibuffer.end_transaction_at(now, cx);
+ assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
- Some((
- anchor,
- excerpt.buffer.read(cx).snapshot(),
- excerpt.path_key.clone(),
- ))
- }
-}
+ // Edit buffer 1 independently
+ buffer_1.update(cx, |buffer_1, cx| {
+ buffer_1.start_transaction_at(now);
+ buffer_1.edit([(3..3, "D")], None, cx);
+ buffer_1.end_transaction_at(now, cx);
-#[gpui::test(iterations = 100)]
-async fn test_random_set_ranges(cx: &mut TestAppContext, mut rng: StdRng) {
- let base_text = "a\n".repeat(100);
- let buf = cx.update(|cx| cx.new(|cx| Buffer::local(base_text, cx)));
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ now += 2 * group_interval;
+ buffer_1.start_transaction_at(now);
+ buffer_1.edit([(4..4, "E")], None, cx);
+ buffer_1.end_transaction_at(now, cx);
+ });
+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
- let operations = env::var("OPERATIONS")
- .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
- .unwrap_or(10);
+ // An undo in the multibuffer undoes the multibuffer transaction
+ // and also any individual buffer edits that have occurred since
+ // that transaction.
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
- fn row_ranges(ranges: &Vec<Range<Point>>) -> Vec<Range<u32>> {
- ranges
- .iter()
- .map(|range| range.start.row..range.end.row)
- .collect()
- }
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
- for _ in 0..operations {
- let snapshot = buf.update(cx, |buf, _| buf.snapshot());
- let num_ranges = rng.random_range(0..=10);
- let max_row = snapshot.max_point().row;
- let mut ranges = (0..num_ranges)
- .map(|_| {
- let start = rng.random_range(0..max_row);
- let end = rng.random_range(start + 1..max_row + 1);
- Point::row_range(start..end)
- })
- .collect::<Vec<_>>();
- ranges.sort_by_key(|range| range.start);
- log::info!("Setting ranges: {:?}", row_ranges(&ranges));
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- PathKey::for_buffer(&buf, cx),
- buf.clone(),
- ranges.clone(),
- 2,
- cx,
- )
- });
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
- let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let mut last_end = None;
- let mut seen_ranges = Vec::default();
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
- for info in snapshot.excerpts() {
- let buffer_snapshot = snapshot
- .buffer_for_id(info.context.start.buffer_id)
- .unwrap();
- let start = info.context.start.to_point(buffer_snapshot);
- let end = info.context.end.to_point(buffer_snapshot);
- seen_ranges.push(start..end);
+ // Undo buffer 2 independently.
+ buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));
+ assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");
- if let Some(last_end) = last_end.take() {
- assert!(
- start > last_end,
- "multibuffer has out-of-order ranges: {:?}; {:?} <= {:?}",
- row_ranges(&seen_ranges),
- start,
- last_end
- )
- }
+ // An undo in the multibuffer undoes the components of the
+ // the last multibuffer transaction that are not already undone.
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");
- ranges.retain(|range| range.start < start || range.end > end);
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
- last_end = Some(end)
- }
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
- assert!(
- ranges.is_empty(),
- "multibuffer {:?} did not include all ranges: {:?}",
- row_ranges(&seen_ranges),
- row_ranges(&ranges)
- );
- }
-}
+ buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));
+ assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
-#[gpui::test(iterations = 100)]
-async fn test_random_multibuffer(cx: &mut TestAppContext, mut rng: StdRng) {
- let operations = env::var("OPERATIONS")
- .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
- .unwrap_or(10);
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- let mut buffers: Vec<Entity<Buffer>> = Vec::new();
- let mut base_texts: HashMap<BufferId, String> = HashMap::default();
- let mut reference = ReferenceMultibuffer::default();
- let mut anchors = Vec::new();
- let mut old_versions = Vec::new();
- let mut needs_diff_calculation = false;
- let mut inverted_diff_main_buffers: HashMap<BufferId, Entity<BufferDiff>> = HashMap::default();
- for _ in 0..operations {
- match rng.random_range(0..100) {
- 0..=14 if !buffers.is_empty() => {
- let buffer = buffers.choose(&mut rng).unwrap();
- buffer.update(cx, |buf, cx| {
- let edit_count = rng.random_range(1..5);
- buf.randomly_edit(&mut rng, edit_count, cx);
- log::info!("buffer text:\n{}", buf.text());
- needs_diff_calculation = true;
- });
- cx.update(|cx| reference.diffs_updated(cx));
- }
- 15..=24 if !reference.excerpts.is_empty() => {
- multibuffer.update(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- let infos = snapshot.excerpts().collect::<Vec<_>>();
- let mut excerpts = HashSet::default();
- for _ in 0..rng.random_range(0..infos.len()) {
- excerpts.extend(infos.choose(&mut rng).cloned());
- }
+ // Redo stack gets cleared after an edit.
+ now += 2 * group_interval;
+ multibuffer.start_transaction_at(now, cx);
+ multibuffer.edit(
+ [(MultiBufferOffset(0)..MultiBufferOffset(0), "X")],
+ None,
+ cx,
+ );
+ multibuffer.end_transaction_at(now, cx);
+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
- let line_count = rng.random_range(0..5);
+ // Transactions can be grouped manually.
+ multibuffer.redo(cx);
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
+ multibuffer.group_until_transaction(transaction_1, cx);
+ multibuffer.undo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
+ multibuffer.redo(cx);
+ assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
+ });
+}
- let excerpt_ixs = excerpts
- .iter()
- .map(|info| {
- reference
- .excerpts
- .iter()
- .position(|e| e.range == info.context)
- .unwrap()
- })
- .collect::<Vec<_>>();
- log::info!("Expanding excerpts {excerpt_ixs:?} by {line_count} lines");
- multibuffer.expand_excerpts(
- excerpts
- .iter()
- .map(|info| snapshot.anchor_in_excerpt(info.context.end).unwrap()),
- line_count,
- ExpandExcerptDirection::UpAndDown,
- cx,
- );
+#[gpui::test]
+async fn test_enclosing_indent(cx: &mut TestAppContext) {
+ async fn enclosing_indent(
+ text: &str,
+ buffer_row: u32,
+ cx: &mut TestAppContext,
+ ) -> Option<(Range<u32>, LineIndent)> {
+ let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
+ let snapshot = cx.read(|cx| buffer.read(cx).snapshot(cx));
+ let (range, indent) = snapshot
+ .enclosing_indent(MultiBufferRow(buffer_row))
+ .await?;
+ Some((range.start.0..range.end.0, indent))
+ }
- reference.expand_excerpts(&excerpts, line_count, cx);
- });
- }
- 25..=34 if !reference.excerpts.is_empty() => {
- let multibuffer =
- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let offset = multibuffer.clip_offset(
- MultiBufferOffset(rng.random_range(0..=multibuffer.len().0)),
- Bias::Left,
- );
- let bias = if rng.random() {
- Bias::Left
- } else {
- Bias::Right
- };
- log::info!("Creating anchor at {} with bias {:?}", offset.0, bias);
- anchors.push(multibuffer.anchor_at(offset, bias));
- anchors.sort_by(|a, b| a.cmp(b, &multibuffer));
+ assert_eq!(
+ enclosing_indent(
+ indoc!(
+ "
+ fn b() {
+ if c {
+ let d = 2;
+ }
+ }
+ "
+ ),
+ 1,
+ cx,
+ )
+ .await,
+ Some((
+ 1..2,
+ LineIndent {
+ tabs: 0,
+ spaces: 4,
+ line_blank: false,
}
- 35..=45 if !reference.excerpts.is_empty() => {
- multibuffer.update(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- let excerpt_ix = rng.random_range(0..reference.excerpts.len());
- let excerpt = &reference.excerpts[excerpt_ix];
+ ))
+ );
- // Skip inverted excerpts - hunks can't be collapsed
- let buffer_id = excerpt.buffer.read(cx).remote_id();
- if reference.inverted_diffs.contains_key(&buffer_id) {
- return;
+ assert_eq!(
+ enclosing_indent(
+ indoc!(
+ "
+ fn b() {
+ if c {
+ let d = 2;
}
-
- let start = excerpt.range.start;
- let end = excerpt.range.end;
- let range = snapshot.anchor_in_excerpt(start).unwrap()
- ..snapshot.anchor_in_excerpt(end).unwrap();
-
- log::info!(
- "expanding diff hunks in range {:?} (excerpt index {excerpt_ix:?}, buffer id {:?})",
- range.to_point(&snapshot),
- buffer_id,
- );
- reference.expand_diff_hunks(excerpt.path_key.clone(), start..end, cx);
- multibuffer.expand_diff_hunks(vec![range], cx);
- });
+ }
+ "
+ ),
+ 2,
+ cx,
+ )
+ .await,
+ Some((
+ 1..2,
+ LineIndent {
+ tabs: 0,
+ spaces: 4,
+ line_blank: false,
}
- 46..=75 if needs_diff_calculation => {
- multibuffer.update(cx, |multibuffer, cx| {
- for buffer in multibuffer.all_buffers() {
- let snapshot = buffer.read(cx).snapshot();
- let buffer_id = snapshot.remote_id();
+ ))
+ );
- if let Some(diff) = multibuffer.diff_for(buffer_id) {
- diff.update(cx, |diff, cx| {
- log::info!("recalculating diff for buffer {:?}", buffer_id,);
- diff.recalculate_diff_sync(&snapshot.text, cx);
- });
- }
+ assert_eq!(
+ enclosing_indent(
+ indoc!(
+ "
+ fn b() {
+ if c {
+ let d = 2;
- if let Some(inverted_diff) = inverted_diff_main_buffers.get(&buffer_id) {
- inverted_diff.update(cx, |diff, cx| {
- log::info!(
- "recalculating inverted diff for main buffer {:?}",
- buffer_id,
- );
- diff.recalculate_diff_sync(&snapshot.text, cx);
- });
- }
+ let e = 5;
}
- reference.diffs_updated(cx);
- needs_diff_calculation = false;
- });
- }
- _ => {
- // Decide if we're creating a new buffer or reusing an existing one
- let create_new_buffer = buffers.is_empty() || rng.random_bool(0.4);
-
- let (excerpt_buffer, diff, inverted_main_buffer) = if create_new_buffer {
- let create_inverted = rng.random_bool(0.3);
-
- if create_inverted {
- let mut main_buffer_text = util::RandomCharIter::new(&mut rng)
- .take(256)
- .collect::<String>();
- let main_buffer = cx.new(|cx| Buffer::local(main_buffer_text.clone(), cx));
- text::LineEnding::normalize(&mut main_buffer_text);
- let main_buffer_id =
- main_buffer.read_with(cx, |buffer, _| buffer.remote_id());
- base_texts.insert(main_buffer_id, main_buffer_text.clone());
- buffers.push(main_buffer.clone());
-
- let diff = cx.new(|cx| {
- BufferDiff::new_with_base_text(
- &main_buffer_text,
- &main_buffer.read(cx).text_snapshot(),
- cx,
- )
- });
+ }
+ "
+ ),
+ 3,
+ cx,
+ )
+ .await,
+ Some((
+ 1..4,
+ LineIndent {
+ tabs: 0,
+ spaces: 4,
+ line_blank: false,
+ }
+ ))
+ );
+}
- let base_text_buffer =
- diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
+#[gpui::test]
+async fn test_summaries_for_anchors(cx: &mut TestAppContext) {
+ let base_text_1 = indoc!(
+ "
+ bar
+ "
+ );
+ let text_1 = indoc!(
+ "
+ BAR
+ "
+ );
+ let base_text_2 = indoc!(
+ "
+ foo
+ "
+ );
+ let text_2 = indoc!(
+ "
+ FOO
+ "
+ );
- // Track for recalculation when main buffer is edited
- inverted_diff_main_buffers.insert(main_buffer_id, diff.clone());
+ let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
+ let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));
+ let diff_1 = cx.new(|cx| {
+ BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
+ });
+ let diff_2 = cx.new(|cx| {
+ BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)
+ });
+ cx.run_until_parked();
- (base_text_buffer, diff, Some(main_buffer))
- } else {
- let mut base_text = util::RandomCharIter::new(&mut rng)
- .take(256)
- .collect::<String>();
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::zero()..buffer_1.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ [Point::zero()..buffer_2.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ multibuffer.add_diff(diff_1.clone(), cx);
+ multibuffer.add_diff(diff_2.clone(), cx);
+ multibuffer
+ });
- let buffer_handle = cx.new(|cx| Buffer::local(base_text.clone(), cx));
- text::LineEnding::normalize(&mut base_text);
- let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
- base_texts.insert(buffer_id, base_text.clone());
- buffers.push(buffer_handle.clone());
+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
+ (multibuffer.snapshot(cx), multibuffer.subscribe())
+ });
- let diff = cx.new(|cx| {
- BufferDiff::new_with_base_text(
- &base_text,
- &buffer_handle.read(cx).text_snapshot(),
- cx,
- )
- });
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc!(
+ "
+ - bar
+ + BAR
- (buffer_handle, diff, None)
- }
- } else {
- // Reuse an existing buffer
- let buffer_handle = buffers.choose(&mut rng).unwrap().clone();
- let buffer_id = buffer_handle.read_with(cx, |buffer, _| buffer.remote_id());
+ - foo
+ + FOO
+ "
+ ),
+ );
- if let Some(diff) = inverted_diff_main_buffers.get(&buffer_id) {
- let base_text_buffer =
- diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
- (base_text_buffer, diff.clone(), Some(buffer_handle))
- } else {
- // Get existing diff or create new one for regular buffer
- let diff = multibuffer
- .read_with(cx, |mb, _| mb.diff_for(buffer_id))
- .unwrap_or_else(|| {
- let base_text = base_texts.get(&buffer_id).unwrap();
- cx.new(|cx| {
- BufferDiff::new_with_base_text(
- base_text,
- &buffer_handle.read(cx).text_snapshot(),
- cx,
- )
- })
- });
- (buffer_handle, diff, None)
- }
- };
+ let anchor_1 = multibuffer.read_with(cx, |multibuffer, cx| {
+ multibuffer
+ .snapshot(cx)
+ .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_1.read(cx).remote_id()))
+ .unwrap()
+ });
+ let point_1 = snapshot.summaries_for_anchors::<Point, _>([&anchor_1])[0];
+ assert_eq!(point_1, Point::new(0, 0));
- let excerpt_buffer_snapshot =
- excerpt_buffer.read_with(cx, |excerpt_buffer, _| excerpt_buffer.snapshot());
- let mut ranges = reference
- .excerpts
- .iter()
- .filter(|excerpt| excerpt.buffer == excerpt_buffer)
- .map(|excerpt| excerpt.range.to_point(&excerpt_buffer_snapshot))
- .collect::<Vec<_>>();
- mutate_excerpt_ranges(&mut rng, &mut ranges, &excerpt_buffer_snapshot, 1);
- let ranges = ranges
- .iter()
- .cloned()
- .map(ExcerptRange::new)
- .collect::<Vec<_>>();
- let path = cx.update(|cx| PathKey::for_buffer(&excerpt_buffer, cx));
- let path_key_index = multibuffer.update(cx, |multibuffer, _| {
- multibuffer.get_or_create_path_key_index(&path)
- });
+ let anchor_2 = multibuffer.read_with(cx, |multibuffer, cx| {
+ multibuffer
+ .snapshot(cx)
+ .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_2.read(cx).remote_id()))
+ .unwrap()
+ });
+ let point_2 = snapshot.summaries_for_anchors::<Point, _>([&anchor_2])[0];
+ assert_eq!(point_2, Point::new(3, 0));
+}
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpt_ranges_for_path(
- path.clone(),
- excerpt_buffer.clone(),
- &excerpt_buffer_snapshot,
- ranges.clone(),
- cx,
- )
- });
+#[gpui::test]
+async fn test_trailing_deletion_without_newline(cx: &mut TestAppContext) {
+ let base_text_1 = "one\ntwo".to_owned();
+ let text_1 = "one\n".to_owned();
- cx.update(|cx| {
- reference.set_excerpts(
- path,
- path_key_index,
- excerpt_buffer.clone(),
- &excerpt_buffer_snapshot,
- ranges,
- cx,
- )
- });
+ let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
+ let diff_1 = cx.new(|cx| {
+ BufferDiff::new_with_base_text(&base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
+ });
+ cx.run_until_parked();
- let excerpt_buffer_id =
- excerpt_buffer.read_with(cx, |buffer, _| buffer.remote_id());
- multibuffer.update(cx, |multibuffer, cx| {
- if multibuffer.diff_for(excerpt_buffer_id).is_none() {
- if let Some(main_buffer) = inverted_main_buffer {
- reference.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);
- multibuffer.add_inverted_diff(diff, main_buffer, cx);
- } else {
- reference.add_diff(diff.clone(), cx);
- multibuffer.add_diff(diff, cx);
- }
- }
- });
- }
- }
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::zero()..buffer_1.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ multibuffer.add_diff(diff_1.clone(), cx);
+ multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
+ multibuffer
+ });
- if rng.random_bool(0.3) {
- multibuffer.update(cx, |multibuffer, cx| {
- old_versions.push((multibuffer.snapshot(cx), multibuffer.subscribe()));
- })
- }
+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
+ (multibuffer.snapshot(cx), multibuffer.subscribe())
+ });
- multibuffer.read_with(cx, |multibuffer, cx| {
- check_multibuffer(multibuffer, &reference, &anchors, cx, &mut rng);
- });
- }
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- for (old_snapshot, subscription) in old_versions {
- check_multibuffer_edits(&snapshot, &old_snapshot, subscription);
- }
-}
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc!(
+ "
+ one
+ - two
+ "
+ ),
+ );
-fn mutate_excerpt_ranges(
- rng: &mut StdRng,
- existing_ranges: &mut Vec<Range<Point>>,
- buffer: &BufferSnapshot,
- operations: u32,
-) {
- let mut ranges_to_add = Vec::new();
+ assert_eq!(snapshot.max_point(), Point::new(2, 0));
+ assert_eq!(snapshot.len().0, 8);
- for _ in 0..operations {
- match rng.random_range(0..5) {
- 0..=1 if !existing_ranges.is_empty() => {
- let index = rng.random_range(0..existing_ranges.len());
- log::info!("Removing excerpt at index {index}");
- existing_ranges.remove(index);
- }
- _ => {
- let end_row = rng.random_range(0..=buffer.max_point().row);
- let start_row = rng.random_range(0..=end_row);
- let end_col = buffer.line_len(end_row);
- log::info!(
- "Inserting excerpt for buffer {:?}, row range {:?}",
- buffer.remote_id(),
- start_row..end_row
- );
- ranges_to_add.push(Point::new(start_row, 0)..Point::new(end_row, end_col));
- }
- }
- }
+ assert_eq!(
+ snapshot
+ .dimensions_from_points::<Point>([Point::new(2, 0)])
+ .collect::<Vec<_>>(),
+ vec![Point::new(2, 0)]
+ );
- existing_ranges.extend(ranges_to_add);
- existing_ranges.sort_by_key(|r| r.start);
-}
+ let (_, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
+ assert_eq!(translated_offset.0, "one\n".len());
+ let (_, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
+ assert_eq!(translated_point, Point::new(1, 0));
-fn check_multibuffer(
- multibuffer: &MultiBuffer,
- reference: &ReferenceMultibuffer,
- anchors: &[Anchor],
- cx: &App,
- rng: &mut StdRng,
-) {
- let snapshot = multibuffer.snapshot(cx);
- let actual_text = snapshot.text();
- let actual_boundary_rows = snapshot
- .excerpt_boundaries_in_range(MultiBufferOffset(0)..)
- .map(|b| b.row)
- .collect::<HashSet<_>>();
- let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
+ // The same, for an excerpt that's not at the end of the multibuffer.
- let anchors_to_check = anchors
- .iter()
- .filter_map(|anchor| {
- snapshot
- .anchor_to_buffer_anchor(*anchor)
- .map(|(anchor, _)| anchor)
- })
- // Intentionally mix in some anchors that are (in general) not contained in any excerpt
- .chain(
- reference
- .excerpts
- .iter()
- .map(|excerpt| excerpt.buffer.read(cx).remote_id())
- .dedup()
- .flat_map(|buffer_id| {
- [
- text::Anchor::min_for_buffer(buffer_id),
- text::Anchor::max_for_buffer(buffer_id),
- ]
- }),
- )
- .map(|anchor| snapshot.anchor_in_buffer(anchor).unwrap())
- .collect::<Vec<_>>();
+ let text_2 = "foo\n".to_owned();
+ let buffer_2 = cx.new(|cx| Buffer::local(&text_2, cx));
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpt_ranges_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ &buffer_2.read(cx).snapshot(),
+ vec![ExcerptRange::new(Point::new(0, 0)..Point::new(1, 0))],
+ cx,
+ );
+ });
- let (expected_text, expected_row_infos, expected_boundary_rows, _) =
- reference.expected_content(cx);
- let expected_anchor_offsets = anchors_to_check
- .iter()
- .map(|anchor| reference.anchor_to_offset(anchor, cx).unwrap())
- .collect::<Vec<_>>();
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc!(
+ "
+ one
+ - two
- let has_diff = actual_row_infos
- .iter()
- .any(|info| info.diff_status.is_some())
- || expected_row_infos
- .iter()
- .any(|info| info.diff_status.is_some());
- let actual_diff = format_diff(
- &actual_text,
- &actual_row_infos,
- &actual_boundary_rows,
- Some(has_diff),
- );
- let expected_diff = format_diff(
- &expected_text,
- &expected_row_infos,
- &expected_boundary_rows,
- Some(has_diff),
+ foo
+ "
+ ),
);
- log::info!("Multibuffer content:\n{}", actual_diff);
-
assert_eq!(
- actual_row_infos.len(),
- actual_text.split('\n').count(),
- "line count: {}",
- actual_text.split('\n').count()
+ snapshot
+ .dimensions_from_points::<Point>([Point::new(2, 0)])
+ .collect::<Vec<_>>(),
+ vec![Point::new(2, 0)]
);
- pretty_assertions::assert_eq!(actual_diff, expected_diff);
- pretty_assertions::assert_eq!(actual_text, expected_text);
- pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);
- for _ in 0..5 {
- let start_row = rng.random_range(0..=expected_row_infos.len());
- assert_eq!(
- snapshot
- .row_infos(MultiBufferRow(start_row as u32))
- .collect::<Vec<_>>(),
- &expected_row_infos[start_row..],
- "buffer_rows({})",
- start_row
- );
- }
+ let buffer_1_id = buffer_1.read_with(cx, |buffer_1, _| buffer_1.remote_id());
+ let (buffer, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
+ assert_eq!(buffer.remote_id(), buffer_1_id);
+ assert_eq!(translated_offset.0, "one\n".len());
+ let (buffer, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
+ assert_eq!(buffer.remote_id(), buffer_1_id);
+ assert_eq!(translated_point, Point::new(1, 0));
+}
- assert_eq!(
- snapshot.widest_line_number(),
- expected_row_infos
- .into_iter()
- .filter_map(|info| {
- // For inverted diffs, deleted rows are visible and should be counted.
- // Only filter out deleted rows that are NOT from inverted diffs.
- let is_inverted_diff = info
- .buffer_id
- .is_some_and(|id| reference.inverted_diffs.contains_key(&id));
- if info.diff_status.is_some_and(|status| status.is_deleted()) && !is_inverted_diff {
- None
- } else {
- info.buffer_row
- }
- })
- .max()
- .unwrap()
- + 1
+#[gpui::test]
+async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
+ let text = indoc!(
+ "
+ ZERO
+ one
+ TWO
+ three
+ six
+ "
+ );
+ let base_text = indoc!(
+ "
+ one
+ two
+ three
+ four
+ five
+ six
+ "
);
- for i in 0..snapshot.len().0 {
- let (_, excerpt_range) = snapshot
- .excerpt_containing(MultiBufferOffset(i)..MultiBufferOffset(i))
- .unwrap();
- reference
- .excerpts
- .iter()
- .find(|reference_excerpt| reference_excerpt.range == excerpt_range.context)
- .expect("corresponding excerpt should exist in reference multibuffer");
- }
- assert_consistent_line_numbers(&snapshot);
- assert_position_translation(&snapshot);
+ let buffer = cx.new(|cx| Buffer::local(text, cx));
+ let diff = cx
+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
+ cx.run_until_parked();
- for (row, line) in expected_text.split('\n').enumerate() {
- assert_eq!(
- snapshot.line_len(MultiBufferRow(row as u32)),
- line.len() as u32,
- "line_len({}).",
- row
- );
- }
+ let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
- let text_rope = Rope::from(expected_text.as_str());
- for _ in 0..10 {
- let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
- let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
+ multibuffer
+ });
- let text_for_range = snapshot
- .text_for_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
- .collect::<String>();
- assert_eq!(
- text_for_range,
- &expected_text[start_ix..end_ix],
- "incorrect text for range {:?}",
- start_ix..end_ix
- );
+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
+ (multibuffer.snapshot(cx), multibuffer.subscribe())
+ });
- let expected_summary =
- MBTextSummary::from(TextSummary::from(&expected_text[start_ix..end_ix]));
- assert_eq!(
- snapshot.text_summary_for_range::<MBTextSummary, _>(
- MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix)
- ),
- expected_summary,
- "incorrect summary for range {:?}",
- start_ix..end_ix
- );
- }
+ assert_eq!(snapshot.text(), base_text);
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc!(
+ "
+ one
+ - two
+ three
+ - four
+ - five
+ six
+ "
+ ),
+ );
- // Anchor resolution
- let summaries = snapshot.summaries_for_anchors::<MultiBufferOffset, _>(anchors);
- assert_eq!(anchors.len(), summaries.len());
- for (anchor, resolved_offset) in anchors.iter().zip(summaries) {
- assert!(resolved_offset <= snapshot.len());
- assert_eq!(
- snapshot.summary_for_anchor::<MultiBufferOffset>(anchor),
- resolved_offset,
- "anchor: {:?}",
- anchor
+ buffer.update(cx, |buffer, cx| {
+ buffer.edit_via_marked_text(
+ indoc!(
+ "
+ ZERO
+ one
+ «<inserted>»W«O
+ T»hree
+ six
+ "
+ ),
+ None,
+ cx,
);
- }
+ });
+ cx.run_until_parked();
+ let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
+ let update = diff
+ .update(cx, |diff, cx| {
+ diff.update_diff(
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(base_text)),
+ cx,
+ )
+ })
+ .await;
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
+ cx.run_until_parked();
- let actual_anchor_offsets = anchors_to_check
- .into_iter()
- .map(|anchor| anchor.to_offset(&snapshot))
- .collect::<Vec<_>>();
- assert_eq!(
- actual_anchor_offsets, expected_anchor_offsets,
- "buffer anchor resolves to wrong offset"
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc! {
+ "
+ one
+ - two
+ - three
+ - four
+ - five
+ six
+ "
+ },
);
- for _ in 0..10 {
- let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
- assert_eq!(
- snapshot
- .reversed_chars_at(MultiBufferOffset(end_ix))
- .collect::<String>(),
- expected_text[..end_ix].chars().rev().collect::<String>(),
- );
- }
+ buffer.update(cx, |buffer, cx| {
+ buffer.set_text("ZERO\nONE\nTWO\n", cx);
+ });
+ cx.run_until_parked();
+ let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
+ let update = diff
+ .update(cx, |diff, cx| {
+ diff.update_diff(
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(base_text)),
+ cx,
+ )
+ })
+ .await;
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
+ cx.run_until_parked();
- for _ in 0..10 {
- let end_ix = rng.random_range(0..=text_rope.len());
- let end_ix = text_rope.floor_char_boundary(end_ix);
- let start_ix = rng.random_range(0..=end_ix);
- let start_ix = text_rope.floor_char_boundary(start_ix);
- assert_eq!(
- snapshot
- .bytes_in_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
- .flatten()
- .copied()
- .collect::<Vec<_>>(),
- expected_text.as_bytes()[start_ix..end_ix].to_vec(),
- "bytes_in_range({:?})",
- start_ix..end_ix,
- );
- }
-}
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc! {
+ "
+ - one
+ - two
+ - three
+ - four
+ - five
+ - six
+ "
+ },
+ );
-fn check_multibuffer_edits(
- snapshot: &MultiBufferSnapshot,
- old_snapshot: &MultiBufferSnapshot,
- subscription: Subscription<MultiBufferOffset>,
-) {
- let edits = subscription.consume().into_inner();
+ diff.update(cx, |diff, cx| {
+ diff.set_base_text(
+ Some("new base\n".into()),
+ buffer.read(cx).text_snapshot(),
+ cx,
+ )
+ })
+ .await;
+ cx.run_until_parked();
- log::info!(
- "applying subscription edits to old text: {:?}: {:#?}",
- old_snapshot.text(),
- edits,
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc! {"
+ - new base
+ "},
);
-
- let mut text = old_snapshot.text();
- for edit in edits {
- let new_text: String = snapshot
- .text_for_range(edit.new.start..edit.new.end)
- .collect();
- text.replace_range(
- (edit.new.start.0..edit.new.start.0 + (edit.old.end.0 - edit.old.start.0)).clone(),
- &new_text,
- );
- pretty_assertions::assert_eq!(
- &text[0..edit.new.end.0],
- snapshot
- .text_for_range(MultiBufferOffset(0)..edit.new.end)
- .collect::<String>()
- );
- }
- pretty_assertions::assert_eq!(text, snapshot.text());
}
#[gpui::test]
-fn test_history(cx: &mut App) {
- let test_settings = SettingsStore::test(cx);
- cx.set_global(test_settings);
+async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {
+ let base_text = "aaa\nbbb\nccc\n";
+ let text = "ddd\n";
+ let buffer = cx.new(|cx| Buffer::local(text, cx));
+ let diff = cx
+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
+ cx.run_until_parked();
- let group_interval: Duration = Duration::from_millis(1);
- let buffer_1 = cx.new(|cx| {
- let mut buf = Buffer::local("1234", cx);
- buf.set_group_interval(group_interval);
- buf
- });
- let buffer_2 = cx.new(|cx| {
- let mut buf = Buffer::local("5678", cx);
- buf.set_group_interval(group_interval);
- buf
- });
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- multibuffer.update(cx, |this, cx| {
- this.set_group_interval(group_interval, cx);
- });
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::zero()..buffer_1.read(cx).max_point()],
- 0,
- cx,
- );
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_2.clone(),
- [Point::zero()..buffer_2.read(cx).max_point()],
- 0,
- cx,
- );
+ let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
+
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
+ multibuffer
});
- let mut now = Instant::now();
+ let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
+ (multibuffer.snapshot(cx), multibuffer.subscribe())
+ });
- multibuffer.update(cx, |multibuffer, cx| {
- let transaction_1 = multibuffer.start_transaction_at(now, cx).unwrap();
- multibuffer.edit(
- [
- (Point::new(0, 0)..Point::new(0, 0), "A"),
- (Point::new(1, 0)..Point::new(1, 0), "A"),
- ],
- None,
- cx,
- );
- multibuffer.edit(
- [
- (Point::new(0, 1)..Point::new(0, 1), "B"),
- (Point::new(1, 1)..Point::new(1, 1), "B"),
- ],
- None,
- cx,
- );
- multibuffer.end_transaction_at(now, cx);
- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
+ assert_eq!(snapshot.text(), base_text);
+ assert_new_snapshot(
+ &multibuffer,
+ &mut snapshot,
+ &mut subscription,
+ cx,
+ indoc!(
+ "
+ - aaa
+ - bbb
+ - ccc
+ "
+ ),
+ );
- // Verify edited ranges for transaction 1
- assert_eq!(
- multibuffer.edited_ranges_for_transaction(transaction_1, cx),
- &[
- MultiBufferOffset(0)..MultiBufferOffset(2),
- MultiBufferOffset(7)..MultiBufferOffset(9),
- ]
- );
+ diff.update(cx, |diff, cx| {
+ diff.set_base_text(Some("ddd\n".into()), buffer.read(cx).text_snapshot(), cx)
+ })
+ .await;
- // Edit buffer 1 through the multibuffer
- now += 2 * group_interval;
- multibuffer.start_transaction_at(now, cx);
- multibuffer.edit(
- [(MultiBufferOffset(2)..MultiBufferOffset(2), "C")],
- None,
- cx,
- );
- multibuffer.end_transaction_at(now, cx);
- assert_eq!(multibuffer.read(cx).text(), "ABC1234\nAB5678");
+ let _hunks: Vec<_> = multibuffer
+ .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
+ .diff_hunks()
+ .collect();
+}
- // Edit buffer 1 independently
- buffer_1.update(cx, |buffer_1, cx| {
- buffer_1.start_transaction_at(now);
- buffer_1.edit([(3..3, "D")], None, cx);
- buffer_1.end_transaction_at(now, cx);
+#[gpui::test]
+async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext) {
+ let base_text = "one\ntwo\nthree\nfour\nfive\n";
+ let index_text = "one\nTWO\nthree\nfour\nfive\n";
+ let buffer_text = "one\nTWO\nthree\nFOUR\nfive\n";
- now += 2 * group_interval;
- buffer_1.start_transaction_at(now);
- buffer_1.edit([(4..4, "E")], None, cx);
- buffer_1.end_transaction_at(now, cx);
- });
- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
+ let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));
- // An undo in the multibuffer undoes the multibuffer transaction
- // and also any individual buffer edits that have occurred since
- // that transaction.
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
+ let unstaged_diff = cx
+ .new(|cx| BufferDiff::new_with_base_text(index_text, &buffer.read(cx).text_snapshot(), cx));
+ cx.run_until_parked();
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
+ let uncommitted_diff = cx.new(|cx| {
+ let mut diff =
+ BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx);
+ diff.set_secondary_diff(unstaged_diff.clone());
+ diff
+ });
+ cx.run_until_parked();
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
+ buffer.update(cx, |buffer, cx| {
+ buffer.edit([(0..0, "ZERO\n")], None, cx);
+ });
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\nAB5678");
+ let base_text_snapshot = unstaged_diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
+ let update = unstaged_diff
+ .update(cx, |diff, cx| {
+ diff.update_diff(
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(index_text)),
+ cx,
+ )
+ })
+ .await;
+ unstaged_diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
- // Undo buffer 2 independently.
- buffer_2.update(cx, |buffer_2, cx| buffer_2.undo(cx));
- assert_eq!(multibuffer.read(cx).text(), "ABCDE1234\n5678");
+ let base_text_buffer =
+ uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
- // An undo in the multibuffer undoes the components of the
- // the last multibuffer transaction that are not already undone.
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "AB1234\n5678");
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer.add_inverted_diff(uncommitted_diff.clone(), buffer.clone(), cx);
+ multibuffer
+ });
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
+ let _hunks: Vec<_> = multibuffer
+ .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
+ .diff_hunks()
+ .collect();
+}
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "AB1234\nAB5678");
+#[gpui::test]
+fn test_new_empty_buffer_uses_untitled_title(cx: &mut App) {
+ let buffer = cx.new(|cx| Buffer::local("", cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- buffer_1.update(cx, |buffer_1, cx| buffer_1.redo(cx));
- assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
+ assert_eq!(multibuffer.read(cx).title(cx), "untitled");
+}
- // Redo stack gets cleared after an edit.
- now += 2 * group_interval;
- multibuffer.start_transaction_at(now, cx);
- multibuffer.edit(
- [(MultiBufferOffset(0)..MultiBufferOffset(0), "X")],
- None,
- cx,
- );
- multibuffer.end_transaction_at(now, cx);
- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "ABCD1234\nAB5678");
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
+#[gpui::test]
+fn test_new_empty_buffer_uses_untitled_title_when_only_contains_whitespace(cx: &mut App) {
+ let buffer = cx.new(|cx| Buffer::local("\n ", cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- // Transactions can be grouped manually.
- multibuffer.redo(cx);
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
- multibuffer.group_until_transaction(transaction_1, cx);
- multibuffer.undo(cx);
- assert_eq!(multibuffer.read(cx).text(), "1234\n5678");
- multibuffer.redo(cx);
- assert_eq!(multibuffer.read(cx).text(), "XABCD1234\nAB5678");
- });
+ assert_eq!(multibuffer.read(cx).title(cx), "untitled");
}
#[gpui::test]
-async fn test_enclosing_indent(cx: &mut TestAppContext) {
- async fn enclosing_indent(
- text: &str,
- buffer_row: u32,
- cx: &mut TestAppContext,
- ) -> Option<(Range<u32>, LineIndent)> {
- let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
- let snapshot = cx.read(|cx| buffer.read(cx).snapshot(cx));
- let (range, indent) = snapshot
- .enclosing_indent(MultiBufferRow(buffer_row))
- .await?;
- Some((range.start.0..range.end.0, indent))
- }
+fn test_new_empty_buffer_takes_first_line_for_title(cx: &mut App) {
+ let buffer = cx.new(|cx| Buffer::local("Hello World\nSecond line", cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- assert_eq!(
- enclosing_indent(
- indoc!(
- "
- fn b() {
- if c {
- let d = 2;
- }
- }
- "
- ),
- 1,
- cx,
- )
- .await,
- Some((
- 1..2,
- LineIndent {
- tabs: 0,
- spaces: 4,
- line_blank: false,
- }
- ))
- );
+ assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
+}
- assert_eq!(
- enclosing_indent(
- indoc!(
- "
- fn b() {
- if c {
- let d = 2;
- }
- }
- "
- ),
- 2,
- cx,
- )
- .await,
- Some((
- 1..2,
- LineIndent {
- tabs: 0,
- spaces: 4,
- line_blank: false,
- }
- ))
- );
+#[gpui::test]
+fn test_new_empty_buffer_takes_trimmed_first_line_for_title(cx: &mut App) {
+ let buffer = cx.new(|cx| Buffer::local("\nHello, World ", cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- assert_eq!(
- enclosing_indent(
- indoc!(
- "
- fn b() {
- if c {
- let d = 2;
-
- let e = 5;
- }
- }
- "
- ),
- 3,
- cx,
- )
- .await,
- Some((
- 1..4,
- LineIndent {
- tabs: 0,
- spaces: 4,
- line_blank: false,
- }
- ))
- );
-}
+ assert_eq!(multibuffer.read(cx).title(cx), "Hello, World");
+}
#[gpui::test]
-async fn test_summaries_for_anchors(cx: &mut TestAppContext) {
- let base_text_1 = indoc!(
- "
- bar
- "
- );
- let text_1 = indoc!(
- "
- BAR
- "
- );
- let base_text_2 = indoc!(
- "
- foo
- "
- );
- let text_2 = indoc!(
- "
- FOO
- "
- );
-
- let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
- let buffer_2 = cx.new(|cx| Buffer::local(text_2, cx));
- let diff_1 = cx.new(|cx| {
- BufferDiff::new_with_base_text(base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
- });
- let diff_2 = cx.new(|cx| {
- BufferDiff::new_with_base_text(base_text_2, &buffer_2.read(cx).text_snapshot(), cx)
- });
- cx.run_until_parked();
-
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
- multibuffer.set_all_diff_hunks_expanded(cx);
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::zero()..buffer_1.read(cx).max_point()],
- 0,
- cx,
- );
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_2.clone(),
- [Point::zero()..buffer_2.read(cx).max_point()],
- 0,
- cx,
- );
- multibuffer.add_diff(diff_1.clone(), cx);
- multibuffer.add_diff(diff_2.clone(), cx);
- multibuffer
- });
-
- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
- (multibuffer.snapshot(cx), multibuffer.subscribe())
- });
-
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc!(
- "
- - bar
- + BAR
-
- - foo
- + FOO
- "
- ),
- );
-
- let anchor_1 = multibuffer.read_with(cx, |multibuffer, cx| {
- multibuffer
- .snapshot(cx)
- .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_1.read(cx).remote_id()))
- .unwrap()
- });
- let point_1 = snapshot.summaries_for_anchors::<Point, _>([&anchor_1])[0];
- assert_eq!(point_1, Point::new(0, 0));
+fn test_new_empty_buffer_uses_truncated_first_line_for_title(cx: &mut App) {
+ let title = "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee";
+ let title_after = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";
+ let buffer = cx.new(|cx| Buffer::local(title, cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- let anchor_2 = multibuffer.read_with(cx, |multibuffer, cx| {
- multibuffer
- .snapshot(cx)
- .anchor_in_excerpt(text::Anchor::min_for_buffer(buffer_2.read(cx).remote_id()))
- .unwrap()
- });
- let point_2 = snapshot.summaries_for_anchors::<Point, _>([&anchor_2])[0];
- assert_eq!(point_2, Point::new(3, 0));
+ assert_eq!(multibuffer.read(cx).title(cx), title_after);
}
#[gpui::test]
-async fn test_trailing_deletion_without_newline(cx: &mut TestAppContext) {
- let base_text_1 = "one\ntwo".to_owned();
- let text_1 = "one\n".to_owned();
+fn test_new_empty_buffer_uses_truncated_first_line_for_title_after_merging_adjacent_spaces(
+ cx: &mut App,
+) {
+ let title = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddddeeeeeeeeee";
+ let title_after = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddd";
+ let buffer = cx.new(|cx| Buffer::local(title, cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- let buffer_1 = cx.new(|cx| Buffer::local(text_1, cx));
- let diff_1 = cx.new(|cx| {
- BufferDiff::new_with_base_text(&base_text_1, &buffer_1.read(cx).text_snapshot(), cx)
- });
- cx.run_until_parked();
+ assert_eq!(multibuffer.read(cx).title(cx), title_after);
+}
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::zero()..buffer_1.read(cx).max_point()],
- 0,
- cx,
- );
- multibuffer.add_diff(diff_1.clone(), cx);
- multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
- multibuffer
- });
+#[gpui::test]
+fn test_new_empty_buffers_title_can_be_set(cx: &mut App) {
+ let buffer = cx.new(|cx| Buffer::local("Hello World", cx));
+ let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
- (multibuffer.snapshot(cx), multibuffer.subscribe())
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_title("Hey".into(), cx)
});
+ assert_eq!(multibuffer.read(cx).title(cx), "Hey");
+}
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc!(
- "
- one
- - two
- "
- ),
- );
+#[gpui::test(iterations = 100)]
+fn test_random_chunk_bitmaps(cx: &mut App, mut rng: StdRng) {
+ let multibuffer = if rng.random() {
+ let len = rng.random_range(0..10000);
+ let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
+ let buffer = cx.new(|cx| Buffer::local(text, cx));
+ cx.new(|cx| MultiBuffer::singleton(buffer, cx))
+ } else {
+ MultiBuffer::build_random(&mut rng, cx)
+ };
- assert_eq!(snapshot.max_point(), Point::new(2, 0));
- assert_eq!(snapshot.len().0, 8);
+ let snapshot = multibuffer.read(cx).snapshot(cx);
- assert_eq!(
- snapshot
- .dimensions_from_points::<Point>([Point::new(2, 0)])
- .collect::<Vec<_>>(),
- vec![Point::new(2, 0)]
+ let chunks = snapshot.chunks(
+ MultiBufferOffset(0)..snapshot.len(),
+ LanguageAwareStyling {
+ tree_sitter: false,
+ diagnostics: false,
+ },
);
- let (_, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
- assert_eq!(translated_offset.0, "one\n".len());
- let (_, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
- assert_eq!(translated_point, Point::new(1, 0));
+ for chunk in chunks {
+ let chunk_text = chunk.text;
+ let chars_bitmap = chunk.chars;
+ let tabs_bitmap = chunk.tabs;
- // The same, for an excerpt that's not at the end of the multibuffer.
+ if chunk_text.is_empty() {
+ assert_eq!(
+ chars_bitmap, 0,
+ "Empty chunk should have empty chars bitmap"
+ );
+ assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
+ continue;
+ }
- let text_2 = "foo\n".to_owned();
- let buffer_2 = cx.new(|cx| Buffer::local(&text_2, cx));
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpt_ranges_for_path(
- PathKey::sorted(1),
- buffer_2.clone(),
- &buffer_2.read(cx).snapshot(),
- vec![ExcerptRange::new(Point::new(0, 0)..Point::new(1, 0))],
- cx,
+ assert!(
+ chunk_text.len() <= 128,
+ "Chunk text length {} exceeds 128 bytes",
+ chunk_text.len()
);
- });
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc!(
- "
- one
- - two
+ // Verify chars bitmap
+ let char_indices = chunk_text
+ .char_indices()
+ .map(|(i, _)| i)
+ .collect::<Vec<_>>();
- foo
- "
- ),
- );
+ for byte_idx in 0..chunk_text.len() {
+ let should_have_bit = char_indices.contains(&byte_idx);
+ let has_bit = chars_bitmap & (1 << byte_idx) != 0;
- assert_eq!(
- snapshot
- .dimensions_from_points::<Point>([Point::new(2, 0)])
- .collect::<Vec<_>>(),
- vec![Point::new(2, 0)]
- );
+ if has_bit != should_have_bit {
+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
+ eprintln!("Char indices: {:?}", char_indices);
+ eprintln!("Chars bitmap: {:#b}", chars_bitmap);
+ }
- let buffer_1_id = buffer_1.read_with(cx, |buffer_1, _| buffer_1.remote_id());
- let (buffer, translated_offset) = snapshot.point_to_buffer_offset(Point::new(2, 0)).unwrap();
- assert_eq!(buffer.remote_id(), buffer_1_id);
- assert_eq!(translated_offset.0, "one\n".len());
- let (buffer, translated_point) = snapshot.point_to_buffer_point(Point::new(2, 0)).unwrap();
- assert_eq!(buffer.remote_id(), buffer_1_id);
- assert_eq!(translated_point, Point::new(1, 0));
-}
+ assert_eq!(
+ has_bit, should_have_bit,
+ "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
+ byte_idx, chunk_text, should_have_bit, has_bit
+ );
+ }
-fn format_diff(
- text: &str,
- row_infos: &Vec<RowInfo>,
- boundary_rows: &HashSet<MultiBufferRow>,
- has_diff: Option<bool>,
-) -> String {
- let has_diff =
- has_diff.unwrap_or_else(|| row_infos.iter().any(|info| info.diff_status.is_some()));
- text.split('\n')
- .enumerate()
- .zip(row_infos)
- .map(|((ix, line), info)| {
- let marker = match info.diff_status.map(|status| status.kind) {
- Some(DiffHunkStatusKind::Added) => "+ ",
- Some(DiffHunkStatusKind::Deleted) => "- ",
- Some(DiffHunkStatusKind::Modified) => unreachable!(),
- None => {
- if has_diff && !line.is_empty() {
- " "
- } else {
- ""
- }
- }
- };
- let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {
- if has_diff {
- " ----------\n"
- } else {
- "---------\n"
- }
- } else {
- ""
- };
- let expand = info
- .expand_info
- .as_ref()
- .map(|expand_info| match expand_info.direction {
- ExpandExcerptDirection::Up => " [↑]",
- ExpandExcerptDirection::Down => " [↓]",
- ExpandExcerptDirection::UpAndDown => " [↕]",
- })
- .unwrap_or_default();
+ for (byte_idx, byte) in chunk_text.bytes().enumerate() {
+ let is_tab = byte == b'\t';
+ let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
- format!("{boundary_row}{marker}{line}{expand}")
- // let mbr = info
- // .multibuffer_row
- // .map(|row| format!("{:0>3}", row.0))
- // .unwrap_or_else(|| "???".to_string());
- // let byte_range = format!("{byte_range_start:0>3}..{byte_range_end:0>3}");
- // format!("{boundary_row}Row: {mbr}, Bytes: {byte_range} | {marker}{line}{expand}")
- })
- .collect::<Vec<_>>()
- .join("\n")
+ if has_bit != is_tab {
+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
+ eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
+ assert_eq!(
+ has_bit, is_tab,
+ "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
+ byte_idx, chunk_text, byte as char, is_tab, has_bit
+ );
+ }
+ }
+ }
}
-// fn format_transforms(snapshot: &MultiBufferSnapshot) -> String {
-// snapshot
-// .diff_transforms
-// .iter()
-// .map(|transform| {
-// let (kind, summary) = match transform {
-// DiffTransform::DeletedHunk { summary, .. } => (" Deleted", (*summary).into()),
-// DiffTransform::FilteredInsertedHunk { summary, .. } => (" Filtered", *summary),
-// DiffTransform::InsertedHunk { summary, .. } => (" Inserted", *summary),
-// DiffTransform::Unmodified { summary, .. } => ("Unmodified", *summary),
-// };
-// format!("{kind}(len: {}, lines: {:?})", summary.len, summary.lines)
-// })
-// .join("\n")
-// }
+#[gpui::test(iterations = 10)]
+fn test_random_chunk_bitmaps_with_diffs(cx: &mut App, mut rng: StdRng) {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ use buffer_diff::BufferDiff;
+ use util::RandomCharIter;
-// fn format_excerpts(snapshot: &MultiBufferSnapshot) -> String {
-// snapshot
-// .excerpts
-// .iter()
-// .map(|excerpt| {
-// format!(
-// "Excerpt(buffer_range = {:?}, lines = {:?}, has_trailing_newline = {:?})",
-// excerpt.range.context.to_point(&excerpt.buffer),
-// excerpt.text_summary.lines,
-// excerpt.has_trailing_newline
-// )
-// })
-// .join("\n")
-// }
+ let multibuffer = if rng.random() {
+ let len = rng.random_range(100..10000);
+ let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
+ let buffer = cx.new(|cx| Buffer::local(text, cx));
+ cx.new(|cx| MultiBuffer::singleton(buffer, cx))
+ } else {
+ MultiBuffer::build_random(&mut rng, cx)
+ };
-#[gpui::test]
-async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
- let text = indoc!(
- "
- ZERO
- one
- TWO
- three
- six
- "
- );
- let base_text = indoc!(
- "
- one
- two
- three
- four
- five
- six
- "
- );
+ let _diff_count = rng.random_range(1..5);
+ let mut diffs = Vec::new();
- let buffer = cx.new(|cx| Buffer::local(text, cx));
- let diff = cx
- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
- cx.run_until_parked();
+ multibuffer.update(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ for buffer_id in snapshot.all_buffer_ids() {
+ if rng.random_bool(0.7) {
+ if let Some(buffer_handle) = multibuffer.buffer(buffer_id) {
+ let buffer_text = buffer_handle.read(cx).text();
+ let mut base_text = String::new();
- let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
+ for line in buffer_text.lines() {
+ if rng.random_bool(0.3) {
+ continue;
+ } else if rng.random_bool(0.3) {
+ let line_len = rng.random_range(0..50);
+ let modified_line = RandomCharIter::new(&mut rng)
+ .take(line_len)
+ .collect::<String>();
+ base_text.push_str(&modified_line);
+ base_text.push('\n');
+ } else {
+ base_text.push_str(line);
+ base_text.push('\n');
+ }
+ }
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
- multibuffer.set_all_diff_hunks_expanded(cx);
- multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
- multibuffer
+ if rng.random_bool(0.5) {
+ let extra_lines = rng.random_range(1..5);
+ for _ in 0..extra_lines {
+ let line_len = rng.random_range(0..50);
+ let extra_line = RandomCharIter::new(&mut rng)
+ .take(line_len)
+ .collect::<String>();
+ base_text.push_str(&extra_line);
+ base_text.push('\n');
+ }
+ }
+
+ let diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ &base_text,
+ &buffer_handle.read(cx).text_snapshot(),
+ cx,
+ )
+ });
+ diffs.push(diff.clone());
+ multibuffer.add_diff(diff, cx);
+ }
+ }
+ }
});
- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
- (multibuffer.snapshot(cx), multibuffer.subscribe())
+ multibuffer.update(cx, |multibuffer, cx| {
+ if rng.random_bool(0.5) {
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ } else {
+ let snapshot = multibuffer.snapshot(cx);
+ let text = snapshot.text();
+
+ let mut ranges = Vec::new();
+ for _ in 0..rng.random_range(1..5) {
+ if snapshot.len().0 == 0 {
+ break;
+ }
+
+ let diff_size = rng.random_range(5..1000);
+ let mut start = rng.random_range(0..snapshot.len().0);
+
+ while !text.is_char_boundary(start) {
+ start = start.saturating_sub(1);
+ }
+
+ let mut end = rng.random_range(start..snapshot.len().0.min(start + diff_size));
+
+ while !text.is_char_boundary(end) {
+ end = end.saturating_add(1);
+ }
+ let start_anchor = snapshot.anchor_after(MultiBufferOffset(start));
+ let end_anchor = snapshot.anchor_before(MultiBufferOffset(end));
+ ranges.push(start_anchor..end_anchor);
+ }
+ multibuffer.expand_diff_hunks(ranges, cx);
+ }
});
- assert_eq!(snapshot.text(), base_text);
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc!(
- "
- one
- - two
- three
- - four
- - five
- six
- "
- ),
- );
+ let snapshot = multibuffer.read(cx).snapshot(cx);
- buffer.update(cx, |buffer, cx| {
- buffer.edit_via_marked_text(
- indoc!(
- "
- ZERO
- one
- «<inserted>»W«O
- T»hree
- six
- "
- ),
- None,
- cx,
- );
- });
- cx.run_until_parked();
- let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
- let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer_snapshot,
- &base_text_snapshot,
- Some(Arc::from(base_text)),
- cx,
- )
- })
- .await;
- diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
- cx.run_until_parked();
-
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc! {
- "
- one
- - two
- - three
- - four
- - five
- six
- "
+ let chunks = snapshot.chunks(
+ MultiBufferOffset(0)..snapshot.len(),
+ LanguageAwareStyling {
+ tree_sitter: false,
+ diagnostics: false,
},
);
- buffer.update(cx, |buffer, cx| {
- buffer.set_text("ZERO\nONE\nTWO\n", cx);
- });
- cx.run_until_parked();
- let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
- let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer_snapshot,
- &base_text_snapshot,
- Some(Arc::from(base_text)),
- cx,
- )
- })
- .await;
- diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
- cx.run_until_parked();
+ for chunk in chunks {
+ let chunk_text = chunk.text;
+ let chars_bitmap = chunk.chars;
+ let tabs_bitmap = chunk.tabs;
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc! {
- "
- - one
- - two
- - three
- - four
- - five
- - six
- "
- },
- );
+ if chunk_text.is_empty() {
+ assert_eq!(
+ chars_bitmap, 0,
+ "Empty chunk should have empty chars bitmap"
+ );
+ assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
+ continue;
+ }
- diff.update(cx, |diff, cx| {
- diff.set_base_text(
- Some("new base\n".into()),
- buffer.read(cx).text_snapshot(),
- cx,
- )
- })
- .await;
- cx.run_until_parked();
+ assert!(
+ chunk_text.len() <= 128,
+ "Chunk text length {} exceeds 128 bytes",
+ chunk_text.len()
+ );
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc! {"
- - new base
- "},
- );
+ let char_indices = chunk_text
+ .char_indices()
+ .map(|(i, _)| i)
+ .collect::<Vec<_>>();
+
+ for byte_idx in 0..chunk_text.len() {
+ let should_have_bit = char_indices.contains(&byte_idx);
+ let has_bit = chars_bitmap & (1 << byte_idx) != 0;
+
+ if has_bit != should_have_bit {
+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
+ eprintln!("Char indices: {:?}", char_indices);
+ eprintln!("Chars bitmap: {:#b}", chars_bitmap);
+ }
+
+ assert_eq!(
+ has_bit, should_have_bit,
+ "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
+ byte_idx, chunk_text, should_have_bit, has_bit
+ );
+ }
+
+ for (byte_idx, byte) in chunk_text.bytes().enumerate() {
+ let is_tab = byte == b'\t';
+ let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
+
+ if has_bit != is_tab {
+ eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
+ eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
+ assert_eq!(
+ has_bit, is_tab,
+ "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
+ byte_idx, chunk_text, byte as char, is_tab, has_bit
+ );
+ }
+ }
+ }
}
#[gpui::test]
-async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {
- let base_text = "aaa\nbbb\nccc\n";
- let text = "ddd\n";
- let buffer = cx.new(|cx| Buffer::local(text, cx));
- let diff = cx
- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
- cx.run_until_parked();
+async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- let base_text_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
+ let base_text = "hello world foo bar\n";
+ let modified_text = "hello WORLD foo BAR\n";
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
- multibuffer.set_all_diff_hunks_expanded(cx);
- multibuffer.add_inverted_diff(diff.clone(), buffer.clone(), cx);
- multibuffer
- });
+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);
- let (mut snapshot, mut subscription) = multibuffer.update(cx, |multibuffer, cx| {
- (multibuffer.snapshot(cx), multibuffer.subscribe())
- });
+ assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]);
+}
- assert_eq!(snapshot.text(), base_text);
- assert_new_snapshot(
- &multibuffer,
- &mut snapshot,
- &mut subscription,
- cx,
- indoc!(
- "
- - aaa
- - bbb
- - ccc
- "
- ),
- );
+#[gpui::test]
+async fn test_word_diff_white_space(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- diff.update(cx, |diff, cx| {
- diff.set_base_text(Some("ddd\n".into()), buffer.read(cx).text_snapshot(), cx)
- })
- .await;
+ let base_text = "hello world foo bar\n";
+ let modified_text = " hello world foo bar\n";
- let _hunks: Vec<_> = multibuffer
- .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
- .diff_hunks()
- .collect();
+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+
+ assert_eq!(word_diffs, vec![" "]);
}
#[gpui::test]
-async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext) {
- let base_text = "one\ntwo\nthree\nfour\nfive\n";
- let index_text = "one\nTWO\nthree\nfour\nfive\n";
- let buffer_text = "one\nTWO\nthree\nFOUR\nfive\n";
+async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- let buffer = cx.new(|cx| Buffer::local(buffer_text, cx));
+ let base_text = "aaa bbb\nccc ddd\n";
+ let modified_text = "aaa BBB\nccc DDD\n";
- let unstaged_diff = cx
- .new(|cx| BufferDiff::new_with_base_text(index_text, &buffer.read(cx).text_snapshot(), cx));
- cx.run_until_parked();
+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);
- let uncommitted_diff = cx.new(|cx| {
- let mut diff =
- BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx);
- diff.set_secondary_diff(unstaged_diff.clone());
- diff
- });
- cx.run_until_parked();
+ assert_eq!(
+ word_diffs,
+ vec!["bbb", "ddd", "BBB", "DDD"],
+ "consecutive modified lines should produce word diffs when line counts match"
+ );
+}
- buffer.update(cx, |buffer, cx| {
- buffer.edit([(0..0, "ZERO\n")], None, cx);
- });
+#[gpui::test]
+async fn test_word_diff_modified_lines_with_deletion_between(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- let base_text_snapshot = unstaged_diff.read_with(cx, |diff, cx| diff.base_text(cx));
- let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
- let update = unstaged_diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer_snapshot,
- &base_text_snapshot,
- Some(Arc::from(index_text)),
- cx,
- )
- })
- .await;
- unstaged_diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
+ let base_text = "aaa bbb\ndeleted line\nccc ddd\n";
+ let modified_text = "aaa BBB\nccc DDD\n";
- let base_text_buffer =
- uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
-
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::singleton(base_text_buffer.clone(), cx);
- multibuffer.set_all_diff_hunks_expanded(cx);
- multibuffer.add_inverted_diff(uncommitted_diff.clone(), buffer.clone(), cx);
- multibuffer
- });
+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);
- let _hunks: Vec<_> = multibuffer
- .read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
- .diff_hunks()
- .collect();
+ assert_eq!(
+ word_diffs,
+ Vec::<String>::new(),
+ "modified lines with a deleted line between should not produce word diffs"
+ );
}
-#[track_caller]
-fn assert_excerpts_match(
- multibuffer: &Entity<MultiBuffer>,
- cx: &mut TestAppContext,
- expected: &str,
-) {
- let mut output = String::new();
- multibuffer.read_with(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- for excerpt in multibuffer.snapshot(cx).excerpts() {
- output.push_str("-----\n");
- output.extend(
- snapshot
- .buffer_for_id(excerpt.context.start.buffer_id)
- .unwrap()
- .text_for_range(excerpt.context),
- );
- if !output.ends_with('\n') {
- output.push('\n');
- }
- }
+#[gpui::test]
+async fn test_word_diff_disabled(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| {
+ let mut settings_store = SettingsStore::test(cx);
+ settings_store.update_user_settings(cx, |settings| {
+ settings.project.all_languages.defaults.word_diff_enabled = Some(false);
+ });
+ settings_store
});
- assert_eq!(output, expected);
-}
+ cx.set_global(settings_store);
-#[track_caller]
-fn assert_new_snapshot(
- multibuffer: &Entity<MultiBuffer>,
- snapshot: &mut MultiBufferSnapshot,
- subscription: &mut Subscription<MultiBufferOffset>,
- cx: &mut TestAppContext,
- expected_diff: &str,
-) {
- let new_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let actual_text = new_snapshot.text();
- let line_infos = new_snapshot
- .row_infos(MultiBufferRow(0))
- .collect::<Vec<_>>();
- let actual_diff = format_diff(&actual_text, &line_infos, &Default::default(), None);
- pretty_assertions::assert_eq!(actual_diff, expected_diff);
- check_edits(
- snapshot,
- &new_snapshot,
- &subscription.consume().into_inner(),
+ let base_text = "hello world\n";
+ let modified_text = "hello WORLD\n";
+
+ let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+
+ assert_eq!(
+ word_diffs,
+ Vec::<String>::new(),
+ "word diffs should be empty when disabled"
);
- *snapshot = new_snapshot;
}
-#[track_caller]
-fn check_edits(
- old_snapshot: &MultiBufferSnapshot,
- new_snapshot: &MultiBufferSnapshot,
- edits: &[Edit<MultiBufferOffset>],
-) {
- let mut text = old_snapshot.text();
- let new_text = new_snapshot.text();
- for edit in edits.iter().rev() {
- if !text.is_char_boundary(edit.old.start.0)
- || !text.is_char_boundary(edit.old.end.0)
- || !new_text.is_char_boundary(edit.new.start.0)
- || !new_text.is_char_boundary(edit.new.end.0)
- {
- panic!(
- "invalid edits: {:?}\nold text: {:?}\nnew text: {:?}",
- edits, text, new_text
- );
- }
+#[gpui::test]
+async fn test_word_diff_expanded_cjk(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- text.replace_range(
- edit.old.start.0..edit.old.end.0,
- &new_text[edit.new.start.0..edit.new.end.0],
- );
- }
+ let base_text = "line 0\nline 1\nhello ab\n";
+ let modified_text = "line 0\nline 1\nhello 写入\n";
- pretty_assertions::assert_eq!(text, new_text, "invalid edits: {:?}", edits);
+ let multibuffer = create_multibuffer_with_diff(base_text, modified_text, cx);
+ multibuffer.update(cx, |mb, cx| {
+ mb.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
+ });
+
+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));
+ let highlighted = assert_word_diff_ranges_valid(&snapshot);
+ assert_eq!(highlighted, vec!["ab", "写入"]);
}
-#[track_caller]
-fn assert_chunks_in_ranges(snapshot: &MultiBufferSnapshot) {
- let full_text = snapshot.text();
- for ix in 0..full_text.len() {
- let mut chunks = snapshot.chunks(
- MultiBufferOffset(0)..snapshot.len(),
- LanguageAwareStyling {
- tree_sitter: false,
- diagnostics: false,
- },
- );
- chunks.seek(MultiBufferOffset(ix)..snapshot.len());
- let tail = chunks.map(|chunk| chunk.text).collect::<String>();
- assert_eq!(tail, &full_text[ix..], "seek to range: {:?}", ix..);
- }
+#[gpui::test]
+async fn test_word_diff_byte_132_collapsed(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
+
+ let prefix = "x".repeat(129);
+ let base_text = format!("{prefix} ab\n");
+ let modified_text = format!("{prefix} 写入\n");
+
+ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);
+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));
+ let highlighted = assert_word_diff_ranges_valid(&snapshot);
+ assert_eq!(highlighted, vec!["写入"]);
}
-#[track_caller]
-fn assert_consistent_line_numbers(snapshot: &MultiBufferSnapshot) {
- let all_line_numbers = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
- for start_row in 1..all_line_numbers.len() {
- let line_numbers = snapshot
- .row_infos(MultiBufferRow(start_row as u32))
- .collect::<Vec<_>>();
- assert_eq!(
- line_numbers,
- all_line_numbers[start_row..],
- "start_row: {start_row}"
- );
- }
+#[gpui::test]
+async fn test_word_diff_byte_132_expanded(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
+
+ let prefix = "x".repeat(129);
+ let base_text = format!("{prefix} ab\n");
+ let modified_text = format!("{prefix} 写入\n");
+
+ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);
+ multibuffer.update(cx, |mb, cx| {
+ mb.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
+ });
+
+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));
+ let highlighted = assert_word_diff_ranges_valid(&snapshot);
+ assert_eq!(highlighted, vec!["ab", "写入"]);
}
-#[track_caller]
-fn assert_position_translation(snapshot: &MultiBufferSnapshot) {
- let text = Rope::from(snapshot.text());
+#[gpui::test]
+async fn test_word_diff_mixed_expanded_and_collapsed(cx: &mut TestAppContext) {
+ let settings_store = cx.update(|cx| SettingsStore::test(cx));
+ cx.set_global(settings_store);
- let mut left_anchors = Vec::new();
- let mut right_anchors = Vec::new();
- let mut offsets = Vec::new();
- let mut points = Vec::new();
- for offset in 0..=text.len() + 1 {
- let offset = MultiBufferOffset(offset);
- let clipped_left = snapshot.clip_offset(offset, Bias::Left);
- let clipped_right = snapshot.clip_offset(offset, Bias::Right);
- assert_eq!(
- clipped_left.0,
- text.clip_offset(offset.0, Bias::Left),
- "clip_offset({offset:?}, Left)"
- );
- assert_eq!(
- clipped_right.0,
- text.clip_offset(offset.0, Bias::Right),
- "clip_offset({offset:?}, Right)"
- );
- assert_eq!(
- snapshot.offset_to_point(clipped_left),
- text.offset_to_point(clipped_left.0),
- "offset_to_point({})",
- clipped_left.0
- );
- assert_eq!(
- snapshot.offset_to_point(clipped_right),
- text.offset_to_point(clipped_right.0),
- "offset_to_point({})",
- clipped_right.0
- );
- let anchor_after = snapshot.anchor_after(clipped_left);
- assert_eq!(
- anchor_after.to_offset(snapshot),
- clipped_left,
- "anchor_after({}).to_offset {anchor_after:?}",
- clipped_left.0
- );
- let anchor_before = snapshot.anchor_before(clipped_left);
- assert_eq!(
- anchor_before.to_offset(snapshot),
- clipped_left,
- "anchor_before({}).to_offset",
- clipped_left.0
- );
- left_anchors.push(anchor_before);
- right_anchors.push(anchor_after);
- offsets.push(clipped_left);
- points.push(text.offset_to_point(clipped_left.0));
- }
+ let prefix = "x".repeat(129);
+ let base_text = format!("first alpha\nmiddle 1\nmiddle 2\n{prefix} ab\n");
+ let modified_text = format!("first BETA\nmiddle 1\nmiddle 2\n{prefix} 写入\n");
- for row in 0..text.max_point().row {
- for column in 0..text.line_len(row) + 1 {
- let point = Point { row, column };
- let clipped_left = snapshot.clip_point(point, Bias::Left);
- let clipped_right = snapshot.clip_point(point, Bias::Right);
- assert_eq!(
- clipped_left,
- text.clip_point(point, Bias::Left),
- "clip_point({point:?}, Left)"
- );
- assert_eq!(
- clipped_right,
- text.clip_point(point, Bias::Right),
- "clip_point({point:?}, Right)"
- );
- assert_eq!(
- snapshot.point_to_offset(clipped_left).0,
- text.point_to_offset(clipped_left),
- "point_to_offset({clipped_left:?})"
- );
- assert_eq!(
- snapshot.point_to_offset(clipped_right).0,
- text.point_to_offset(clipped_right),
- "point_to_offset({clipped_right:?})"
- );
- }
- }
+ let multibuffer = create_multibuffer_with_diff(&base_text, &modified_text, cx);
- assert_eq!(
- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&left_anchors),
- offsets,
- "left_anchors <-> offsets"
- );
- assert_eq!(
- snapshot.summaries_for_anchors::<Point, _>(&left_anchors),
- points,
- "left_anchors <-> points"
- );
- assert_eq!(
- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&right_anchors),
- offsets,
- "right_anchors <-> offsets"
- );
- assert_eq!(
- snapshot.summaries_for_anchors::<Point, _>(&right_anchors),
- points,
- "right_anchors <-> points"
- );
+ let hunks: Vec<_> = multibuffer
+ .read_with(cx, |mb, cx| mb.snapshot(cx))
+ .diff_hunks()
+ .collect();
+ assert_eq!(hunks.len(), 2, "expected 2 distinct diff hunks");
- for (anchors, bias) in [(&left_anchors, Bias::Left), (&right_anchors, Bias::Right)] {
- for (ix, (offset, anchor)) in offsets.iter().zip(anchors).enumerate() {
- if ix > 0 && *offset == MultiBufferOffset(252) && offset > &offsets[ix - 1] {
- let prev_anchor = left_anchors[ix - 1];
- assert!(
- anchor.cmp(&prev_anchor, snapshot).is_gt(),
- "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_gt()",
- offsets[ix],
- offsets[ix - 1],
- );
- assert!(
- prev_anchor.cmp(anchor, snapshot).is_lt(),
- "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_lt()",
- offsets[ix - 1],
- offsets[ix],
- );
- }
- }
- }
-
- if let Some((buffer, offset)) = snapshot.point_to_buffer_offset(snapshot.max_point()) {
- assert!(offset.0 <= buffer.len());
- }
- if let Some((buffer, point)) = snapshot.point_to_buffer_point(snapshot.max_point()) {
- assert!(point <= buffer.max_point());
- }
-}
-
-fn assert_line_indents(snapshot: &MultiBufferSnapshot) {
- let max_row = snapshot.max_point().row;
- let buffer_id = snapshot.excerpts().next().unwrap().context.start.buffer_id;
- let text = text::Buffer::new(ReplicaId::LOCAL, buffer_id, snapshot.text());
- let mut line_indents = text
- .line_indents_in_row_range(0..max_row + 1)
- .collect::<Vec<_>>();
- for start_row in 0..snapshot.max_point().row {
- pretty_assertions::assert_eq!(
- snapshot
- .line_indents(MultiBufferRow(start_row), |_| true)
- .map(|(row, indent, _)| (row.0, indent))
- .collect::<Vec<_>>(),
- &line_indents[(start_row as usize)..],
- "line_indents({start_row})"
- );
- }
-
- line_indents.reverse();
- pretty_assertions::assert_eq!(
- snapshot
- .reversed_line_indents(MultiBufferRow(max_row), |_| true)
- .map(|(row, indent, _)| (row.0, indent))
- .collect::<Vec<_>>(),
- &line_indents[..],
- "reversed_line_indents({max_row})"
- );
-}
-
-#[gpui::test]
-fn test_new_empty_buffer_uses_untitled_title(cx: &mut App) {
- let buffer = cx.new(|cx| Buffer::local("", cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ // Expand ONLY the first hunk, leaving the second hunk collapsed
+ multibuffer.update(cx, |mb, cx| {
+ mb.expand_diff_hunks(vec![hunks[0].multi_buffer_range.clone()], cx);
+ });
- assert_eq!(multibuffer.read(cx).title(cx), "untitled");
+ let snapshot = multibuffer.read_with(cx, |mb, cx| mb.snapshot(cx));
+ let highlighted = assert_word_diff_ranges_valid(&snapshot);
+ // Hunk 1 (expanded) yields deleted + modified words: ["alpha", "BETA"]
+ // Hunk 2 (collapsed) yields modified word only: ["写入"]
+ assert_eq!(highlighted, vec!["alpha", "BETA", "写入"]);
}
+/// Tests `excerpt_containing` and `excerpts_for_range` (functions mapping multi-buffer text-coordinates to excerpts)
#[gpui::test]
-fn test_new_empty_buffer_uses_untitled_title_when_only_contains_whitespace(cx: &mut App) {
- let buffer = cx.new(|cx| Buffer::local("\n ", cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+fn test_excerpts_containment_functions(cx: &mut App) {
+ // Multibuffer content for these tests:
+ // 0123
+ // 0: aa0
+ // 1: aa1
+ // -----
+ // 2: bb0
+ // 3: bb1
+ // -----MultiBufferOffset(0)..
+ // 4: cc0
- assert_eq!(multibuffer.read(cx).title(cx), "untitled");
-}
+ let buffer_1 = cx.new(|cx| Buffer::local("aa0\naa1", cx));
+ let buffer_2 = cx.new(|cx| Buffer::local("bb0\nbb1", cx));
+ let buffer_3 = cx.new(|cx| Buffer::local("cc0", cx));
-#[gpui::test]
-fn test_new_empty_buffer_takes_first_line_for_title(cx: &mut App) {
- let buffer = cx.new(|cx| Buffer::local("Hello World\nSecond line", cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
-}
+ let (excerpt_1_info, excerpt_2_info, excerpt_3_info) =
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
+ );
-#[gpui::test]
-fn test_new_empty_buffer_takes_trimmed_first_line_for_title(cx: &mut App) {
- let buffer = cx.new(|cx| Buffer::local("\nHello, World ", cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
+ );
- assert_eq!(multibuffer.read(cx).title(cx), "Hello, World");
-}
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(2),
+ buffer_3.clone(),
+ [Point::new(0, 0)..Point::new(0, 3)],
+ 0,
+ cx,
+ );
-#[gpui::test]
-fn test_new_empty_buffer_uses_truncated_first_line_for_title(cx: &mut App) {
- let title = "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee";
- let title_after = "aaaaaaaaaabbbbbbbbbbccccccccccdddddddddd";
- let buffer = cx.new(|cx| Buffer::local(title, cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ let snapshot = multibuffer.snapshot(cx);
+ let mut excerpts = snapshot.excerpts();
+ (
+ excerpts.next().unwrap(),
+ excerpts.next().unwrap(),
+ excerpts.next().unwrap(),
+ )
+ });
- assert_eq!(multibuffer.read(cx).title(cx), title_after);
-}
+ let snapshot = multibuffer.read(cx).snapshot(cx);
-#[gpui::test]
-fn test_new_empty_buffer_uses_truncated_first_line_for_title_after_merging_adjacent_spaces(
- cx: &mut App,
-) {
- let title = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddddeeeeeeeeee";
- let title_after = "aaaaaaaaaabbbbbbbbbb ccccccccccddddddddd";
- let buffer = cx.new(|cx| Buffer::local(title, cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
+ assert_eq!(snapshot.text(), "aa0\naa1\nbb0\nbb1\ncc0");
- assert_eq!(multibuffer.read(cx).title(cx), title_after);
-}
+ //// Test `excerpts_for_range`
-#[gpui::test]
-fn test_new_empty_buffers_title_can_be_set(cx: &mut App) {
- let buffer = cx.new(|cx| Buffer::local("Hello World", cx));
- let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx));
- assert_eq!(multibuffer.read(cx).title(cx), "Hello World");
+ let p00 = snapshot.point_to_offset(Point::new(0, 0));
+ let p10 = snapshot.point_to_offset(Point::new(1, 0));
+ let p20 = snapshot.point_to_offset(Point::new(2, 0));
+ let p23 = snapshot.point_to_offset(Point::new(2, 3));
+ let p13 = snapshot.point_to_offset(Point::new(1, 3));
+ let p40 = snapshot.point_to_offset(Point::new(4, 0));
+ let p43 = snapshot.point_to_offset(Point::new(4, 3));
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_title("Hey".into(), cx)
- });
- assert_eq!(multibuffer.read(cx).title(cx), "Hey");
-}
+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p00).collect();
+ assert_eq!(excerpts.len(), 1);
+ assert_eq!(excerpts[0].range, excerpt_1_info);
-#[gpui::test(iterations = 100)]
-fn test_random_chunk_bitmaps(cx: &mut App, mut rng: StdRng) {
- let multibuffer = if rng.random() {
- let len = rng.random_range(0..10000);
- let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
- let buffer = cx.new(|cx| Buffer::local(text, cx));
- cx.new(|cx| MultiBuffer::singleton(buffer, cx))
- } else {
- MultiBuffer::build_random(&mut rng, cx)
- };
+ // Cursor at very end of excerpt 3
+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p43..p43).collect();
+ assert_eq!(excerpts.len(), 1);
+ assert_eq!(excerpts[0].range, excerpt_3_info);
- let snapshot = multibuffer.read(cx).snapshot(cx);
+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p23).collect();
+ assert_eq!(excerpts.len(), 2);
+ assert_eq!(excerpts[0].range, excerpt_1_info);
+ assert_eq!(excerpts[1].range, excerpt_2_info);
- let chunks = snapshot.chunks(
- MultiBufferOffset(0)..snapshot.len(),
- LanguageAwareStyling {
- tree_sitter: false,
- diagnostics: false,
- },
- );
+ // This range represent an selection with end-point just inside excerpt_2
+ // Today we only expand the first excerpt, but another interpretation that
+ // we could consider is expanding both here
+ let excerpts: Vec<_> = snapshot.excerpts_for_range(p10..p20).collect();
+ assert_eq!(excerpts.len(), 1);
+ assert_eq!(excerpts[0].range, excerpt_1_info);
- for chunk in chunks {
- let chunk_text = chunk.text;
- let chars_bitmap = chunk.chars;
- let tabs_bitmap = chunk.tabs;
+ //// Test that `excerpts_for_range` and `excerpt_containing` agree for all single offsets (cursor positions)
+ for offset in 0..=snapshot.len().0 {
+ let offset = MultiBufferOffset(offset);
+ let excerpts_for_range: Vec<_> = snapshot.excerpts_for_range(offset..offset).collect();
+ assert_eq!(
+ excerpts_for_range.len(),
+ 1,
+ "Expected exactly one excerpt for offset {offset}",
+ );
- if chunk_text.is_empty() {
- assert_eq!(
- chars_bitmap, 0,
- "Empty chunk should have empty chars bitmap"
- );
- assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
- continue;
- }
+ let (_, excerpt_containing) =
+ snapshot
+ .excerpt_containing(offset..offset)
+ .unwrap_or_else(|| {
+ panic!("Expected excerpt_containing to find excerpt for offset {offset}")
+ });
- assert!(
- chunk_text.len() <= 128,
- "Chunk text length {} exceeds 128 bytes",
- chunk_text.len()
+ assert_eq!(
+ excerpts_for_range[0].range, excerpt_containing,
+ "excerpts_for_range and excerpt_containing should agree for offset {offset}",
);
+ }
- // Verify chars bitmap
- let char_indices = chunk_text
- .char_indices()
- .map(|(i, _)| i)
- .collect::<Vec<_>>();
+ //// Test `excerpt_containing` behavior with ranges:
- for byte_idx in 0..chunk_text.len() {
- let should_have_bit = char_indices.contains(&byte_idx);
- let has_bit = chars_bitmap & (1 << byte_idx) != 0;
+ // Ranges intersecting a single-excerpt
+ let (_, containing) = snapshot.excerpt_containing(p00..p13).unwrap();
+ assert_eq!(containing, excerpt_1_info);
- if has_bit != should_have_bit {
- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
- eprintln!("Char indices: {:?}", char_indices);
- eprintln!("Chars bitmap: {:#b}", chars_bitmap);
- }
+ // Ranges intersecting multiple excerpts (should return None)
+ let containing = snapshot.excerpt_containing(p20..p40);
+ assert!(
+ containing.is_none(),
+ "excerpt_containing should return None for ranges spanning multiple excerpts"
+ );
+}
- assert_eq!(
- has_bit, should_have_bit,
- "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
- byte_idx, chunk_text, should_have_bit, has_bit
- );
- }
-
- for (byte_idx, byte) in chunk_text.bytes().enumerate() {
- let is_tab = byte == b'\t';
- let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
-
- if has_bit != is_tab {
- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
- eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
- assert_eq!(
- has_bit, is_tab,
- "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
- byte_idx, chunk_text, byte as char, is_tab, has_bit
- );
- }
- }
- }
-}
-
-#[gpui::test(iterations = 10)]
-fn test_random_chunk_bitmaps_with_diffs(cx: &mut App, mut rng: StdRng) {
- let settings_store = SettingsStore::test(cx);
- cx.set_global(settings_store);
- use buffer_diff::BufferDiff;
- use util::RandomCharIter;
-
- let multibuffer = if rng.random() {
- let len = rng.random_range(100..10000);
- let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
- let buffer = cx.new(|cx| Buffer::local(text, cx));
- cx.new(|cx| MultiBuffer::singleton(buffer, cx))
- } else {
- MultiBuffer::build_random(&mut rng, cx)
- };
-
- let _diff_count = rng.random_range(1..5);
- let mut diffs = Vec::new();
-
- multibuffer.update(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- for buffer_id in snapshot.all_buffer_ids() {
- if rng.random_bool(0.7) {
- if let Some(buffer_handle) = multibuffer.buffer(buffer_id) {
- let buffer_text = buffer_handle.read(cx).text();
- let mut base_text = String::new();
-
- for line in buffer_text.lines() {
- if rng.random_bool(0.3) {
- continue;
- } else if rng.random_bool(0.3) {
- let line_len = rng.random_range(0..50);
- let modified_line = RandomCharIter::new(&mut rng)
- .take(line_len)
- .collect::<String>();
- base_text.push_str(&modified_line);
- base_text.push('\n');
- } else {
- base_text.push_str(line);
- base_text.push('\n');
- }
- }
-
- if rng.random_bool(0.5) {
- let extra_lines = rng.random_range(1..5);
- for _ in 0..extra_lines {
- let line_len = rng.random_range(0..50);
- let extra_line = RandomCharIter::new(&mut rng)
- .take(line_len)
- .collect::<String>();
- base_text.push_str(&extra_line);
- base_text.push('\n');
- }
- }
-
- let diff = cx.new(|cx| {
- BufferDiff::new_with_base_text(
- &base_text,
- &buffer_handle.read(cx).text_snapshot(),
- cx,
- )
- });
- diffs.push(diff.clone());
- multibuffer.add_diff(diff, cx);
- }
- }
- }
- });
+#[gpui::test]
+fn test_range_to_buffer_ranges(cx: &mut App) {
+ let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));
+ let buffer_2 = cx.new(|cx| Buffer::local("ccc", cx));
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
multibuffer.update(cx, |multibuffer, cx| {
- if rng.random_bool(0.5) {
- multibuffer.set_all_diff_hunks_expanded(cx);
- } else {
- let snapshot = multibuffer.snapshot(cx);
- let text = snapshot.text();
-
- let mut ranges = Vec::new();
- for _ in 0..rng.random_range(1..5) {
- if snapshot.len().0 == 0 {
- break;
- }
-
- let diff_size = rng.random_range(5..1000);
- let mut start = rng.random_range(0..snapshot.len().0);
-
- while !text.is_char_boundary(start) {
- start = start.saturating_sub(1);
- }
-
- let mut end = rng.random_range(start..snapshot.len().0.min(start + diff_size));
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
+ );
- while !text.is_char_boundary(end) {
- end = end.saturating_add(1);
- }
- let start_anchor = snapshot.anchor_after(MultiBufferOffset(start));
- let end_anchor = snapshot.anchor_before(MultiBufferOffset(end));
- ranges.push(start_anchor..end_anchor);
- }
- multibuffer.expand_diff_hunks(ranges, cx);
- }
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ [Point::new(0, 0)..Point::new(0, 3)],
+ 0,
+ cx,
+ );
});
let snapshot = multibuffer.read(cx).snapshot(cx);
+ assert_eq!(snapshot.text(), "aaa\nbbb\nccc");
- let chunks = snapshot.chunks(
- MultiBufferOffset(0)..snapshot.len(),
- LanguageAwareStyling {
- tree_sitter: false,
- diagnostics: false,
- },
- );
+ let excerpt_2_start = Point::new(2, 0);
- for chunk in chunks {
- let chunk_text = chunk.text;
- let chars_bitmap = chunk.chars;
- let tabs_bitmap = chunk.tabs;
+ let ranges_half_open = snapshot.range_to_buffer_ranges(Point::zero()..excerpt_2_start);
+ assert_eq!(
+ ranges_half_open.len(),
+ 1,
+ "Half-open range ending at excerpt start should EXCLUDE that excerpt"
+ );
+ assert_eq!(ranges_half_open[0].1, BufferOffset(0)..BufferOffset(7));
+ assert_eq!(
+ ranges_half_open[0].0.remote_id(),
+ buffer_1.read(cx).remote_id()
+ );
- if chunk_text.is_empty() {
- assert_eq!(
- chars_bitmap, 0,
- "Empty chunk should have empty chars bitmap"
+ let buffer_empty = cx.new(|cx| Buffer::local("", cx));
+ let multibuffer_trailing_empty = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ let (_te_excerpt_1_info, _te_excerpt_2_info) =
+ multibuffer_trailing_empty.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
);
- assert_eq!(tabs_bitmap, 0, "Empty chunk should have empty tabs bitmap");
- continue;
- }
-
- assert!(
- chunk_text.len() <= 128,
- "Chunk text length {} exceeds 128 bytes",
- chunk_text.len()
- );
- let char_indices = chunk_text
- .char_indices()
- .map(|(i, _)| i)
- .collect::<Vec<_>>();
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_empty.clone(),
+ [Point::new(0, 0)..Point::new(0, 0)],
+ 0,
+ cx,
+ );
- for byte_idx in 0..chunk_text.len() {
- let should_have_bit = char_indices.contains(&byte_idx);
- let has_bit = chars_bitmap & (1 << byte_idx) != 0;
+ let snapshot = multibuffer.snapshot(cx);
+ let mut infos = snapshot.excerpts();
+ (infos.next().unwrap(), infos.next().unwrap())
+ });
- if has_bit != should_have_bit {
- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
- eprintln!("Char indices: {:?}", char_indices);
- eprintln!("Chars bitmap: {:#b}", chars_bitmap);
- }
+ let snapshot_trailing = multibuffer_trailing_empty.read(cx).snapshot(cx);
+ assert_eq!(snapshot_trailing.text(), "aaa\nbbb\n");
- assert_eq!(
- has_bit, should_have_bit,
- "Chars bitmap mismatch at byte index {} in chunk {:?}. Expected bit: {}, Got bit: {}",
- byte_idx, chunk_text, should_have_bit, has_bit
- );
- }
+ let max_point = snapshot_trailing.max_point();
- for (byte_idx, byte) in chunk_text.bytes().enumerate() {
- let is_tab = byte == b'\t';
- let has_bit = tabs_bitmap & (1 << byte_idx) != 0;
+ let ranges_half_open_max = snapshot_trailing.range_to_buffer_ranges(Point::zero()..max_point);
+ assert_eq!(
+ ranges_half_open_max.len(),
+ 2,
+ "Should include trailing empty excerpts"
+ );
+ assert_eq!(ranges_half_open_max[1].1, BufferOffset(0)..BufferOffset(0));
- if has_bit != is_tab {
- eprintln!("Chunk text bytes: {:?}", chunk_text.as_bytes());
- eprintln!("Tabs bitmap: {:#b}", tabs_bitmap);
- assert_eq!(
- has_bit, is_tab,
- "Tabs bitmap mismatch at byte index {} in chunk {:?}. Byte: {:?}, Expected bit: {}, Got bit: {}",
- byte_idx, chunk_text, byte as char, is_tab, has_bit
- );
+ for snapshot in [&snapshot, &snapshot_trailing] {
+ for start in 0..=snapshot.len().0 {
+ for end in start..=snapshot.len().0 {
+ let range = MultiBufferOffset(start)..MultiBufferOffset(end);
+ let expected = snapshot
+ .range_to_buffer_ranges(range.clone())
+ .into_iter()
+ .map(|(buffer, range, _)| (buffer.remote_id(), range, None))
+ .collect::<Vec<_>>();
+ let actual = snapshot
+ .range_to_buffer_ranges_with_deleted_hunks(range.clone())
+ .map(|(buffer, range, anchor)| (buffer.remote_id(), range, anchor))
+ .collect::<Vec<_>>();
+ assert_eq!(actual, expected, "{range:?}");
}
}
}
}
-fn collect_word_diffs(
- base_text: &str,
- modified_text: &str,
- cx: &mut TestAppContext,
-) -> Vec<String> {
- let buffer = cx.new(|cx| Buffer::local(modified_text, cx));
+#[gpui::test]
+fn test_range_to_buffer_ranges_zero_length_at_excerpt_boundary(cx: &mut App) {
+ let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));
+ let buffer_2 = cx.new(|cx| Buffer::local("ccc\nddd", cx));
+
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_1.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
+ );
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_2.clone(),
+ [Point::new(0, 0)..Point::new(1, 3)],
+ 0,
+ cx,
+ );
+ });
+
+ let snapshot = multibuffer.read(cx).snapshot(cx);
+ assert_eq!(snapshot.text(), "aaa\nbbb\nccc\nddd");
+
+ // This point is right at the start of the very first excerpt, so if we get
+ // a buffer range, we should get `0..0`
+ let excerpt_2_start = Point::new(2, 0);
+ let expected_ranges = vec![BufferOffset(0)..BufferOffset(0)];
+ let ranges = snapshot
+ .range_to_buffer_ranges(excerpt_2_start..excerpt_2_start)
+ .into_iter()
+ .map(|tup| tup.1)
+ .collect_vec();
+
+ assert_eq!(
+ ranges, expected_ranges,
+ "Zero-length range at excerpt boundary should return the excerpt at that point"
+ );
+}
+
+#[gpui::test]
+async fn test_buffer_range_to_excerpt_ranges(cx: &mut TestAppContext) {
+ let base_text = indoc!(
+ "
+ aaa
+ bbb
+ ccc
+ ddd
+ eee
+ ppp
+ qqq
+ rrr
+ fff
+ ggg
+ hhh
+ "
+ );
+ let text = indoc!(
+ "
+ aaa
+ BBB
+ ddd
+ eee
+ ppp
+ qqq
+ rrr
+ FFF
+ ggg
+ hhh
+ "
+ );
+
+ let buffer = cx.new(|cx| Buffer::local(text, cx));
let diff = cx
.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
cx.run_until_parked();
let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer.clone(),
+ [
+ Point::new(0, 0)..Point::new(3, 3),
+ Point::new(7, 0)..Point::new(9, 3),
+ ],
+ 0,
+ cx,
+ );
multibuffer.add_diff(diff.clone(), cx);
multibuffer
});
@@ -6066,1131 +5263,2066 @@ fn collect_word_diffs(
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
});
+ cx.run_until_parked();
let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let text = snapshot.text();
- snapshot
- .diff_hunks()
- .flat_map(|hunk| hunk.word_diffs)
- .map(|range| text[range.start.0..range.end.0].to_string())
- .collect()
-}
+ let actual_diff = format_diff(
+ &snapshot.text(),
+ &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),
+ &Default::default(),
+ None,
+ );
+ let expected_diff = indoc!(
+ "
+ aaa
+ - bbb
+ - ccc
+ + BBB
+ ddd
+ eee [\u{2193}]
+ - fff [\u{2191}]
+ + FFF
+ ggg
+ hhh [\u{2193}]"
+ );
+ pretty_assertions::assert_eq!(actual_diff, expected_diff);
-#[gpui::test]
-async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) {
- let settings_store = cx.update(|cx| SettingsStore::test(cx));
- cx.set_global(settings_store);
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
- let base_text = "hello world foo bar\n";
- let modified_text = "hello WORLD foo BAR\n";
+ let query_spanning_deleted_hunk = buffer_snapshot.anchor_after(Point::new(0, 0))
+ ..buffer_snapshot.anchor_before(Point::new(1, 3));
+ assert_eq!(
+ snapshot
+ .buffer_range_to_excerpt_ranges(query_spanning_deleted_hunk)
+ .map(|range| range.to_point(&snapshot))
+ .collect::<Vec<_>>(),
+ vec![
+ Point::new(0, 0)..Point::new(1, 0),
+ Point::new(3, 0)..Point::new(3, 3),
+ ],
+ );
- let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+ let query_within_contiguous_main_buffer = buffer_snapshot.anchor_after(Point::new(1, 0))
+ ..buffer_snapshot.anchor_before(Point::new(2, 3));
+ assert_eq!(
+ snapshot
+ .buffer_range_to_excerpt_ranges(query_within_contiguous_main_buffer)
+ .map(|range| range.to_point(&snapshot))
+ .collect::<Vec<_>>(),
+ vec![Point::new(3, 0)..Point::new(4, 3)],
+ );
- assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]);
+ let query_spanning_both_excerpts = buffer_snapshot.anchor_after(Point::new(2, 0))
+ ..buffer_snapshot.anchor_before(Point::new(8, 3));
+ assert_eq!(
+ snapshot
+ .buffer_range_to_excerpt_ranges(query_spanning_both_excerpts)
+ .map(|range| range.to_point(&snapshot))
+ .collect::<Vec<_>>(),
+ vec![
+ Point::new(4, 0)..Point::new(5, 3),
+ Point::new(7, 0)..Point::new(8, 3),
+ ],
+ );
}
#[gpui::test]
-async fn test_word_diff_white_space(cx: &mut TestAppContext) {
- let settings_store = cx.update(|cx| SettingsStore::test(cx));
- cx.set_global(settings_store);
-
- let base_text = "hello world foo bar\n";
- let modified_text = " hello world foo bar\n";
-
- let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+fn test_cannot_seek_backward_after_excerpt_replacement(cx: &mut TestAppContext) {
+ let buffer_b_text: String = (0..50).map(|i| format!("line_b {i}\n")).collect();
+ let buffer_b = cx.new(|cx| Buffer::local(buffer_b_text, cx));
- assert_eq!(word_diffs, vec![" "]);
-}
+ let buffer_c_text: String = (0..10).map(|i| format!("line_c {i}\n")).collect();
+ let buffer_c = cx.new(|cx| Buffer::local(buffer_c_text, cx));
-#[gpui::test]
-async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) {
- let settings_store = cx.update(|cx| SettingsStore::test(cx));
- cx.set_global(settings_store);
+ let buffer_d_text: String = (0..10).map(|i| format!("line_d {i}\n")).collect();
+ let buffer_d = cx.new(|cx| Buffer::local(buffer_d_text, cx));
- let base_text = "aaa bbb\nccc ddd\n";
- let modified_text = "aaa BBB\nccc DDD\n";
+ let path_b = PathKey::with_sort_prefix(0, rel_path("bbb.rs").into_arc());
+ let path_c = PathKey::with_sort_prefix(0, rel_path("ddd.rs").into_arc());
+ let path_d = PathKey::with_sort_prefix(0, rel_path("ccc.rs").into_arc());
- let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- assert_eq!(
- word_diffs,
- vec!["bbb", "ddd", "BBB", "DDD"],
- "consecutive modified lines should produce word diffs when line counts match"
- );
-}
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ path_b.clone(),
+ buffer_b.clone(),
+ vec![
+ Point::row_range(0..3),
+ Point::row_range(15..18),
+ Point::row_range(30..33),
+ ],
+ 0,
+ cx,
+ );
+ });
-#[gpui::test]
-async fn test_word_diff_modified_lines_with_deletion_between(cx: &mut TestAppContext) {
- let settings_store = cx.update(|cx| SettingsStore::test(cx));
- cx.set_global(settings_store);
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ path_c.clone(),
+ buffer_c.clone(),
+ vec![Point::row_range(0..3)],
+ 0,
+ cx,
+ );
+ });
- let base_text = "aaa bbb\ndeleted line\nccc ddd\n";
- let modified_text = "aaa BBB\nccc DDD\n";
+ let (anchor_in_e_b2, anchor_in_e_b3) = multibuffer.read_with(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ let excerpt_infos = snapshot.excerpts().collect::<Vec<_>>();
+ assert_eq!(excerpt_infos.len(), 4, "expected 4 excerpts (3×B + 1×C)");
- let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+ let e_b2_info = excerpt_infos[1].clone();
+ let e_b3_info = excerpt_infos[2].clone();
- assert_eq!(
- word_diffs,
- Vec::<String>::new(),
- "modified lines with a deleted line between should not produce word diffs"
- );
-}
+ let anchor_b2 = snapshot.anchor_in_excerpt(e_b2_info.context.start).unwrap();
+ let anchor_b3 = snapshot.anchor_in_excerpt(e_b3_info.context.start).unwrap();
+ (anchor_b2, anchor_b3)
+ });
-#[gpui::test]
-async fn test_word_diff_disabled(cx: &mut TestAppContext) {
- let settings_store = cx.update(|cx| {
- let mut settings_store = SettingsStore::test(cx);
- settings_store.update_user_settings(cx, |settings| {
- settings.project.all_languages.defaults.word_diff_enabled = Some(false);
- });
- settings_store
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ path_b.clone(),
+ buffer_b.clone(),
+ vec![Point::row_range(0..3), Point::row_range(28..36)],
+ 0,
+ cx,
+ );
});
- cx.set_global(settings_store);
- let base_text = "hello world\n";
- let modified_text = "hello WORLD\n";
-
- let word_diffs = collect_word_diffs(base_text, modified_text, cx);
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_path(
+ path_d.clone(),
+ buffer_d.clone(),
+ vec![Point::row_range(0..3)],
+ 0,
+ cx,
+ );
+ });
- assert_eq!(
- word_diffs,
- Vec::<String>::new(),
- "word diffs should be empty when disabled"
- );
+ multibuffer.read_with(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ snapshot.summaries_for_anchors::<Point, _>(&[anchor_in_e_b2, anchor_in_e_b3]);
+ });
}
-/// Tests `excerpt_containing` and `excerpts_for_range` (functions mapping multi-buffer text-coordinates to excerpts)
#[gpui::test]
-fn test_excerpts_containment_functions(cx: &mut App) {
- // Multibuffer content for these tests:
- // 0123
- // 0: aa0
- // 1: aa1
- // -----
- // 2: bb0
- // 3: bb1
- // -----MultiBufferOffset(0)..
- // 4: cc0
-
- let buffer_1 = cx.new(|cx| Buffer::local("aa0\naa1", cx));
- let buffer_2 = cx.new(|cx| Buffer::local("bb0\nbb1", cx));
- let buffer_3 = cx.new(|cx| Buffer::local("cc0", cx));
-
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
-
- let (excerpt_1_info, excerpt_2_info, excerpt_3_info) =
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
- 0,
- cx,
- );
-
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_2.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
- 0,
- cx,
- );
-
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(2),
- buffer_3.clone(),
- [Point::new(0, 0)..Point::new(0, 3)],
- 0,
- cx,
- );
-
- let snapshot = multibuffer.snapshot(cx);
- let mut excerpts = snapshot.excerpts();
- (
- excerpts.next().unwrap(),
- excerpts.next().unwrap(),
- excerpts.next().unwrap(),
- )
- });
-
- let snapshot = multibuffer.read(cx).snapshot(cx);
-
- assert_eq!(snapshot.text(), "aa0\naa1\nbb0\nbb1\ncc0");
-
- //// Test `excerpts_for_range`
+fn test_resolving_max_anchor_for_buffer(cx: &mut TestAppContext) {
+ let dock_base_text = indoc! {"
+ 0
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ "};
- let p00 = snapshot.point_to_offset(Point::new(0, 0));
- let p10 = snapshot.point_to_offset(Point::new(1, 0));
- let p20 = snapshot.point_to_offset(Point::new(2, 0));
- let p23 = snapshot.point_to_offset(Point::new(2, 3));
- let p13 = snapshot.point_to_offset(Point::new(1, 3));
- let p40 = snapshot.point_to_offset(Point::new(4, 0));
- let p43 = snapshot.point_to_offset(Point::new(4, 3));
+ let dock_text = indoc! {"
+ 0
+ 4
+ 5
+ 6
+ 10
+ 11
+ 12
+ "};
- let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p00).collect();
- assert_eq!(excerpts.len(), 1);
- assert_eq!(excerpts[0].range, excerpt_1_info);
+ let dock_buffer = cx.new(|cx| Buffer::local(dock_text, cx));
+ let diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text(dock_base_text, &dock_buffer.read(cx).snapshot(), cx)
+ });
- // Cursor at very end of excerpt 3
- let excerpts: Vec<_> = snapshot.excerpts_for_range(p43..p43).collect();
- assert_eq!(excerpts.len(), 1);
- assert_eq!(excerpts[0].range, excerpt_3_info);
+ let workspace_text = "second buffer\n";
+ let workspace_buffer = cx.new(|cx| Buffer::local(workspace_text, cx));
- let excerpts: Vec<_> = snapshot.excerpts_for_range(p00..p23).collect();
- assert_eq!(excerpts.len(), 2);
- assert_eq!(excerpts[0].range, excerpt_1_info);
- assert_eq!(excerpts[1].range, excerpt_2_info);
+ let dock_path = PathKey::with_sort_prefix(0, rel_path("").into_arc());
+ let workspace_path = PathKey::with_sort_prefix(1, rel_path("").into_arc());
- // This range represent an selection with end-point just inside excerpt_2
- // Today we only expand the first excerpt, but another interpretation that
- // we could consider is expanding both here
- let excerpts: Vec<_> = snapshot.excerpts_for_range(p10..p20).collect();
- assert_eq!(excerpts.len(), 1);
- assert_eq!(excerpts[0].range, excerpt_1_info);
+ let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- //// Test that `excerpts_for_range` and `excerpt_containing` agree for all single offsets (cursor positions)
- for offset in 0..=snapshot.len().0 {
- let offset = MultiBufferOffset(offset);
- let excerpts_for_range: Vec<_> = snapshot.excerpts_for_range(offset..offset).collect();
- assert_eq!(
- excerpts_for_range.len(),
- 1,
- "Expected exactly one excerpt for offset {offset}",
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpt_ranges_for_path(
+ dock_path,
+ dock_buffer.clone(),
+ &dock_buffer.read(cx).snapshot(),
+ vec![
+ ExcerptRange::new(Point::zero()..Point::new(1, 1)),
+ ExcerptRange::new(Point::new(3, 0)..Point::new(4, 2)),
+ ],
+ cx,
);
-
- let (_, excerpt_containing) =
- snapshot
- .excerpt_containing(offset..offset)
- .unwrap_or_else(|| {
- panic!("Expected excerpt_containing to find excerpt for offset {offset}")
- });
-
- assert_eq!(
- excerpts_for_range[0].range, excerpt_containing,
- "excerpts_for_range and excerpt_containing should agree for offset {offset}",
+ multibuffer.set_excerpt_ranges_for_path(
+ workspace_path,
+ workspace_buffer.clone(),
+ &workspace_buffer.read(cx).snapshot(),
+ vec![ExcerptRange::new(
+ Point::zero()..workspace_buffer.read(cx).max_point(),
+ )],
+ cx,
);
- }
-
- //// Test `excerpt_containing` behavior with ranges:
-
- // Ranges intersecting a single-excerpt
- let (_, containing) = snapshot.excerpt_containing(p00..p13).unwrap();
- assert_eq!(containing, excerpt_1_info);
+ multibuffer.add_diff(diff, cx);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ });
- // Ranges intersecting multiple excerpts (should return None)
- let containing = snapshot.excerpt_containing(p20..p40);
- assert!(
- containing.is_none(),
- "excerpt_containing should return None for ranges spanning multiple excerpts"
+ let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let diff = format_diff(
+ &snapshot.text(),
+ &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),
+ &Default::default(),
+ None,
+ );
+ assert_eq!(
+ diff,
+ indoc! {"
+ 0
+ - 1
+ - 2
+ - 3
+ 4 [↓]
+ 6 [↑]
+ - 7
+ - 8
+ - 9
+ 10 [↓]
+ second buffer
+ "}
);
+
+ multibuffer.update(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ let point = snapshot
+ .anchor_in_buffer(text::Anchor::max_for_buffer(
+ dock_buffer.read(cx).remote_id(),
+ ))
+ .unwrap()
+ .to_point(&snapshot);
+ assert_eq!(point, Point::new(10, 0));
+ })
}
#[gpui::test]
-fn test_range_to_buffer_ranges(cx: &mut App) {
- let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));
- let buffer_2 = cx.new(|cx| Buffer::local("ccc", cx));
+fn test_is_valid_anchor_past_last_excerpt_for_buffer(cx: &mut TestAppContext) {
+ let buffer_a = cx.new(|cx| Buffer::local("aaa\nbbb\nccc\n", cx));
+ buffer_a.update(cx, |buffer, cx| {
+ let len = buffer.len();
+ buffer.edit([(len..len, "ddd\neee\n")], None, cx);
+ });
+ let buffer_b = cx.new(|cx| Buffer::local("xxx\n", cx));
+ for line in ["yyy\n", "zzz\n", "www\n", "vvv\n"] {
+ buffer_b.update(cx, |buffer, cx| {
+ let len = buffer.len();
+ buffer.edit([(len..len, line)], None, cx);
+ });
+ }
+
+ let path_a = PathKey::with_sort_prefix(0, rel_path("aaa.rs").into_arc());
+ let path_b = PathKey::with_sort_prefix(1, rel_path("bbb.rs").into_arc());
let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+
multibuffer.update(cx, |multibuffer, cx| {
multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
+ path_a.clone(),
+ buffer_a.clone(),
+ vec![Point::new(1, 0)..Point::new(2, 3)],
0,
cx,
);
-
multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_2.clone(),
- [Point::new(0, 0)..Point::new(0, 3)],
+ path_b.clone(),
+ buffer_b.clone(),
+ vec![Point::new(1, 0)..Point::new(3, 3)],
0,
cx,
);
});
- let snapshot = multibuffer.read(cx).snapshot(cx);
- assert_eq!(snapshot.text(), "aaa\nbbb\nccc");
-
- let excerpt_2_start = Point::new(2, 0);
-
- let ranges_half_open = snapshot.range_to_buffer_ranges(Point::zero()..excerpt_2_start);
- assert_eq!(
- ranges_half_open.len(),
- 1,
- "Half-open range ending at excerpt start should EXCLUDE that excerpt"
- );
- assert_eq!(ranges_half_open[0].1, BufferOffset(0)..BufferOffset(7));
- assert_eq!(
- ranges_half_open[0].0.remote_id(),
- buffer_1.read(cx).remote_id()
- );
-
- let buffer_empty = cx.new(|cx| Buffer::local("", cx));
- let multibuffer_trailing_empty = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- let (_te_excerpt_1_info, _te_excerpt_2_info) =
- multibuffer_trailing_empty.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_1.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
- 0,
- cx,
- );
-
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_empty.clone(),
- [Point::new(0, 0)..Point::new(0, 0)],
- 0,
- cx,
- );
-
- let snapshot = multibuffer.snapshot(cx);
- let mut infos = snapshot.excerpts();
- (infos.next().unwrap(), infos.next().unwrap())
- });
-
- let snapshot_trailing = multibuffer_trailing_empty.read(cx).snapshot(cx);
- assert_eq!(snapshot_trailing.text(), "aaa\nbbb\n");
-
- let max_point = snapshot_trailing.max_point();
+ multibuffer.read_with(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
- let ranges_half_open_max = snapshot_trailing.range_to_buffer_ranges(Point::zero()..max_point);
- assert_eq!(
- ranges_half_open_max.len(),
- 2,
- "Should include trailing empty excerpts"
- );
- assert_eq!(ranges_half_open_max[1].1, BufferOffset(0)..BufferOffset(0));
+ let buffer_a_snapshot = buffer_a.read(cx).snapshot();
+ let anchor_past_excerpt = buffer_a_snapshot.anchor_after(Point::new(4, 0));
+ let mb_anchor = snapshot.anchor_in_buffer(anchor_past_excerpt).unwrap();
- for snapshot in [&snapshot, &snapshot_trailing] {
- for start in 0..=snapshot.len().0 {
- for end in start..=snapshot.len().0 {
- let range = MultiBufferOffset(start)..MultiBufferOffset(end);
- let expected = snapshot
- .range_to_buffer_ranges(range.clone())
- .into_iter()
- .map(|(buffer, range, _)| (buffer.remote_id(), range, None))
- .collect::<Vec<_>>();
- let actual = snapshot
- .range_to_buffer_ranges_with_deleted_hunks(range.clone())
- .map(|(buffer, range, anchor)| (buffer.remote_id(), range, anchor))
- .collect::<Vec<_>>();
- assert_eq!(actual, expected, "{range:?}");
- }
- }
- }
+ assert!(
+ !mb_anchor.is_valid(&snapshot),
+ "anchor past the last excerpt for its buffer should not be valid"
+ );
+ });
}
-#[gpui::test]
-fn test_range_to_buffer_ranges_zero_length_at_excerpt_boundary(cx: &mut App) {
- let buffer_1 = cx.new(|cx| Buffer::local("aaa\nbbb", cx));
- let buffer_2 = cx.new(|cx| Buffer::local("ccc\nddd", cx));
+/// The contract between anchor comparison and anchor resolution that every
+/// sorted-input consumer relies on (`summaries_for_anchors*`, forward-only
+/// cursors, and persistent trees ordered by anchor comparison such as the
+/// editor's fold tree):
+///
+/// 1. Within one snapshot, comparison tracks resolution: if `a.cmp(b)` is
+/// `Less`, `a` must not resolve after `b`, and anchors that compare
+/// `Equal` must resolve to the same offset.
+/// 2. Across structural changes (edits, diff base text changes, a path key
+/// reused for a different buffer, buffers leaving), a pair's comparison
+/// never inverts: `Less` may weaken to `Equal`, but must not become
+/// `Greater`. (Even the collapse to `Equal` is hazardous for consumers
+/// that sort ranges with end tie-breaks, but it is tolerated here so
+/// that outright inversions stay visible.)
+///
+/// Shrinking yields a minimal operation sequence for whichever violating
+/// mechanism it finds. Mechanisms found so far, each fixed and pinned by a
+/// distilled test:
+/// - stale-path anchors sorted by buffer id but resolved to the end of
+/// their path's region
+/// (`test_stale_path_anchor_comparison_tracks_resolution`);
+/// - diff base anchors' validity filter flipping comparison results when a
+/// base text edit deleted the region one anchor of a pair pointed into
+/// (`test_folds_stay_sorted_when_diff_base_text_replaced` in the
+/// editor's block_map tests);
+/// - plain anchors resolved before phantom deleted-hunk rows they compare
+/// after (`test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows`).
+#[gpui::property_test(config = proptest::prelude::ProptestConfig {
+ failure_persistence: Some(Box::new(
+ proptest::test_runner::FileFailurePersistence::WithSource("proptest-regressions"),
+ )),
+ ..Default::default()
+})]
+async fn test_anchor_comparison_tracks_resolution(
+ cx: &mut TestAppContext,
+ #[strategy = proptest::collection::vec(proptest::prelude::any::<AnchorContractOp>(), 1..16)]
+ ops: Vec<AnchorContractOp>,
+) {
+ let base_text_variants = [
+ "DEL1\nDEL2\nbbb\nccc\nddd\n",
+ "DEL1\nbbb\nccc\nddd\n",
+ "DEL2\nbbb\nccc\nddd\n",
+ "bbb\nccc\nddd\n",
+ ];
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ let mut buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
+ let mut diff_a = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ base_text_variants[0],
+ &buffer_a.read(cx).text_snapshot(),
+ cx,
+ )
+ });
+ let buffer_b = cx.new(|cx| Buffer::local("xxx\nyyy\n", cx));
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
+ // Diff views expand all hunks, which materializes deleted rows from
+ // the base text and gives anchors in those rows `diff_base_anchor`s.
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer
+ });
multibuffer.update(cx, |multibuffer, cx| {
+ let max_point_a = buffer_a.read(cx).max_point();
+ let max_point_b = buffer_b.read(cx).max_point();
multibuffer.set_excerpts_for_path(
PathKey::sorted(0),
- buffer_1.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
+ buffer_a.clone(),
+ [Point::zero()..max_point_a],
0,
cx,
);
multibuffer.set_excerpts_for_path(
PathKey::sorted(1),
- buffer_2.clone(),
- [Point::new(0, 0)..Point::new(1, 3)],
- 0,
- cx,
- );
- });
-
- let snapshot = multibuffer.read(cx).snapshot(cx);
- assert_eq!(snapshot.text(), "aaa\nbbb\nccc\nddd");
-
- // This point is right at the start of the very first excerpt, so if we get
- // a buffer range, we should get `0..0`
- let excerpt_2_start = Point::new(2, 0);
- let expected_ranges = vec![BufferOffset(0)..BufferOffset(0)];
- let ranges = snapshot
- .range_to_buffer_ranges(excerpt_2_start..excerpt_2_start)
- .into_iter()
- .map(|tup| tup.1)
- .collect_vec();
-
- assert_eq!(
- ranges, expected_ranges,
- "Zero-length range at excerpt boundary should return the excerpt at that point"
- );
-}
-
-#[gpui::test]
-async fn test_buffer_range_to_excerpt_ranges(cx: &mut TestAppContext) {
- let base_text = indoc!(
- "
- aaa
- bbb
- ccc
- ddd
- eee
- ppp
- qqq
- rrr
- fff
- ggg
- hhh
- "
- );
- let text = indoc!(
- "
- aaa
- BBB
- ddd
- eee
- ppp
- qqq
- rrr
- FFF
- ggg
- hhh
- "
- );
-
- let buffer = cx.new(|cx| Buffer::local(text, cx));
- let diff = cx
- .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
- cx.run_until_parked();
-
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer.clone(),
- [
- Point::new(0, 0)..Point::new(3, 3),
- Point::new(7, 0)..Point::new(9, 3),
- ],
+ buffer_b.clone(),
+ [Point::zero()..max_point_b],
0,
cx,
);
- multibuffer.add_diff(diff.clone(), cx);
- multibuffer
- });
-
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
+ multibuffer.add_diff(diff_a.clone(), cx);
});
cx.run_until_parked();
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let mut anchors: Vec<Anchor> = Vec::new();
+ let mut previous_orderings: std::collections::HashMap<(usize, usize), cmp::Ordering> =
+ Default::default();
+ let mut buffer_b_present = true;
+ let mut departed_diffs: Vec<Entity<BufferDiff>> = Vec::new();
- let actual_diff = format_diff(
- &snapshot.text(),
- &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),
- &Default::default(),
- None,
- );
- let expected_diff = indoc!(
- "
- aaa
- - bbb
- - ccc
- + BBB
- ddd
- eee [\u{2193}]
- - fff [\u{2191}]
- + FFF
- ggg
- hhh [\u{2193}]"
- );
- pretty_assertions::assert_eq!(actual_diff, expected_diff);
-
- let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
-
- let query_spanning_deleted_hunk = buffer_snapshot.anchor_after(Point::new(0, 0))
- ..buffer_snapshot.anchor_before(Point::new(1, 3));
- assert_eq!(
- snapshot
- .buffer_range_to_excerpt_ranges(query_spanning_deleted_hunk)
- .map(|range| range.to_point(&snapshot))
- .collect::<Vec<_>>(),
- vec![
- Point::new(0, 0)..Point::new(1, 0),
- Point::new(3, 0)..Point::new(3, 3),
- ],
- );
+ for (step, op) in ops.iter().enumerate() {
+ match op {
+ AnchorContractOp::CreateAnchor {
+ position,
+ left_bias,
+ } => {
+ let snapshot =
+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let offset = MultiBufferOffset(snapshot.len().0 * (*position as usize) / 1000);
+ let bias = if *left_bias { Bias::Left } else { Bias::Right };
+ anchors.push(snapshot.anchor_at(offset, bias));
+ }
+ AnchorContractOp::EditBuffer { position, insert } => {
+ buffer_a.update(cx, |buffer, cx| {
+ let offset = buffer.len() * (*position as usize) / 1000;
+ if *insert || buffer.len() == 0 {
+ buffer.edit([(offset..offset, "Q\n")], None, cx);
+ } else {
+ let end = (offset + 1).min(buffer.len());
+ buffer.edit([(offset..end, "")], None, cx);
+ }
+ });
+ }
+ AnchorContractOp::ChangeBaseText { variant } => {
+ let buffer_a_text_snapshot =
+ buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
+ diff_a
+ .update(cx, |diff, cx| {
+ diff.set_base_text(
+ Some(base_text_variants[*variant].into()),
+ buffer_a_text_snapshot,
+ cx,
+ )
+ })
+ .await;
+ }
+ AnchorContractOp::RekeyPath => {
+ buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
+ diff_a = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ base_text_variants[0],
+ &buffer_a.read(cx).text_snapshot(),
+ cx,
+ )
+ });
+ // Departed diffs belong to the departed buffer; reinstalling
+ // them would no longer exercise base buffer swaps.
+ departed_diffs.clear();
+ multibuffer.update(cx, |multibuffer, cx| {
+ let max_point = buffer_a.read(cx).max_point();
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(0),
+ buffer_a.clone(),
+ [Point::zero()..max_point],
+ 0,
+ cx,
+ );
+ multibuffer.add_diff(diff_a.clone(), cx);
+ });
+ }
+ AnchorContractOp::SwapDiff { reinstall, variant } => {
+ let buffer_a_text_snapshot =
+ buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
+ let next_diff = if *reinstall && let Some(previous_diff) = departed_diffs.pop() {
+ // Recompute the reinstalled diff against the buffer's
+ // current text; its base text buffer (and so the buffer
+ // id anchors compare by) is preserved.
+ let base_text = previous_diff
+ .read_with(cx, |diff, cx| diff.base_text_string(cx))
+ .map(Arc::from);
+ previous_diff
+ .update(cx, |diff, cx| {
+ diff.set_base_text(base_text, buffer_a_text_snapshot, cx)
+ })
+ .await;
+ previous_diff
+ } else {
+ cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ base_text_variants[*variant],
+ &buffer_a_text_snapshot,
+ cx,
+ )
+ })
+ };
+ departed_diffs.push(std::mem::replace(&mut diff_a, next_diff));
+ multibuffer.update(cx, |multibuffer, cx| {
+ multibuffer.add_diff(diff_a.clone(), cx);
+ });
+ }
+ AnchorContractOp::BiasAnchor { index, right } => {
+ if !anchors.is_empty() {
+ let snapshot =
+ multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let k = (anchors.len() * (*index as usize) / 1001).min(anchors.len() - 1);
+ let rebiased = if *right {
+ anchors[k].bias_right(&snapshot)
+ } else {
+ anchors[k].bias_left(&snapshot)
+ };
+ anchors.push(rebiased);
+ }
+ }
+ AnchorContractOp::ToggleSecondBuffer => {
+ multibuffer.update(cx, |multibuffer, cx| {
+ if buffer_b_present {
+ multibuffer.remove_excerpts_for_buffer(buffer_b.read(cx).remote_id(), cx);
+ } else {
+ let max_point = buffer_b.read(cx).max_point();
+ multibuffer.set_excerpts_for_path(
+ PathKey::sorted(1),
+ buffer_b.clone(),
+ [Point::zero()..max_point],
+ 0,
+ cx,
+ );
+ }
+ });
+ buffer_b_present = !buffer_b_present;
+ }
+ }
+ cx.run_until_parked();
- let query_within_contiguous_main_buffer = buffer_snapshot.anchor_after(Point::new(1, 0))
- ..buffer_snapshot.anchor_before(Point::new(2, 3));
- assert_eq!(
- snapshot
- .buffer_range_to_excerpt_ranges(query_within_contiguous_main_buffer)
- .map(|range| range.to_point(&snapshot))
- .collect::<Vec<_>>(),
- vec![Point::new(3, 0)..Point::new(4, 3)],
- );
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ for i in 0..anchors.len() {
+ for j in i + 1..anchors.len() {
+ let ordering = anchors[i].cmp(&anchors[j], &snapshot);
+ let offset_i = anchors[i].to_offset(&snapshot);
+ let offset_j = anchors[j].to_offset(&snapshot);
+ let resolution_consistent = match ordering {
+ cmp::Ordering::Less => offset_i <= offset_j,
+ cmp::Ordering::Equal => offset_i == offset_j,
+ cmp::Ordering::Greater => offset_i >= offset_j,
+ };
+ assert!(
+ resolution_consistent,
+ "after step {step} ({op:?}), comparison contradicts resolution:\n\
+ anchor {i}: {:?}\n resolves to {offset_i:?}\n\
+ anchor {j}: {:?}\n resolves to {offset_j:?}\n\
+ but compares {ordering:?}",
+ anchors[i], anchors[j],
+ );
- let query_spanning_both_excerpts = buffer_snapshot.anchor_after(Point::new(2, 0))
- ..buffer_snapshot.anchor_before(Point::new(8, 3));
- assert_eq!(
- snapshot
- .buffer_range_to_excerpt_ranges(query_spanning_both_excerpts)
- .map(|range| range.to_point(&snapshot))
- .collect::<Vec<_>>(),
- vec![
- Point::new(4, 0)..Point::new(5, 3),
- Point::new(7, 0)..Point::new(8, 3),
- ],
- );
+ if let Some(previous) = previous_orderings.insert((i, j), ordering) {
+ let inverted = matches!(
+ (previous, ordering),
+ (cmp::Ordering::Less, cmp::Ordering::Greater)
+ | (cmp::Ordering::Greater, cmp::Ordering::Less)
+ );
+ assert!(
+ !inverted,
+ "after step {step} ({op:?}), comparison inverted over time:\n\
+ anchor {i}: {:?}\n\
+ anchor {j}: {:?}\n\
+ compared {previous:?} before this step, {ordering:?} after",
+ anchors[i], anchors[j],
+ );
+ }
+ }
+ }
+ }
}
+/// Distilled from `test_anchor_comparison_tracks_resolution`'s minimal
+/// shrunk counterexample (create anchor, re-key the path, create anchor).
+/// After a path key is reused for a different buffer, an anchor into the
+/// departed buffer sorts against anchors into the new buffer by buffer id,
+/// so resolution must land it on the matching side of the path's region:
+/// the start when the departed buffer's id is lower than the current
+/// occupant's, the end otherwise. When resolution instead ignored that
+/// order (it always chose the end), sorted-input consumers feeding
+/// comparison-sorted anchors to forward-only cursors walked backward in
+/// offset space — the "cannot seek backward" crash family (e.g. ZED-95K).
#[gpui::test]
-fn test_cannot_seek_backward_after_excerpt_replacement(cx: &mut TestAppContext) {
- let buffer_b_text: String = (0..50).map(|i| format!("line_b {i}\n")).collect();
- let buffer_b = cx.new(|cx| Buffer::local(buffer_b_text, cx));
-
- let buffer_c_text: String = (0..10).map(|i| format!("line_c {i}\n")).collect();
- let buffer_c = cx.new(|cx| Buffer::local(buffer_c_text, cx));
-
- let buffer_d_text: String = (0..10).map(|i| format!("line_d {i}\n")).collect();
- let buffer_d = cx.new(|cx| Buffer::local(buffer_d_text, cx));
-
- let path_b = PathKey::with_sort_prefix(0, rel_path("bbb.rs").into_arc());
- let path_c = PathKey::with_sort_prefix(0, rel_path("ddd.rs").into_arc());
- let path_d = PathKey::with_sort_prefix(0, rel_path("ccc.rs").into_arc());
-
+async fn test_stale_path_anchor_comparison_tracks_resolution(cx: &mut TestAppContext) {
+ let old_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
-
multibuffer.update(cx, |multibuffer, cx| {
+ let max_point = old_buffer.read(cx).max_point();
multibuffer.set_excerpts_for_path(
- path_b.clone(),
- buffer_b.clone(),
- vec![
- Point::row_range(0..3),
- Point::row_range(15..18),
- Point::row_range(30..33),
- ],
+ PathKey::sorted(0),
+ old_buffer.clone(),
+ [Point::zero()..max_point],
0,
cx,
);
});
+ let stale = multibuffer.read_with(cx, |multibuffer, cx| {
+ multibuffer
+ .snapshot(cx)
+ .anchor_at(MultiBufferOffset(0), Bias::Right)
+ });
+ let new_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
multibuffer.update(cx, |multibuffer, cx| {
+ let max_point = new_buffer.read(cx).max_point();
multibuffer.set_excerpts_for_path(
- path_c.clone(),
- buffer_c.clone(),
- vec![Point::row_range(0..3)],
+ PathKey::sorted(0),
+ new_buffer.clone(),
+ [Point::zero()..max_point],
0,
cx,
);
});
+ cx.run_until_parked();
- let (anchor_in_e_b2, anchor_in_e_b3) = multibuffer.read_with(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- let excerpt_infos = snapshot.excerpts().collect::<Vec<_>>();
- assert_eq!(excerpt_infos.len(), 4, "expected 4 excerpts (3×B + 1×C)");
-
- let e_b2_info = excerpt_infos[1].clone();
- let e_b3_info = excerpt_infos[2].clone();
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let fresh = snapshot.anchor_at(MultiBufferOffset(0), Bias::Right);
- let anchor_b2 = snapshot.anchor_in_excerpt(e_b2_info.context.start).unwrap();
- let anchor_b3 = snapshot.anchor_in_excerpt(e_b3_info.context.start).unwrap();
- (anchor_b2, anchor_b3)
- });
+ let ordering = stale.cmp(&fresh, &snapshot);
+ let stale_offset = stale.to_offset(&snapshot);
+ let fresh_offset = fresh.to_offset(&snapshot);
+ let resolution_consistent = match ordering {
+ cmp::Ordering::Less => stale_offset <= fresh_offset,
+ cmp::Ordering::Equal => stale_offset == fresh_offset,
+ cmp::Ordering::Greater => stale_offset >= fresh_offset,
+ };
+ assert!(
+ resolution_consistent,
+ "stale anchor {stale:?} resolves to {stale_offset:?} and fresh anchor {fresh:?} \
+ resolves to {fresh_offset:?}, but they compare {ordering:?}"
+ );
+}
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- path_b.clone(),
- buffer_b.clone(),
- vec![Point::row_range(0..3), Point::row_range(28..36)],
- 0,
- cx,
- );
+/// Distilled from `test_anchor_comparison_tracks_resolution`'s second
+/// shrunk counterexample. An expanded deleted hunk's phantom rows occupy
+/// its attachment anchor's tie space in the buffer's CRDT order: anchor
+/// comparison places a plain buffer anchor after the hunk's rows exactly
+/// when it sorts past the attachment anchor, which can only happen once
+/// the buffer text separating them has been deleted. Resolution must
+/// place the anchor on the same side. It used to depend on which
+/// transform the walk's cursor rested on: arriving on the deleted hunk
+/// itself applied the CRDT rule, but arriving on the preceding buffer
+/// content returned early, parking the anchor before rows it compares
+/// after — so `to_offset` and a shared-cursor `summaries_for_anchors`
+/// disagreed about the same anchor, and comparison-sorted consumers fed
+/// forward-only cursors positions that moved backward.
+#[gpui::test]
+async fn test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows(cx: &mut TestAppContext) {
+ let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";
+ let buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
+ let diff_a = cx.new(|cx| {
+ BufferDiff::new_with_base_text(base_text, &buffer_a.read(cx).text_snapshot(), cx)
+ });
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
+ multibuffer.set_all_diff_hunks_expanded(cx);
+ multibuffer
});
-
multibuffer.update(cx, |multibuffer, cx| {
+ let max_point_a = buffer_a.read(cx).max_point();
multibuffer.set_excerpts_for_path(
- path_d.clone(),
- buffer_d.clone(),
- vec![Point::row_range(0..3)],
+ PathKey::sorted(0),
+ buffer_a.clone(),
+ [Point::zero()..max_point_a],
0,
cx,
);
+ multibuffer.add_diff(diff_a.clone(), cx);
});
+ cx.run_until_parked();
- multibuffer.read_with(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- snapshot.summaries_for_anchors::<Point, _>(&[anchor_in_e_b2, anchor_in_e_b3]);
- });
-}
-
-#[gpui::test]
-fn test_resolving_max_anchor_for_buffer(cx: &mut TestAppContext) {
- let dock_base_text = indoc! {"
- 0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- "};
-
- let dock_text = indoc! {"
- 0
- 4
- 5
- 6
- 10
- 11
- 12
- "};
-
- let dock_buffer = cx.new(|cx| Buffer::local(dock_text, cx));
- let diff = cx.new(|cx| {
- BufferDiff::new_with_base_text(dock_base_text, &dock_buffer.read(cx).snapshot(), cx)
+ // Delete the first "d" (insertion offset 8), then anchor before the last
+ // "d" (insertion offset 10).
+ buffer_a.update(cx, |buffer, cx| {
+ buffer.edit([(8..9, "")], None, cx);
});
+ cx.run_until_parked();
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\ndd\n");
+ let plain_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Left);
- let workspace_text = "second buffer\n";
- let workspace_buffer = cx.new(|cx| Buffer::local(workspace_text, cx));
-
- let dock_path = PathKey::with_sort_prefix(0, rel_path("").into_arc());
- let workspace_path = PathKey::with_sort_prefix(1, rel_path("").into_arc());
+ // Recompute the diff against the edited buffer: a "-ddd/+dd" hunk
+ // appears, attached at the buffer position both anchors will collapse
+ // to. Anchor one character into its phantom "ddd" row.
+ let buffer_a_text_snapshot = buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
+ diff_a
+ .update(cx, |diff, cx| {
+ diff.set_base_text(Some(base_text.into()), buffer_a_text_snapshot, cx)
+ })
+ .await;
+ cx.run_until_parked();
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\ndd\n");
+ let hunk_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Right);
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+ assert_eq!(
+ plain_anchor.cmp(&hunk_anchor, &snapshot),
+ cmp::Ordering::Greater
+ );
+ assert_eq!(plain_anchor.to_offset(&snapshot), MultiBufferOffset(23));
+ assert_eq!(hunk_anchor.to_offset(&snapshot), MultiBufferOffset(19));
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpt_ranges_for_path(
- dock_path,
- dock_buffer.clone(),
- &dock_buffer.read(cx).snapshot(),
- vec![
- ExcerptRange::new(Point::zero()..Point::new(1, 1)),
- ExcerptRange::new(Point::new(3, 0)..Point::new(4, 2)),
- ],
- cx,
- );
- multibuffer.set_excerpt_ranges_for_path(
- workspace_path,
- workspace_buffer.clone(),
- &workspace_buffer.read(cx).snapshot(),
- vec![ExcerptRange::new(
- Point::zero()..workspace_buffer.read(cx).max_point(),
- )],
- cx,
- );
- multibuffer.add_diff(diff, cx);
- multibuffer.set_all_diff_hunks_expanded(cx);
+ // Delete the "d" separating the two anchors (insertion offset 9). Their
+ // text anchors now both collapse to the seam where the phantom row
+ // hangs, and only the CRDT order remembers which side of it each
+ // belongs on.
+ buffer_a.update(cx, |buffer, cx| {
+ buffer.edit([(8..9, "")], None, cx);
});
+ cx.run_until_parked();
+ let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\nd\n");
- let snapshot = multibuffer.update(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let diff = format_diff(
- &snapshot.text(),
- &snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>(),
- &Default::default(),
- None,
+ assert_eq!(
+ plain_anchor.cmp(&hunk_anchor, &snapshot),
+ cmp::Ordering::Greater,
+ "comparison must not change: the buffer order of the anchors is immutable"
);
assert_eq!(
- diff,
- indoc! {"
- 0
- - 1
- - 2
- - 3
- 4 [↓]
- 6 [↑]
- - 7
- - 8
- - 9
- 10 [↓]
- second buffer
- "}
+ hunk_anchor.to_offset(&snapshot),
+ MultiBufferOffset(19),
+ "the hunk-interior anchor stays one character into the phantom row"
+ );
+ assert_eq!(
+ plain_anchor.to_offset(&snapshot),
+ MultiBufferOffset(22),
+ "the plain anchor sorts past the hunk's attachment anchor, so it must \
+ resolve past the phantom rows"
+ );
+ assert_eq!(
+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&[hunk_anchor, plain_anchor]),
+ vec![MultiBufferOffset(19), MultiBufferOffset(22)],
+ "the shared-cursor batch path must agree with individual resolution"
);
+}
- multibuffer.update(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
- let point = snapshot
- .anchor_in_buffer(text::Anchor::max_for_buffer(
- dock_buffer.read(cx).remote_id(),
- ))
- .unwrap()
- .to_point(&snapshot);
- assert_eq!(point, Point::new(10, 0));
- })
+#[ctor::ctor(unsafe)]
+fn init_logger() {
+ zlog::init_test();
}
-#[gpui::test]
-fn test_is_valid_anchor_past_last_excerpt_for_buffer(cx: &mut TestAppContext) {
- let buffer_a = cx.new(|cx| Buffer::local("aaa\nbbb\nccc\n", cx));
- buffer_a.update(cx, |buffer, cx| {
- let len = buffer.len();
- buffer.edit([(len..len, "ddd\neee\n")], None, cx);
- });
- let buffer_b = cx.new(|cx| Buffer::local("xxx\n", cx));
- for line in ["yyy\n", "zzz\n", "www\n", "vvv\n"] {
- buffer_b.update(cx, |buffer, cx| {
- let len = buffer.len();
- buffer.edit([(len..len, line)], None, cx);
- });
- }
+/// A naive implementation of a multi-buffer that does not maintain
+/// any derived state, used for comparison in a randomized test.
+#[derive(Default)]
+struct ReferenceMultibuffer {
+ excerpts: Vec<ReferenceExcerpt>,
+ diffs: HashMap<BufferId, Entity<BufferDiff>>,
+ inverted_diffs: HashMap<BufferId, (Entity<BufferDiff>, Entity<language::Buffer>)>,
+ expanded_diff_hunks_by_buffer: HashMap<BufferId, Vec<text::Anchor>>,
+}
- let path_a = PathKey::with_sort_prefix(0, rel_path("aaa.rs").into_arc());
- let path_b = PathKey::with_sort_prefix(1, rel_path("bbb.rs").into_arc());
+#[derive(Clone, Debug)]
+struct ReferenceExcerpt {
+ path_key: PathKey,
+ path_key_index: PathKeyIndex,
+ buffer: Entity<Buffer>,
+ range: Range<text::Anchor>,
+}
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
+#[derive(Clone, Debug)]
+struct ReferenceRegion {
+ buffer_id: Option<BufferId>,
+ range: Range<usize>,
+ buffer_range: Range<Point>,
+ // if this is a deleted hunk, the main buffer anchor to which the deleted content is attached
+ deleted_hunk_anchor: Option<text::Anchor>,
+ status: Option<DiffHunkStatus>,
+ excerpt: Option<ReferenceExcerpt>,
+}
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.set_excerpts_for_path(
- path_a.clone(),
- buffer_a.clone(),
- vec![Point::new(1, 0)..Point::new(2, 3)],
- 0,
- cx,
- );
- multibuffer.set_excerpts_for_path(
- path_b.clone(),
- buffer_b.clone(),
- vec![Point::new(1, 0)..Point::new(3, 3)],
- 0,
- cx,
- );
- });
+impl ReferenceMultibuffer {
+ fn expand_excerpts(
+ &mut self,
+ excerpts: &HashSet<ExcerptRange<text::Anchor>>,
+ line_count: u32,
+ cx: &mut App,
+ ) {
+ use text::AnchorRangeExt as _;
- multibuffer.read_with(cx, |multibuffer, cx| {
- let snapshot = multibuffer.snapshot(cx);
+ if line_count == 0 || excerpts.is_empty() {
+ return;
+ }
- let buffer_a_snapshot = buffer_a.read(cx).snapshot();
- let anchor_past_excerpt = buffer_a_snapshot.anchor_after(Point::new(4, 0));
- let mb_anchor = snapshot.anchor_in_buffer(anchor_past_excerpt).unwrap();
+ let mut excerpts_by_buffer: HashMap<BufferId, Vec<ExcerptRange<text::Anchor>>> =
+ HashMap::default();
+ for excerpt in excerpts {
+ excerpts_by_buffer
+ .entry(excerpt.context.start.buffer_id)
+ .or_default()
+ .push(excerpt.clone())
+ }
- assert!(
- !mb_anchor.is_valid(&snapshot),
- "anchor past the last excerpt for its buffer should not be valid"
- );
- });
-}
+ for (buffer_id, excerpts_to_expand) in excerpts_by_buffer {
+ let mut buffer = None;
+ let mut buffer_snapshot = None;
+ let mut path = None;
+ let mut path_key_index = None;
+ let mut new_ranges =
+ self.excerpts
+ .iter()
+ .filter(|excerpt| excerpt.range.start.buffer_id == buffer_id)
+ .map(|excerpt| {
+ let snapshot = excerpt.buffer.read(cx).snapshot();
+ let mut range = excerpt.range.to_point(&snapshot);
+ if excerpts_to_expand.iter().any(|info| {
+ excerpt.range.contains_anchor(info.context.start, &snapshot)
+ }) {
+ range.start = Point::new(range.start.row.saturating_sub(line_count), 0);
+ range.end = snapshot
+ .clip_point(Point::new(range.end.row + line_count, 0), Bias::Left);
+ range.end.column = snapshot.line_len(range.end.row);
+ }
+ buffer = Some(excerpt.buffer.clone());
+ buffer_snapshot = Some(snapshot);
+ path = Some(excerpt.path_key.clone());
+ path_key_index = Some(excerpt.path_key_index);
+ ExcerptRange::new(range)
+ })
+ .collect::<Vec<_>>();
-/// The contract between anchor comparison and anchor resolution that every
-/// sorted-input consumer relies on (`summaries_for_anchors*`, forward-only
-/// cursors, and persistent trees ordered by anchor comparison such as the
-/// editor's fold tree):
-///
-/// 1. Within one snapshot, comparison tracks resolution: if `a.cmp(b)` is
-/// `Less`, `a` must not resolve after `b`, and anchors that compare
-/// `Equal` must resolve to the same offset.
-/// 2. Across structural changes (edits, diff base text changes, a path key
-/// reused for a different buffer, buffers leaving), a pair's comparison
-/// never inverts: `Less` may weaken to `Equal`, but must not become
-/// `Greater`. (Even the collapse to `Equal` is hazardous for consumers
-/// that sort ranges with end tie-breaks, but it is tolerated here so
-/// that outright inversions stay visible.)
-///
-/// Shrinking yields a minimal operation sequence for whichever violating
-/// mechanism it finds. Mechanisms found so far, each fixed and pinned by a
-/// distilled test:
-/// - stale-path anchors sorted by buffer id but resolved to the end of
-/// their path's region
-/// (`test_stale_path_anchor_comparison_tracks_resolution`);
-/// - diff base anchors' validity filter flipping comparison results when a
-/// base text edit deleted the region one anchor of a pair pointed into
-/// (`test_folds_stay_sorted_when_diff_base_text_replaced` in the
-/// editor's block_map tests);
-/// - plain anchors resolved before phantom deleted-hunk rows they compare
-/// after (`test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows`).
-#[gpui::property_test(config = proptest::prelude::ProptestConfig {
- failure_persistence: Some(Box::new(
- proptest::test_runner::FileFailurePersistence::WithSource("proptest-regressions"),
- )),
- ..Default::default()
-})]
-async fn test_anchor_comparison_tracks_resolution(
- cx: &mut TestAppContext,
- #[strategy = proptest::collection::vec(proptest::prelude::any::<AnchorContractOp>(), 1..16)]
- ops: Vec<AnchorContractOp>,
-) {
- let base_text_variants = [
- "DEL1\nDEL2\nbbb\nccc\nddd\n",
- "DEL1\nbbb\nccc\nddd\n",
- "DEL2\nbbb\nccc\nddd\n",
- "bbb\nccc\nddd\n",
- ];
+ new_ranges.sort_by_key(|nr| nr.context.start);
- let mut buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
- let mut diff_a = cx.new(|cx| {
- BufferDiff::new_with_base_text(
- base_text_variants[0],
- &buffer_a.read(cx).text_snapshot(),
- cx,
- )
- });
- let buffer_b = cx.new(|cx| Buffer::local("xxx\nyyy\n", cx));
- let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
- // Diff views expand all hunks, which materializes deleted rows from
- // the base text and gives anchors in those rows `diff_base_anchor`s.
- multibuffer.set_all_diff_hunks_expanded(cx);
- multibuffer
- });
- multibuffer.update(cx, |multibuffer, cx| {
- let max_point_a = buffer_a.read(cx).max_point();
- let max_point_b = buffer_b.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_a.clone(),
- [Point::zero()..max_point_a],
- 0,
- cx,
- );
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_b.clone(),
- [Point::zero()..max_point_b],
- 0,
- cx,
+ self.set_excerpts(
+ path.unwrap(),
+ path_key_index.unwrap(),
+ buffer.unwrap(),
+ &buffer_snapshot.unwrap(),
+ new_ranges,
+ cx,
+ );
+ }
+ }
+
+ fn set_excerpts(
+ &mut self,
+ path_key: PathKey,
+ path_key_index: PathKeyIndex,
+ buffer: Entity<Buffer>,
+ buffer_snapshot: &BufferSnapshot,
+ ranges: Vec<ExcerptRange<Point>>,
+ cx: &mut App,
+ ) {
+ self.excerpts.retain(|excerpt| {
+ excerpt.path_key != path_key && excerpt.buffer.entity_id() != buffer.entity_id()
+ });
+
+ let ranges = MultiBuffer::merge_excerpt_ranges(&ranges);
+
+ let (Ok(ix) | Err(ix)) = self
+ .excerpts
+ .binary_search_by(|probe| probe.path_key.cmp(&path_key));
+ self.excerpts.splice(
+ ix..ix,
+ ranges.into_iter().map(|range| ReferenceExcerpt {
+ path_key: path_key.clone(),
+ path_key_index,
+ buffer: buffer.clone(),
+ range: buffer_snapshot.anchor_before(range.context.start)
+ ..buffer_snapshot.anchor_after(range.context.end),
+ }),
);
- multibuffer.add_diff(diff_a.clone(), cx);
- });
- cx.run_until_parked();
+ self.update_expanded_diff_hunks_for_buffer(buffer_snapshot.remote_id(), cx);
+ }
- let mut anchors: Vec<Anchor> = Vec::new();
- let mut previous_orderings: std::collections::HashMap<(usize, usize), cmp::Ordering> =
- Default::default();
- let mut buffer_b_present = true;
- let mut departed_diffs: Vec<Entity<BufferDiff>> = Vec::new();
+ fn expand_diff_hunks(&mut self, path_key: PathKey, range: Range<text::Anchor>, cx: &App) {
+ let excerpt = self
+ .excerpts
+ .iter_mut()
+ .find(|e| {
+ e.path_key == path_key
+ && e.range
+ .start
+ .cmp(&range.start, &e.buffer.read(cx).snapshot())
+ .is_le()
+ && e.range
+ .end
+ .cmp(&range.end, &e.buffer.read(cx).snapshot())
+ .is_ge()
+ })
+ .unwrap();
+ let buffer = excerpt.buffer.read(cx).snapshot();
+ let buffer_id = buffer.remote_id();
- for (step, op) in ops.iter().enumerate() {
- match op {
- AnchorContractOp::CreateAnchor {
- position,
- left_bias,
- } => {
- let snapshot =
- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let offset = MultiBufferOffset(snapshot.len().0 * (*position as usize) / 1000);
- let bias = if *left_bias { Bias::Left } else { Bias::Right };
- anchors.push(snapshot.anchor_at(offset, bias));
+ // Skip inverted excerpts - hunks are always expanded
+ if self.inverted_diffs.contains_key(&buffer_id) {
+ return;
+ }
+
+ let Some(diff) = self.diffs.get(&buffer_id) else {
+ return;
+ };
+ let excerpt_range = excerpt.range.to_point(&buffer);
+ let expanded_diff_hunks = self
+ .expanded_diff_hunks_by_buffer
+ .entry(buffer_id)
+ .or_default();
+ for hunk in diff
+ .read(cx)
+ .snapshot(cx)
+ .hunks_intersecting_range(range, &buffer)
+ {
+ let hunk_range = hunk.buffer_range.to_point(&buffer);
+ if hunk_range.start < excerpt_range.start || hunk_range.start > excerpt_range.end {
+ continue;
}
- AnchorContractOp::EditBuffer { position, insert } => {
- buffer_a.update(cx, |buffer, cx| {
- let offset = buffer.len() * (*position as usize) / 1000;
- if *insert || buffer.len() == 0 {
- buffer.edit([(offset..offset, "Q\n")], None, cx);
- } else {
- let end = (offset + 1).min(buffer.len());
- buffer.edit([(offset..end, "")], None, cx);
- }
- });
- }
- AnchorContractOp::ChangeBaseText { variant } => {
- let buffer_a_text_snapshot =
- buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
- diff_a
- .update(cx, |diff, cx| {
- diff.set_base_text(
- Some(base_text_variants[*variant].into()),
- buffer_a_text_snapshot,
- cx,
- )
- })
- .await;
+ if let Err(ix) = expanded_diff_hunks
+ .binary_search_by(|anchor| anchor.cmp(&hunk.buffer_range.start, &buffer))
+ {
+ log::info!(
+ "expanding diff hunk {:?}. excerpt range: {:?}, buffer {:?}",
+ hunk_range,
+ excerpt_range,
+ buffer.remote_id()
+ );
+ expanded_diff_hunks.insert(ix, hunk.buffer_range.start);
+ } else {
+ log::trace!("hunk {hunk_range:?} already expanded in excerpt");
}
- AnchorContractOp::RekeyPath => {
- buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
- diff_a = cx.new(|cx| {
- BufferDiff::new_with_base_text(
- base_text_variants[0],
- &buffer_a.read(cx).text_snapshot(),
- cx,
- )
- });
- // Departed diffs belong to the departed buffer; reinstalling
- // them would no longer exercise base buffer swaps.
- departed_diffs.clear();
- multibuffer.update(cx, |multibuffer, cx| {
- let max_point = buffer_a.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_a.clone(),
- [Point::zero()..max_point],
- 0,
- cx,
- );
- multibuffer.add_diff(diff_a.clone(), cx);
+ }
+ }
+
+ fn expected_content(
+ &self,
+ cx: &App,
+ ) -> (
+ String,
+ Vec<RowInfo>,
+ HashSet<MultiBufferRow>,
+ Vec<ReferenceRegion>,
+ ) {
+ use util::maybe;
+
+ let mut text = String::new();
+ let mut regions = Vec::<ReferenceRegion>::new();
+ let mut excerpt_boundary_rows = HashSet::default();
+ for excerpt in &self.excerpts {
+ excerpt_boundary_rows.insert(MultiBufferRow(text.matches('\n').count() as u32));
+ let buffer = excerpt.buffer.read(cx);
+ let buffer_id = buffer.remote_id();
+ let buffer_range = excerpt.range.to_offset(buffer);
+
+ if let Some((diff, main_buffer)) = self.inverted_diffs.get(&buffer_id) {
+ let diff_snapshot = diff.read(cx).snapshot(cx);
+ let main_buffer_snapshot = main_buffer.read(cx).snapshot();
+
+ let mut offset = buffer_range.start;
+ for hunk in diff_snapshot.hunks_intersecting_base_text_range(
+ buffer_range.clone(),
+ &main_buffer_snapshot.text,
+ ) {
+ let mut hunk_base_range = hunk.diff_base_byte_range.clone();
+
+ hunk_base_range.end = hunk_base_range.end.min(buffer_range.end);
+ if hunk_base_range.start > buffer_range.end
+ || hunk_base_range.start < buffer_range.start
+ {
+ continue;
+ }
+
+ // Add the text before the hunk
+ if hunk_base_range.start >= offset {
+ let len = text.len();
+ text.extend(buffer.text_for_range(offset..hunk_base_range.start));
+ if text.len() > len {
+ regions.push(ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range: len..text.len(),
+ buffer_range: (offset..hunk_base_range.start).to_point(&buffer),
+ status: None,
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
+ });
+ }
+ }
+
+ // Add the "deleted" region (base text that's not in main)
+ if !hunk_base_range.is_empty() {
+ let len = text.len();
+ text.extend(buffer.text_for_range(hunk_base_range.clone()));
+ regions.push(ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range: len..text.len(),
+ buffer_range: hunk_base_range.to_point(&buffer),
+ status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
+ });
+ }
+
+ offset = hunk_base_range.end;
+ }
+
+ // Add remaining buffer text
+ let len = text.len();
+ text.extend(buffer.text_for_range(offset..buffer_range.end));
+ text.push('\n');
+ regions.push(ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range: len..text.len(),
+ buffer_range: (offset..buffer_range.end).to_point(&buffer),
+ status: None,
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
});
- }
- AnchorContractOp::SwapDiff { reinstall, variant } => {
- let buffer_a_text_snapshot =
- buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
- let next_diff = if *reinstall && let Some(previous_diff) = departed_diffs.pop() {
- // Recompute the reinstalled diff against the buffer's
- // current text; its base text buffer (and so the buffer
- // id anchors compare by) is preserved.
- let base_text = previous_diff
- .read_with(cx, |diff, cx| diff.base_text_string(cx))
- .map(Arc::from);
- previous_diff
- .update(cx, |diff, cx| {
- diff.set_base_text(base_text, buffer_a_text_snapshot, cx)
+ } else {
+ let diff = self.diffs.get(&buffer_id).unwrap().read(cx).snapshot(cx);
+ let base_buffer = diff.base_text();
+
+ let mut offset = buffer_range.start;
+ let hunks = diff
+ .hunks_intersecting_range(excerpt.range.clone(), buffer)
+ .peekable();
+
+ for hunk in hunks {
+ // Ignore hunks that are outside the excerpt range.
+ let mut hunk_range = hunk.buffer_range.to_offset(buffer);
+
+ hunk_range.end = hunk_range.end.min(buffer_range.end);
+ if hunk_range.start > buffer_range.end || hunk_range.start < buffer_range.start
+ {
+ log::trace!("skipping hunk outside excerpt range");
+ continue;
+ }
+
+ if !self
+ .expanded_diff_hunks_by_buffer
+ .get(&buffer_id)
+ .cloned()
+ .into_iter()
+ .flatten()
+ .any(|expanded_anchor| {
+ expanded_anchor
+ .cmp(&hunk.buffer_range.start, buffer)
+ .is_eq()
})
- .await;
- previous_diff
- } else {
- cx.new(|cx| {
- BufferDiff::new_with_base_text(
- base_text_variants[*variant],
- &buffer_a_text_snapshot,
- cx,
- )
- })
- };
- departed_diffs.push(std::mem::replace(&mut diff_a, next_diff));
- multibuffer.update(cx, |multibuffer, cx| {
- multibuffer.add_diff(diff_a.clone(), cx);
- });
- }
- AnchorContractOp::BiasAnchor { index, right } => {
- if !anchors.is_empty() {
- let snapshot =
- multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let k = (anchors.len() * (*index as usize) / 1001).min(anchors.len() - 1);
- let rebiased = if *right {
- anchors[k].bias_right(&snapshot)
- } else {
- anchors[k].bias_left(&snapshot)
- };
- anchors.push(rebiased);
- }
- }
- AnchorContractOp::ToggleSecondBuffer => {
- multibuffer.update(cx, |multibuffer, cx| {
- if buffer_b_present {
- multibuffer.remove_excerpts_for_buffer(buffer_b.read(cx).remote_id(), cx);
- } else {
- let max_point = buffer_b.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(1),
- buffer_b.clone(),
- [Point::zero()..max_point],
- 0,
- cx,
- );
+ {
+ log::trace!("skipping a hunk that's not marked as expanded");
+ continue;
}
- });
- buffer_b_present = !buffer_b_present;
- }
- }
- cx.run_until_parked();
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- for i in 0..anchors.len() {
- for j in i + 1..anchors.len() {
- let ordering = anchors[i].cmp(&anchors[j], &snapshot);
- let offset_i = anchors[i].to_offset(&snapshot);
- let offset_j = anchors[j].to_offset(&snapshot);
- let resolution_consistent = match ordering {
- cmp::Ordering::Less => offset_i <= offset_j,
- cmp::Ordering::Equal => offset_i == offset_j,
- cmp::Ordering::Greater => offset_i >= offset_j,
- };
+ if !hunk.buffer_range.start.is_valid(buffer) {
+ log::trace!("skipping hunk with deleted start: {:?}", hunk.range);
+ continue;
+ }
+
+ if hunk_range.start >= offset {
+ // Add the buffer text before the hunk
+ let len = text.len();
+ text.extend(buffer.text_for_range(offset..hunk_range.start));
+ if text.len() > len {
+ regions.push(ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range: len..text.len(),
+ buffer_range: (offset..hunk_range.start).to_point(&buffer),
+ status: None,
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
+ });
+ }
+
+ // Add the deleted text for the hunk.
+ if !hunk.diff_base_byte_range.is_empty() {
+ let mut base_text = base_buffer
+ .text_for_range(hunk.diff_base_byte_range.clone())
+ .collect::<String>();
+ if !base_text.ends_with('\n') {
+ base_text.push('\n');
+ }
+ let len = text.len();
+ text.push_str(&base_text);
+ regions.push(ReferenceRegion {
+ buffer_id: Some(base_buffer.remote_id()),
+ range: len..text.len(),
+ buffer_range: hunk.diff_base_byte_range.to_point(&base_buffer),
+ status: Some(DiffHunkStatus::deleted(hunk.secondary_status)),
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: Some(hunk.buffer_range.start),
+ });
+ }
+
+ offset = hunk_range.start;
+ }
+
+ // Add the inserted text for the hunk.
+ if hunk_range.end > offset {
+ let len = text.len();
+ text.extend(buffer.text_for_range(offset..hunk_range.end));
+ let range = len..text.len();
+ let region = ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range,
+ buffer_range: (offset..hunk_range.end).to_point(&buffer),
+ status: Some(DiffHunkStatus::added(hunk.secondary_status)),
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
+ };
+ offset = hunk_range.end;
+ regions.push(region);
+ }
+ }
+
+ // Add the buffer text for the rest of the excerpt.
+ let len = text.len();
+ text.extend(buffer.text_for_range(offset..buffer_range.end));
+ text.push('\n');
+ regions.push(ReferenceRegion {
+ buffer_id: Some(buffer_id),
+ range: len..text.len(),
+ buffer_range: (offset..buffer_range.end).to_point(&buffer),
+ status: None,
+ excerpt: Some(excerpt.clone()),
+ deleted_hunk_anchor: None,
+ });
+ }
+ }
+
+ // Remove final trailing newline.
+ if self.excerpts.is_empty() {
+ regions.push(ReferenceRegion {
+ buffer_id: None,
+ range: 0..1,
+ buffer_range: Point::new(0, 0)..Point::new(0, 1),
+ status: None,
+ excerpt: None,
+ deleted_hunk_anchor: None,
+ });
+ } else {
+ text.pop();
+ let region = regions.last_mut().unwrap();
+ assert!(region.deleted_hunk_anchor.is_none());
+ region.range.end -= 1;
+ }
+
+ // Retrieve the row info using the region that contains
+ // the start of each multi-buffer line.
+ let mut ix = 0;
+ let row_infos = text
+ .split('\n')
+ .map(|line| {
+ let row_info = regions
+ .iter()
+ .rposition(|region| {
+ region.range.contains(&ix) || (ix == text.len() && ix == region.range.end)
+ })
+ .map_or(RowInfo::default(), |region_ix| {
+ let region = regions[region_ix].clone();
+ let buffer_row = region.buffer_range.start.row
+ + text[region.range.start..ix].matches('\n').count() as u32;
+ let main_buffer = region.excerpt.as_ref().map(|e| e.buffer.clone());
+ let excerpt_range = region.excerpt.as_ref().map(|e| &e.range);
+ let is_excerpt_start = region_ix == 0
+ || regions[region_ix - 1].excerpt.as_ref().map(|e| &e.range)
+ != excerpt_range
+ || regions[region_ix - 1].range.is_empty();
+ let mut is_excerpt_end = region_ix == regions.len() - 1
+ || regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)
+ != excerpt_range;
+ let is_start = !text[region.range.start..ix].contains('\n');
+ let is_last_region = region_ix == regions.len() - 1;
+ let mut is_end = if region.range.end > text.len() {
+ !text[ix..].contains('\n')
+ } else {
+ let remaining_newlines = text[ix..region.range.end.min(text.len())]
+ .matches('\n')
+ .count();
+ remaining_newlines == if is_last_region { 0 } else { 1 }
+ };
+ if region_ix < regions.len() - 1
+ && !text[ix..].contains("\n")
+ && (region.status == Some(DiffHunkStatus::added_none())
+ || region.status.is_some_and(|s| s.is_deleted()))
+ && regions[region_ix + 1].excerpt.as_ref().map(|e| &e.range)
+ == excerpt_range
+ && regions[region_ix + 1].range.start == text.len()
+ {
+ is_end = true;
+ is_excerpt_end = true;
+ }
+ let multibuffer_row =
+ MultiBufferRow(text[..ix].matches('\n').count() as u32);
+ let mut expand_direction = None;
+ if let Some(buffer) = &main_buffer {
+ let needs_expand_up = is_excerpt_start && is_start && buffer_row > 0;
+ let needs_expand_down = is_excerpt_end
+ && is_end
+ && buffer.read(cx).max_point().row > buffer_row;
+ expand_direction = if needs_expand_up && needs_expand_down {
+ Some(ExpandExcerptDirection::UpAndDown)
+ } else if needs_expand_up {
+ Some(ExpandExcerptDirection::Up)
+ } else if needs_expand_down {
+ Some(ExpandExcerptDirection::Down)
+ } else {
+ None
+ };
+ }
+ RowInfo {
+ buffer_id: region.buffer_id,
+ diff_status: region.status,
+ buffer_row: Some(buffer_row),
+ wrapped_buffer_row: None,
+
+ multibuffer_row: Some(multibuffer_row),
+ expand_info: maybe!({
+ let direction = expand_direction?;
+ let excerpt = region.excerpt.as_ref()?;
+ Some(ExpandInfo {
+ direction,
+ start_anchor: Anchor::in_buffer(
+ excerpt.path_key_index,
+ excerpt.range.start,
+ ),
+ })
+ }),
+ }
+ });
+ ix += line.len() + 1;
+ row_info
+ })
+ .collect();
+
+ (text, row_infos, excerpt_boundary_rows, regions)
+ }
+
+ fn diffs_updated(&mut self, cx: &mut App) {
+ let buffer_ids = self.diffs.keys().copied().collect::<Vec<_>>();
+ for buffer_id in buffer_ids {
+ self.update_expanded_diff_hunks_for_buffer(buffer_id, cx);
+ }
+ }
+
+ fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut App) {
+ let buffer_id = diff.read(cx).buffer_id;
+ self.diffs.insert(buffer_id, diff);
+ }
+
+ fn add_inverted_diff(
+ &mut self,
+ diff: Entity<BufferDiff>,
+ main_buffer: Entity<language::Buffer>,
+ cx: &App,
+ ) {
+ let base_text_buffer_id = diff.read(cx).base_text(cx).remote_id();
+ self.inverted_diffs
+ .insert(base_text_buffer_id, (diff, main_buffer));
+ }
+
+ fn update_expanded_diff_hunks_for_buffer(&mut self, buffer_id: BufferId, cx: &mut App) {
+ let excerpts = self
+ .excerpts
+ .iter()
+ .filter(|excerpt| excerpt.buffer.read(cx).remote_id() == buffer_id)
+ .collect::<Vec<_>>();
+ let Some(buffer) = excerpts.first().map(|excerpt| excerpt.buffer.clone()) else {
+ self.expanded_diff_hunks_by_buffer.remove(&buffer_id);
+ return;
+ };
+ let buffer_snapshot = buffer.read(cx).snapshot();
+ let Some(diff) = self.diffs.get(&buffer_id) else {
+ self.expanded_diff_hunks_by_buffer.remove(&buffer_id);
+ return;
+ };
+ let diff = diff.read(cx).snapshot(cx);
+ let hunks = diff
+ .hunks_in_row_range(0..u32::MAX, &buffer_snapshot)
+ .collect::<Vec<_>>();
+ self.expanded_diff_hunks_by_buffer
+ .entry(buffer_id)
+ .or_default()
+ .retain(|hunk_anchor| {
+ if !hunk_anchor.is_valid(&buffer_snapshot) {
+ return false;
+ }
+
+ let Ok(ix) = hunks.binary_search_by(|hunk| {
+ hunk.buffer_range.start.cmp(hunk_anchor, &buffer_snapshot)
+ }) else {
+ return false;
+ };
+ let hunk_range = hunks[ix].buffer_range.to_point(&buffer_snapshot);
+ excerpts.iter().any(|excerpt| {
+ let excerpt_range = excerpt.range.to_point(&buffer_snapshot);
+ hunk_range.start >= excerpt_range.start && hunk_range.start <= excerpt_range.end
+ })
+ });
+ }
+
+ fn anchor_to_offset(&self, anchor: &Anchor, cx: &App) -> Option<MultiBufferOffset> {
+ if anchor.diff_base_anchor().is_some() {
+ panic!("reference multibuffer cannot yet resolve anchors inside deleted hunks");
+ }
+ let (anchor, snapshot, path_key) = self.anchor_to_buffer_anchor(anchor, cx)?;
+ // TODO(cole) can maybe make this and expected content call a common function instead
+ let (text, _, _, regions) = self.expected_content(cx);
+
+ // Locate the first region that contains or is past the putative location of the buffer anchor
+ let ix = regions.partition_point(|region| {
+ let excerpt = region
+ .excerpt
+ .as_ref()
+ .expect("should have no buffers in empty reference multibuffer");
+ excerpt
+ .path_key
+ .cmp(&path_key)
+ .then_with(|| {
+ if excerpt.range.end.cmp(&anchor, &snapshot).is_lt() {
+ Ordering::Less
+ } else if excerpt.range.start.cmp(&anchor, &snapshot).is_gt() {
+ Ordering::Greater
+ } else {
+ Ordering::Equal
+ }
+ })
+ .then_with(|| {
+ if let Some(deleted_hunk_anchor) = region.deleted_hunk_anchor {
+ deleted_hunk_anchor.cmp(&anchor, &snapshot)
+ } else {
+ let point = anchor.to_point(&snapshot);
+ assert_eq!(region.buffer_id, Some(snapshot.remote_id()));
+ if region.buffer_range.end < point {
+ Ordering::Less
+ } else if region.buffer_range.start > point {
+ Ordering::Greater
+ } else {
+ Ordering::Equal
+ }
+ }
+ })
+ .is_lt()
+ });
+
+ let Some(region) = regions.get(ix) else {
+ return Some(MultiBufferOffset(text.len()));
+ };
+
+ let offset = if region.buffer_id == Some(snapshot.remote_id()) {
+ let buffer_offset = anchor.to_offset(&snapshot);
+ let buffer_range = region.buffer_range.to_offset(&snapshot);
+ assert!(buffer_offset <= buffer_range.end);
+ let overshoot = buffer_offset.saturating_sub(buffer_range.start);
+ region.range.start + overshoot
+ } else {
+ region.range.start
+ };
+ Some(MultiBufferOffset(offset))
+ }
+
+ fn anchor_to_buffer_anchor(
+ &self,
+ anchor: &Anchor,
+ cx: &App,
+ ) -> Option<(text::Anchor, BufferSnapshot, PathKey)> {
+ let (excerpt, anchor) = match anchor {
+ Anchor::Min => {
+ let excerpt = self.excerpts.first()?;
+ (excerpt, excerpt.range.start)
+ }
+ Anchor::Excerpt(excerpt_anchor) => (
+ self.excerpts.iter().find(|excerpt| {
+ excerpt.buffer.read(cx).remote_id() == excerpt_anchor.buffer_id()
+ })?,
+ excerpt_anchor.text_anchor,
+ ),
+ Anchor::Max => {
+ let excerpt = self.excerpts.last()?;
+ (excerpt, excerpt.range.end)
+ }
+ };
+
+ Some((
+ anchor,
+ excerpt.buffer.read(cx).snapshot(),
+ excerpt.path_key.clone(),
+ ))
+ }
+}
+
+fn mutate_excerpt_ranges(
+ rng: &mut StdRng,
+ existing_ranges: &mut Vec<Range<Point>>,
+ buffer: &BufferSnapshot,
+ operations: u32,
+) {
+ let mut ranges_to_add = Vec::new();
+
+ for _ in 0..operations {
+ match rng.random_range(0..5) {
+ 0..=1 if !existing_ranges.is_empty() => {
+ let index = rng.random_range(0..existing_ranges.len());
+ log::info!("Removing excerpt at index {index}");
+ existing_ranges.remove(index);
+ }
+ _ => {
+ let end_row = rng.random_range(0..=buffer.max_point().row);
+ let start_row = rng.random_range(0..=end_row);
+ let end_col = buffer.line_len(end_row);
+ log::info!(
+ "Inserting excerpt for buffer {:?}, row range {:?}",
+ buffer.remote_id(),
+ start_row..end_row
+ );
+ ranges_to_add.push(Point::new(start_row, 0)..Point::new(end_row, end_col));
+ }
+ }
+ }
+
+ existing_ranges.extend(ranges_to_add);
+ existing_ranges.sort_by_key(|r| r.start);
+}
+
+fn check_multibuffer(
+ multibuffer: &MultiBuffer,
+ reference: &ReferenceMultibuffer,
+ anchors: &[Anchor],
+ cx: &App,
+ rng: &mut StdRng,
+) {
+ let snapshot = multibuffer.snapshot(cx);
+ let actual_text = snapshot.text();
+ let actual_boundary_rows = snapshot
+ .excerpt_boundaries_in_range(MultiBufferOffset(0)..)
+ .map(|b| b.row)
+ .collect::<HashSet<_>>();
+ let actual_row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
+
+ let anchors_to_check = anchors
+ .iter()
+ .filter_map(|anchor| {
+ snapshot
+ .anchor_to_buffer_anchor(*anchor)
+ .map(|(anchor, _)| anchor)
+ })
+ // Intentionally mix in some anchors that are (in general) not contained in any excerpt
+ .chain(
+ reference
+ .excerpts
+ .iter()
+ .map(|excerpt| excerpt.buffer.read(cx).remote_id())
+ .dedup()
+ .flat_map(|buffer_id| {
+ [
+ text::Anchor::min_for_buffer(buffer_id),
+ text::Anchor::max_for_buffer(buffer_id),
+ ]
+ }),
+ )
+ .map(|anchor| snapshot.anchor_in_buffer(anchor).unwrap())
+ .collect::<Vec<_>>();
+
+ let (expected_text, expected_row_infos, expected_boundary_rows, _) =
+ reference.expected_content(cx);
+ let expected_anchor_offsets = anchors_to_check
+ .iter()
+ .map(|anchor| reference.anchor_to_offset(anchor, cx).unwrap())
+ .collect::<Vec<_>>();
+
+ let has_diff = actual_row_infos
+ .iter()
+ .any(|info| info.diff_status.is_some())
+ || expected_row_infos
+ .iter()
+ .any(|info| info.diff_status.is_some());
+ let actual_diff = format_diff(
+ &actual_text,
+ &actual_row_infos,
+ &actual_boundary_rows,
+ Some(has_diff),
+ );
+ let expected_diff = format_diff(
+ &expected_text,
+ &expected_row_infos,
+ &expected_boundary_rows,
+ Some(has_diff),
+ );
+
+ log::info!("Multibuffer content:\n{}", actual_diff);
+
+ assert_eq!(
+ actual_row_infos.len(),
+ actual_text.split('\n').count(),
+ "line count: {}",
+ actual_text.split('\n').count()
+ );
+ pretty_assertions::assert_eq!(actual_diff, expected_diff);
+ pretty_assertions::assert_eq!(actual_text, expected_text);
+ pretty_assertions::assert_eq!(actual_row_infos, expected_row_infos);
+
+ for _ in 0..5 {
+ let start_row = rng.random_range(0..=expected_row_infos.len());
+ assert_eq!(
+ snapshot
+ .row_infos(MultiBufferRow(start_row as u32))
+ .collect::<Vec<_>>(),
+ &expected_row_infos[start_row..],
+ "buffer_rows({})",
+ start_row
+ );
+ }
+
+ assert_eq!(
+ snapshot.widest_line_number(),
+ expected_row_infos
+ .into_iter()
+ .filter_map(|info| {
+ // For inverted diffs, deleted rows are visible and should be counted.
+ // Only filter out deleted rows that are NOT from inverted diffs.
+ let is_inverted_diff = info
+ .buffer_id
+ .is_some_and(|id| reference.inverted_diffs.contains_key(&id));
+ if info.diff_status.is_some_and(|status| status.is_deleted()) && !is_inverted_diff {
+ None
+ } else {
+ info.buffer_row
+ }
+ })
+ .max()
+ .unwrap()
+ + 1
+ );
+ for i in 0..snapshot.len().0 {
+ let (_, excerpt_range) = snapshot
+ .excerpt_containing(MultiBufferOffset(i)..MultiBufferOffset(i))
+ .unwrap();
+ reference
+ .excerpts
+ .iter()
+ .find(|reference_excerpt| reference_excerpt.range == excerpt_range.context)
+ .expect("corresponding excerpt should exist in reference multibuffer");
+ }
+
+ assert_consistent_line_numbers(&snapshot);
+ assert_position_translation(&snapshot);
+
+ for (row, line) in expected_text.split('\n').enumerate() {
+ assert_eq!(
+ snapshot.line_len(MultiBufferRow(row as u32)),
+ line.len() as u32,
+ "line_len({}).",
+ row
+ );
+ }
+
+ let text_rope = Rope::from(expected_text.as_str());
+ for _ in 0..10 {
+ let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
+ let start_ix = text_rope.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
+
+ let text_for_range = snapshot
+ .text_for_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
+ .collect::<String>();
+ assert_eq!(
+ text_for_range,
+ &expected_text[start_ix..end_ix],
+ "incorrect text for range {:?}",
+ start_ix..end_ix
+ );
+
+ let expected_summary =
+ MBTextSummary::from(TextSummary::from(&expected_text[start_ix..end_ix]));
+ assert_eq!(
+ snapshot.text_summary_for_range::<MBTextSummary, _>(
+ MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix)
+ ),
+ expected_summary,
+ "incorrect summary for range {:?}",
+ start_ix..end_ix
+ );
+ }
+
+ // Anchor resolution
+ let summaries = snapshot.summaries_for_anchors::<MultiBufferOffset, _>(anchors);
+ assert_eq!(anchors.len(), summaries.len());
+ for (anchor, resolved_offset) in anchors.iter().zip(summaries) {
+ assert!(resolved_offset <= snapshot.len());
+ assert_eq!(
+ snapshot.summary_for_anchor::<MultiBufferOffset>(anchor),
+ resolved_offset,
+ "anchor: {:?}",
+ anchor
+ );
+ }
+
+ let actual_anchor_offsets = anchors_to_check
+ .into_iter()
+ .map(|anchor| anchor.to_offset(&snapshot))
+ .collect::<Vec<_>>();
+ assert_eq!(
+ actual_anchor_offsets, expected_anchor_offsets,
+ "buffer anchor resolves to wrong offset"
+ );
+
+ for _ in 0..10 {
+ let end_ix = text_rope.clip_offset(rng.random_range(0..=text_rope.len()), Bias::Right);
+ assert_eq!(
+ snapshot
+ .reversed_chars_at(MultiBufferOffset(end_ix))
+ .collect::<String>(),
+ expected_text[..end_ix].chars().rev().collect::<String>(),
+ );
+ }
+
+ for _ in 0..10 {
+ let end_ix = rng.random_range(0..=text_rope.len());
+ let end_ix = text_rope.floor_char_boundary(end_ix);
+ let start_ix = rng.random_range(0..=end_ix);
+ let start_ix = text_rope.floor_char_boundary(start_ix);
+ assert_eq!(
+ snapshot
+ .bytes_in_range(MultiBufferOffset(start_ix)..MultiBufferOffset(end_ix))
+ .flatten()
+ .copied()
+ .collect::<Vec<_>>(),
+ expected_text.as_bytes()[start_ix..end_ix].to_vec(),
+ "bytes_in_range({:?})",
+ start_ix..end_ix,
+ );
+ }
+}
+
+fn check_multibuffer_edits(
+ snapshot: &MultiBufferSnapshot,
+ old_snapshot: &MultiBufferSnapshot,
+ subscription: Subscription<MultiBufferOffset>,
+) {
+ let edits = subscription.consume().into_inner();
+
+ log::info!(
+ "applying subscription edits to old text: {:?}: {:#?}",
+ old_snapshot.text(),
+ edits,
+ );
+
+ let mut text = old_snapshot.text();
+ for edit in edits {
+ let new_text: String = snapshot
+ .text_for_range(edit.new.start..edit.new.end)
+ .collect();
+ text.replace_range(
+ (edit.new.start.0..edit.new.start.0 + (edit.old.end.0 - edit.old.start.0)).clone(),
+ &new_text,
+ );
+ pretty_assertions::assert_eq!(
+ &text[0..edit.new.end.0],
+ snapshot
+ .text_for_range(MultiBufferOffset(0)..edit.new.end)
+ .collect::<String>()
+ );
+ }
+ pretty_assertions::assert_eq!(text, snapshot.text());
+}
+
+fn format_diff(
+ text: &str,
+ row_infos: &Vec<RowInfo>,
+ boundary_rows: &HashSet<MultiBufferRow>,
+ has_diff: Option<bool>,
+) -> String {
+ let has_diff =
+ has_diff.unwrap_or_else(|| row_infos.iter().any(|info| info.diff_status.is_some()));
+ text.split('\n')
+ .enumerate()
+ .zip(row_infos)
+ .map(|((ix, line), info)| {
+ let marker = match info.diff_status.map(|status| status.kind) {
+ Some(DiffHunkStatusKind::Added) => "+ ",
+ Some(DiffHunkStatusKind::Deleted) => "- ",
+ Some(DiffHunkStatusKind::Modified) => unreachable!(),
+ None => {
+ if has_diff && !line.is_empty() {
+ " "
+ } else {
+ ""
+ }
+ }
+ };
+ let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {
+ if has_diff {
+ " ----------\n"
+ } else {
+ "---------\n"
+ }
+ } else {
+ ""
+ };
+ let expand = info
+ .expand_info
+ .as_ref()
+ .map(|expand_info| match expand_info.direction {
+ ExpandExcerptDirection::Up => " [↑]",
+ ExpandExcerptDirection::Down => " [↓]",
+ ExpandExcerptDirection::UpAndDown => " [↕]",
+ })
+ .unwrap_or_default();
+
+ format!("{boundary_row}{marker}{line}{expand}")
+ // let mbr = info
+ // .multibuffer_row
+ // .map(|row| format!("{:0>3}", row.0))
+ // .unwrap_or_else(|| "???".to_string());
+ // let byte_range = format!("{byte_range_start:0>3}..{byte_range_end:0>3}");
+ // format!("{boundary_row}Row: {mbr}, Bytes: {byte_range} | {marker}{line}{expand}")
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+// fn format_transforms(snapshot: &MultiBufferSnapshot) -> String {
+// snapshot
+// .diff_transforms
+// .iter()
+// .map(|transform| {
+// let (kind, summary) = match transform {
+// DiffTransform::DeletedHunk { summary, .. } => (" Deleted", (*summary).into()),
+// DiffTransform::FilteredInsertedHunk { summary, .. } => (" Filtered", *summary),
+// DiffTransform::InsertedHunk { summary, .. } => (" Inserted", *summary),
+// DiffTransform::Unmodified { summary, .. } => ("Unmodified", *summary),
+// };
+// format!("{kind}(len: {}, lines: {:?})", summary.len, summary.lines)
+// })
+// .join("\n")
+// }
+
+// fn format_excerpts(snapshot: &MultiBufferSnapshot) -> String {
+// snapshot
+// .excerpts
+// .iter()
+// .map(|excerpt| {
+// format!(
+// "Excerpt(buffer_range = {:?}, lines = {:?}, has_trailing_newline = {:?})",
+// excerpt.range.context.to_point(&excerpt.buffer),
+// excerpt.text_summary.lines,
+// excerpt.has_trailing_newline
+// )
+// })
+// .join("\n")
+// }
+
+#[track_caller]
+fn assert_excerpts_match(
+ multibuffer: &Entity<MultiBuffer>,
+ cx: &mut TestAppContext,
+ expected: &str,
+) {
+ let mut output = String::new();
+ multibuffer.read_with(cx, |multibuffer, cx| {
+ let snapshot = multibuffer.snapshot(cx);
+ for excerpt in multibuffer.snapshot(cx).excerpts() {
+ output.push_str("-----\n");
+ output.extend(
+ snapshot
+ .buffer_for_id(excerpt.context.start.buffer_id)
+ .unwrap()
+ .text_for_range(excerpt.context),
+ );
+ if !output.ends_with('\n') {
+ output.push('\n');
+ }
+ }
+ });
+ assert_eq!(output, expected);
+}
+
+#[track_caller]
+fn assert_new_snapshot(
+ multibuffer: &Entity<MultiBuffer>,
+ snapshot: &mut MultiBufferSnapshot,
+ subscription: &mut Subscription<MultiBufferOffset>,
+ cx: &mut TestAppContext,
+ expected_diff: &str,
+) {
+ let new_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
+ let actual_text = new_snapshot.text();
+ let line_infos = new_snapshot
+ .row_infos(MultiBufferRow(0))
+ .collect::<Vec<_>>();
+ let actual_diff = format_diff(&actual_text, &line_infos, &Default::default(), None);
+ pretty_assertions::assert_eq!(actual_diff, expected_diff);
+ check_edits(
+ snapshot,
+ &new_snapshot,
+ &subscription.consume().into_inner(),
+ );
+ *snapshot = new_snapshot;
+}
+
+#[track_caller]
+fn check_edits(
+ old_snapshot: &MultiBufferSnapshot,
+ new_snapshot: &MultiBufferSnapshot,
+ edits: &[Edit<MultiBufferOffset>],
+) {
+ let mut text = old_snapshot.text();
+ let new_text = new_snapshot.text();
+ for edit in edits.iter().rev() {
+ if !text.is_char_boundary(edit.old.start.0)
+ || !text.is_char_boundary(edit.old.end.0)
+ || !new_text.is_char_boundary(edit.new.start.0)
+ || !new_text.is_char_boundary(edit.new.end.0)
+ {
+ panic!(
+ "invalid edits: {:?}\nold text: {:?}\nnew text: {:?}",
+ edits, text, new_text
+ );
+ }
+
+ text.replace_range(
+ edit.old.start.0..edit.old.end.0,
+ &new_text[edit.new.start.0..edit.new.end.0],
+ );
+ }
+
+ pretty_assertions::assert_eq!(text, new_text, "invalid edits: {:?}", edits);
+}
+
+#[track_caller]
+fn assert_chunks_in_ranges(snapshot: &MultiBufferSnapshot) {
+ let full_text = snapshot.text();
+ for ix in 0..full_text.len() {
+ let mut chunks = snapshot.chunks(
+ MultiBufferOffset(0)..snapshot.len(),
+ LanguageAwareStyling {
+ tree_sitter: false,
+ diagnostics: false,
+ },
+ );
+ chunks.seek(MultiBufferOffset(ix)..snapshot.len());
+ let tail = chunks.map(|chunk| chunk.text).collect::<String>();
+ assert_eq!(tail, &full_text[ix..], "seek to range: {:?}", ix..);
+ }
+}
+
+#[track_caller]
+fn assert_consistent_line_numbers(snapshot: &MultiBufferSnapshot) {
+ let all_line_numbers = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
+ for start_row in 1..all_line_numbers.len() {
+ let line_numbers = snapshot
+ .row_infos(MultiBufferRow(start_row as u32))
+ .collect::<Vec<_>>();
+ assert_eq!(
+ line_numbers,
+ all_line_numbers[start_row..],
+ "start_row: {start_row}"
+ );
+ }
+}
+
+#[track_caller]
+fn assert_position_translation(snapshot: &MultiBufferSnapshot) {
+ let text = Rope::from(snapshot.text());
+
+ let mut left_anchors = Vec::new();
+ let mut right_anchors = Vec::new();
+ let mut offsets = Vec::new();
+ let mut points = Vec::new();
+ for offset in 0..=text.len() + 1 {
+ let offset = MultiBufferOffset(offset);
+ let clipped_left = snapshot.clip_offset(offset, Bias::Left);
+ let clipped_right = snapshot.clip_offset(offset, Bias::Right);
+ assert_eq!(
+ clipped_left.0,
+ text.clip_offset(offset.0, Bias::Left),
+ "clip_offset({offset:?}, Left)"
+ );
+ assert_eq!(
+ clipped_right.0,
+ text.clip_offset(offset.0, Bias::Right),
+ "clip_offset({offset:?}, Right)"
+ );
+ assert_eq!(
+ snapshot.offset_to_point(clipped_left),
+ text.offset_to_point(clipped_left.0),
+ "offset_to_point({})",
+ clipped_left.0
+ );
+ assert_eq!(
+ snapshot.offset_to_point(clipped_right),
+ text.offset_to_point(clipped_right.0),
+ "offset_to_point({})",
+ clipped_right.0
+ );
+ let anchor_after = snapshot.anchor_after(clipped_left);
+ assert_eq!(
+ anchor_after.to_offset(snapshot),
+ clipped_left,
+ "anchor_after({}).to_offset {anchor_after:?}",
+ clipped_left.0
+ );
+ let anchor_before = snapshot.anchor_before(clipped_left);
+ assert_eq!(
+ anchor_before.to_offset(snapshot),
+ clipped_left,
+ "anchor_before({}).to_offset",
+ clipped_left.0
+ );
+ left_anchors.push(anchor_before);
+ right_anchors.push(anchor_after);
+ offsets.push(clipped_left);
+ points.push(text.offset_to_point(clipped_left.0));
+ }
+
+ for row in 0..text.max_point().row {
+ for column in 0..text.line_len(row) + 1 {
+ let point = Point { row, column };
+ let clipped_left = snapshot.clip_point(point, Bias::Left);
+ let clipped_right = snapshot.clip_point(point, Bias::Right);
+ assert_eq!(
+ clipped_left,
+ text.clip_point(point, Bias::Left),
+ "clip_point({point:?}, Left)"
+ );
+ assert_eq!(
+ clipped_right,
+ text.clip_point(point, Bias::Right),
+ "clip_point({point:?}, Right)"
+ );
+ assert_eq!(
+ snapshot.point_to_offset(clipped_left).0,
+ text.point_to_offset(clipped_left),
+ "point_to_offset({clipped_left:?})"
+ );
+ assert_eq!(
+ snapshot.point_to_offset(clipped_right).0,
+ text.point_to_offset(clipped_right),
+ "point_to_offset({clipped_right:?})"
+ );
+ }
+ }
+
+ assert_eq!(
+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&left_anchors),
+ offsets,
+ "left_anchors <-> offsets"
+ );
+ assert_eq!(
+ snapshot.summaries_for_anchors::<Point, _>(&left_anchors),
+ points,
+ "left_anchors <-> points"
+ );
+ assert_eq!(
+ snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&right_anchors),
+ offsets,
+ "right_anchors <-> offsets"
+ );
+ assert_eq!(
+ snapshot.summaries_for_anchors::<Point, _>(&right_anchors),
+ points,
+ "right_anchors <-> points"
+ );
+
+ for (anchors, bias) in [(&left_anchors, Bias::Left), (&right_anchors, Bias::Right)] {
+ for (ix, (offset, anchor)) in offsets.iter().zip(anchors).enumerate() {
+ if ix > 0 && *offset == MultiBufferOffset(252) && offset > &offsets[ix - 1] {
+ let prev_anchor = left_anchors[ix - 1];
assert!(
- resolution_consistent,
- "after step {step} ({op:?}), comparison contradicts resolution:\n\
- anchor {i}: {:?}\n resolves to {offset_i:?}\n\
- anchor {j}: {:?}\n resolves to {offset_j:?}\n\
- but compares {ordering:?}",
- anchors[i], anchors[j],
+ anchor.cmp(&prev_anchor, snapshot).is_gt(),
+ "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_gt()",
+ offsets[ix],
+ offsets[ix - 1],
+ );
+ assert!(
+ prev_anchor.cmp(anchor, snapshot).is_lt(),
+ "anchor({}, {bias:?}).cmp(&anchor({}, {bias:?}).is_lt()",
+ offsets[ix - 1],
+ offsets[ix],
);
-
- if let Some(previous) = previous_orderings.insert((i, j), ordering) {
- let inverted = matches!(
- (previous, ordering),
- (cmp::Ordering::Less, cmp::Ordering::Greater)
- | (cmp::Ordering::Greater, cmp::Ordering::Less)
- );
- assert!(
- !inverted,
- "after step {step} ({op:?}), comparison inverted over time:\n\
- anchor {i}: {:?}\n\
- anchor {j}: {:?}\n\
- compared {previous:?} before this step, {ordering:?} after",
- anchors[i], anchors[j],
- );
- }
}
}
}
-}
-/// Distilled from `test_anchor_comparison_tracks_resolution`'s minimal
-/// shrunk counterexample (create anchor, re-key the path, create anchor).
-/// After a path key is reused for a different buffer, an anchor into the
-/// departed buffer sorts against anchors into the new buffer by buffer id,
-/// so resolution must land it on the matching side of the path's region:
-/// the start when the departed buffer's id is lower than the current
-/// occupant's, the end otherwise. When resolution instead ignored that
-/// order (it always chose the end), sorted-input consumers feeding
-/// comparison-sorted anchors to forward-only cursors walked backward in
-/// offset space — the "cannot seek backward" crash family (e.g. ZED-95K).
-#[gpui::test]
-async fn test_stale_path_anchor_comparison_tracks_resolution(cx: &mut TestAppContext) {
- let old_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
- let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
- multibuffer.update(cx, |multibuffer, cx| {
- let max_point = old_buffer.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- old_buffer.clone(),
- [Point::zero()..max_point],
- 0,
- cx,
- );
- });
- let stale = multibuffer.read_with(cx, |multibuffer, cx| {
- multibuffer
- .snapshot(cx)
- .anchor_at(MultiBufferOffset(0), Bias::Right)
- });
+ if let Some((buffer, offset)) = snapshot.point_to_buffer_offset(snapshot.max_point()) {
+ assert!(offset.0 <= buffer.len());
+ }
+ if let Some((buffer, point)) = snapshot.point_to_buffer_point(snapshot.max_point()) {
+ assert!(point <= buffer.max_point());
+ }
+}
- let new_buffer = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
- multibuffer.update(cx, |multibuffer, cx| {
- let max_point = new_buffer.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- new_buffer.clone(),
- [Point::zero()..max_point],
- 0,
- cx,
+fn assert_line_indents(snapshot: &MultiBufferSnapshot) {
+ let max_row = snapshot.max_point().row;
+ let buffer_id = snapshot.excerpts().next().unwrap().context.start.buffer_id;
+ let text = text::Buffer::new(ReplicaId::LOCAL, buffer_id, snapshot.text());
+ let mut line_indents = text
+ .line_indents_in_row_range(0..max_row + 1)
+ .collect::<Vec<_>>();
+ for start_row in 0..snapshot.max_point().row {
+ pretty_assertions::assert_eq!(
+ snapshot
+ .line_indents(MultiBufferRow(start_row), |_| true)
+ .map(|(row, indent, _)| (row.0, indent))
+ .collect::<Vec<_>>(),
+ &line_indents[(start_row as usize)..],
+ "line_indents({start_row})"
);
- });
- cx.run_until_parked();
-
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- let fresh = snapshot.anchor_at(MultiBufferOffset(0), Bias::Right);
+ }
- let ordering = stale.cmp(&fresh, &snapshot);
- let stale_offset = stale.to_offset(&snapshot);
- let fresh_offset = fresh.to_offset(&snapshot);
- let resolution_consistent = match ordering {
- cmp::Ordering::Less => stale_offset <= fresh_offset,
- cmp::Ordering::Equal => stale_offset == fresh_offset,
- cmp::Ordering::Greater => stale_offset >= fresh_offset,
- };
- assert!(
- resolution_consistent,
- "stale anchor {stale:?} resolves to {stale_offset:?} and fresh anchor {fresh:?} \
- resolves to {fresh_offset:?}, but they compare {ordering:?}"
+ line_indents.reverse();
+ pretty_assertions::assert_eq!(
+ snapshot
+ .reversed_line_indents(MultiBufferRow(max_row), |_| true)
+ .map(|(row, indent, _)| (row.0, indent))
+ .collect::<Vec<_>>(),
+ &line_indents[..],
+ "reversed_line_indents({max_row})"
);
}
-/// Distilled from `test_anchor_comparison_tracks_resolution`'s second
-/// shrunk counterexample. An expanded deleted hunk's phantom rows occupy
-/// its attachment anchor's tie space in the buffer's CRDT order: anchor
-/// comparison places a plain buffer anchor after the hunk's rows exactly
-/// when it sorts past the attachment anchor, which can only happen once
-/// the buffer text separating them has been deleted. Resolution must
-/// place the anchor on the same side. It used to depend on which
-/// transform the walk's cursor rested on: arriving on the deleted hunk
-/// itself applied the CRDT rule, but arriving on the preceding buffer
-/// content returned early, parking the anchor before rows it compares
-/// after — so `to_offset` and a shared-cursor `summaries_for_anchors`
-/// disagreed about the same anchor, and comparison-sorted consumers fed
-/// forward-only cursors positions that moved backward.
-#[gpui::test]
-async fn test_collapsed_plain_anchor_resolves_past_deleted_hunk_rows(cx: &mut TestAppContext) {
- let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";
- let buffer_a = cx.new(|cx| Buffer::local("bbb\nccc\nddd\n", cx));
- let diff_a = cx.new(|cx| {
- BufferDiff::new_with_base_text(base_text, &buffer_a.read(cx).text_snapshot(), cx)
- });
+fn collect_word_diffs(
+ base_text: &str,
+ modified_text: &str,
+ cx: &mut TestAppContext,
+) -> Vec<String> {
+ let buffer = cx.new(|cx| Buffer::local(modified_text, cx));
+ let diff = cx
+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
+ cx.run_until_parked();
+
let multibuffer = cx.new(|cx| {
- let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
- multibuffer.set_all_diff_hunks_expanded(cx);
+ let mut multibuffer = MultiBuffer::singleton(buffer.clone(), cx);
+ multibuffer.add_diff(diff.clone(), cx);
multibuffer
});
+
multibuffer.update(cx, |multibuffer, cx| {
- let max_point_a = buffer_a.read(cx).max_point();
- multibuffer.set_excerpts_for_path(
- PathKey::sorted(0),
- buffer_a.clone(),
- [Point::zero()..max_point_a],
- 0,
- cx,
- );
- multibuffer.add_diff(diff_a.clone(), cx);
+ multibuffer.expand_diff_hunks(vec![Anchor::Min..Anchor::Max], cx);
});
- cx.run_until_parked();
- // Delete the first "d" (insertion offset 8), then anchor before the last
- // "d" (insertion offset 10).
- buffer_a.update(cx, |buffer, cx| {
- buffer.edit([(8..9, "")], None, cx);
- });
- cx.run_until_parked();
let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\ndd\n");
- let plain_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Left);
+ let text = snapshot.text();
- // Recompute the diff against the edited buffer: a "-ddd/+dd" hunk
- // appears, attached at the buffer position both anchors will collapse
- // to. Anchor one character into its phantom "ddd" row.
- let buffer_a_text_snapshot = buffer_a.read_with(cx, |buffer, _| buffer.text_snapshot());
- diff_a
- .update(cx, |diff, cx| {
- diff.set_base_text(Some(base_text.into()), buffer_a_text_snapshot, cx)
- })
- .await;
+ snapshot
+ .diff_hunks()
+ .flat_map(|hunk| hunk.word_diffs)
+ .map(|range| text[range.start.0..range.end.0].to_string())
+ .collect()
+}
+
+fn create_multibuffer_with_diff(
+ base_text: &str,
+ modified_text: &str,
+ cx: &mut TestAppContext,
+) -> Entity<MultiBuffer> {
+ let buffer = cx.new(|cx| Buffer::local(modified_text, cx));
+ let diff = cx
+ .new(|cx| BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx));
cx.run_until_parked();
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\ndd\n");
- let hunk_anchor = snapshot.anchor_at(MultiBufferOffset(19), Bias::Right);
- assert_eq!(
- plain_anchor.cmp(&hunk_anchor, &snapshot),
- cmp::Ordering::Greater
- );
- assert_eq!(plain_anchor.to_offset(&snapshot), MultiBufferOffset(23));
- assert_eq!(hunk_anchor.to_offset(&snapshot), MultiBufferOffset(19));
+ cx.new(|cx| {
+ let mut mb = MultiBuffer::singleton(buffer, cx);
+ mb.add_diff(diff, cx);
+ mb
+ })
+}
- // Delete the "d" separating the two anchors (insertion offset 9). Their
- // text anchors now both collapse to the seam where the phantom row
- // hangs, and only the CRDT order remembers which side of it each
- // belongs on.
- buffer_a.update(cx, |buffer, cx| {
- buffer.edit([(8..9, "")], None, cx);
- });
- cx.run_until_parked();
- let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
- assert_eq!(snapshot.text(), "DEL1\nDEL2\nbbb\nccc\nddd\nd\n");
+fn assert_word_diff_ranges_valid(snapshot: &MultiBufferSnapshot) -> Vec<String> {
+ let text = snapshot.text();
+ let ranges: Vec<_> = snapshot
+ .diff_hunks()
+ .flat_map(|hunk| hunk.word_diffs)
+ .collect();
- assert_eq!(
- plain_anchor.cmp(&hunk_anchor, &snapshot),
- cmp::Ordering::Greater,
- "comparison must not change: the buffer order of the anchors is immutable"
- );
- assert_eq!(
- hunk_anchor.to_offset(&snapshot),
- MultiBufferOffset(19),
- "the hunk-interior anchor stays one character into the phantom row"
- );
- assert_eq!(
- plain_anchor.to_offset(&snapshot),
- MultiBufferOffset(22),
- "the plain anchor sorts past the hunk's attachment anchor, so it must \
- resolve past the phantom rows"
- );
- assert_eq!(
- snapshot.summaries_for_anchors::<MultiBufferOffset, _>(&[hunk_anchor, plain_anchor]),
- vec![MultiBufferOffset(19), MultiBufferOffset(22)],
- "the shared-cursor batch path must agree with individual resolution"
- );
+ for range in &ranges {
+ assert!(
+ range.start.0 <= range.end.0 && range.end.0 <= text.len(),
+ "word diff range {:?} is outside text of length {}",
+ range,
+ text.len()
+ );
+ assert!(
+ text.is_char_boundary(range.start.0),
+ "invalid start boundary in {:?} (byte {})",
+ range,
+ range.start.0
+ );
+ assert!(
+ text.is_char_boundary(range.end.0),
+ "invalid end boundary in {:?} (byte {})",
+ range,
+ range.end.0
+ );
+ }
+
+ ranges
+ .iter()
+ .map(|range| text[range.start.0..range.end.0].to_owned())
+ .collect()
}
/// Operations for `test_anchor_comparison_tracks_resolution`, generated up