Struct FuzzyFinder 

pub struct FuzzyFinder<String: Sync + Send + 'static> {
    pub kind: FuzzyKind,
    pub matcher: Nucleo<String>,
    pub input: Input,
    pub item_count: u32,
    pub matched_item_count: u32,
    pub index: u32,
    /* private fields */
}

The fuzzy picker of file. it may be in one of 3 kinds:

• for file, it will match against paths from current folder,
• for lines, it will match against any text of a text files from current folder,
• for actions, it will match against any text from help, allowing to run an action when you forgot the keybind.

Internally, it’s just :

• a Nucleo matcher,
• a few u32: index, top (first displayed index), height of the window, item count, matched item count
• and the current selection as a string.

The matcher is used externally by display to get the displayed matches and internally to update the selection when the user type something or move around.

The interface shouldn’t change much, except to add more shortcut.

Fields

kind: FuzzyKind

kind of fuzzy: Line (match lines into text file), File (match file against their name), Action (match an action)

matcher: Nucleo<String>

The fuzzy matcher

input: Input

typed input by the user

item_count: u32

number of parsed item

matched_item_count: u32

number of matched item

index: u32

selected index. Should always been smaller than matched_item_count

Implementations

impl<String: Sync + Send + 'static> FuzzyFinder<String>

where Vec<String>: FromIterator<String>,

pub fn new(kind: FuzzyKind) -> Self

Creates a new fuzzy matcher for this kind.

pub fn set_height(self, height: usize) -> Self

Set the terminal height of the fuzzy picker. It should always be called after new

pub fn should_preview(&self) -> bool

True iff a preview should be built for this fuzzy finder. It only makes sense to preview files not lines nor actions.

pub fn injector(&self) -> Injector<String>

Get an Injector from the internal Nucleo instance.

pub fn update_input(&mut self, append: bool)

if insert char: append = true, if delete char: append = false,

pub fn tick(&mut self, force: bool)

tick the matcher. refresh the selection if the status changed or if force = true.

pub fn top_bottom(&self) -> (u32, u32)

Calculate the first & last matching index which should be stored in content. It assumes the index can’t change by more than one at a time. Returning both values (top & bottom) allows to avoid mutating self here. This method can be called in crate::io::Display to know what matches should be drawn.

It should only be called after a refresh of the matcher to be sure the matched_item_count is correct.

Several cases :

• if there’s not enough element to fill the display, take everything.
• if the selection is in the top 4 rows, scroll up if possible.
• if the selection is in the last 4 rows, scroll down if possible.
• otherwise, don’t move.

Scrolling is done only at top or bottom, not in the middle of the screen. It feels more natural.

pub fn resize(&mut self, height: usize)

Set the new height and refresh the content.

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

Returns the selected element, if its index is valid. It should never return None if the content isn’t empty.

impl FuzzyFinder<String>

pub fn navigate(&mut self, direction: Direction)

pub fn find_files(&self, current_path: PathBuf)

pub fn find_action(&self, help: String)

pub fn find_line(&self, tokio_greper: TokioCommand)

Trait Implementations

impl<String: Sync + Send + 'static> Default for FuzzyFinder<String>

where Vec<String>: FromIterator<String>,

fn default() -> Self

Returns the “default value” for a type.