Working math

Author: Guibi1

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 dirs = "6.0.0"
+evalexpr = "13.1.0"
 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"] }

Cargo.toml

@@ -3,7 +3,6 @@ use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::rc::Rc;
 
-use freedesktop_icons::lookup;
 use gpui::{App, Resource, SharedString};
 use nucleo_matcher::Utf32String;
 
@@ -23,24 +22,20 @@ pub struct DesktopEntry {
 }
 
 impl Entry for DesktopEntry {
-    fn id(&self) -> &SharedString {
-        &self.id
+    fn id(&self) -> SharedString {
+        self.id.clone()
     }
 
-    fn text(&self) -> &SharedString {
-        &self.name
+    fn text(&self) -> SharedString {
+        self.name.clone()
     }
 
-    fn description(&self) -> Option<&SharedString> {
-        self.description.as_ref()
+    fn description(&self) -> Option<SharedString> {
+        self.description.clone()
     }
 
-    fn icon(&self) -> Option<&Resource> {
-        self.icon.as_ref()
-    }
-
-    fn haystack(&self) -> nucleo_matcher::Utf32Str<'_> {
-        self.haystack.slice(..)
+    fn icon(&self) -> Option<Resource> {
+        self.icon.clone()
     }
 
     fn can_favorite(&self) -> bool {
@@ -49,7 +44,7 @@ impl Entry for DesktopEntry {
 
     fn execute(&self, cx: &mut App) -> EntryExecuteResult {
         cx.global_mut::<SearchEntries>()
-            .increment_frequency(self.id());
+            .increment_frequency(&self.id);
 
         let config = cx.global::<Config>();
         let mut cmd = if self.open_in_terminal {
@@ -110,7 +105,12 @@ impl DesktopEntry {
                 .map(|description| SharedString::from(description.into_owned()));
             let icon = entry
                 .icon()
-                .and_then(|icon| lookup(icon).with_cache().with_size(28).find())
+                .and_then(|icon| {
+                    freedesktop_icons::lookup(icon)
+                        .with_cache()
+                        .with_size(28)
+                        .find()
+                })
                 .map(|path| Resource::Path(path.into()));
             let haystack = Utf32String::from(match description {
                 Some(ref d) => name.to_string() + " " + d.as_str(),

src/finder/desktop/entry.rs

@@ -42,7 +42,7 @@ impl SearchEntries {
     pub fn favorites(&self) -> Vec<Rc<dyn Entry>> {
         self.favorites
             .iter()
-            .filter_map(|id| self.entries.iter().find(|entry| entry.id() == id))
+            .filter_map(|id| self.entries.iter().find(|entry| entry.id == *id))
             .map(|e| e.clone() as Rc<dyn Entry>)
             .collect()
     }
@@ -70,15 +70,20 @@ impl Finder for SearchEntries {
         }
     }
 
-    fn default_entries(&self) -> impl Iterator<Item = Rc<dyn Entry>> {
-        self.entries.iter().map(|e| e.clone() as Rc<dyn Entry>)
+    fn default_entries(&self) -> Option<Vec<Rc<dyn Entry>>> {
+        Some(
+            self.entries
+                .iter()
+                .map(|e| e.clone() as Rc<dyn Entry>)
+                .collect(),
+        )
     }
 
     fn filtered_entries(
         &self,
         matcher: &mut nucleo_matcher::Matcher,
         search_term: &str,
-    ) -> impl Iterator<Item = Rc<dyn Entry>> {
+    ) -> Option<Vec<Rc<dyn Entry>>> {
         let search_pattern = Pattern::new(
             search_term,
             CaseMatching::Ignore,
@@ -92,14 +97,18 @@ impl Finder for SearchEntries {
             .enumerate()
             .filter_map(|(idx, entry)| {
                 search_pattern
-                    .score(entry.haystack(), matcher)
+                    .score(entry.haystack.slice(..), matcher)
                     .map(|score| (idx, score))
             })
             .collect();
         result.sort_by_key(|(_, score)| Reverse(*score));
-        result
-            .into_iter()
-            .map(|(i, _)| self.entries[i].clone() as Rc<dyn Entry>)
+
+        Some(
+            result
+                .into_iter()
+                .map(|(i, _)| self.entries[i].clone() as Rc<dyn Entry>)
+                .collect(),
+        )
     }
 }
 

src/finder/desktop/mod.rs

@@ -0,0 +1,34 @@
+use gpui::{App, Resource, SharedString};
+
+use crate::finder::{Entry, EntryExecuteResult};
+
+pub struct MathEntry {
+    pub result: SharedString,
+}
+
+impl Entry for MathEntry {
+    fn id(&self) -> SharedString {
+        self.result.clone()
+    }
+
+    fn text(&self) -> SharedString {
+        self.result.clone()
+    }
+
+    fn description(&self) -> Option<SharedString> {
+        None
+    }
+
+    fn icon(&self) -> Option<Resource> {
+        None
+    }
+
+    fn can_favorite(&self) -> bool {
+        false
+    }
+
+    fn execute(&self, cx: &mut App) -> EntryExecuteResult {
+        cx.write_to_clipboard(self.result.to_string().into());
+        EntryExecuteResult::CloseWindow
+    }
+}

src/finder/math/entry.rs

@@ -0,0 +1,30 @@
+use std::rc::Rc;
+
+use crate::finder::{Entry, Finder, math::entry::MathEntry};
+
+mod entry;
+
+pub struct MathFinder {}
+
+impl Finder for MathFinder {
+    fn new() -> Self {
+        Self {}
+    }
+
+    fn default_entries(&self) -> Option<Vec<Rc<dyn Entry>>> {
+        None
+    }
+
+    fn filtered_entries(
+        &self,
+        _matcher: &mut nucleo_matcher::Matcher,
+        search_term: &str,
+    ) -> Option<Vec<Rc<dyn Entry>>> {
+        let search_term = search_term.strip_prefix('=')?;
+        let value = evalexpr::eval(search_term).ok()?;
+
+        Some(vec![Rc::new(MathEntry {
+            result: value.to_string().into(),
+        })])
+    }
+}

src/finder/math/mod.rs

@@ -2,37 +2,44 @@ use std::rc::Rc;
 
 use gpui::{App, Resource, SharedString};
 
+use crate::finder::desktop::SearchEntries;
+use crate::finder::math::MathFinder;
+
 pub mod desktop;
+pub mod math;
+
+pub fn default_finders() -> Vec<Box<dyn Finder>> {
+    vec![Box::new(SearchEntries::new()), Box::new(MathFinder::new())]
+}
 
 pub trait Finder {
-    fn new() -> Self;
+    fn new() -> Self
+    where
+        Self: Sized;
 
     /// Returns the entries when no search is performed.
-    fn default_entries(&self) -> impl Iterator<Item = Rc<dyn Entry>>;
+    fn default_entries(&self) -> Option<Vec<Rc<dyn Entry>>>;
 
     /// Returns the entries that match the given pattern.
     fn filtered_entries(
         &self,
         matcher: &mut nucleo_matcher::Matcher,
         search_term: &str,
-    ) -> impl Iterator<Item = Rc<dyn Entry>>;
+    ) -> Option<Vec<Rc<dyn Entry>>>;
 }
 
 pub trait Entry {
     /// Get a unique identifier for this entry.
-    fn id(&self) -> &SharedString;
+    fn id(&self) -> SharedString;
 
     /// Get the main text of this entry.
-    fn text(&self) -> &SharedString;
+    fn text(&self) -> SharedString;
 
     /// Get the subtle description of this entry.
-    fn description(&self) -> Option<&SharedString>;
+    fn description(&self) -> Option<SharedString>;
 
     /// Get the icon of this entry.
-    fn icon(&self) -> Option<&Resource>;
-
-    /// Get the text to use for searching this entry.
-    fn haystack(&self) -> nucleo_matcher::Utf32Str<'_>;
+    fn icon(&self) -> Option<Resource>;
 
     /// If this entry can be favorited.
     fn can_favorite(&self) -> bool;

src/finder/mod.rs

@@ -10,7 +10,7 @@ use gpui::{
 
 use crate::config::Config;
 use crate::finder::desktop::SearchEntries;
-use crate::finder::{Entry, EntryExecuteResult, Finder};
+use crate::finder::{Entry, EntryExecuteResult, Finder, default_finders};
 use crate::ui::actions::{Close, ExecuteEntry, SelectNextEntry, SelectPrevEntry, ToggleFavorite};
 use crate::ui::elements::{EntryButton, Icon, PowerOptions, Separator, Shortcut, TextInput};
 
@@ -34,6 +34,8 @@ pub struct Waystart {
     list_scroll_handle: UniformListScrollHandle,
     search_bar: Entity<TextInput>,
     selected: usize,
+
+    finders: Vec<Box<dyn Finder>>,
     matcher: RefCell<nucleo_matcher::Matcher>,
 }
 
@@ -51,10 +53,12 @@ impl Waystart {
 
         Self {
             focus_handle,
-            entries: cx.global::<SearchEntries>().default_entries().collect(),
+            entries: cx.global::<SearchEntries>().default_entries().unwrap(),
             list_scroll_handle: UniformListScrollHandle::new(),
             search_bar,
             selected: 0,
+
+            finders: default_finders(),
             matcher: RefCell::new(nucleo_matcher::Matcher::default()),
         }
     }
@@ -66,21 +70,28 @@ impl Waystart {
     }
 
     fn filter_results(&mut self, cx: &mut Context<Self>) {
-        if let Some(entries) = cx.try_global::<SearchEntries>() {
-            self.entries.clear();
-            let search_term = self.search_bar.read(cx).content().trim();
+        self.entries.clear();
+        let search_term = self.search_bar.read(cx).content().trim();
 
-            if search_term.is_empty() {
-                self.entries.extend(entries.default_entries());
-            } else {
-                let mut matcher = self.matcher.borrow_mut();
-                self.entries
-                    .extend(entries.filtered_entries(&mut matcher, search_term));
-            }
-
-            self.selected = 0;
-            cx.notify();
+        if search_term.is_empty() {
+            self.entries.extend(
+                self.finders
+                    .iter()
+                    .filter_map(|finder| finder.default_entries())
+                    .flatten(),
+            );
+        } else {
+            let mut matcher = self.matcher.borrow_mut();
+            self.entries.extend(
+                self.finders
+                    .iter()
+                    .filter_map(|finder| finder.filtered_entries(&mut matcher, search_term))
+                    .flatten(),
+            );
         }
+
+        self.selected = 0;
+        cx.notify();
     }
 
     fn on_close(_: &Close, window: &mut Window, _cx: &mut App) {