use std::path::Path;
use crate::git;
#[cfg(test)]
mod tests;
const SKIPPED_FOLDERS: [&str; 4] = [".git", "target", "node_modules", "__pycache__"];
const MAX_FILES: usize = 20_000;
pub struct Finder {
pub query: String,
files: Vec<String>,
matches: Vec<usize>,
pub selected: usize,
plain: bool,
}
pub fn project_files(root: &Path) -> Vec<String> {
git::list_files(root)
.filter(|files| !files.is_empty())
.unwrap_or_else(|| {
let mut files = Vec::new();
walk(root, "", &mut files);
files
})
}
fn score(query: &str, path: &str) -> Option<usize> {
let query = query.to_lowercase();
let path = path.to_lowercase();
let name = path.rsplit('/').next().unwrap_or(&path);
let rank = if name.starts_with(&query) {
0
} else if name.contains(&query) {
1
} else if path.contains(&query) {
2
} else {
let mut letters = path.chars();
if !query.chars().all(|wanted| letters.any(|c| c == wanted)) {
return None;
}
3
};
Some(rank * 10_000 + path.len())
}
fn walk(dir: &Path, prefix: &str, files: &mut Vec<String>) {
let Ok(listing) = std::fs::read_dir(dir) else {
return;
};
let mut items: Vec<_> = listing.flatten().collect();
items.sort_by_key(|item| item.file_name());
for item in items {
if files.len() >= MAX_FILES {
return;
}
let name = item.file_name().to_string_lossy().into_owned();
let path = format!("{prefix}{name}");
if item.path().is_dir() {
if !SKIPPED_FOLDERS.contains(&name.as_str()) {
walk(&item.path(), &format!("{path}/"), files);
}
} else {
files.push(path);
}
}
}
impl Finder {
pub fn new(root: &Path) -> Self {
Self::with_files(project_files(root))
}
pub fn with_files(files: Vec<String>) -> Self {
Self::build(files, false)
}
pub fn list(items: Vec<String>) -> Self {
Self::build(items, true)
}
fn build(files: Vec<String>, plain: bool) -> Self {
let mut finder = Self {
query: String::new(),
files,
matches: Vec::new(),
selected: 0,
plain,
};
finder.update();
finder
}
fn update(&mut self) {
self.selected = 0;
if self.plain {
let query = self.query.to_lowercase();
self.matches = (0..self.files.len())
.filter(|index| self.files[*index].to_lowercase().contains(&query))
.collect();
return;
}
let mut scored: Vec<(usize, usize)> = self
.files
.iter()
.enumerate()
.filter_map(|(index, path)| Some((score(&self.query, path)?, index)))
.collect();
scored.sort();
self.matches = scored.into_iter().map(|(_, index)| index).collect();
}
pub fn type_char(&mut self, c: char) {
self.query.push(c);
self.update();
}
pub fn backspace(&mut self) {
self.query.pop();
self.update();
}
pub fn move_by(&mut self, rows: isize) {
let last = self.matches.len().saturating_sub(1) as isize;
self.selected = (self.selected as isize + rows).clamp(0, last) as usize;
}
pub fn visible(&self, count: usize) -> Vec<(&str, bool)> {
let first = (self.selected + 1).saturating_sub(count);
self.matches
.iter()
.enumerate()
.skip(first)
.take(count)
.map(|(position, index)| (self.files[*index].as_str(), position == self.selected))
.collect()
}
pub fn chosen_index(&self) -> Option<usize> {
self.matches.get(self.selected).copied()
}
pub fn chosen(&self) -> Option<&str> {
self.matches
.get(self.selected)
.map(|index| self.files[*index].as_str())
}
}