Struct DocumentChange 

pub struct DocumentChange {
    pub range: TextRange,
    pub new_text: String,
    pub old_text: Option<String>,
}

A single text edit: replace range in the source with new_text.

old_text optionally records what the caller believes the range currently contains. When present, try_apply verifies it against the source and rejects the edit as EditError::StaleEdit on mismatch. Callers should not author undo evidence themselves — apply the change with try_apply and use the derived AppliedChange::inverse instead.

Fields

range: TextRange

The byte range that is replaced.

new_text: String

The text that replaces range.

old_text: Option<String>

Optional precondition: the text the caller expects at range. Verified by try_apply when present.

Implementations

impl DocumentChange

pub fn replace(range: TextRange, new_text: impl Into<String>) -> Self

Creates a change that replaces range with new_text, with no old_text precondition. The true removed text is derived from the source by try_apply.

pub fn replace_expecting( range: TextRange, new_text: impl Into<String>, old_text: impl Into<String>, ) -> Self

Creates a change that replaces range with new_text, asserting that the range currently contains old_text. try_apply rejects the edit as EditError::StaleEdit if the assertion does not hold.

pub fn new( range: TextRange, new_text: impl Into<String>, old_text: impl Into<String>, ) -> Self

👎Deprecated:

trusts caller-authored old_text (unverified undo evidence); use replace/replace_expecting + try_apply

Creates a new DocumentChange from caller-authored parts.

pub fn try_apply(&self, source: &str) -> Result<AppliedChange, EditError>

Applies this change to source, validating it first.

Checks, in order:

1. the range is well-formed (start <= end) — EditError::Range;
2. the range lies within source — EditError::OutOfBounds;
3. both endpoints sit on UTF-8 character boundaries — EditError::NotCharBoundary;
4. if old_text is present, it matches the source at the range — EditError::StaleEdit.

On success, returns an AppliedChange carrying the modified document and an inverse derived from the actual removed text, so the inverse is truthful even if the caller supplied no old_text.

use scrybe_core::change::{DocumentChange, TextRange};

let range = TextRange::try_new(7, 12).unwrap();
let change = DocumentChange::replace(range, "Rust");
let applied = change.try_apply("Hello, world!").unwrap();
assert_eq!(applied.new_text, "Hello, Rust!");
// The inverse is derived from the document, not authored by us.
let undone = applied.inverse.try_apply(&applied.new_text).unwrap();
assert_eq!(undone.new_text, "Hello, world!");

pub fn apply(&self, source: &str) -> String

👎Deprecated:

panics on invalid input; use try_apply

Applies this change to source, returning the modified string.

Panics if the change is invalid for source: range out of bounds or off a character boundary, or (unlike the historical behavior) a present old_text that does not match the source.

pub fn inverse(&self) -> Self

👎Deprecated:

built from caller-authored old_text, which may not match the document; use the derived AppliedChange::inverse from try_apply

Returns the inverse of this change (suitable for undoing).

The inverse replaces the region [start .. start + new_text.len()] (i.e. the bytes written by apply) back with old_text.

Trait Implementations

impl Clone for DocumentChange

fn clone(&self) -> DocumentChange

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DocumentChange

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for DocumentChange

impl PartialEq for DocumentChange

fn eq(&self, other: &DocumentChange) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DocumentChange