388 lines
14 KiB
Rust
388 lines
14 KiB
Rust
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,
|
|
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.
|
|
///
|
|
/// 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.
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
#[derive(Debug, Clone, PartialEq, Default)]
|
|
pub struct EditedText<'a, T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
text: &'a str,
|
|
operations: Vec<OrderedOperation<T>>,
|
|
pub(crate) cursors: Vec<CursorPosition>,
|
|
}
|
|
|
|
impl<'a> EditedText<'a, String> {
|
|
/// Create an `EditedText` from the given original (old) and updated (new)
|
|
/// strings. The returned `EditedText` represents the changes from the
|
|
/// original to the updated text. When the return value is applied to
|
|
/// the original text, it will result in the updated text. The default
|
|
/// word tokenizer is used to tokenize the text which splits the text on
|
|
/// whitespaces.
|
|
#[must_use]
|
|
pub fn from_strings(original: &'a str, updated: TextWithCursors<'a>) -> Self {
|
|
Self::from_strings_with_tokenizer(original, updated, &word_tokenizer)
|
|
}
|
|
}
|
|
|
|
impl<'a, T> EditedText<'a, T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
/// Create an `EditedText` from the given original (old) and updated (new)
|
|
/// strings. The returned `EditedText` represents the changes from the
|
|
/// original to the updated text. When the return value is applied to
|
|
/// the original text, it will result in the updated text. The tokenizer
|
|
/// function is used to tokenize the text.
|
|
pub fn from_strings_with_tokenizer(
|
|
original: &'a str,
|
|
updated: TextWithCursors<'a>,
|
|
tokenizer: &Tokenizer<T>,
|
|
) -> Self {
|
|
let original_tokens = (tokenizer)(original);
|
|
let updated_tokens = (tokenizer)(&updated.text);
|
|
|
|
let diff: Vec<RawOperation<T>> = diff(&original_tokens, &updated_tokens);
|
|
|
|
Self::new(
|
|
original,
|
|
Self::cook_operations(Self::elongate_operations(diff)).collect(),
|
|
updated.cursors,
|
|
)
|
|
}
|
|
|
|
fn elongate_operations<I>(raw_operations: I) -> Vec<RawOperation<T>>
|
|
where
|
|
I: IntoIterator<Item = RawOperation<T>>,
|
|
{
|
|
// 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;
|
|
|
|
let mut result: Vec<RawOperation<T>> = 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<dyn Iterator<Item = RawOperation<T>>>
|
|
}
|
|
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<dyn Iterator<Item = RawOperation<T>>>
|
|
}
|
|
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<dyn Iterator<Item = RawOperation<T>>>,
|
|
})
|
|
.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<I>(raw_operations: I) -> impl Iterator<Item = OrderedOperation<T>>
|
|
where
|
|
I: IntoIterator<Item = RawOperation<T>>,
|
|
{
|
|
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.
|
|
fn new(
|
|
text: &'a str,
|
|
operations: Vec<OrderedOperation<T>>,
|
|
mut cursors: Vec<CursorPosition>,
|
|
) -> Self {
|
|
operations
|
|
.iter()
|
|
.zip(operations.iter().skip(1))
|
|
.for_each(|(previous, next)| {
|
|
debug_assert!(
|
|
previous.operation.start_index() <= next.operation.start_index(),
|
|
"{} must not come before {} yet it does",
|
|
previous.operation,
|
|
next.operation
|
|
);
|
|
});
|
|
|
|
cursors.sort_by_key(|cursor| cursor.char_index);
|
|
|
|
Self {
|
|
text,
|
|
operations,
|
|
cursors,
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn merge(self, other: Self) -> Self {
|
|
debug_assert_eq!(
|
|
self.text, other.text,
|
|
"`EditedText`-s must be derived from the same text to be mergable"
|
|
);
|
|
|
|
let mut left_merge_context = MergeContext::default();
|
|
let mut right_merge_context = MergeContext::default();
|
|
|
|
let mut merged_cursors = Vec::with_capacity(self.cursors.len() + other.cursors.len());
|
|
let mut left_cursors = self.cursors.into_iter().peekable();
|
|
let mut right_cursors = other.cursors.into_iter().peekable();
|
|
|
|
let merged_operations: Vec<OrderedOperation<T>> = self
|
|
.operations
|
|
.into_iter()
|
|
// The current text is always the left; the other operation is the right side.
|
|
.map(|op| (op, Side::Left))
|
|
.merge_sorted_by_key(
|
|
other.operations.into_iter().map(|op| (op, Side::Right)),
|
|
|(operation, _)| {
|
|
(
|
|
operation.order,
|
|
operation.operation.start_index(),
|
|
// Make sure that the ordering is deterministic regardless which text
|
|
// is left or right.
|
|
match &operation.operation {
|
|
Operation::Equal { index, .. } => index.to_string(),
|
|
Operation::Insert { text, .. } => text
|
|
.iter()
|
|
.map(crate::tokenizer::token::Token::original)
|
|
.collect::<String>(),
|
|
Operation::Delete {
|
|
deleted_character_count,
|
|
..
|
|
} => deleted_character_count.to_string(),
|
|
},
|
|
)
|
|
},
|
|
)
|
|
.flat_map(|(OrderedOperation { order, operation }, side)| {
|
|
let original_start = operation.start_index() as i64;
|
|
let original_end = operation.end_index();
|
|
|
|
match side {
|
|
Side::Left => {
|
|
let result = operation.merge_operations_with_context(
|
|
&mut right_merge_context,
|
|
&mut left_merge_context,
|
|
);
|
|
|
|
if let Some(ref op @ (Operation::Insert { .. } | Operation::Equal { .. })) =
|
|
result
|
|
{
|
|
while let Some(mut cursor) =
|
|
left_cursors.next_if(|cursor| cursor.char_index <= original_end + 1)
|
|
{
|
|
let shift = op.start_index() as i64 - original_start;
|
|
|
|
cursor.char_index = (op.start_index() as i64)
|
|
.max(cursor.char_index as i64 + shift)
|
|
as usize;
|
|
merged_cursors.push(cursor);
|
|
}
|
|
}
|
|
|
|
result
|
|
}
|
|
Side::Right => {
|
|
let result = operation.merge_operations_with_context(
|
|
&mut left_merge_context,
|
|
&mut right_merge_context,
|
|
);
|
|
|
|
if let Some(ref op @ (Operation::Insert { .. } | Operation::Equal { .. })) =
|
|
result
|
|
{
|
|
while let Some(mut cursor) = right_cursors
|
|
.next_if(|cursor| cursor.char_index <= original_end + 1)
|
|
{
|
|
let shift = op.start_index() as i64 - original_start;
|
|
|
|
cursor.char_index = (op.start_index() as i64)
|
|
.max(cursor.char_index as i64 + shift)
|
|
as usize;
|
|
merged_cursors.push(cursor);
|
|
}
|
|
}
|
|
|
|
result
|
|
}
|
|
}
|
|
.map(|operation| OrderedOperation { order, operation })
|
|
.into_iter()
|
|
})
|
|
.collect();
|
|
|
|
let last_index = merged_operations
|
|
.iter()
|
|
.filter(|operation| {
|
|
matches!(
|
|
operation.operation,
|
|
Operation::Insert { .. } | Operation::Equal { .. }
|
|
)
|
|
})
|
|
.next_back()
|
|
.map_or(0, |op| op.operation.end_index());
|
|
|
|
for cursor in left_cursors.chain(right_cursors) {
|
|
merged_cursors.push(cursor.with_index(last_index));
|
|
}
|
|
|
|
Self::new(self.text, merged_operations, merged_cursors)
|
|
}
|
|
|
|
/// Apply the operations to the text and return the resulting text.
|
|
#[must_use]
|
|
pub fn apply(&self) -> String {
|
|
let mut builder: StringBuilder<'_> = StringBuilder::new(self.text);
|
|
|
|
for OrderedOperation { operation, .. } in &self.operations {
|
|
builder = operation.apply(builder);
|
|
}
|
|
|
|
builder.build()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::env;
|
|
|
|
use insta::assert_debug_snapshot;
|
|
use pretty_assertions::assert_eq;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_calculate_operations() {
|
|
let left = "hello world! How are you? Adam";
|
|
let right = "Hello, my friend! How are you doing? Albert";
|
|
|
|
let operations = EditedText::from_strings(left, right.into());
|
|
|
|
insta::assert_debug_snapshot!(operations);
|
|
|
|
let new_right = operations.apply();
|
|
assert_eq!(new_right.to_string(), right);
|
|
}
|
|
|
|
#[test]
|
|
fn test_calculate_operations_with_no_diff() {
|
|
let text = "hello world!";
|
|
|
|
let operations = EditedText::from_strings(text, text.into());
|
|
|
|
assert_debug_snapshot!(operations);
|
|
|
|
let new_right = operations.apply();
|
|
assert_eq!(new_right.to_string(), text);
|
|
}
|
|
|
|
#[test]
|
|
fn test_calculate_operations_with_insert() {
|
|
let original = "hello world! ...";
|
|
let left = "Hello world! I'm Andras.";
|
|
let right = "Hello world! How are you?";
|
|
let expected = "Hello world! How are you? I'm Andras.";
|
|
|
|
let operations_1 = EditedText::from_strings(original, left.into());
|
|
let operations_2 = EditedText::from_strings(original, right.into());
|
|
|
|
let operations = operations_1.merge(operations_2);
|
|
assert_eq!(operations.apply(), expected);
|
|
}
|
|
}
|