@@ -1,12 +1,151 @@
-use std::mem;
+use std::{iter::Peekable, mem, ops::Range};
type Edit = buffer::Edit<u32>;
#[derive(Default, Debug, PartialEq, Eq)]
struct Patch(Vec<Edit>);
+fn compose_edits(old_edit: &Edit, new_edit: &Edit) -> Edit {
+ let mut composed = old_edit.clone();
+ if old_edit.new.start > new_edit.old.start {
+ composed.old.start -= old_edit.new.start - new_edit.old.start;
+ composed.new.start = new_edit.old.start;
+ }
+ if new_edit.old.end > old_edit.new.end {
+ composed.old.end += new_edit.old.end - old_edit.new.end;
+ composed.new.end = new_edit.old.end;
+ }
+ let new_edit_delta = new_edit.new.len() as i32 - new_edit.old.len() as i32;
+ composed.new.end = (composed.new.end as i32 + new_edit_delta) as u32;
+ composed
+}
+
impl Patch {
fn compose(&self, new: &Self) -> Patch {
+ enum EditSource {
+ Old,
+ New,
+ }
+
+ let mut composed_edits = Vec::new();
+ let mut old_delta = 0;
+ let mut new_delta = 0;
+ let mut old_edits = self.0.iter().cloned().peekable();
+ let mut new_edits = new.0.iter().cloned().peekable();
+
+ fn peek_next(
+ old_edits: &mut Peekable<impl Iterator<Item = Edit>>,
+ new_edits: &mut Peekable<impl Iterator<Item = Edit>>,
+ ) -> Option<EditSource> {
+ match (old_edits.peek(), new_edits.peek()) {
+ (Some(old_edit), Some(new_edit)) => {
+ if old_edit.new.start <= new_edit.old.start {
+ Some(EditSource::Old)
+ } else {
+ Some(EditSource::New)
+ }
+ }
+ (Some(_), None) => Some(EditSource::Old),
+ (None, Some(_)) => Some(EditSource::New),
+ (None, None) => None,
+ }
+ }
+
+ while let Some(source) = peek_next(&mut old_edits, &mut new_edits) {
+ let mut intermediate_end;
+ let mut composed_edit;
+ match source {
+ EditSource::Old => {
+ let edit = old_edits.next().unwrap();
+ println!("pulling an old edit {:?}", edit);
+ old_delta += edit_delta(&edit);
+ intermediate_end = edit.new.end;
+ composed_edit = edit.clone();
+ apply_delta(&mut composed_edit.new, new_delta);
+ println!(" composed edit: {:?}", composed_edit);
+ }
+ EditSource::New => {
+ let edit = new_edits.next().unwrap();
+ println!("pulling a new edit {:?}", edit);
+ new_delta += edit_delta(&edit);
+ intermediate_end = edit.old.end;
+ composed_edit = edit.clone();
+ apply_delta(&mut composed_edit.old, -old_delta);
+ println!(" composed edit: {:?}", composed_edit);
+ }
+ }
+
+ while let Some(source) = peek_next(&mut old_edits, &mut new_edits) {
+ match source {
+ EditSource::Old => {
+ if let Some(old_edit) = old_edits.peek() {
+ if old_edit.new.start <= intermediate_end {
+ let old_edit = old_edits.next().unwrap();
+ println!(" merging with an old edit {:?}", old_edit);
+
+ if old_edit.old.start < composed_edit.old.start {
+ composed_edit.new.start =
+ composed_edit.old.start - old_edit.old.start;
+ composed_edit.old.start = old_edit.old.start;
+ }
+
+ if old_edit.old.end > composed_edit.old.end {
+ println!(
+ " old edit end exceeds composed edit by {:?}",
+ old_edit.old.end - composed_edit.old.end
+ );
+ composed_edit.new.end +=
+ old_edit.old.end - composed_edit.old.end;
+ composed_edit.old.end = old_edit.old.end;
+ intermediate_end = old_edit.new.end;
+
+ println!(
+ " composed edit after expansion, before delta {:?}",
+ composed_edit,
+ );
+ }
+ let edit_delta = edit_delta(&old_edit);
+ println!(" edit delta is {}", edit_delta);
+ composed_edit.old.end =
+ (composed_edit.old.end as i32 - edit_delta) as u32;
+ println!(" composed edit is now {:?}", composed_edit);
+ old_delta += edit_delta;
+ continue;
+ }
+ }
+ break;
+ }
+ EditSource::New => {
+ if let Some(new_edit) = new_edits.peek() {
+ if new_edit.old.start <= intermediate_end {
+ let new_edit = new_edits.next().unwrap();
+ println!(" merging with a new edit {:?}", new_edit);
+ if new_edit.old.end > intermediate_end {
+ let expansion = new_edit.old.end - intermediate_end;
+ composed_edit.old.end += expansion;
+ composed_edit.new.end += expansion;
+ intermediate_end = new_edit.old.end;
+ }
+ let edit_delta = edit_delta(&new_edit);
+ composed_edit.new.end =
+ (composed_edit.new.end as i32 + edit_delta) as u32;
+ println!(" composed edit is now {:?}", composed_edit);
+ new_delta += edit_delta;
+ continue;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ composed_edits.push(composed_edit);
+ }
+
+ Patch(composed_edits)
+ }
+
+ fn compose1(&self, new: &Self) -> Patch {
let mut composed = Vec::<Edit>::new();
let mut old_edits = self.0.iter().cloned().peekable();
let mut old_delta = 0;
@@ -106,6 +245,15 @@ impl Patch {
}
}
+fn edit_delta(edit: &Edit) -> i32 {
+ edit.new.len() as i32 - edit.old.len() as i32
+}
+
+fn apply_delta(range: &mut Range<u32>, delta: i32) {
+ range.start = (range.start as i32 + delta) as u32;
+ range.end = (range.end as i32 + delta) as u32;
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -277,6 +425,26 @@ mod tests {
);
}
+ #[test]
+ fn test_compose_edits() {
+ assert_eq!(
+ compose_edits(
+ &Edit {
+ old: 3..3,
+ new: 3..6,
+ },
+ &Edit {
+ old: 2..7,
+ new: 2..4,
+ },
+ ),
+ Edit {
+ old: 2..4,
+ new: 2..4
+ }
+ );
+ }
+
#[gpui::test]
fn test_two_new_edits_touching_one_old_edit() {
assert_patch_composition(
@@ -314,7 +482,7 @@ mod tests {
}
#[gpui::test(iterations = 1000)]
- fn test_random(mut rng: StdRng) {
+ fn test_random_patch_compositions(mut rng: StdRng) {
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
.unwrap_or(2);