Added really basic favorites

Author: Guibi1

Cargo.lock

@@ -4,9 +4,10 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+dirs = "6.0.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" ] }
+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"] }

Cargo.toml

@@ -1,5 +1,5 @@
-use std::env;
 use std::path::PathBuf;
+use std::sync::LazyLock;
 
 use gpui::{Global, Rgba, SharedString, rgb};
 use serde::Deserialize;
@@ -46,16 +46,15 @@ impl Global for Config {}
 
 impl Config {
     pub fn load() -> Self {
-        match std::fs::read_to_string(Self::get_path()) {
+        match std::fs::read_to_string(&*CONFIG_SAVE_PATH) {
             Ok(file) => toml::from_str(&file).expect("Failed to parse the config file"),
             Err(_) => Self::default(),
         }
     }
-
-    fn get_path() -> PathBuf {
-        match env::var("XDG_CONFIG_DIR") {
-            Ok(config) => PathBuf::from(config).join("waystart.toml"),
-            Err(_) => env::home_dir().unwrap().join(".config/waystart.toml"),
-        }
-    }
 }
+
+static CONFIG_SAVE_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
+    dirs::data_dir()
+        .expect("Failed to get config directory")
+        .join("waystart.toml")
+});

src/config.rs

@@ -1,6 +1,4 @@
-use std::collections::HashSet;
 use std::env;
-use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::sync::LazyLock;
@@ -14,7 +12,7 @@ use crate::config::Config;
 
 #[derive(Debug)]
 pub struct Application {
-    pub id: String,
+    pub id: SharedString,
     pub name: SharedString,
     pub description: Option<SharedString>,
     pub icon: Option<Resource>,
@@ -56,59 +54,54 @@ impl Application {
             }
         }
     }
-}
-
-impl Hash for Application {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-    }
-}
-
-impl PartialEq for Application {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl Eq for Application {}
 
-pub fn load_applications() -> Vec<Application> {
-    let locales = get_languages_from_env();
+    pub fn load() -> Vec<Self> {
+        let locales = get_languages_from_env();
 
-    Iter::new(default_paths())
-        .entries(Some(&locales))
-        .filter_map(|entry| {
+        let mut applications = Vec::new();
+        for entry in Iter::new(default_paths()).entries(Some(&locales)) {
             if entry.no_display() || entry.hidden() {
-                return None;
+                continue;
             }
 
-            let name = SharedString::from(entry.name(&locales)?.into_owned());
+            let id = SharedString::from(entry.id().to_string());
+            if applications.iter().any(|a: &Application| a.id == id) {
+                continue;
+            }
+
+            let Ok(exec) = entry.parse_exec_with_uris(&[], &locales) else {
+                continue;
+            };
+            let name = match entry.name(&locales) {
+                Some(name) => SharedString::from(name.into_owned()),
+                None => continue,
+            };
             let description = entry
                 .comment(&locales)
-                .map(|c| SharedString::from(c.into_owned()));
+                .map(|description| SharedString::from(description.into_owned()));
             let icon = entry
                 .icon()
-                .and_then(|i| lookup(i).with_cache().with_size(28).find())
-                .map(|i| i.into());
+                .and_then(|icon| lookup(icon).with_cache().with_size(28).find())
+                .map(|path| Resource::Path(path.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(),
+            applications.push(Application {
+                id,
                 name,
                 description,
                 icon,
                 searchable,
-                exec: entry.parse_exec_with_uris(&[], &locales).ok()?,
+                exec,
                 working_dir: entry.path().and_then(|entry| entry.parse().ok()),
                 open_in_terminal: entry.terminal(),
-            })
-        })
-        .collect::<HashSet<Application>>()
-        .into_iter()
-        .collect()
+            });
+        }
+
+        applications
+    }
 }
 
 static TERMINAL: LazyLock<&str> = LazyLock::new(|| {

src/entries/application.rs

@@ -0,0 +1,54 @@
+use std::collections::HashSet;
+use std::ops::{Deref, DerefMut};
+use std::path::PathBuf;
+use std::sync::LazyLock;
+
+use gpui::SharedString;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub(super) struct Favorites {
+    favorites: HashSet<SharedString>,
+}
+
+impl Favorites {
+    pub fn load() -> Self {
+        match std::fs::read_to_string(&*FAVORITES_SAVE_PATH) {
+            Ok(file) => toml::from_str(&file).expect("Failed to parse favorites"),
+            Err(_) => Self {
+                favorites: HashSet::new(),
+            },
+        }
+    }
+
+    pub async fn save(&self) {
+        let content = toml::to_string(&self).expect("Failed to serialize favorites");
+        if let Err(err) = smol::fs::write(&*FAVORITES_SAVE_PATH, content).await {
+            eprintln!(
+                "Failed to save favorites at {}: {}",
+                FAVORITES_SAVE_PATH.to_string_lossy(),
+                err
+            );
+        }
+    }
+}
+
+impl Deref for Favorites {
+    type Target = HashSet<SharedString>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.favorites
+    }
+}
+
+impl DerefMut for Favorites {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.favorites
+    }
+}
+
+static FAVORITES_SAVE_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
+    dirs::data_dir()
+        .expect("Failed to get data directory")
+        .join("waystart.toml")
+});

