improv: improvements for cosmic app list applet

Author: wiiznokes

README.md

@@ -18,7 +18,7 @@ fn main() {
     for path in Iter::new(default_paths()) {
         let path_src = PathSource::guess_from(&path);
         if let Ok(bytes) = fs::read_to_string(&path) {
-            if let Ok(entry) = DesktopEntry::decode_from_str(&path, &bytes, &locales) {
+            if let Ok(entry) = DesktopEntry::from_str(&path, &bytes, &locales) {
                 println!("{:?}: {}\n---\n{}", path_src, path.display(), entry);
             }
         }

examples/all_files.rs

@@ -13,7 +13,7 @@ fn main() {
     for path in Iter::new(default_paths()) {
         let path_src = PathSource::guess_from(&path);
         if let Ok(bytes) = fs::read_to_string(&path) {
-            if let Ok(entry) = DesktopEntry::decode_from_str(&path, &bytes, &locales) {
+            if let Ok(entry) = DesktopEntry::from_str(&path, &bytes, &locales) {
                 println!("{:?}: {}\n---\n{}", path_src, path.display(), entry);
             }
         }

examples/bench.rs

@@ -26,7 +26,7 @@ fn bench_borrowed(it: u32) {
 
         for path in paths {
             if let Ok(bytes) = fs::read_to_string(&path) {
-                if let Ok(_entry) = DesktopEntry::decode_from_str(&path, &bytes, &locale) {}
+                if let Ok(_entry) = DesktopEntry::from_str(&path, &bytes, &locale) {}
             }
         }
 
@@ -46,7 +46,7 @@ fn bench_owned(it: u32) {
         let now = Instant::now();
 
         for path in paths {
-            if let Ok(_entry) = DesktopEntry::decode_from_path(path, &locale) {}
+            if let Ok(_entry) = DesktopEntry::from_path(path, &locale) {}
         }
 
         total_time += now.elapsed();
@@ -64,7 +64,7 @@ fn bench_owned_optimized(it: u32) {
 
         let now = Instant::now();
 
-        let _ = DesktopEntry::decode_from_paths(paths, &locale)
+        let _ = DesktopEntry::from_paths(paths, &locale)
             .filter_map(|e| e.ok())
             .collect::<Vec<_>>();
 

examples/specific_file.rs

@@ -12,7 +12,7 @@ fn main() {
     //     }
     // }
 
-    if let Ok(entry) = DesktopEntry::decode_from_path(path.to_path_buf(), locales) {
+    if let Ok(entry) = DesktopEntry::from_path(path.to_path_buf(), locales) {
         println!("{}\n---\n{}", path.display(), entry);
     }
 }

src/decoder.rs

@@ -19,7 +19,7 @@ pub enum DecodeError {
 }
 
 impl<'a> DesktopEntry<'a> {
-    pub fn decode_from_str<L>(
+    pub fn from_str<L>(
         path: &'a Path,
         input: &'a str,
         locales: &[L],
@@ -54,7 +54,7 @@ impl<'a> DesktopEntry<'a> {
         })
     }
 
-    pub fn decode_from_paths<'i, 'l: 'i, L>(
+    pub fn from_paths<'i, 'l: 'i, L>(
         paths: impl Iterator<Item = PathBuf> + 'i,
         locales: &'l [L],
     ) -> impl Iterator<Item = Result<DesktopEntry<'static>, DecodeError>> + 'i
@@ -68,7 +68,7 @@ impl<'a> DesktopEntry<'a> {
     }
 
     /// Return an owned [`DesktopEntry`]
-    pub fn decode_from_path<L>(
+    pub fn from_path<L>(
         path: PathBuf,
         locales: &[L],
     ) -> Result<DesktopEntry<'static>, DecodeError>

src/lib.rs

@@ -24,112 +24,76 @@ pub type Locale<'a> = Cow<'a, str>;
 pub type LocaleMap<'a> = BTreeMap<Locale<'a>, Value<'a>>;
 pub type Value<'a> = Cow<'a, str>;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct DesktopEntry<'a> {
     pub appid: Cow<'a, str>,
     pub groups: Groups<'a>,
     pub path: Cow<'a, Path>,
     pub ubuntu_gettext_domain: Option<Cow<'a, str>>,
 }
 
+impl DesktopEntry<'_> {
+    /// Construct a new [`DesktopEntry`] from an appid. The name field will be
+    /// set to that appid.
+    pub fn from_appid<'a>(appid: &'a str) -> DesktopEntry<'a> {
+        let mut de = DesktopEntry {
+            appid: Cow::Borrowed(appid),
+            groups: Groups::default(),
+            path: Cow::Owned(PathBuf::from("")),
+            ubuntu_gettext_domain: None,
+        };
+        de.add_desktop_entry("Name", appid);
+        de
+    }
+}
+
 impl<'a> DesktopEntry<'a> {
-    pub fn into_owned(self) -> DesktopEntry<'static> {
+    // note that we shoudn't implement ToOwned in this case: https://stackoverflow.com/questions/72105604/implement-toowned-for-user-defined-types
+    pub fn to_owned(&self) -> DesktopEntry<'static> {
         let mut new_groups = Groups::new();
 
-        for (group, key_map) in self.groups {
+        for (group, key_map) in &self.groups {
             let mut new_key_map = KeyMap::new();
 
             for (key, (value, locale_map)) in key_map {
                 let mut new_locale_map = LocaleMap::new();
 
                 for (locale, value) in locale_map {
                     new_locale_map.insert(
-                        Cow::Owned(locale.into_owned()),
-                        Cow::Owned(value.into_owned()),
+                        Cow::Owned(locale.to_string()),
+                        Cow::Owned(value.to_string()),
                     );
                 }
 
                 new_key_map.insert(
-                    Cow::Owned(key.into_owned()),
-                    (Cow::Owned(value.into_owned()), new_locale_map),
+                    Cow::Owned(key.to_string()),
+                    (Cow::Owned(value.to_string()), new_locale_map),
                 );
             }
 
-            new_groups.insert(Cow::Owned(group.into_owned()), new_key_map);
+            new_groups.insert(Cow::Owned(group.to_string()), new_key_map);
         }
 
         DesktopEntry {
-            appid: Cow::Owned(self.appid.into_owned()),
+            appid: Cow::Owned(self.appid.to_string()),
             groups: new_groups,
-            ubuntu_gettext_domain: self
-                .ubuntu_gettext_domain
-                .map(|e| Cow::Owned(e.into_owned())),
-            path: Cow::Owned(self.path.into_owned()),
+            ubuntu_gettext_domain: if let Some(ubuntu_gettext_domain) = &self.ubuntu_gettext_domain
+            {
+                Some(Cow::Owned(ubuntu_gettext_domain.to_string()))
+            } else {
+                None
+            },
+            path: Cow::Owned(self.path.to_path_buf()),
         }
     }
 }
 
 impl<'a> DesktopEntry<'a> {
-    /// An action is defined as `[Desktop Action actions-name]` where `action-name`
-    /// is defined in the `Actions` field of `[Desktop Entry]`.
-    /// Example: to get the `Name` field of this `new-window` action
-    /// ```txt
-    /// [Desktop Action new-window]
-    /// Name=Open a New Window
-    /// ```
-    /// you will need to call
-    /// ```rust
-    /// entry.action_entry("new-window", "Name")
-    /// ```
-    pub fn action_entry(&'a self, action: &str, key: &str) -> Option<&'a str> {
-        let group = self
-            .groups
-            .get(["Desktop Action ", action].concat().as_str());
-
-        Self::entry(group, key)
-    }
-
-    pub fn action_entry_localized<L: AsRef<str>>(
-        &'a self,
-        action: &str,
-        key: &str,
-        locales: &[L],
-    ) -> Option<Cow<'a, str>> {
-        let group = self
-            .groups
-            .get(["Desktop Action ", action].concat().as_str());
-
-        Self::localized_entry(self.ubuntu_gettext_domain.as_deref(), group, key, locales)
-    }
-
-    pub fn action_exec(&'a self, action: &str) -> Option<&'a str> {
-        self.action_entry(action, "Exec")
-    }
-
-    pub fn action_name<L: AsRef<str>>(
-        &'a self,
-        action: &str,
-        locales: &[L],
-    ) -> Option<Cow<'a, str>> {
-        self.action_entry_localized(action, "Name", locales)
-    }
-
-    /// Return actions separated by `;`
-    pub fn actions(&'a self) -> Option<&'a str> {
-        self.desktop_entry("Actions")
-    }
-
-    /// Return categories separated by `;`
-    pub fn categories(&'a self) -> Option<&'a str> {
-        self.desktop_entry("Categories")
-    }
-
-    pub fn comment<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>> {
-        self.desktop_entry_localized("Comment", locales)
+    pub fn id(&'a self) -> &'a str {
+        self.appid.as_ref()
     }
 
-    /// A desktop entry field is any field under the
-    /// `[Desktop Entry]` line
+    /// A desktop entry field is any field under the `[Desktop Entry]` section.
     pub fn desktop_entry(&'a self, key: &str) -> Option<&'a str> {
         Self::entry(self.groups.get("Desktop Entry"), key).map(|e| e.as_ref())
     }
@@ -147,12 +111,30 @@ impl<'a> DesktopEntry<'a> {
         )
     }
 
-    pub fn exec(&'a self) -> Option<&'a str> {
-        self.desktop_entry("Exec")
+    /// Insert a new field to this [`DesktopEntry`], in the `[Desktop Entry]` section, removing
+    /// the previous value and locales in any.
+    pub fn add_desktop_entry<'b>(&'b mut self, key: &'a str, value: &'a str)
+    where
+        'a: 'b,
+    {
+        let action_key = "Desktop Entry";
+        let key = Cow::Borrowed(key);
+        let value = (Cow::Borrowed(value), LocaleMap::default());
+
+        match self.groups.get_mut(action_key) {
+            Some(keymap) => {
+                keymap.insert(key, value);
+            }
+            None => {
+                let mut keymap = KeyMap::default();
+                keymap.insert(key, value);
+                self.groups.insert(Cow::Borrowed(action_key), keymap);
+            }
+        }
     }
 
-    pub fn flatpak(&'a self) -> Option<&'a str> {
-        self.desktop_entry("X-Flatpak")
+    pub fn name<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>> {
+        self.desktop_entry_localized("Name", locales)
     }
 
     pub fn generic_name<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>> {
@@ -163,8 +145,18 @@ impl<'a> DesktopEntry<'a> {
         self.desktop_entry("Icon")
     }
 
-    pub fn id(&'a self) -> &'a str {
-        self.appid.as_ref()
+    /// This is an human readable description of the desktop file.
+    pub fn comment<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>> {
+        self.desktop_entry_localized("Comment", locales)
+    }
+
+    pub fn exec(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Exec")
+    }
+
+    /// Return categories separated by `;`
+    pub fn categories(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Categories")
     }
 
     /// Return keywords separated by `;`
@@ -177,10 +169,6 @@ impl<'a> DesktopEntry<'a> {
         self.desktop_entry("MimeType")
     }
 
-    pub fn name<L: AsRef<str>>(&'a self, locales: &[L]) -> Option<Cow<'a, str>> {
-        self.desktop_entry_localized("Name", locales)
-    }
-
     pub fn no_display(&'a self) -> bool {
         self.desktop_entry_bool("NoDisplay")
     }
@@ -189,6 +177,10 @@ impl<'a> DesktopEntry<'a> {
         self.desktop_entry("OnlyShowIn")
     }
 
+    pub fn flatpak(&'a self) -> Option<&'a str> {
+        self.desktop_entry("X-Flatpak")
+    }
+
     pub fn prefers_non_default_gpu(&'a self) -> bool {
         self.desktop_entry_bool("PrefersNonDefaultGPU")
     }
@@ -209,6 +201,55 @@ impl<'a> DesktopEntry<'a> {
         self.desktop_entry("Type")
     }
 
+    /// Return actions separated by `;`
+    pub fn actions(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Actions")
+    }
+
+    /// An action is defined as `[Desktop Action actions-name]` where `action-name`
+    /// is defined in the `Actions` field of `[Desktop Entry]`.
+    /// Example: to get the `Name` field of this `new-window` action
+    /// ```txt
+    /// [Desktop Action new-window]
+    /// Name=Open a New Window
+    /// ```
+    /// you will need to call
+    /// ```rust
+    /// entry.action_entry("new-window", "Name")
+    /// ```
+    pub fn action_entry(&'a self, action: &str, key: &str) -> Option<&'a str> {
+        let group = self
+            .groups
+            .get(["Desktop Action ", action].concat().as_str());
+
+        Self::entry(group, key)
+    }
+
+    pub fn action_entry_localized<L: AsRef<str>>(
+        &'a self,
+        action: &str,
+        key: &str,
+        locales: &[L],
+    ) -> Option<Cow<'a, str>> {
+        let group = self
+            .groups
+            .get(["Desktop Action ", action].concat().as_str());
+
+        Self::localized_entry(self.ubuntu_gettext_domain.as_deref(), group, key, locales)
+    }
+
+    pub fn action_name<L: AsRef<str>>(
+        &'a self,
+        action: &str,
+        locales: &[L],
+    ) -> Option<Cow<'a, str>> {
+        self.action_entry_localized(action, "Name", locales)
+    }
+
+    pub fn action_exec(&'a self, action: &str) -> Option<&'a str> {
+        self.action_entry(action, "Exec")
+    }
+
     fn desktop_entry_bool(&'a self, key: &str) -> bool {
         self.desktop_entry(key).map_or(false, |v| v == "true")
     }

src/test.rs

@@ -8,7 +8,7 @@ fn test() {
 
     let locales = &["fr", "fr_FR.UTF-8"];
 
-    if let Ok(entry) = DesktopEntry::decode_from_path(path.to_path_buf(), locales) {
+    if let Ok(entry) = DesktopEntry::from_path(path.to_path_buf(), locales) {
         let e = DesktopEntry::localized_entry(
             None,
             entry.groups.get("Desktop Entry"),