Enum Edit

Source

pub enum Edit {
    Insert {
        position: Position,
        text: String,
    },
    Delete {
        position: Position,
        text: String,
    },
}

Expand description

A single atomic edit operation.

Edits are self-contained and can be inverted for undo/redo. Each edit records the position where it occurred and the text involved.

§Undo/Redo

Use Edit::inverse to get the operation that undoes this edit:

Insert becomes Delete
Delete becomes Insert

§Example

use reovim_kernel::api::v1::*;

let insert = Edit::insert(Position::new(0, 5), "Hello");
assert!(insert.is_insert());
assert_eq!(insert.text(), "Hello");

// Get the inverse for undo
let undo = insert.inverse();
assert!(undo.is_delete());
assert_eq!(undo.position(), Position::new(0, 5));

Variants§

§

Insert

Text was inserted at a position.

Fields

§position: Position

Position where text was inserted.

§text: String

The inserted text.

§

Delete

Text was deleted at a position.

Fields

§position: Position

Position where deletion started.

§text: String

The deleted text.

Implementations§

Source §

impl Edit

Source

pub fn insert(position: Position, text: impl Into<String>) -> Self

Create an insert edit.

Source

pub fn delete(position: Position, text: impl Into<String>) -> Self

Create a delete edit.

Source

pub fn inverse(&self) -> Self

Get the inverse of this edit (for undo).

Insert becomes Delete and vice versa. The position and text are preserved.

Source

pub const fn position(&self) -> Position

Get the position where this edit occurred.

Source

pub fn text(&self) -> &str

Get the text involved in this edit.

Source

pub const fn is_insert(&self) -> bool

Check if this edit is an insertion.

Source

pub const fn is_delete(&self) -> bool

Check if this edit is a deletion.

Source

pub fn is_empty(&self) -> bool

Check if this edit has no effect (empty text).

Source

pub fn transform(&self, against: &Self) -> Self

Transform this edit’s position through another edit.

Returns a new edit with the same text but a position adjusted to account for the effect of against. This is the OT inclusion transformation (IT) applied at the edit level.

§Example

use reovim_kernel::api::v1::*;

// An insert at (0,5) transformed through an earlier insert of "abc" at (0,2)
let edit = Edit::insert(Position::new(0, 5), "hello");
let against = Edit::insert(Position::new(0, 2), "abc");
let transformed = edit.transform(&against);
assert_eq!(transformed.position(), Position::new(0, 8)); // 5 + 3
assert_eq!(transformed.text(), "hello"); // text unchanged