465 lines
16 KiB
Rust
465 lines
16 KiB
Rust
use core::fmt::{Debug, Display};
|
|
use std::ops::Range;
|
|
|
|
#[cfg(feature = "serde")]
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use super::merge_context::MergeContext;
|
|
use crate::{
|
|
Token,
|
|
operation_transformation::ordered_operation::OrderedOperation,
|
|
utils::{
|
|
find_longest_prefix_contained_within::find_longest_prefix_contained_within,
|
|
string_builder::StringBuilder,
|
|
},
|
|
};
|
|
|
|
/// Represents a change that can be applied on a `StringBuilder`.
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
#[derive(Clone, PartialEq)]
|
|
pub enum Operation<T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
Equal {
|
|
length: usize,
|
|
|
|
#[cfg(debug_assertions)]
|
|
text: Option<String>,
|
|
},
|
|
|
|
Insert {
|
|
text: Vec<Token<T>>,
|
|
},
|
|
|
|
Delete {
|
|
deleted_character_count: usize,
|
|
|
|
#[cfg(debug_assertions)]
|
|
deleted_text: Option<String>,
|
|
},
|
|
}
|
|
|
|
|
|
|
|
impl<T> Operation<T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
/// Creates an equal operation with the given index.
|
|
/// This operation is used to indicate that the text at the given index
|
|
/// is unchanged.
|
|
pub fn create_equal( length: usize) -> Option<Self> {
|
|
Some(Operation::Equal {
|
|
length,
|
|
|
|
#[cfg(debug_assertions)]
|
|
text: None,
|
|
})
|
|
}
|
|
|
|
pub fn create_equal_with_text( text: String) -> Option<Self> {
|
|
if text.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
Some(Operation::Equal {
|
|
length: text.chars().count(),
|
|
|
|
#[cfg(debug_assertions)]
|
|
text: Some(text),
|
|
})
|
|
}
|
|
|
|
/// Creates an insert operation with the given index and text.
|
|
/// If the text is empty (meaning that the operation would be a no-op),
|
|
/// returns None.
|
|
pub fn create_insert(text: Vec<Token<T>>) -> Option<Self> {
|
|
if text.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
Some(Operation::Insert { text })
|
|
}
|
|
|
|
/// Creates a delete operation with the given index and number of
|
|
/// to-be-deleted characters. If the operation would delete 0 (meaning
|
|
/// that the operation would be a no-op), returns None.
|
|
pub fn create_delete(deleted_character_count: usize) -> Option<Self> {
|
|
if deleted_character_count == 0 {
|
|
return None;
|
|
}
|
|
|
|
Some(Operation::Delete {
|
|
deleted_character_count,
|
|
|
|
#[cfg(debug_assertions)]
|
|
deleted_text: None,
|
|
})
|
|
}
|
|
|
|
pub fn create_delete_with_text(text: String) -> Option<Self> {
|
|
if text.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
Some(Operation::Delete {
|
|
deleted_character_count: text.chars().count(),
|
|
|
|
#[cfg(debug_assertions)]
|
|
deleted_text: Some(text),
|
|
})
|
|
}
|
|
|
|
/// Applies the operation to the given `StringBuilder`, returning the
|
|
/// modified `StringBuilder`.
|
|
///
|
|
/// When compiled in debug mode, panics if a delete operation is attempted
|
|
/// on a range of text that does not match the text to be deleted.
|
|
pub fn apply<'a>(&self, mut builder: StringBuilder<'a>) -> StringBuilder<'a> {
|
|
match self {
|
|
Operation::Equal {
|
|
#[cfg(debug_assertions)]
|
|
text,
|
|
length,
|
|
..
|
|
} => {
|
|
#[cfg(debug_assertions)]
|
|
debug_assert!(
|
|
text.as_ref()
|
|
.is_none_or(|text| builder.get_slice(self.range()) == *text),
|
|
"Text (`{}`) which is supposed to be equal does not match the text in the \
|
|
range: `{}`",
|
|
text.as_ref().unwrap_or(&"".to_owned()),
|
|
builder.get_slice(self.range())
|
|
);
|
|
|
|
builder.retain(*length)
|
|
}
|
|
Operation::Insert { text, .. } => {
|
|
builder.insert(&text.iter().map(Token::original).collect::<String>())
|
|
}
|
|
Operation::Delete {
|
|
#[cfg(debug_assertions)]
|
|
deleted_text,
|
|
deleted_character_count,
|
|
..
|
|
} => {
|
|
#[cfg(debug_assertions)]
|
|
debug_assert!(
|
|
deleted_text
|
|
.as_ref()
|
|
.is_none_or(|text| builder.get_slice(self.range()) == *text),
|
|
"Text to-be-deleted `{}` does not match the text in the range: `{}`",
|
|
deleted_text.as_ref().unwrap_or(&"".to_owned()),
|
|
builder.get_slice(self.range())
|
|
);
|
|
|
|
builder.delete(*deleted_character_count)
|
|
}
|
|
}
|
|
|
|
builder
|
|
}
|
|
|
|
|
|
/// Returns the number of affected characters. It is always greater than 0
|
|
/// because empty operations cannot be created.
|
|
pub fn len(&self) -> usize {
|
|
match self {
|
|
Operation::Equal { length, .. } => *length,
|
|
Operation::Insert { text, .. } => text.iter().map(Token::get_original_length).sum(),
|
|
Operation::Delete {
|
|
deleted_character_count,
|
|
..
|
|
} => *deleted_character_count,
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Merges the operation with the given context, producing a new operation
|
|
/// and updating the context. This implements a comples FSM that handles
|
|
/// the merging of operations in a way that is consistent with the text.
|
|
/// The contexts are updated in-place.
|
|
#[allow(clippy::too_many_lines)]
|
|
pub fn merge_operations_with_context(
|
|
self,
|
|
order: usize,
|
|
affecting_context: &mut MergeContext<T>,
|
|
produced_context: &mut MergeContext<T>,
|
|
other_operation: Option<OrderedOperation<T>>,
|
|
) -> Option<Operation<T>> {
|
|
affecting_context.consume_last_operation_if_it_is_too_behind(self.start_index() as i64);
|
|
let operation = self.with_shifted_index(affecting_context.shift);
|
|
|
|
match (operation, affecting_context.last_operation()) {
|
|
(operation @ Operation::Insert { .. }, None | Some(Operation::Equal { .. })) => {
|
|
produced_context.shift += operation.len() as i64;
|
|
produced_context.consume_and_replace_last_operation(Some(operation.clone()));
|
|
Some(operation)
|
|
}
|
|
|
|
(
|
|
Operation::Insert { text, index },
|
|
Some(Operation::Insert {
|
|
text: previous_inserted_text,
|
|
..
|
|
}),
|
|
) => {
|
|
// In case the current insert's prefix appears in the previously inserted text,
|
|
// we can trim the current insert to only include the non-overlapping part.
|
|
// This way, we don't end up duplicating text.
|
|
let offset_in_tokens =
|
|
find_longest_prefix_contained_within(previous_inserted_text, &text);
|
|
let offset_in_length = text
|
|
.iter()
|
|
.take(offset_in_tokens)
|
|
.map(Token::get_original_length)
|
|
.sum::<usize>();
|
|
let trimmed_operation =
|
|
Operation::create_insert(index, text[offset_in_tokens..].to_vec());
|
|
|
|
affecting_context.shift -= offset_in_length as i64;
|
|
produced_context.shift += trimmed_operation
|
|
.as_ref()
|
|
.map(Operation::len)
|
|
.unwrap_or_default() as i64;
|
|
produced_context.consume_and_replace_last_operation(trimmed_operation.clone());
|
|
|
|
trimmed_operation
|
|
}
|
|
|
|
(
|
|
operation @ Operation::Delete { .. },
|
|
None | Some(Operation::Insert { .. } | Operation::Equal { .. }),
|
|
) => {
|
|
produced_context.consume_and_replace_last_operation(Some(operation.clone()));
|
|
Some(operation)
|
|
}
|
|
|
|
(
|
|
operation @ Operation::Insert { .. },
|
|
Some(last_delete @ Operation::Delete { .. }),
|
|
) => {
|
|
produced_context.shift += operation.len() as i64;
|
|
|
|
debug_assert!(
|
|
last_delete.range().contains(&operation.start_index()),
|
|
"There is a last delete ({last_delete}) but the operation ({operation}) is \
|
|
not contained in it"
|
|
);
|
|
|
|
let difference = operation.start_index() as i64 - last_delete.start_index() as i64;
|
|
|
|
let moved_operation = operation.with_index(last_delete.start_index());
|
|
|
|
affecting_context.replace_last_operation(Operation::create_delete(
|
|
moved_operation.end_index(),
|
|
(last_delete.len() as i64 - difference) as usize,
|
|
));
|
|
affecting_context.shift -= difference;
|
|
|
|
produced_context.consume_and_replace_last_operation(Some(moved_operation.clone()));
|
|
|
|
Some(moved_operation)
|
|
}
|
|
|
|
(
|
|
operation @ Operation::Delete { .. },
|
|
Some(last_delete @ Operation::Delete { .. }),
|
|
) => {
|
|
debug_assert!(
|
|
last_delete.range().contains(&operation.start_index()),
|
|
"There is a last delete ({last_delete}) but the operation ({operation}) is \
|
|
not contained in it"
|
|
);
|
|
|
|
let difference = operation.start_index() as i64 - last_delete.start_index() as i64;
|
|
|
|
let updated_delete = Operation::create_delete(
|
|
last_delete.start_index(),
|
|
0.max(operation.end_index() as i64 - last_delete.end_index() as i64) as usize,
|
|
);
|
|
|
|
affecting_context.replace_last_operation(Operation::create_delete(
|
|
last_delete.start_index(),
|
|
0.max(last_delete.end_index() as i64 - operation.end_index() as i64) as usize,
|
|
));
|
|
affecting_context.shift -= difference;
|
|
|
|
produced_context.consume_and_replace_last_operation(updated_delete.clone());
|
|
|
|
updated_delete
|
|
}
|
|
(
|
|
ref operation @ Operation::Equal {
|
|
length,
|
|
#[cfg(debug_assertions)]
|
|
ref text,
|
|
..
|
|
},
|
|
Some(last_delete @ Operation::Delete { .. }),
|
|
) => {
|
|
debug_assert!(
|
|
last_delete.range().contains(&operation.start_index()),
|
|
"There is a last delete ({last_delete}) but the operation ({operation}) is \
|
|
not contained in it"
|
|
);
|
|
|
|
let overlap = (length as i64)
|
|
.min(last_delete.end_index() as i64 - operation.start_index() as i64);
|
|
|
|
#[cfg(debug_assertions)]
|
|
let result = text.as_ref().map_or_else(
|
|
|| {
|
|
Operation::create_equal(
|
|
operation.end_index().min(last_delete.end_index()) - 1,
|
|
(length as i64 - overlap) as usize,
|
|
)
|
|
},
|
|
|text| {
|
|
Operation::create_equal_with_text(
|
|
operation.end_index().min(last_delete.end_index()) - 1,
|
|
text.chars().skip(overlap as usize).collect::<String>(),
|
|
)
|
|
},
|
|
);
|
|
|
|
#[cfg(not(debug_assertions))]
|
|
let result = Operation::create_equal(
|
|
operation.end_index().min(last_delete.end_index()),
|
|
(length as i64 - overlap) as usize,
|
|
);
|
|
|
|
result
|
|
}
|
|
|
|
(operation @ Operation::Equal { .. }, _) => {
|
|
let result = if let Some(other_operation) = other_operation {
|
|
if matches!(other_operation.operation, Operation::Equal { .. })
|
|
&& operation.len() == other_operation.operation.len()
|
|
&& order == other_operation.order
|
|
{
|
|
println!(" !!!equal to next");
|
|
Operation::create_equal(operation.start_index(), 0)
|
|
} else {
|
|
Some(operation)
|
|
}
|
|
} else {
|
|
Some(operation)
|
|
};
|
|
|
|
produced_context.consume_and_replace_last_operation(result.clone());
|
|
|
|
result
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> Display for Operation<T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
match self {
|
|
Operation::Equal {
|
|
length,
|
|
|
|
#[cfg(debug_assertions)]
|
|
text,
|
|
} => {
|
|
#[cfg(debug_assertions)]
|
|
write!(
|
|
f,
|
|
"<equal {}>",
|
|
text.as_ref()
|
|
.map(|text| format!("'{}'", text.replace('\n', "\\n")))
|
|
.unwrap_or(format!("{length} characters")),
|
|
)?;
|
|
|
|
#[cfg(not(debug_assertions))]
|
|
write!(f, "<equal {length}>")?;
|
|
|
|
Ok(())
|
|
}
|
|
Operation::Insert { text } => {
|
|
write!(
|
|
f,
|
|
"<insert '{}'>",
|
|
text.iter()
|
|
.map(Token::original)
|
|
.collect::<String>()
|
|
.replace('\n', "\\n"),
|
|
)
|
|
}
|
|
Operation::Delete {
|
|
deleted_character_count,
|
|
|
|
#[cfg(debug_assertions)]
|
|
deleted_text,
|
|
} => {
|
|
#[cfg(debug_assertions)]
|
|
write!(
|
|
f,
|
|
"<delete {}>",
|
|
deleted_text
|
|
.as_ref()
|
|
.map(|text| format!("'{}'", text.replace('\n', "\\n")))
|
|
.unwrap_or(format!("{deleted_character_count} characters")),
|
|
)?;
|
|
|
|
#[cfg(not(debug_assertions))]
|
|
write!(
|
|
f,
|
|
"<delete {deleted_character_count} characters>",
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> Debug for Operation<T>
|
|
where
|
|
T: PartialEq + Clone + std::fmt::Debug,
|
|
{
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{self}") }
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use pretty_assertions::assert_eq;
|
|
|
|
use super::*;
|
|
|
|
|
|
#[test]
|
|
fn test_apply_delete_with_create() {
|
|
let builder = StringBuilder::new("hello world");
|
|
let delete_operation =
|
|
Operation::<()>::create_delete_with_text("hello ".to_owned()).unwrap();
|
|
let retain_operation = Operation::<()>::create_equal( 5).unwrap();
|
|
|
|
let mut builder = delete_operation.apply(builder);
|
|
builder = retain_operation.apply(builder);
|
|
|
|
assert_eq!(builder.build(), "world");
|
|
}
|
|
|
|
#[test]
|
|
fn test_apply_insert() {
|
|
let builder = StringBuilder::new("hello");
|
|
|
|
let retain_operation = Operation::<()>::create_equal(5).unwrap();
|
|
let insert_operation = Operation::create_insert(vec![" my friend".into()]).unwrap();
|
|
|
|
let mut builder = retain_operation.apply(builder);
|
|
builder = insert_operation.apply(builder);
|
|
|
|
assert_eq!(builder.build(), "hello my friend");
|
|
}
|
|
}
|