//! This module is for "block objects" i.e. text objects delimited by brackets/parentheses. use std::ops::Range; use itertools::Itertools;use string_offset::CharOffset;use warpui_core::text::TextBuffer; use crate::vim::{BracketChar, BracketEnd, BracketType};use crate::vim_find_matching_bracket; /// Vim's block-based text objects, e.g. `di{`. This includes a string of text enclosed by any pair/// of [`BracketType`], not including the brackets themselves./// See https://vimdoc.sourceforge.net/htmldoc/motion.html#ib/// or enter ":help i{" in Vim.////// There may be whitespace in within the brackets which is also not included. If the closing/// bracket is on a different line then the opening bracket, and there is only whitespace between/// the closing bracket and the newline preceding it, all that space plus the newline are _not_/// included in the text object. (AFAIK this is not documented.) We can refer to that space as/// "trailing padding". Furthermore, the `c` and `d` commands differ in how they respect "leading/// padding", i.e. the whitespace plus newline after the opening bracket, in that `d` will delete/// the leading padding but `c` will not. The `preserve_leading_padding` parameter controls this.////// Returns None when the buffer is empty, the offset is out of bounds, or there is no matching/// pair of brackets of the type we're looking for around the cursor.pub fn vim_inner_block<T, C>(    buffer: &T,    offset: C,    bracket_type: BracketType,    preserve_leading_padding: bool,) -> Option<Range<CharOffset>>where    T: TextBuffer + ?Sized,    C: Into<CharOffset>,{    let block_range = vim_a_block(buffer, offset, bracket_type)?;    let (mut block_start, mut block_end) = (block_range.start, block_range.end);     // Move bounds by 1 to remove the brackets, though we may need to trim any trailing or leading    // padding.    block_start += 1;    block_end -= 1;     // First, check if we need to remove trailing padding from the range.    if let Some((i, _)) = buffer        .chars_rev_at(block_end)        .ok()?        .take_while(|c| c.is_whitespace())        .find_position(|c| *c == '\n')    {        block_end -= i + 1;    }     // Finally, if we're doing a command that preserves leading padding, e.g. `c`, check if we need    // to remove that from the range.    if preserve_leading_padding        && let Some((i, _)) = buffer            .chars_at(block_start)            .ok()?            .take_while(|c| c.is_whitespace())            .find_position(|c| *c == '\n')    {        block_start += i + 1;    }     Some(block_start..block_end)} /// Vim's block-based text objects, e.g. `da{`. This includes a string of text enclosed by any pair/// of [`BracketType`], including the brackets themselves./// See https://vimdoc.sourceforge.net/htmldoc/motion.html#ab/// or enter ":help a{" in Vim.////// Returns None when the buffer is empty, the offset is out of bounds, or there is no matching/// pair of brackets of the type we're looking for around the cursor.pub fn vim_a_block<T, C>(    buffer: &T,    offset: C,    bracket_type: BracketType,) -> Option<Range<CharOffset>>where    T: TextBuffer + ?Sized,    C: Into<CharOffset>,{    let offset = offset.into();    // If the buffer is empty, return early.    let c = buffer.chars_at(offset).ok()?.next()?;     // Check if the cursor is already on a bracket of the type we're looking for.    match BracketChar::try_from(c) {        // If it is, just call [`vim_find_matching_bracket`] for the other bracket.        Ok(bracket) if bracket.kind == bracket_type => {            let other_offset = vim_find_matching_bracket(buffer, &bracket, offset)?;            // We may have just moved backwards or forwards. Make sure the smaller offset comes            // first in the range bounds.            let (start_offset, end_offset) = if other_offset > offset {                (offset, other_offset)            } else {                (other_offset, offset)            };            Some(start_offset..end_offset + 1)        }        // If not, perform the search in both directions.        _ => {            let end_offset = vim_find_matching_bracket(                buffer,                &BracketChar {                    end: BracketEnd::Opening,                    kind: bracket_type,                },                offset,            )?;            let start_offset = vim_find_matching_bracket(                buffer,                &BracketChar {                    end: BracketEnd::Closing,                    kind: bracket_type,                },                end_offset,            )?;            Some(start_offset..end_offset + 1)        }    }} #[cfg(test)]#[path = "block_tests.rs"]mod tests;