Struct Buffer 

pub struct Buffer { /* private fields */ }

In-memory text buffer + cursor + viewport + per-row span cache.

This is the core type the rest of sqeel-buffer builds on. Phase 1 of the migration ships construction + getters only; motion / edit / render APIs land in later phases. The lines invariant — at least one entry, never empty — is preserved by every later mutation.

Implementations

impl Buffer

pub fn new() -> Self

Construct an empty buffer with one empty row + cursor at (0, 0). Caller publishes a viewport size on first draw.

pub fn from_str(text: &str) -> Self

Build a buffer from a flat string. Splits on \n; a trailing \n produces a trailing empty line (matches every text editor’s behaviour and keeps from_text(buf.as_string()) an identity round-trip in the common case).

pub fn lines(&self) -> &[String]

pub fn line(&self, row: usize) -> Option<&str>

pub fn cursor(&self) -> Position

pub fn sticky_col(&self) -> Option<usize>

pub fn viewport(&self) -> Viewport

pub fn viewport_mut(&mut self) -> &mut Viewport

pub fn dirty_gen(&self) -> u64

pub fn set_cursor(&mut self, pos: Position)

Set cursor without scrolling. Caller is responsible for calling Buffer::ensure_cursor_visible when they want viewport follow. Clamps row and col to valid positions so motion helpers don’t have to repeat the bound check.

pub fn set_sticky_col(&mut self, col: Option<usize>)

Replace the sticky col (vim’s curswant). Motion code sets this after vertical / horizontal moves; the buffer doesn’t touch it on its own.

pub fn ensure_cursor_visible(&mut self)

Bring the cursor into the visible viewport, scrolling by the minimum amount needed. When viewport.wrap != Wrap::None and viewport.text_width > 0, scrolling is screen-line aware: top_row is advanced one visible doc row at a time until the cursor’s screen row falls inside the viewport’s height.

pub fn cursor_screen_row(&self) -> Option<usize>

Cursor’s screen row offset (0-based) from viewport.top_row under the current wrap mode + text_width. None when wrap is off, the cursor row is hidden by a fold, or the cursor sits above top_row. Used by host-side scrolloff math.

pub fn screen_rows_between(&self, start: usize, end: usize) -> usize

Number of screen rows the doc range start..=end occupies under the current wrap mode. Skips fold-hidden rows. Empty / past-end ranges return 0. Wrap::None returns the visible doc-row count (one screen row per doc row).

pub fn max_top_for_height(&self, height: usize) -> usize

Earliest top_row such that screen_rows_between(top, last) is at least height. Lets host-side scrolloff math clamp top_row so the buffer never leaves blank rows below the content. When the buffer’s total screen rows are smaller than height this returns 0.

pub fn clamp_position(&self, pos: Position) -> Position

Clamp pos to the buffer’s content. Out-of-range row gets pulled to the last row; out-of-range col gets pulled to the row’s char count (one past last char — insertion point).

pub fn set_spans(&mut self, spans: Vec<Vec<Span>>)

Replace the per-row syntax span overlay. Used by the host once tree-sitter (or any other producer) has fresh styling for the visible window. spans[row] corresponds to row row; rows beyond spans.len() get no styling.

pub fn replace_all(&mut self, text: &str)

Replace the buffer’s full text in place. Cursor + sticky col are clamped to the new content; viewport stays put. Used during the migration off tui-textarea so the buffer can mirror the textarea’s content after every edit without rebuilding the whole struct.

pub fn marks(&self) -> &BTreeMap<char, Position>

pub fn spans(&self) -> &[Vec<Span>]

pub fn as_string(&self) -> String

Concatenate the rows into a single String joined by \n. Inverse of Buffer::from_str for content built without a trailing newline.

pub fn row_count(&self) -> usize

Number of rows in the buffer. Always >= 1.

impl Buffer

pub fn apply_edit(&mut self, edit: Edit) -> Edit

Apply edit and return the inverse. Pushing the inverse back through Buffer::apply_edit restores the previous state.

impl Buffer

pub fn folds(&self) -> &[Fold]

pub fn add_fold(&mut self, start_row: usize, end_row: usize, closed: bool)

Register a new fold. If an existing fold has the same start_row, it’s replaced; otherwise the new one is inserted in start-row order. Empty / inverted ranges are rejected.

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

Drop the fold whose range covers row. Returns true when a fold was actually removed.

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

Open the fold at row (no-op if already open or no fold).

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

Close the fold at row (no-op if already closed or no fold).

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

Flip the closed/open state of the fold containing row.

pub fn open_all_folds(&mut self)

zR — open every fold.

pub fn clear_all_folds(&mut self)

zE — eliminate every fold.

pub fn close_all_folds(&mut self)

zM — close every fold.

pub fn fold_at_row(&self, row: usize) -> Option<&Fold>

