Enum Snippet 

#[repr(u8)]
pub enum Snippet {
    At(Boundary),
    From(Boundary),
    To(Boundary),
    Between {
        start: Boundary,
        end: Boundary,
    },
    All,
}

Specifies a text range through boundary markers or positions.

The exceptions are the Between variant (which takes two Boundary arguments for the start and end; and the All variant (which takes no Boundary argument, because it implies the entire file. The From variant implies an end position of End Of File, and the To variant implies a start position of the Beginning Of File.

Variants

At(Boundary)

Targets a single boundary location.

From(Boundary)

Selects from a boundary to end of file.

To(Boundary)

Selects from beginning of file to a boundary.

Between

Selects the range between two boundaries.

Fields

start: Boundary

Starting boundary of the range.

end: Boundary

Ending boundary of the range.

All

Selects the entire file.

Implementations

impl Snippet

pub fn replace( &self, rope: &Rope, replacement: &str, ) -> Result<Rope, SnippetError>

Replaces the text selected by this snippet with the given replacement string.

This method resolves the snippet’s boundaries to determine the target range, validates the replacement text, and returns a new Rope with the replacement applied.

Behavior by Snippet Type

• Zero-width range (start == end): Performs insertion at the position
• Empty replacement: Performs deletion of the selected range
• Non-empty replacement on non-zero range: Performs edit (replace existing text)

Arguments

• rope - The rope containing the text to modify
• replacement - The string to insert at the resolved position

Returns

Returns a new Rope with the replacement applied.

Errors

Returns SnippetError::BoundaryError if the snippet’s boundaries cannot be resolved. Returns SnippetError::InvalidRange if the resolved range is invalid (start >= end). Returns SnippetError::InvalidUtf8 if the replacement string contains null bytes. Returns SnippetError::OutOfBounds if the resolved range exceeds rope length.

Examples

Insert text at a position:

use textum::{Snippet, Target, Boundary, BoundaryMode};
use ropey::Rope;

let rope = Rope::from_str("hello world");
let target = Target::Char(4); // The o in "hello"
let boundary = Boundary::new(target, BoundaryMode::Exclude); // Exclude the o
let snippet = Snippet::At(boundary);

let result = snippet.replace(&rope, ", beautiful").unwrap();
assert_eq!(result.to_string(), "hello, beautiful world");

Delete a line:

use textum::{Snippet, Target, Boundary, BoundaryMode};
use ropey::Rope;

let rope = Rope::from_str("line1\nline2\nline3\n");
let target = Target::Line(1); // Second line
let boundary = Boundary::new(target, BoundaryMode::Include);
let snippet = Snippet::At(boundary);

let result = snippet.replace(&rope, "").unwrap();
assert_eq!(result.to_string(), "line1\nline3\n");

Replace text between boundaries:

use textum::{Snippet, Target, Boundary, BoundaryMode};
use ropey::Rope;

let rope = Rope::from_str("<!-- comment -->text<!-- /comment -->");
let start_target = Target::Literal("<!-- comment -->".to_string());
let end_target = Target::Literal("<!-- /comment -->".to_string());
let start_boundary = Boundary::new(start_target, BoundaryMode::Exclude);
let end_boundary = Boundary::new(end_target, BoundaryMode::Exclude);
let snippet = Snippet::Between { start: start_boundary, end: end_boundary };

let result = snippet.replace(&rope, "new content").unwrap();
assert_eq!(result.to_string(), "<!-- comment -->new content<!-- /comment -->");

impl Snippet

pub fn resolve(&self, rope: &Rope) -> Result<SnippetResolution, SnippetError>

Resolves this snippet into absolute character indices.

Errors

Returns SnippetError if boundaries cannot be resolved or the resulting range is invalid.

Trait Implementations

impl Clone for Snippet

fn clone(&self) -> Snippet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Snippet

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

Formats the value using the given formatter.

impl Hash for Snippet

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Snippet

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Snippet

impl StructuralPartialEq for Snippet