Struct Patch 

pub struct Patch {
    pub file: String,
    pub snippet: Snippet,
    pub replacement: String,
    pub symbol_path: Option<Vec<String>>,
}

A single atomic patch operation on a file.

Patches operate through the Snippet system, providing flexible target matching and boundary semantics. Character positions are 0-indexed and represent positions in the file as a sequence of Unicode scalar values.

Examples

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

// Replace using literal target
let mut rope = Rope::from_str("hello world");
let patch = Patch::from_literal_target(
    "main.rs".to_string(),
    "world",
    BoundaryMode::Include,
    "rust",
);
patch.apply(&mut rope).unwrap();
assert_eq!(rope.to_string(), "hello rust");

// Delete using line range
let mut rope = Rope::from_str("line1\nline2\nline3\n");
let patch = Patch::from_line_range(
    "main.rs".to_string(),
    1,
    2,
    "",
);
patch.apply(&mut rope).unwrap();
assert_eq!(rope.to_string(), "line1\nline3\n");

Fields

file: String

File path this patch applies to.

snippet: Snippet

Snippet defining the target range for this patch.

replacement: String

Replacement text to insert at the resolved range.

Empty string performs deletion of the resolved range.

symbol_path: Option<Vec<String>>

Available on crate feature symbol_path only.

Optional symbol path for robust positioning (non-functional, reserved for future use).

Implementations

impl Patch

pub fn apply(&self, rope: &mut Rope) -> Result<(), PatchError>

Apply this patch to a rope in-place.

The rope is modified by resolving the snippet to a character range, then removing that range and inserting the replacement text. Changes are applied atomically - if the patch cannot be applied, the rope is left unchanged.

Errors

Returns PatchError if the snippet cannot be resolved or if the resolved range extends beyond the rope’s character count.

Examples

use ropey::Rope;
use textum::Patch;

let mut rope = Rope::from_str("hello world");
let patch = Patch::from_literal_target(
    "test.txt".to_string(),
    "world",
    textum::BoundaryMode::Include,
    "rust",
);

patch.apply(&mut rope).unwrap();
assert_eq!(rope.to_string(), "hello rust");

pub fn from_literal_target( file: String, needle: &str, mode: BoundaryMode, replacement: impl Into<String>, ) -> Self

Create a patch from a literal string target.

Constructs a patch that matches the first occurrence of needle in the file and applies the boundary mode to determine inclusion/exclusion.

Arguments

• file - Path to the file this patch targets
• needle - Exact string to match
• mode - Whether to include, exclude, or extend the boundary
• replacement - Text to insert (empty string for deletion)

Examples

use textum::{Patch, BoundaryMode};

let patch = Patch::from_literal_target(
    "src/main.rs".to_string(),
    "old_name",
    BoundaryMode::Include,
    "new_name",
);

pub fn from_line_range( file: String, start_line: usize, end_line: usize, replacement: impl Into<String>, ) -> Self

Create a patch from a line range.

Constructs a patch that targets a range of lines, with the start line included and the end line excluded (half-open range semantics).

Arguments

• file - Path to the file this patch targets
• start_line - Starting line number (0-indexed, inclusive)
• end_line - Ending line number (0-indexed, exclusive)
• replacement - Text to insert (empty string for deletion)

Examples

use textum::Patch;

// Delete lines 5-10
let patch = Patch::from_line_range(
    "src/main.rs".to_string(),
    5,
    10,
    "",
);

pub fn from_line_positions( file: String, line_start: usize, col_start: usize, line_end: usize, col_end: usize, _rope: &Rope, replacement: impl Into<String>, ) -> Self

Create a patch from line-based positions.

This is useful for interoperating with tools that report positions in terms of lines and columns (like cargo diagnostics). Line and column indices are 0-based.

Arguments

• file - Path to the file this patch targets
• line_start - Starting line number (0-indexed)
• col_start - Starting column within the line (0-indexed)
• line_end - Ending line number (0-indexed)
• col_end - Ending column within the line (0-indexed)
• rope - A rope containing the file content, used to validate positions
• replacement - Replacement text

Examples

use ropey::Rope;
use textum::Patch;

let rope = Rope::from_str("line 1\nline 2\nline 3");
let patch = Patch::from_line_positions(
    "test.txt".to_string(),
    1,
    0,
    1,
    6,
    &rope,
    "EDITED",
);

Trait Implementations

impl Clone for Patch

fn clone(&self) -> Patch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Patch

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

Formats the value using the given formatter.

impl<'__facet> Facet<'__facet> for Patch

const VTABLE: &'static ValueVTable

Function pointers to perform various operations: print the full type name (with generic type parameters), use the Display implementation, the Debug implementation, build a default value, clone, etc.

const SHAPE: &'static Shape

The shape of this type