Struct RopeBuffer 

pub struct RopeBuffer { /* private fields */ }

The open note’s text, cursor, selection and history.

Implementations

impl RopeBuffer

pub fn new(text: Text) -> Self

pub fn replace(&mut self, text: Text)

Replace the whole buffer, dropping the history with it.

pub fn text(&self) -> &Text

pub fn snapshot(&self) -> Snapshot

pub fn row(&self, row: usize) -> Option<Cow<'_, str>>

One row’s text, or None past the end.

pub fn row_count(&self) -> usize

How many rows the buffer has. Never zero.

pub fn rows(&self) -> Vec<String>

Every row, materialised.

Not a cache: nothing is maintained between calls, so the cost lands on the caller that wants a vector rather than on every edit. That is the whole difference from the shim this replaced.

pub fn joined_rows(&self, first: usize, last: usize) -> String

Rows first..=last, joined with newlines.

pub fn row_len(&self, row: usize) -> usize

Characters in one row.

pub fn cursor(&self) -> (usize, usize)

pub fn is_empty(&self) -> bool

pub fn selection_range(&self) -> Option<((usize, usize), (usize, usize))>

pub fn yank_text(&self) -> String

pub fn set_yank_text(&mut self, text: impl Into<String>)

pub fn search_pattern(&self) -> Option<&Regex>

pub fn take_outcome(&mut self) -> EditOutcome

pub fn edit<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R

Run f as one undo group.

Every mutation inside lands in a single history entry, however many primitives it takes. Nested calls belong to the outermost group, so a compound action built from the single-mutation helpers is still one undo.

pub fn continue_group(&mut self)

The next mutation joins the previous group instead of starting one.

The policy is the backend’s, because only it knows what the user was doing — mid-word against after a pause, inside an Insert session against having left it. This is the mechanism; typing_run and the vim engine are the two callers that hold an opinion.

pub fn insert_str(&mut self, s: impl AsRef<str>) -> bool

pub fn insert_char(&mut self, c: char)

pub fn insert_newline(&mut self)

pub fn delete_str(&mut self, clusters: usize) -> bool

Delete clusters grapheme clusters forward, a line break counting as one.

Clusters and not scalars, because a delete may not leave half a character behind: forward_by steps whole clusters, so a caller counting scalars over a flag or a ZWJ emoji spends the difference on the text after it.

pub fn delete_char(&mut self) -> bool

Backspace.

pub fn delete_next_char(&mut self) -> bool

Forward delete.

pub fn delete_word(&mut self) -> bool

pub fn delete_next_word(&mut self) -> bool

pub fn cut(&mut self) -> bool

pub fn copy(&mut self)

Copying reads: it leaves the selection where it is, and an empty one leaves the register alone rather than emptying it.

pub fn paste(&mut self) -> bool

pub fn undo(&mut self) -> bool

pub fn redo(&mut self) -> bool

pub fn cluster_at(&self, row: usize, col: usize) -> (usize, usize)

The character at column col of row, as its start and end columns.

One character on screen can be several chars in the buffer — ❤️ is two, a decomposed é is e plus U+0301 — so “the char under the cursor” is a grapheme cluster, and only its edges are positions the buffer accepts. A column inside a cluster belongs to that cluster; one at or past the row’s end gives the row’s end twice.

The edges are the text’s own (motion::next_cluster), so this can never call a column an edge that the buffer would then refuse.

pub fn clusters_through(&self, row: usize, from: usize, to: usize) -> usize

How many characters (grapheme clusters) columns from..=to of row span. At least one.

One segmentation pass over the row — the same Unicode rule the text applies, over the same row, so the two agree on every edge inside it. Stepping motion::next_cluster per character instead is correct but re-checks context at every step, which on a paragraph-long row is a visible stall.

pub fn col_after_clusters(&self, row: usize, col: usize, n: usize) -> usize

The column n characters right of the character at col on row, stopping at the row’s last character. One pass, as Self::clusters_through.

pub fn set_mark(&mut self, name: char, (row, col): (usize, usize)) -> bool

Put mark name at (row, col). false, setting nothing, when the buffer has no such position.

From here on the mark follows the text it points at: rows added or removed above it carry it along, text typed before it on its row pushes it right, and deleting the text under it collapses it to where the deletion began. Undo and redo put it back where it was before and after each change. The edit buffer owns the marks, beside the cursor and the history that saves them.

pub fn mark(&self, name: char) -> Option<(usize, usize)>

Where mark name points now, if it is set.

pub fn move_cursor(&mut self, movement: CursorMove)

Move the cursor, extending a live selection.

Directional movement keeps the anchor deliberately: that is how vim’s Visual mode extends.

pub fn jump_to(&mut self, row: usize, col: usize) -> bool

Move the cursor to (row, col), refusing a position the buffer cannot address rather than landing somewhere else.

pub fn move_to(&mut self, to: Position)

Move to a position the caller worked out itself — a visual-line motion, which needs a layout the buffer does not have.

pub fn start_selection(&mut self)

pub fn cancel_selection(&mut self)

pub fn select_all(&mut self)

pub fn set_selection( &mut self, start: (usize, usize), end: (usize, usize), ) -> bool

pub fn text_between( &self, start: (usize, usize), end: (usize, usize), ) -> Option<String>

The text between two (row, col) pairs, in either order; None when the range is empty or names a position the buffer cannot address.

pub fn selection_text(&self) -> Option<String>

The selected text, or None when nothing — or nothing of width — is selected.

pub fn indent_rows(&mut self, rows: RangeInclusive<usize>, dedent: bool) -> bool

Indent or dedent rows by one indent step, as one undo group — and one transaction.

Indenting puts indent_width spaces at the start of every row — always spaces, never a tab. Dedenting takes up to one step of leading spaces, or the run up to and including a first tab, which counts as a whole step: " \tfoo" loses both spaces and the tab and stops there.

The cursor keeps the character it sat on — its column moves by its own row’s change, so >> on the n of one leaves it on n, neovim’s rule — and a selection is put back the same way, endpoint by endpoint. Both fall out of the engine’s own mapping across the transaction, so the history entry holds the cursor’s real before and after, and an undo or redo lands where the user was. Rows past the end are ignored. Reports whether any text changed; a dedent that finds nothing to remove changes nothing and says so.

pub fn set_search_pattern(&mut self, pattern: &str) -> Result<(), Error>

pub fn search_forward(&mut self, match_cursor: bool) -> bool

Move the cursor to the next match. Never extends a selection.

pub fn search_back(&mut self, match_cursor: bool) -> bool

Move the cursor to the previous match. Never extends a selection.

pub fn search_repeat(&mut self, backward: bool) -> bool

Repeat the persisted pattern (vim n / N).

pub fn match_at_cursor(&self) -> Option<((usize, usize), (usize, usize))>

The span of the match starting exactly at the cursor, if any.

Trait Implementations

impl Debug for RopeBuffer

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

Formats the value using the given formatter.

impl Default for RopeBuffer

fn default() -> Self

Returns the “default value” for a type.