Added fuzzy find

Author: Guibi1

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2024"
 freedesktop-desktop-entry = { version = "0.7.13", default-features = false }
 freedesktop-icons = "0.4.0"
 gpui = { git = "https://github.com/zed-industries/zed", default-features = false, features = ["wayland" ] }
+nucleo-matcher = "0.3.1"
 rust-embed = "8.7.2"
 serde = { version = "1.0.219", features = ["derive"] }
 smol = "2.0.2"

Cargo.toml

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use gpui::{Global, Rgba, SharedString, rgb};
 use serde::Deserialize;
 
-#[derive(Deserialize)]
+#[derive(Default, Deserialize)]
 #[serde(default)]
 pub struct Config {
     pub terminal: Option<String>,
@@ -26,15 +26,6 @@ pub struct ThemeConfig {
     pub accent_foreground: Rgba,
 }
 
-impl Default for Config {
-    fn default() -> Self {
-        Self {
-            terminal: None,
-            theme: ThemeConfig::default(),
-        }
-    }
-}
-
 impl Default for ThemeConfig {
     fn default() -> Self {
         Self {

src/config.rs

@@ -8,6 +8,7 @@ use std::sync::LazyLock;
 use freedesktop_desktop_entry::{Iter, default_paths, get_languages_from_env};
 use freedesktop_icons::lookup;
 use gpui::{Resource, SharedString};
+use nucleo_matcher::Utf32String;
 
 use crate::config::Config;
 
@@ -17,6 +18,7 @@ pub struct Application {
     pub name: SharedString,
     pub description: Option<SharedString>,
     pub icon: Option<Resource>,
+    pub searchable: Utf32String,
     exec: Vec<String>,
     working_dir: Option<PathBuf>,
     open_in_terminal: bool,
@@ -80,14 +82,25 @@ pub fn load_applications() -> Vec<Application> {
                 return None;
             }
 
+            let name = SharedString::from(entry.name(&locales)?.into_owned());
+            let description = entry
+                .comment(&locales)
+                .map(|c| SharedString::from(c.into_owned()));
+            let icon = entry
+                .icon()
+                .and_then(|i| lookup(i).with_cache().with_size(28).find())
+                .map(|i| i.into());
+            let searchable = Utf32String::from(match description {
+                Some(ref d) => name.to_string() + " " + d.as_str(),
+                None => name.to_string(),
+            });
+
             Some(Application {
                 id: entry.id().to_string(),
-                name: entry.name(&locales).map(|c| c.into_owned().into())?,
-                description: entry.comment(&locales).map(|c| c.into_owned().into()),
-                icon: entry
-                    .icon()
-                    .and_then(|i| lookup(i).with_cache().with_size(28).find())
-                    .map(|i| i.into()),
+                name,
+                description,
+                icon,
+                searchable,
                 exec: entry.parse_exec_with_uris(&[], &locales).ok()?,
                 working_dir: entry.path().and_then(|entry| entry.parse().ok()),
                 open_in_terminal: entry.terminal(),
@@ -109,7 +122,7 @@ static TERMINAL: LazyLock<&str> = LazyLock::new(|| {
         "konsole",
     ]
     .into_iter()
-    .find(|term| paths.iter().any(|dir| dir.join(&term).is_file()))
+    .find(|term| paths.iter().any(|dir| dir.join(term).is_file()))
     .expect(
         "Failed to find a terminal emulator in your PATH. Please use the config to specify one.",
     )

src/entries/application.rs

@@ -1,8 +1,11 @@
+use std::cell::RefCell;
 use std::cmp::Reverse;
 use std::ops::Deref;
 use std::rc::Rc;
 
 use gpui::{App, Global, Resource, SharedString};
+use nucleo_matcher::pattern::{AtomKind, CaseMatching, Normalization, Pattern};
+use nucleo_matcher::{Matcher, Utf32Str};
 
 use crate::config::Config;
 use crate::entries::application::Application;
@@ -41,6 +44,12 @@ impl Entry {
         }
     }
 
+    pub fn searchable(&self) -> Utf32Str<'_> {
+        match self {
+            Entry::Application(entry) => entry.searchable.slice(..),
+        }
+    }
+
     pub fn open(&self, cx: &mut App) -> bool {
         cx.global_mut::<SearchEntries>()
             .increment_frequency(self.id());
@@ -55,6 +64,7 @@ impl Entry {
 pub struct SearchEntries {
     entries: Vec<Entry>,
     frequencies: Frequencies,
+    matcher: RefCell<Matcher>,
 }
 
 impl SearchEntries {
@@ -68,6 +78,7 @@ impl SearchEntries {
         Self {
             entries,
             frequencies: Frequencies::load(),
+            matcher: RefCell::new(Matcher::default()),
         }
     }
 
@@ -82,18 +93,32 @@ impl SearchEntries {
     }
 
     pub fn filtered(&self, search_term: &str) -> Vec<Entry> {
-        if search_term.trim().is_empty() {
+        let search_term = search_term.trim();
+        if search_term.is_empty() {
             return self.entries.clone();
         }
 
-        self.entries
+        let p = Pattern::new(
+            search_term,
+            CaseMatching::Ignore,
+            Normalization::Smart,
+            AtomKind::Fuzzy,
+        );
+
+        let mut matcher = self.matcher.borrow_mut();
+        let mut result: Vec<_> = self
+            .entries
             .iter()
-            .filter(|entry| {
-                entry.name().to_lowercase().contains(search_term)
-                    || entry
-                        .description()
-                        .is_some_and(|desc| desc.to_lowercase().contains(search_term))
+            .filter_map(|item| {
+                p.score(item.searchable(), &mut matcher)
+                    .map(|score| (item, score))
             })
+            .collect();
+        result.sort_by_key(|(_, score)| Reverse(*score));
+
+        result
+            .into_iter()
+            .map(|(entry, _)| entry)
             .cloned()
             .collect()
     }