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 indent_width(&self) -> u8

Spaces one indent step inserts. Both backends read this, so >> and Tab move a line by the same amount.

pub fn set_indent_width(&mut self, spaces: u8)

pub fn hard_tab_indent(&self) -> bool

pub fn set_hard_tab_indent(&mut self, hard: bool)

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 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 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.

pub fn span_between( &self, start: (usize, usize), end: (usize, usize), ) -> Option<Span>

The span between two (row, col) pairs, for callers that still speak in them.

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.