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

Lint

Browse source
This commit is contained in:
Andras Schmelczer 2025-06-22 14:58:38 +01:00
commit df6ec254ca
No known key found for this signature in database
GPG key ID: FC8F2C3D3D1A718C
4 changed files with 21 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/operation_transformation/edited_text.rs
View file

@ -7,7 +7,7 @@ use crate::{
operation_transformation::utils::{ operation_transformation::utils::{
cook_operations::cook_operations, elongate_operations::elongate_operations, cook_operations::cook_operations, elongate_operations::elongate_operations,
}, },
tokenizer::{word_tokenizer::word_tokenizer, Tokenizer}, tokenizer::{Tokenizer, word_tokenizer::word_tokenizer},
utils::{side::Side, string_builder::StringBuilder}, utils::{side::Side, string_builder::StringBuilder},
}; };

2
src/operation_transformation/operation.rs
View file

@ -245,7 +245,7 @@ where
Operation::create_delete_with_text( Operation::create_delete_with_text(
order + overlap, order + overlap,
text.chars() text.chars()
.skip((deleted_character_count - new_length) as usize) .skip(deleted_character_count - new_length)
.collect::<String>(), .collect::<String>(),
) )
}, },

25
src/operation_transformation/utils/cook_operations.rs
View file

@ -1,12 +1,13 @@
use crate::{diffs::raw_operation::RawOperation, operation_transformation::Operation}; use crate::{diffs::raw_operation::RawOperation, operation_transformation::Operation};
/// Turn raw operations into ordered operations while keeping track of indexes. /// Turn raw operations into ordered operations while keeping track of the
/// original token's indexes.
pub fn cook_operations<I, T>(raw_operations: I) -> impl Iterator<Item = Operation<T>> pub fn cook_operations<I, T>(raw_operations: I) -> impl Iterator<Item = Operation<T>>
where where
I: IntoIterator<Item = RawOperation<T>>, I: IntoIterator<Item = RawOperation<T>>,
T: PartialEq + Clone + std::fmt::Debug, T: PartialEq + Clone + std::fmt::Debug,
{ {
let mut order = 0; // this is the start index of the operation on the original text let mut original_text_index = 0; // this is the start index of the operation on the original text
raw_operations.into_iter().map(move |raw_operation| { raw_operations.into_iter().map(move |raw_operation| {
let length = raw_operation.original_text_length(); let length = raw_operation.original_text_length();
@ -14,24 +15,30 @@ where
match raw_operation { match raw_operation {
RawOperation::Equal(..) => { RawOperation::Equal(..) => {
let op = if cfg!(debug_assertions) { let op = if cfg!(debug_assertions) {
Operation::create_equal_with_text(order, raw_operation.get_original_text()) Operation::create_equal_with_text(
original_text_index,
raw_operation.get_original_text(),
)
} else { } else {
Operation::create_equal(order, length) Operation::create_equal(original_text_index, length)
}; };
order += length; original_text_index += length;
op op
} }
RawOperation::Insert(tokens) => Operation::create_insert(order, tokens), RawOperation::Insert(tokens) => Operation::create_insert(original_text_index, tokens),
RawOperation::Delete(..) => { RawOperation::Delete(..) => {
let op = if cfg!(debug_assertions) { let op = if cfg!(debug_assertions) {
Operation::create_delete_with_text(order, raw_operation.get_original_text()) Operation::create_delete_with_text(
original_text_index,
raw_operation.get_original_text(),
)
} else { } else {
Operation::create_delete(order, length) Operation::create_delete(original_text_index, length)
}; };
order += length; original_text_index += length;
op op
} }

68
src/operation_transformation/utils/elongate_operations.rs
View file

@ -17,6 +17,9 @@ where
let mut maybe_previous_insert: Option<RawOperation<T>> = None; let mut maybe_previous_insert: Option<RawOperation<T>> = None;
let mut maybe_previous_delete: Option<RawOperation<T>> = None; let mut maybe_previous_delete: Option<RawOperation<T>> = None;
// We don't elongate `equals` as they're needed to maintain cursor positions
// when merging against deletes.
let mut result: Vec<RawOperation<T>> = raw_operations let mut result: Vec<RawOperation<T>> = raw_operations
.into_iter() .into_iter()
.flat_map(|next| match next { .flat_map(|next| match next {
@ -60,68 +63,3 @@ where
result result
} }
// #[cfg(test)]
// mod tests {
// 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_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_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(_)));
// }
// }