andras/reconcile
1
0
Fork 0
Code Issues Pull requests 5 Projects Releases Packages Wiki Activity Actions

Don't elongate equals

Browse source
This commit is contained in:
Andras Schmelczer 2025-06-15 11:12:03 +01:00
parent 1fd6450484
commit 82e77eec89
No known key found for this signature in database
GPG key ID: FC8F2C3D3D1A718C
3 changed files with 90 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

14
reconcile/src/operation_transformation/snapshots/reconcile__operation_transformation__edited_text__tests__calculate_operations.snap
View file

@ -16,7 +16,19 @@ EditedText {
},
OrderedOperation {
order: 12,
operation: <equal ' How are' from index 17>,
operation: <equal ' ' from index 17>,
},
OrderedOperation {
order: 13,
operation: <equal 'How' from index 18>,
},
OrderedOperation {
order: 16,
operation: <equal ' ' from index 21>,
},
OrderedOperation {
order: 17,
operation: <equal 'are' from index 22>,
},
OrderedOperation {
order: 20,

10
reconcile/src/operation_transformation/snapshots/reconcile__operation_transformation__edited_text__tests__calculate_operations_with_no_diff.snap
View file

@ -8,7 +8,15 @@ EditedText {
operations: [
OrderedOperation {
order: 0,
operation: <equal 'hello world!' from index 0>,
operation: <equal 'hello' from index 0>,
},
OrderedOperation {
order: 5,
operation: <equal ' ' from index 5>,
},
OrderedOperation {
order: 6,
operation: <equal 'world!' from index 6>,
},
],
cursors: [],

163
reconcile/src/operation_transformation/utils/elongate_operations.rs
View file

@ -10,16 +10,13 @@ where
I: IntoIterator<Item = RawOperation<T>>,
T: PartialEq + Clone + std::fmt::Debug,
{
// This might look bad, but this makes sense. The inserts and deletes can be
// This might look bad, but this makes sense. The inserts and deltes can be
// interleaved, such as: IDIDID and we need to turn this into IIIDDD.
// So we need to keep track of both the last insert and delete operations, not
// just the last one.
let mut maybe_previous_insert: Option<RawOperation<T>> = None;
let mut maybe_previous_delete: Option<RawOperation<T>> = None;
// Equals can't be interleaved with inserts and deletes
let mut maybe_previous_equal: Option<RawOperation<T>> = None;
let mut result: Vec<RawOperation<T>> = raw_operations
.into_iter()
.flat_map(|next| match next {
@ -30,12 +27,7 @@ where
}
prev => {
maybe_previous_insert = Some(next);
Box::new(
maybe_previous_equal
.take()
.into_iter()
.chain(prev.into_iter()),
) as Box<dyn Iterator<Item = RawOperation<T>>>
Box::new(prev.into_iter())
}
},
RawOperation::Delete(..) => match maybe_previous_delete.take() {
@ -45,30 +37,16 @@ where
}
prev => {
maybe_previous_delete = Some(next);
Box::new(
maybe_previous_equal
.take()
.into_iter()
.chain(prev.into_iter()),
) as Box<dyn Iterator<Item = RawOperation<T>>>
}
},
RawOperation::Equal(..) => match maybe_previous_equal.take() {
Some(prev) if prev.is_right_joinable() && next.is_left_joinable() => {
maybe_previous_equal = Some(prev.extend(next));
Box::new(iter::empty()) as Box<dyn Iterator<Item = RawOperation<T>>>
}
prev => {
maybe_previous_equal = Some(next);
Box::new(
maybe_previous_insert
.take()
.into_iter()
.chain(maybe_previous_delete.take())
.chain(prev.into_iter()),
) as Box<dyn Iterator<Item = RawOperation<T>>>
Box::new(prev.into_iter())
}
},
RawOperation::Equal(..) => Box::new(
maybe_previous_insert
.take()
.into_iter()
.chain(maybe_previous_delete.take())
.chain(iter::once(next)),
) as Box<dyn Iterator<Item = RawOperation<T>>>,
})
.collect();
@ -80,75 +58,70 @@ where
result.push(prev);
}
if let Some(prev) = maybe_previous_equal {
result.push(prev);
}
result
}
#[cfg(test)]
// #[cfg(test)]
// mod tests {
mod tests {
// use super::*;
use super::*;
// #[test]
// fn test_elongate_operations_empty() {
// let operations: Vec<RawOperation<()>> = vec![];
// let result = elongate_operations(operations);
// assert_eq!(result, vec![]);
// }
#[test]
fn test_elongate_operations_empty() {
let operations: Vec<RawOperation<()>> = vec![];
let result = elongate_operations(operations);
assert_eq!(result, vec![]);
}
// #[test]
// fn test_elongate_operations_single_operation() {
// let operations = vec![RawOperation::Insert(vec!["test".into()])];
// let result = elongate_operations(operations);
// assert_eq!(result.len(), 1);
// assert!(matches!(result[0], RawOperation::Insert(_)));
// }
#[test]
fn test_elongate_operations_single_operation() {
let operations = vec![RawOperation::Insert(vec!["test".into()])];
let result = elongate_operations(operations);
assert_eq!(result.len(), 1);
assert!(matches!(result[0], RawOperation::Insert(_)));
}
// #[test]
// fn test_elongate_operations_interleaved() {
// let operations = vec![
// RawOperation::Insert(vec!["a".into()]),
// RawOperation::Delete(vec!["b".into()]),
// RawOperation::Insert(vec!["c".into()]),
// RawOperation::Delete(vec!["d".into()]),
// ];
// let result = elongate_operations(operations);
// assert_eq!(result.len(), 2);
// assert!(matches!(result[0], RawOperation::Insert(_)));
// assert!(matches!(result[1], RawOperation::Delete(_)));
// }
#[test]
fn test_elongate_operations_interleaved() {
let operations = vec![
RawOperation::Insert(vec!["a".into()]),
RawOperation::Delete(vec!["b".into()]),
RawOperation::Insert(vec!["c".into()]),
RawOperation::Delete(vec!["d".into()]),
];
let result = elongate_operations(operations);
assert_eq!(result.len(), 2);
assert!(matches!(result[0], RawOperation::Insert(_)));
assert!(matches!(result[1], RawOperation::Delete(_)));
}
// #[test]
// fn test_elongate_operations_with_equal() {
// let operations = vec![
// RawOperation::Equal(vec!["a".into()]),
// RawOperation::Equal(vec!["b".into()]),
// RawOperation::Insert(vec!["c".into()]),
// RawOperation::Insert(vec!["d".into()]),
// ];
// let result = elongate_operations(operations);
// assert_eq!(result.len(), 2);
// assert!(matches!(result[0], RawOperation::Equal(_)));
// assert!(matches!(result[1], RawOperation::Insert(_)));
// }
#[test]
fn test_elongate_operations_with_equal() {
let operations = vec![
RawOperation::Equal(vec!["a".into()]),
RawOperation::Equal(vec!["b".into()]),
RawOperation::Insert(vec!["c".into()]),
RawOperation::Insert(vec!["d".into()]),
];
let result = elongate_operations(operations);
assert_eq!(result.len(), 2);
assert!(matches!(result[0], RawOperation::Equal(_)));
assert!(matches!(result[1], RawOperation::Insert(_)));
}
#[test]
fn test_elongate_operations_mixed_sequence() {
let operations = vec![
RawOperation::Insert(vec!["a".into()]),
RawOperation::Equal(vec!["b".into()]),
RawOperation::Delete(vec!["c".into()]),
RawOperation::Equal(vec!["d".into()]),
];
let result = elongate_operations(operations);
assert_eq!(result.len(), 4);
assert!(matches!(result[0], RawOperation::Insert(_)));
assert!(matches!(result[1], RawOperation::Equal(_)));
assert!(matches!(result[2], RawOperation::Delete(_)));
assert!(matches!(result[3], RawOperation::Equal(_)));
}
}
// #[test]
// fn test_elongate_operations_mixed_sequence() {
// let operations = vec![
// RawOperation::Insert(vec!["a".into()]),
// RawOperation::Equal(vec!["b".into()]),
// RawOperation::Delete(vec!["c".into()]),
// RawOperation::Equal(vec!["d".into()]),
// ];
// let result = elongate_operations(operations);
// assert_eq!(result.len(), 4);
// assert!(matches!(result[0], RawOperation::Insert(_)));
// assert!(matches!(result[1], RawOperation::Equal(_)));
// assert!(matches!(result[2], RawOperation::Delete(_)));
// assert!(matches!(result[3], RawOperation::Equal(_)));
// }
// }