First fold whose range contains row (most folds are non-overlapping in vim’s model, so the first match is the only match). Useful for the host’s za/zo/zc handlers.

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

True iff row is hidden by a closed fold (any fold).

pub fn next_visible_row(&self, row: usize) -> Option<usize>

First visible row strictly after row, skipping any rows hidden by closed folds. Returns None past the end of the buffer. Drives fold-aware j: closed folds count as a single visual line.

pub fn prev_visible_row(&self, row: usize) -> Option<usize>

First visible row strictly before row, skipping hidden rows. Returns None past the top of the buffer.

pub fn invalidate_folds_in_range(&mut self, start_row: usize, end_row: usize)

Drop every fold that touches [start_row, end_row]. Edit paths call this to invalidate folds whose contents the user just mutated — vim’s “edits inside a fold open it” behaviour.

impl Buffer

pub fn move_left(&mut self, count: usize)

h — clamps at column 0; never wraps to the previous line.

pub fn move_right_in_line(&mut self, count: usize)

l — clamps at the last char on the line. Operator callers wanting “one past end” use Buffer::move_right_to_end.

pub fn move_right_to_end(&mut self, count: usize)

Operator-context l: allowed past the last char so a range motion includes it. Clamps at chars() (one past end).

pub fn move_line_start(&mut self)

0 — first column of the current row.

pub fn move_first_non_blank(&mut self)

^ — first non-blank column. On a blank line it lands on 0.

pub fn move_line_end(&mut self)

$ — last char on the row. Empty rows stay at column 0.

pub fn move_last_non_blank(&mut self)

g_ — last non-blank char on the row. Empty / all-blank rows stay at column 0.

pub fn move_paragraph_prev(&mut self, count: usize)

{ — previous blank line above the cursor, or row 0.

pub fn move_paragraph_next(&mut self, count: usize)

} — next blank line below the cursor, or last row.

pub fn move_up(&mut self, count: usize)

k — count rows up; sticky col preserved across short rows.

pub fn move_down(&mut self, count: usize)

j — count rows down; sticky col preserved across short rows.

pub fn move_screen_up(&mut self, count: usize)

gk — count visual rows up. With Wrap::None (or before the host has published text_width), falls back to move_up so existing tests + non-wrap callers behave unchanged. Under wrap, walks one screen segment at a time, crossing into the previous doc row only after exhausting the current row’s segments.

pub fn move_screen_down(&mut self, count: usize)

gj — count visual rows down. See Buffer::move_screen_up.

pub fn move_top(&mut self)

gg — first row, first non-blank.

pub fn move_bottom(&mut self, count: usize)

G — last row (or count - 1 when count > 0), first non-blank. count = 0 (the unprefixed form) jumps to the buffer’s bottom.

pub fn move_word_fwd(&mut self, big: bool, count: usize)

w / W — start of next word. big = true treats every non-whitespace run as one word (vim’s WORD).

pub fn move_word_back(&mut self, big: bool, count: usize)

b / B — start of previous word.

pub fn match_bracket(&mut self) -> bool

% — jump to the matching bracket. Walks the buffer counting nesting depth so nested pairs resolve correctly. Returns true when the cursor moved.

pub fn find_char_on_line(&mut self, ch: char, forward: bool, till: bool) -> bool

f / F / t / T — find ch on the current row. forward = true searches right of the cursor; till = true stops one cell short of the match (the t/T semantic). Returns true when the cursor moved.

pub fn move_word_end(&mut self, big: bool, count: usize)

e / E — end of current/next word.

pub fn move_viewport_top(&mut self, offset: usize)

H — top of the visible viewport plus offset rows (0-based; vim uses 1-based count where bare H = 0). Lands on the first non-blank of the resolved row.

pub fn move_viewport_middle(&mut self)

M — middle row of the visible viewport.

pub fn move_viewport_bottom(&mut self, offset: usize)

L — bottom of the visible viewport, minus offset rows.

pub fn move_word_end_back(&mut self, big: bool, count: usize)

ge / gE — end of previous word. Walks backward until the cursor sits on the last char of a word (the next char is a different kind, or end-of-line).

impl Buffer

pub fn set_search_pattern(&mut self, re: Option<Regex>)

Set the active search pattern. Pass None to clear. Subsequent Buffer::search_forward / search_backward calls use the new pattern; n / N repeat the last set pattern.

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

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

Move the cursor to the next match starting from (or just after, when skip_current = true) the cursor. Wraps end-of- buffer to row 0. Returns true when a match was found.

pub fn search_backward(&mut self, skip_current: bool) -> bool

Move to the previous match. Symmetric with search_forward but walks rows backwards and picks the rightmost match in each row.

pub fn search_matches(&mut self, row: usize) -> Vec<(usize, usize)>

Match positions on row as (byte_start, byte_end). Used by the render layer to paint search-match bg.

Trait Implementations

impl Default for Buffer

fn default() -> Self

Returns the “default value” for a type.