Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Extract a TextBuffer from Buffer, which has no tree or file

Browse source 
Co-Authored-By: Antonio Scandurra <me@as-cii.com>
Co-Authored-By: Nathan Sobo <nathan@zed.dev>
This commit is contained in:
Max Brunsfeld 2021-10-19 19:17:52 +02:00
parent 76774d6a3c
commit 30e2e2014d
4 changed files with 1490 additions and 1403 deletions
Download patch file Download diff file Expand all files Collapse all files

1855
crates/buffer/src/lib.rs
View file

File diff suppressed because it is too large Load diff

427
crates/buffer/src/tests/buffer.rs
View file

@ -11,23 +11,20 @@ use std::{
time::{Duration, Instant}, time::{Duration, Instant},
}; };
#[gpui::test] #[test]
fn test_edit(cx: &mut gpui::MutableAppContext) { fn test_edit() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("abc".into()));
let mut buffer = Buffer::new(0, "abc", cx);
assert_eq!(buffer.text(), "abc"); assert_eq!(buffer.text(), "abc");
buffer.edit(vec![3..3], "def", cx); buffer.edit(vec![3..3], "def");
assert_eq!(buffer.text(), "abcdef"); assert_eq!(buffer.text(), "abcdef");
buffer.edit(vec![0..0], "ghi", cx); buffer.edit(vec![0..0], "ghi");
assert_eq!(buffer.text(), "ghiabcdef"); assert_eq!(buffer.text(), "ghiabcdef");
buffer.edit(vec![5..5], "jkl", cx); buffer.edit(vec![5..5], "jkl");
assert_eq!(buffer.text(), "ghiabjklcdef"); assert_eq!(buffer.text(), "ghiabjklcdef");
buffer.edit(vec![6..7], "", cx); buffer.edit(vec![6..7], "");
assert_eq!(buffer.text(), "ghiabjlcdef"); assert_eq!(buffer.text(), "ghiabjlcdef");
buffer.edit(vec![4..9], "mno", cx); buffer.edit(vec![4..9], "mno");
assert_eq!(buffer.text(), "ghiamnoef"); assert_eq!(buffer.text(), "ghiamnoef");
buffer
});
} }
#[gpui::test] #[gpui::test]
@ -88,7 +85,7 @@ fn test_edit_events(cx: &mut gpui::MutableAppContext) {
} }
#[gpui::test(iterations = 100)] #[gpui::test(iterations = 100)]
fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) { fn test_random_edits(mut rng: StdRng) {
let operations = env::var("OPERATIONS") let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable")) .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(10); .unwrap_or(10);
@ -97,8 +94,7 @@ fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
let mut reference_string = RandomCharIter::new(&mut rng) let mut reference_string = RandomCharIter::new(&mut rng)
.take(reference_string_len) .take(reference_string_len)
.collect::<String>(); .collect::<String>();
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new(reference_string.clone().into()));
let mut buffer = Buffer::new(0, reference_string.as_str(), cx);
buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200)); buffer.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
let mut buffer_versions = Vec::new(); let mut buffer_versions = Vec::new();
log::info!( log::info!(
@ -108,7 +104,7 @@ fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
); );
for _i in 0..operations { for _i in 0..operations {
let (old_ranges, new_text) = buffer.randomly_mutate(&mut rng, cx); let (old_ranges, new_text) = buffer.randomly_mutate(&mut rng);
for old_range in old_ranges.iter().rev() { for old_range in old_ranges.iter().rev() {
reference_string.replace_range(old_range.clone(), &new_text); reference_string.replace_range(old_range.clone(), &new_text);
} }
@ -120,7 +116,7 @@ fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
); );
if rng.gen_bool(0.25) { if rng.gen_bool(0.25) {
buffer.randomly_undo_redo(&mut rng, cx); buffer.randomly_undo_redo(&mut rng);
reference_string = buffer.text(); reference_string = buffer.text();
log::info!( log::info!(
"buffer text {:?}, version: {:?}", "buffer text {:?}, version: {:?}",
@ -156,28 +152,20 @@ fn test_random_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
for edit in edits { for edit in edits {
let old_start = (edit.old_bytes.start as isize + delta) as usize; let old_start = (edit.old_bytes.start as isize + delta) as usize;
let new_text: String = buffer.text_for_range(edit.new_bytes.clone()).collect(); let new_text: String = buffer.text_for_range(edit.new_bytes.clone()).collect();
old_buffer.edit( old_buffer.edit(Some(old_start..old_start + edit.deleted_bytes()), new_text);
Some(old_start..old_start + edit.deleted_bytes()),
new_text,
cx,
);
delta += edit.delta(); delta += edit.delta();
} }
assert_eq!(old_buffer.text(), buffer.text()); assert_eq!(old_buffer.text(), buffer.text());
} }
buffer
});
} }
#[gpui::test] #[test]
fn test_line_len(cx: &mut gpui::MutableAppContext) { fn test_line_len() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
let mut buffer = Buffer::new(0, "", cx); buffer.edit(vec![0..0], "abcd\nefg\nhij");
buffer.edit(vec![0..0], "abcd\nefg\nhij", cx); buffer.edit(vec![12..12], "kl\nmno");
buffer.edit(vec![12..12], "kl\nmno", cx); buffer.edit(vec![18..18], "\npqrs\n");
buffer.edit(vec![18..18], "\npqrs\n", cx); buffer.edit(vec![18..21], "\nPQ");
buffer.edit(vec![18..21], "\nPQ", cx);
assert_eq!(buffer.line_len(0), 4); assert_eq!(buffer.line_len(0), 4);
assert_eq!(buffer.line_len(1), 3); assert_eq!(buffer.line_len(1), 3);
@ -185,14 +173,11 @@ fn test_line_len(cx: &mut gpui::MutableAppContext) {
assert_eq!(buffer.line_len(3), 3); assert_eq!(buffer.line_len(3), 3);
assert_eq!(buffer.line_len(4), 4); assert_eq!(buffer.line_len(4), 4);
assert_eq!(buffer.line_len(5), 0); assert_eq!(buffer.line_len(5), 0);
buffer
});
} }
#[gpui::test] #[test]
fn test_text_summary_for_range(cx: &mut gpui::MutableAppContext) { fn test_text_summary_for_range() {
cx.add_model(|cx| { let buffer = TextBuffer::new(0, 0, History::new("ab\nefg\nhklm\nnopqrs\ntuvwxyz".into()));
let buffer = Buffer::new(0, "ab\nefg\nhklm\nnopqrs\ntuvwxyz", cx);
assert_eq!( assert_eq!(
buffer.text_summary_for_range(1..3), buffer.text_summary_for_range(1..3),
TextSummary { TextSummary {
@ -248,18 +233,15 @@ fn test_text_summary_for_range(cx: &mut gpui::MutableAppContext) {
longest_row_chars: 6, longest_row_chars: 6,
} }
); );
buffer
});
} }
#[gpui::test] #[test]
fn test_chars_at(cx: &mut gpui::MutableAppContext) { fn test_chars_at() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
let mut buffer = Buffer::new(0, "", cx); buffer.edit(vec![0..0], "abcd\nefgh\nij");
buffer.edit(vec![0..0], "abcd\nefgh\nij", cx); buffer.edit(vec![12..12], "kl\nmno");
buffer.edit(vec![12..12], "kl\nmno", cx); buffer.edit(vec![18..18], "\npqrs");
buffer.edit(vec![18..18], "\npqrs", cx); buffer.edit(vec![18..21], "\nPQ");
buffer.edit(vec![18..21], "\nPQ", cx);
let chars = buffer.chars_at(Point::new(0, 0)); let chars = buffer.chars_at(Point::new(0, 0));
assert_eq!(chars.collect::<String>(), "abcd\nefgh\nijkl\nmno\nPQrs"); assert_eq!(chars.collect::<String>(), "abcd\nefgh\nijkl\nmno\nPQrs");
@ -277,47 +259,43 @@ fn test_chars_at(cx: &mut gpui::MutableAppContext) {
assert_eq!(chars.collect::<String>(), "PQrs"); assert_eq!(chars.collect::<String>(), "PQrs");
// Regression test: // Regression test:
let mut buffer = Buffer::new(0, "", cx); let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
buffer.edit(vec![0..0], "[workspace]\nmembers = [\n \"xray_core\",\n \"xray_server\",\n \"xray_cli\",\n \"xray_wasm\",\n]\n", cx); buffer.edit(vec![0..0], "[workspace]\nmembers = [\n \"xray_core\",\n \"xray_server\",\n \"xray_cli\",\n \"xray_wasm\",\n]\n");
buffer.edit(vec![60..60], "\n", cx); buffer.edit(vec![60..60], "\n");
let chars = buffer.chars_at(Point::new(6, 0)); let chars = buffer.chars_at(Point::new(6, 0));
assert_eq!(chars.collect::<String>(), " \"xray_wasm\",\n]\n"); assert_eq!(chars.collect::<String>(), " \"xray_wasm\",\n]\n");
buffer
});
} }
#[gpui::test] #[test]
fn test_anchors(cx: &mut gpui::MutableAppContext) { fn test_anchors() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
let mut buffer = Buffer::new(0, "", cx); buffer.edit(vec![0..0], "abc");
buffer.edit(vec![0..0], "abc", cx);
let left_anchor = buffer.anchor_before(2); let left_anchor = buffer.anchor_before(2);
let right_anchor = buffer.anchor_after(2); let right_anchor = buffer.anchor_after(2);
buffer.edit(vec![1..1], "def\n", cx); buffer.edit(vec![1..1], "def\n");
assert_eq!(buffer.text(), "adef\nbc"); assert_eq!(buffer.text(), "adef\nbc");
assert_eq!(left_anchor.to_offset(&buffer), 6); assert_eq!(left_anchor.to_offset(&buffer), 6);
assert_eq!(right_anchor.to_offset(&buffer), 6); assert_eq!(right_anchor.to_offset(&buffer), 6);
assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 }); assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 }); assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
buffer.edit(vec![2..3], "", cx); buffer.edit(vec![2..3], "");
assert_eq!(buffer.text(), "adf\nbc"); assert_eq!(buffer.text(), "adf\nbc");
assert_eq!(left_anchor.to_offset(&buffer), 5); assert_eq!(left_anchor.to_offset(&buffer), 5);
assert_eq!(right_anchor.to_offset(&buffer), 5); assert_eq!(right_anchor.to_offset(&buffer), 5);
assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 }); assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 }); assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
buffer.edit(vec![5..5], "ghi\n", cx); buffer.edit(vec![5..5], "ghi\n");
assert_eq!(buffer.text(), "adf\nbghi\nc"); assert_eq!(buffer.text(), "adf\nbghi\nc");
assert_eq!(left_anchor.to_offset(&buffer), 5); assert_eq!(left_anchor.to_offset(&buffer), 5);
assert_eq!(right_anchor.to_offset(&buffer), 9); assert_eq!(right_anchor.to_offset(&buffer), 9);
assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 }); assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
assert_eq!(right_anchor.to_point(&buffer), Point { row: 2, column: 0 }); assert_eq!(right_anchor.to_point(&buffer), Point { row: 2, column: 0 });
buffer.edit(vec![7..9], "", cx); buffer.edit(vec![7..9], "");
assert_eq!(buffer.text(), "adf\nbghc"); assert_eq!(buffer.text(), "adf\nbghc");
assert_eq!(left_anchor.to_offset(&buffer), 5); assert_eq!(left_anchor.to_offset(&buffer), 5);
assert_eq!(right_anchor.to_offset(&buffer), 7); assert_eq!(right_anchor.to_offset(&buffer), 7);
@ -423,18 +401,15 @@ fn test_anchors(cx: &mut gpui::MutableAppContext) {
.unwrap(), .unwrap(),
Ordering::Greater Ordering::Greater
); );
buffer
});
} }
#[gpui::test] #[test]
fn test_anchors_at_start_and_end(cx: &mut gpui::MutableAppContext) { fn test_anchors_at_start_and_end() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("".into()));
let mut buffer = Buffer::new(0, "", cx);
let before_start_anchor = buffer.anchor_before(0); let before_start_anchor = buffer.anchor_before(0);
let after_end_anchor = buffer.anchor_after(0); let after_end_anchor = buffer.anchor_after(0);
buffer.edit(vec![0..0], "abc", cx); buffer.edit(vec![0..0], "abc");
assert_eq!(buffer.text(), "abc"); assert_eq!(buffer.text(), "abc");
assert_eq!(before_start_anchor.to_offset(&buffer), 0); assert_eq!(before_start_anchor.to_offset(&buffer), 0);
assert_eq!(after_end_anchor.to_offset(&buffer), 3); assert_eq!(after_end_anchor.to_offset(&buffer), 3);
@ -442,15 +417,13 @@ fn test_anchors_at_start_and_end(cx: &mut gpui::MutableAppContext) {
let after_start_anchor = buffer.anchor_after(0); let after_start_anchor = buffer.anchor_after(0);
let before_end_anchor = buffer.anchor_before(3); let before_end_anchor = buffer.anchor_before(3);
buffer.edit(vec![3..3], "def", cx); buffer.edit(vec![3..3], "def");
buffer.edit(vec![0..0], "ghi", cx); buffer.edit(vec![0..0], "ghi");
assert_eq!(buffer.text(), "ghiabcdef"); assert_eq!(buffer.text(), "ghiabcdef");
assert_eq!(before_start_anchor.to_offset(&buffer), 0); assert_eq!(before_start_anchor.to_offset(&buffer), 0);
assert_eq!(after_start_anchor.to_offset(&buffer), 3); assert_eq!(after_start_anchor.to_offset(&buffer), 3);
assert_eq!(before_end_anchor.to_offset(&buffer), 6); assert_eq!(before_end_anchor.to_offset(&buffer), 6);
assert_eq!(after_end_anchor.to_offset(&buffer), 9); assert_eq!(after_end_anchor.to_offset(&buffer), 9);
buffer
});
} }
#[gpui::test] #[gpui::test]
@ -469,247 +442,221 @@ async fn test_apply_diff(mut cx: gpui::TestAppContext) {
cx.read(|cx| assert_eq!(buffer.read(cx).text(), text)); cx.read(|cx| assert_eq!(buffer.read(cx).text(), text));
} }
#[gpui::test] #[test]
fn test_undo_redo(cx: &mut gpui::MutableAppContext) { fn test_undo_redo() {
cx.add_model(|cx| { let mut buffer = TextBuffer::new(0, 0, History::new("1234".into()));
let mut buffer = Buffer::new(0, "1234", cx);
// Set group interval to zero so as to not group edits in the undo stack. // Set group interval to zero so as to not group edits in the undo stack.
buffer.history.group_interval = Duration::from_secs(0); buffer.history.group_interval = Duration::from_secs(0);
buffer.edit(vec![1..1], "abx", cx); buffer.edit(vec![1..1], "abx");
buffer.edit(vec![3..4], "yzef", cx); buffer.edit(vec![3..4], "yzef");
buffer.edit(vec![3..5], "cd", cx); buffer.edit(vec![3..5], "cd");
assert_eq!(buffer.text(), "1abcdef234"); assert_eq!(buffer.text(), "1abcdef234");
let transactions = buffer.history.undo_stack.clone(); let transactions = buffer.history.undo_stack.clone();
assert_eq!(transactions.len(), 3); assert_eq!(transactions.len(), 3);
buffer.undo_or_redo(transactions[0].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[0].clone()).unwrap();
assert_eq!(buffer.text(), "1cdef234"); assert_eq!(buffer.text(), "1cdef234");
buffer.undo_or_redo(transactions[0].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[0].clone()).unwrap();
assert_eq!(buffer.text(), "1abcdef234"); assert_eq!(buffer.text(), "1abcdef234");
buffer.undo_or_redo(transactions[1].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[1].clone()).unwrap();
assert_eq!(buffer.text(), "1abcdx234"); assert_eq!(buffer.text(), "1abcdx234");
buffer.undo_or_redo(transactions[2].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[2].clone()).unwrap();
assert_eq!(buffer.text(), "1abx234"); assert_eq!(buffer.text(), "1abx234");
buffer.undo_or_redo(transactions[1].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[1].clone()).unwrap();
assert_eq!(buffer.text(), "1abyzef234"); assert_eq!(buffer.text(), "1abyzef234");
buffer.undo_or_redo(transactions[2].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[2].clone()).unwrap();
assert_eq!(buffer.text(), "1abcdef234"); assert_eq!(buffer.text(), "1abcdef234");
buffer.undo_or_redo(transactions[2].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[2].clone()).unwrap();
assert_eq!(buffer.text(), "1abyzef234"); assert_eq!(buffer.text(), "1abyzef234");
buffer.undo_or_redo(transactions[0].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[0].clone()).unwrap();
assert_eq!(buffer.text(), "1yzef234"); assert_eq!(buffer.text(), "1yzef234");
buffer.undo_or_redo(transactions[1].clone(), cx).unwrap(); buffer.undo_or_redo(transactions[1].clone()).unwrap();
assert_eq!(buffer.text(), "1234"); assert_eq!(buffer.text(), "1234");
buffer
});
} }
#[gpui::test] #[test]
fn test_history(cx: &mut gpui::MutableAppContext) { fn test_history() {
cx.add_model(|cx| {
let mut now = Instant::now(); let mut now = Instant::now();
let mut buffer = Buffer::new(0, "123456", cx); let mut buffer = TextBuffer::new(0, 0, History::new("123456".into()));
let set_id = let set_id = if let Operation::UpdateSelections { set_id, .. } =
buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap(), cx); buffer.add_selection_set(buffer.selections_from_ranges(vec![4..4]).unwrap())
{
set_id
} else {
unreachable!()
};
buffer.start_transaction_at(Some(set_id), now).unwrap(); buffer.start_transaction_at(Some(set_id), now).unwrap();
buffer.edit(vec![2..4], "cd", cx); buffer.edit(vec![2..4], "cd");
buffer.end_transaction_at(Some(set_id), now, cx).unwrap(); buffer.end_transaction_at(Some(set_id), now).unwrap();
assert_eq!(buffer.text(), "12cd56"); assert_eq!(buffer.text(), "12cd56");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
buffer.start_transaction_at(Some(set_id), now).unwrap(); buffer.start_transaction_at(Some(set_id), now).unwrap();
buffer buffer
.update_selection_set( .update_selection_set(set_id, buffer.selections_from_ranges(vec![1..3]).unwrap())
set_id,
buffer.selections_from_ranges(vec![1..3]).unwrap(),
cx,
)
.unwrap(); .unwrap();
buffer.edit(vec![4..5], "e", cx); buffer.edit(vec![4..5], "e");
buffer.end_transaction_at(Some(set_id), now, cx).unwrap(); buffer.end_transaction_at(Some(set_id), now).unwrap();
assert_eq!(buffer.text(), "12cde6"); assert_eq!(buffer.text(), "12cde6");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
now += buffer.history.group_interval + Duration::from_millis(1); now += buffer.history.group_interval + Duration::from_millis(1);
buffer.start_transaction_at(Some(set_id), now).unwrap(); buffer.start_transaction_at(Some(set_id), now).unwrap();
buffer buffer
.update_selection_set( .update_selection_set(set_id, buffer.selections_from_ranges(vec![2..2]).unwrap())
set_id,
buffer.selections_from_ranges(vec![2..2]).unwrap(),
cx,
)
.unwrap(); .unwrap();
buffer.edit(vec![0..1], "a", cx); buffer.edit(vec![0..1], "a");
buffer.edit(vec![1..1], "b", cx); buffer.edit(vec![1..1], "b");
buffer.end_transaction_at(Some(set_id), now, cx).unwrap(); buffer.end_transaction_at(Some(set_id), now).unwrap();
assert_eq!(buffer.text(), "ab2cde6"); assert_eq!(buffer.text(), "ab2cde6");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
// Last transaction happened past the group interval, undo it on its // Last transaction happened past the group interval, undo it on its
// own. // own.
buffer.undo(cx); buffer.undo();
assert_eq!(buffer.text(), "12cde6"); assert_eq!(buffer.text(), "12cde6");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
// First two transactions happened within the group interval, undo them // First two transactions happened within the group interval, undo them
// together. // together.
buffer.undo(cx); buffer.undo();
assert_eq!(buffer.text(), "123456"); assert_eq!(buffer.text(), "123456");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![4..4]);
// Redo the first two transactions together. // Redo the first two transactions together.
buffer.redo(cx); buffer.redo();
assert_eq!(buffer.text(), "12cde6"); assert_eq!(buffer.text(), "12cde6");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![1..3]);
// Redo the last transaction on its own. // Redo the last transaction on its own.
buffer.redo(cx); buffer.redo();
assert_eq!(buffer.text(), "ab2cde6"); assert_eq!(buffer.text(), "ab2cde6");
assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]); assert_eq!(buffer.selection_ranges(set_id).unwrap(), vec![3..3]);
buffer.start_transaction_at(None, now).unwrap(); buffer.start_transaction_at(None, now).unwrap();
buffer.end_transaction_at(None, now, cx).unwrap(); assert!(buffer.end_transaction_at(None, now).is_none());
buffer.undo(cx); buffer.undo();
assert_eq!(buffer.text(), "12cde6"); assert_eq!(buffer.text(), "12cde6");
buffer
});
} }
#[gpui::test] #[test]
fn test_concurrent_edits(cx: &mut gpui::MutableAppContext) { fn test_concurrent_edits() {
let text = "abcdef"; let text = "abcdef";
let buffer1 = cx.add_model(|cx| Buffer::new(1, text, cx)); let mut buffer1 = TextBuffer::new(1, 0, History::new(text.into()));
let buffer2 = cx.add_model(|cx| Buffer::new(2, text, cx)); let mut buffer2 = TextBuffer::new(2, 0, History::new(text.into()));
let buffer3 = cx.add_model(|cx| Buffer::new(3, text, cx)); let mut buffer3 = TextBuffer::new(3, 0, History::new(text.into()));
let buf1_op = buffer1.update(cx, |buffer, cx| { let buf1_op = buffer1.edit(vec![1..2], "12");
buffer.edit(vec![1..2], "12", cx); assert_eq!(buffer1.text(), "a12cdef");
assert_eq!(buffer.text(), "a12cdef"); let buf2_op = buffer2.edit(vec![3..4], "34");
buffer.operations.last().unwrap().clone() assert_eq!(buffer2.text(), "abc34ef");
}); let buf3_op = buffer3.edit(vec![5..6], "56");
let buf2_op = buffer2.update(cx, |buffer, cx| { assert_eq!(buffer3.text(), "abcde56");
buffer.edit(vec![3..4], "34", cx);
assert_eq!(buffer.text(), "abc34ef");
buffer.operations.last().unwrap().clone()
});
let buf3_op = buffer3.update(cx, |buffer, cx| {
buffer.edit(vec![5..6], "56", cx);
assert_eq!(buffer.text(), "abcde56");
buffer.operations.last().unwrap().clone()
});
buffer1.update(cx, |buffer, _| { buffer1.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
buffer.apply_op(buf2_op.clone()).unwrap(); buffer1.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
buffer.apply_op(buf3_op.clone()).unwrap(); buffer2.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
}); buffer2.apply_op(Operation::Edit(buf3_op.clone())).unwrap();
buffer2.update(cx, |buffer, _| { buffer3.apply_op(Operation::Edit(buf1_op.clone())).unwrap();
buffer.apply_op(buf1_op.clone()).unwrap(); buffer3.apply_op(Operation::Edit(buf2_op.clone())).unwrap();
buffer.apply_op(buf3_op.clone()).unwrap();
});
buffer3.update(cx, |buffer, _| {
buffer.apply_op(buf1_op.clone()).unwrap();
buffer.apply_op(buf2_op.clone()).unwrap();
});
assert_eq!(buffer1.read(cx).text(), "a12c34e56"); assert_eq!(buffer1.text(), "a12c34e56");
assert_eq!(buffer2.read(cx).text(), "a12c34e56"); assert_eq!(buffer2.text(), "a12c34e56");
assert_eq!(buffer3.read(cx).text(), "a12c34e56"); assert_eq!(buffer3.text(), "a12c34e56");
} }
#[gpui::test(iterations = 100)] // #[gpui::test(iterations = 100)]
fn test_random_concurrent_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) { // fn test_random_concurrent_edits(cx: &mut gpui::MutableAppContext, mut rng: StdRng) {
let peers = env::var("PEERS") // let peers = env::var("PEERS")
.map(|i| i.parse().expect("invalid `PEERS` variable")) // .map(|i| i.parse().expect("invalid `PEERS` variable"))
.unwrap_or(5); // .unwrap_or(5);
let operations = env::var("OPERATIONS") // let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable")) // .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(10); // .unwrap_or(10);
let base_text_len = rng.gen_range(0..10); // let base_text_len = rng.gen_range(0..10);
let base_text = RandomCharIter::new(&mut rng) // let base_text = RandomCharIter::new(&mut rng)
.take(base_text_len) // .take(base_text_len)
.collect::<String>(); // .collect::<String>();
let mut replica_ids = Vec::new(); // let mut replica_ids = Vec::new();
let mut buffers = Vec::new(); // let mut buffers = Vec::new();
let mut network = Network::new(rng.clone()); // let mut network = Network::new(rng.clone());
for i in 0..peers { // for i in 0..peers {
let buffer = cx.add_model(|cx| { // let buffer = cx.add_model(|cx| {
let mut buf = Buffer::new(i as ReplicaId, base_text.as_str(), cx); // let mut buf = Buffer::new(i as ReplicaId, base_text.as_str(), cx);
buf.history.group_interval = Duration::from_millis(rng.gen_range(0..=200)); // buf.history.group_interval = Duration::from_millis(rng.gen_range(0..=200));
buf // buf
}); // });
buffers.push(buffer); // buffers.push(buffer);
replica_ids.push(i as u16); // replica_ids.push(i as u16);
network.add_peer(i as u16); // network.add_peer(i as u16);
} // }
log::info!("initial text: {:?}", base_text); // log::info!("initial text: {:?}", base_text);
let mut mutation_count = operations; // let mut mutation_count = operations;
loop { // loop {
let replica_index = rng.gen_range(0..peers); // let replica_index = rng.gen_range(0..peers);
let replica_id = replica_ids[replica_index]; // let replica_id = replica_ids[replica_index];
buffers[replica_index].update(cx, |buffer, cx| match rng.gen_range(0..=100) { // buffers[replica_index].update(cx, |buffer, cx| match rng.gen_range(0..=100) {
0..=50 if mutation_count != 0 => { // 0..=50 if mutation_count != 0 => {
buffer.randomly_mutate(&mut rng, cx); // buffer.randomly_mutate(&mut rng, cx);
network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations)); // network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations));
log::info!("buffer {} text: {:?}", buffer.replica_id, buffer.text()); // log::info!("buffer {} text: {:?}", buffer.replica_id, buffer.text());
mutation_count -= 1; // mutation_count -= 1;
} // }
51..=70 if mutation_count != 0 => { // 51..=70 if mutation_count != 0 => {
buffer.randomly_undo_redo(&mut rng, cx); // buffer.randomly_undo_redo(&mut rng, cx);
network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations)); // network.broadcast(buffer.replica_id, mem::take(&mut buffer.operations));
mutation_count -= 1; // mutation_count -= 1;
} // }
71..=100 if network.has_unreceived(replica_id) => { // 71..=100 if network.has_unreceived(replica_id) => {
let ops = network.receive(replica_id); // let ops = network.receive(replica_id);
if !ops.is_empty() { // if !ops.is_empty() {
log::info!( // log::info!(
"peer {} applying {} ops from the network.", // "peer {} applying {} ops from the network.",
replica_id, // replica_id,
ops.len() // ops.len()
); // );
buffer.apply_ops(ops, cx).unwrap(); // buffer.apply_ops(ops, cx).unwrap();
} // }
} // }
_ => {} // _ => {}
}); // });
if mutation_count == 0 && network.is_idle() { // if mutation_count == 0 && network.is_idle() {
break; // break;
} // }
} // }
let first_buffer = buffers[0].read(cx); // let first_buffer = buffers[0].read(cx);
for buffer in &buffers[1..] { // for buffer in &buffers[1..] {
let buffer = buffer.read(cx); // let buffer = buffer.read(cx);
assert_eq!( // assert_eq!(
buffer.text(), // buffer.text(),
first_buffer.text(), // first_buffer.text(),
"Replica {} text != Replica 0 text", // "Replica {} text != Replica 0 text",
buffer.replica_id // buffer.replica_id
); // );
assert_eq!( // assert_eq!(
buffer.selection_sets().collect::<HashMap<_, _>>(), // buffer.selection_sets().collect::<HashMap<_, _>>(),
first_buffer.selection_sets().collect::<HashMap<_, _>>() // first_buffer.selection_sets().collect::<HashMap<_, _>>()
); // );
assert_eq!( // assert_eq!(
buffer.all_selection_ranges().collect::<HashMap<_, _>>(), // buffer.all_selection_ranges().collect::<HashMap<_, _>>(),
first_buffer // first_buffer
.all_selection_ranges() // .all_selection_ranges()
.collect::<HashMap<_, _>>() // .collect::<HashMap<_, _>>()
); // );
} // }
} // }
#[derive(Clone)] #[derive(Clone)]
struct Envelope<T: Clone> { struct Envelope<T: Clone> {

13
crates/buffer/src/tests/syntax.rs
View file

@ -351,6 +351,19 @@ fn test_contiguous_ranges() {
); );
} }
impl Buffer {
pub fn enclosing_bracket_point_ranges<T: ToOffset>(
&self,
range: Range<T>,
) -> Option<(Range<Point>, Range<Point>)> {
self.enclosing_bracket_ranges(range).map(|(start, end)| {
let point_start = start.start.to_point(self)..start.end.to_point(self);
let point_end = end.start.to_point(self)..end.end.to_point(self);
(point_start, point_end)
})
}
}
fn rust_lang() -> Arc<Language> { fn rust_lang() -> Arc<Language> {
Arc::new( Arc::new(
Language::new( Language::new(

2
crates/editor/src/display_map.rs
View file

@ -436,7 +436,7 @@ mod tests {
} }
} }
_ => { _ => {
buffer.update(&mut cx, |buffer, cx| buffer.randomly_mutate(&mut rng, cx)); buffer.update(&mut cx, |buffer, cx| buffer.randomly_edit(&mut rng, 5, cx));
} }
} }