src/entries/favorites.rs

@@ -1,44 +1,37 @@
 use std::cmp::Ordering;
 use std::collections::HashMap;
-use std::env;
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
+use std::sync::LazyLock;
 use std::time::SystemTime;
 
+use gpui::SharedString;
 use serde::{Deserialize, Serialize};
 
-pub(super) struct Frequencies(HashMap<String, EntryFrequency>);
+pub(super) struct Frequencies(HashMap<SharedString, EntryFrequency>);
 
 impl Frequencies {
     pub fn load() -> Self {
-        Self(match std::fs::read_to_string(Self::get_path()) {
+        Self(match std::fs::read_to_string(&*FREQUENCIES_SAVE_PATH) {
             Ok(file) => toml::from_str(&file).expect("Failed to parse frequency history"),
             Err(_) => HashMap::new(),
         })
     }
 
     pub async fn save(&self) {
         let content = toml::to_string(&self.0).expect("Failed to serialize frequency history");
-        let path = Self::get_path();
-        if let Err(err) = smol::fs::write(&path, content).await {
+        if let Err(err) = smol::fs::write(&*FREQUENCIES_SAVE_PATH, content).await {
             eprintln!(
                 "Failed to save frequency history at {}: {}",
-                path.to_string_lossy(),
+                FREQUENCIES_SAVE_PATH.to_string_lossy(),
                 err
             );
         }
     }
-
-    fn get_path() -> PathBuf {
-        match env::var("XDG_CACHE_HOME") {
-            Ok(config) => PathBuf::from(config).join("waystart.toml"),
-            Err(_) => env::home_dir().unwrap().join(".cache/waystart.toml"),
-        }
-    }
 }
 
 impl Deref for Frequencies {
-    type Target = HashMap<String, EntryFrequency>;
+    type Target = HashMap<SharedString, EntryFrequency>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -119,3 +112,9 @@ impl PartialEq for EntryFrequency {
         self.cmp(other).is_eq()
     }
 }
+
+static FREQUENCIES_SAVE_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
+    dirs::cache_dir()
+        .expect("Failed to get cache directory")
+        .join("waystart.toml")
+});

src/entries/frequency.rs

@@ -9,9 +9,11 @@ use nucleo_matcher::{Matcher, Utf32Str};
 
 use crate::config::Config;
 use crate::entries::application::Application;
+use crate::entries::favorites::Favorites;
 use crate::entries::frequency::{EntryFrequency, Frequencies};
 
 mod application;
+mod favorites;
 mod frequency;
 
 #[derive(Clone)]
@@ -20,7 +22,7 @@ pub enum Entry {
 }
 
 impl Entry {
-    pub fn id(&self) -> &str {
+    pub fn id(&self) -> &SharedString {
         match self {
             Entry::Application(entry) => &entry.id,
         }
@@ -64,12 +66,13 @@ impl Entry {
 pub struct SearchEntries {
     entries: Vec<Entry>,
     frequencies: Frequencies,
+    favorites: Favorites,
     matcher: RefCell<Matcher>,
 }
 
 impl SearchEntries {
     pub fn load() -> Self {
-        let entries = application::load_applications()
+        let entries = Application::load()
             .into_iter()
             .map(Rc::new)
             .map(Entry::Application)
@@ -78,17 +81,24 @@ impl SearchEntries {
         Self {
             entries,
             frequencies: Frequencies::load(),
+            favorites: Favorites::load(),
             matcher: RefCell::new(Matcher::default()),
         }
     }
 
     pub async fn save(&self) {
         self.frequencies.save().await;
+        self.favorites.save().await;
     }
 
     pub fn sort_by_frequency(&mut self) {
         self.entries.sort_by_cached_key(|e| {
-            Reverse(self.frequencies.get(e.id()).cloned().unwrap_or_default())
+            Reverse(
+                self.frequencies
+                    .get(e.id().as_str())
+                    .cloned()
+                    .unwrap_or_default(),
+            )
         });
     }
 
@@ -123,12 +133,24 @@ impl SearchEntries {
             .collect()
     }
 
-    pub fn increment_frequency(&mut self, entry_id: &str) {
+    pub fn favorites(&self) -> Vec<Entry> {
+        self.favorites
+            .iter()
+            .filter_map(|id| self.entries.iter().find(|entry| entry.id() == id))
+            .cloned()
+            .collect()
+    }
+
+    pub fn add_favorite(&mut self, entry: &Entry) {
+        self.favorites.insert(entry.id().clone());
+    }
+
+    pub fn increment_frequency(&mut self, entry_id: &SharedString) {
         if let Some(frequency) = self.frequencies.get_mut(entry_id) {
             frequency.increment();
         } else {
             self.frequencies
-                .insert(entry_id.to_string(), EntryFrequency::new());
+                .insert(entry_id.clone(), EntryFrequency::new());
         }
     }
 }