andras/reconcile
andras/reconcile
Watch
1
0
Fork
You've already forked reconcile
 0
Code Issues Pull requests 10 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
commit 82e77eec89
No known key found for this signature in database
GPG key ID: FC8F2C3D3D1A718C
1 changed files with 96 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

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(_)));
// }
// }