From 2dc0ada1fbb44371288315dd2ec712ee0eaa7f0f Mon Sep 17 00:00:00 2001 From: Andras Schmelczer Date: Sat, 14 Jun 2025 11:44:20 +0100 Subject: [PATCH] Extract utils --- .../operation_transformation/edited_text.rs | 132 ++---------------- .../src/operation_transformation/utils.rs | 2 + .../utils/cook_operations.rs | 55 ++++++++ .../utils/elongate_operations.rs | 62 ++++++++ 4 files changed, 132 insertions(+), 119 deletions(-) create mode 100644 backend/reconcile/src/operation_transformation/utils.rs create mode 100644 backend/reconcile/src/operation_transformation/utils/cook_operations.rs create mode 100644 backend/reconcile/src/operation_transformation/utils/elongate_operations.rs diff --git a/backend/reconcile/src/operation_transformation/edited_text.rs b/backend/reconcile/src/operation_transformation/edited_text.rs index b83441f6..1e6bf849 100644 --- a/backend/reconcile/src/operation_transformation/edited_text.rs +++ b/backend/reconcile/src/operation_transformation/edited_text.rs @@ -1,23 +1,29 @@ -use core::iter; - #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; use super::{CursorPosition, Operation, TextWithCursors, ordered_operation::OrderedOperation}; use crate::{ diffs::{myers::diff, raw_operation::RawOperation}, - operation_transformation::merge_context::MergeContext, + operation_transformation::{ + merge_context::MergeContext, + utils::{cook_operations::cook_operations, elongate_operations::elongate_operations}, + }, tokenizer::{Tokenizer, word_tokenizer::word_tokenizer}, utils::{merge_iters::MergeSorted as _, side::Side, string_builder::StringBuilder}, }; -/// A sequence of operations that can be applied to a text document. -/// `EditedText` supports merging two sequences of operations using the -/// principle of Operational Transformation. +/// A text document and a sequence of operations that can be applied to the text +/// document. `EditedText` supports merging two sequences of operations using +/// the principles of Operational Transformation. /// /// It's mainly created through the `from_strings` method, then merged with /// another `EditedText` derived from the same original text and then applied to /// the original text to get the reconciled text of concurrent edits. +/// +/// In addition to text and operations, it also keeps track of cursor positions +/// in the original text. The cursor positions are updated when the operations +/// are applied, so that the cursor positions can be used to restore the +/// cursor positions in the updated text. #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[derive(Debug, Clone, PartialEq, Default)] pub struct EditedText<'a, T> @@ -63,123 +69,11 @@ where Self::new( original, - Self::cook_operations(Self::elongate_operations(diff)).collect(), + cook_operations(elongate_operations(diff)).collect(), updated.cursors, ) } - fn elongate_operations(raw_operations: I) -> Vec> - where - I: IntoIterator>, - { - // 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> = None; - let mut maybe_previous_delete: Option> = None; - - let mut result: Vec> = raw_operations - .into_iter() - .flat_map(|next| match next { - RawOperation::Insert(..) => match maybe_previous_insert.take() { - Some(prev) if prev.is_right_joinable() && next.is_left_joinable() => { - maybe_previous_insert = Some(prev.extend(next)); - Box::new(iter::empty()) as Box>> - } - prev => { - maybe_previous_insert = Some(next); - Box::new(prev.into_iter()) - } - }, - RawOperation::Delete(..) => match maybe_previous_delete.take() { - Some(prev) if prev.is_right_joinable() && next.is_left_joinable() => { - maybe_previous_delete = Some(prev.extend(next)); - Box::new(iter::empty()) as Box>> - } - prev => { - maybe_previous_delete = Some(next); - 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>>, - }) - .collect(); - - if let Some(prev) = maybe_previous_insert { - result.push(prev); - } - - if let Some(prev) = maybe_previous_delete { - result.push(prev); - } - - result - } - - // Turn raw operations into ordered operations while keeping track of old & new - // indexes. - fn cook_operations(raw_operations: I) -> impl Iterator> - where - I: IntoIterator>, - { - let mut new_index = 0; // this is the start index of the operation on the new text - let mut order = 0; // this is the start index of the operation on the original text - - raw_operations.into_iter().filter_map(move |raw_operation| { - let length = raw_operation.original_text_length(); - - match raw_operation { - RawOperation::Equal(..) => { - let op = if cfg!(debug_assertions) { - Operation::create_equal_with_text( - new_index, - raw_operation.get_original_text(), - ) - } else { - Operation::create_equal(new_index, length) - } - .map(|operation| OrderedOperation { order, operation }); - - new_index += length; - order += length; - - op - } - RawOperation::Insert(tokens) => { - let op = Operation::create_insert(new_index, tokens) - .map(|operation| OrderedOperation { order, operation }); - - new_index += length; - - op - } - RawOperation::Delete(..) => { - let op = if cfg!(debug_assertions) { - Operation::create_delete_with_text( - new_index, - raw_operation.get_original_text(), - ) - } else { - Operation::create_delete(new_index, length) - } - .map(|operation| OrderedOperation { order, operation }); - - order += length; - - op - } - } - }) - } - /// Create a new `EditedText` with the given operations. /// The operations must be in the order in which they are meant to be /// applied. The operations must not overlap. diff --git a/backend/reconcile/src/operation_transformation/utils.rs b/backend/reconcile/src/operation_transformation/utils.rs new file mode 100644 index 00000000..5169be92 --- /dev/null +++ b/backend/reconcile/src/operation_transformation/utils.rs @@ -0,0 +1,2 @@ +pub mod cook_operations; +pub mod elongate_operations; diff --git a/backend/reconcile/src/operation_transformation/utils/cook_operations.rs b/backend/reconcile/src/operation_transformation/utils/cook_operations.rs new file mode 100644 index 00000000..44056898 --- /dev/null +++ b/backend/reconcile/src/operation_transformation/utils/cook_operations.rs @@ -0,0 +1,55 @@ +use crate::{ + diffs::raw_operation::RawOperation, + operation_transformation::{Operation, ordered_operation::OrderedOperation}, +}; + +/// Turn raw operations into ordered operations while keeping track of old & new +/// indexes. +pub fn cook_operations(raw_operations: I) -> impl Iterator> +where + I: IntoIterator>, + T: PartialEq + Clone + std::fmt::Debug, +{ + let mut new_index = 0; // this is the start index of the operation on the new text + let mut order = 0; // this is the start index of the operation on the original text + + raw_operations.into_iter().filter_map(move |raw_operation| { + let length = raw_operation.original_text_length(); + + match raw_operation { + RawOperation::Equal(..) => { + let op = if cfg!(debug_assertions) { + Operation::create_equal_with_text(new_index, raw_operation.get_original_text()) + } else { + Operation::create_equal(new_index, length) + } + .map(|operation| OrderedOperation { order, operation }); + + new_index += length; + order += length; + + op + } + RawOperation::Insert(tokens) => { + let op = Operation::create_insert(new_index, tokens) + .map(|operation| OrderedOperation { order, operation }); + + new_index += length; + + op + } + RawOperation::Delete(..) => { + let op = if cfg!(debug_assertions) { + Operation::create_delete_with_text(new_index, raw_operation.get_original_text()) + } else { + Operation::create_delete(new_index, length) + } + .map(|operation| OrderedOperation { order, operation }); + + order += length; + + op + } + } + }) +} diff --git a/backend/reconcile/src/operation_transformation/utils/elongate_operations.rs b/backend/reconcile/src/operation_transformation/utils/elongate_operations.rs new file mode 100644 index 00000000..c0a19811 --- /dev/null +++ b/backend/reconcile/src/operation_transformation/utils/elongate_operations.rs @@ -0,0 +1,62 @@ +use core::iter; + +use crate::diffs::raw_operation::RawOperation; + +/// Elongates the operations by merging adjacent insertions and deletions that +/// can be joined. This makes the subsequent merging of operations more +/// intuitive. +pub fn elongate_operations(raw_operations: I) -> Vec> +where + I: IntoIterator>, + T: PartialEq + Clone + std::fmt::Debug, +{ + // This might look bad, but this makes sense. The inserts and deletes 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> = None; + let mut maybe_previous_delete: Option> = None; + + let mut result: Vec> = raw_operations + .into_iter() + .flat_map(|next| match next { + RawOperation::Insert(..) => match maybe_previous_insert.take() { + Some(prev) if prev.is_right_joinable() && next.is_left_joinable() => { + maybe_previous_insert = Some(prev.extend(next)); + Box::new(iter::empty()) as Box>> + } + prev => { + maybe_previous_insert = Some(next); + Box::new(prev.into_iter()) + } + }, + RawOperation::Delete(..) => match maybe_previous_delete.take() { + Some(prev) if prev.is_right_joinable() && next.is_left_joinable() => { + maybe_previous_delete = Some(prev.extend(next)); + Box::new(iter::empty()) as Box>> + } + prev => { + maybe_previous_delete = Some(next); + 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>>, + }) + .collect(); + + if let Some(prev) = maybe_previous_insert { + result.push(prev); + } + + if let Some(prev) = maybe_previous_delete { + result.push(prev); + } + + result +}