feat: Support X-Ubuntu-Gettext-Domain

Author: mmstick

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "freedesktop-desktop-entry"
-version = "0.3.3"
+version = "0.4.0"
 authors = ["Michael Aaron Murphy <[email protected]>"]
 edition = "2018"
 homepage = "https://codeberg.org/mmstick/freedesktop-desktop-entry"
@@ -14,5 +14,6 @@ maintenance = { status = "passively-maintained" }
 
 [dependencies]
 dirs = "3"
+gettext-rs = { version = "0.7", features = ["gettext-system"]}
 memchr = "2"
 thiserror = "1"

src/lib.rs

@@ -4,7 +4,7 @@ extern crate thiserror;
 mod iter;
 
 pub use self::iter::Iter;
-
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
@@ -27,38 +27,52 @@ pub struct DesktopEntry<'a> {
     pub appid: &'a str,
     pub groups: Groups<'a>,
     pub path: &'a Path,
+    pub ubuntu_gettext_domain: Option<&'a str>,
 }
 
 impl<'a> DesktopEntry<'a> {
-    pub fn action_entry(&self, action: &str, key: &str, locale: Option<&str>) -> Option<&'a str> {
+    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(
+        &'a self,
+        action: &str,
+        key: &str,
+        locale: Option<&str>,
+    ) -> Option<Cow<'a, str>> {
         let group = self
             .groups
             .get(["Desktop Action ", action].concat().as_str());
 
-        Self::localized_entry(group, key, locale)
+        Self::localized_entry(self.ubuntu_gettext_domain, group, key, locale)
     }
 
-    pub fn action_exec(&self, action: &str) -> Option<&'a str> {
-        self.action_entry(action, "Exec", None)
+    pub fn action_exec(&'a self, action: &str) -> Option<&'a str> {
+        self.action_entry(action, "Exec")
     }
 
-    pub fn action_name(&self, action: &str, locale: Option<&str>) -> Option<&'a str> {
-        self.action_entry(action, "Name", locale)
+    pub fn action_name(&'a self, action: &str, locale: Option<&str>) -> Option<Cow<'a, str>> {
+        self.action_entry_localized(action, "Name", locale)
     }
 
-    pub fn actions(&self) -> Option<&'a str> {
-        self.desktop_entry("Actions", None)
+    pub fn actions(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Actions")
     }
 
-    pub fn categories(&self) -> Option<&'a str> {
-        self.desktop_entry("Categories", None)
+    pub fn categories(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Categories")
     }
 
-    pub fn comment(&self, locale: Option<&str>) -> Option<&'a str> {
-        self.desktop_entry("Comment", locale)
+    pub fn comment(&'a self, locale: Option<&str>) -> Option<Cow<'a, str>> {
+        self.desktop_entry_localized("Comment", locale)
     }
 
-    pub fn decode<'b>(path: &'b Path, input: &'b str) -> Result<DesktopEntry<'b>, DecodeError> {
+    pub fn decode(path: &'a Path, input: &'a str) -> Result<DesktopEntry<'a>, DecodeError> {
         let appid = path
             .file_stem()
             .ok_or(DecodeError::AppID)?
@@ -69,6 +83,8 @@ impl<'a> DesktopEntry<'a> {
 
         let mut active_group = "";
 
+        let mut ubuntu_gettext_domain = None;
+
         for mut line in input.lines() {
             line = line.trim();
             if line.is_empty() || line.starts_with('#') {
@@ -101,6 +117,11 @@ impl<'a> DesktopEntry<'a> {
                     }
                 }
 
+                if key == "X-Ubuntu-Gettext-Domain" {
+                    ubuntu_gettext_domain = Some(value);
+                    continue;
+                }
+
                 groups
                     .entry(active_group)
                     .or_insert_with(Default::default)
@@ -114,74 +135,93 @@ impl<'a> DesktopEntry<'a> {
             appid,
             groups,
             path,
+            ubuntu_gettext_domain,
         })
     }
 
-    pub fn desktop_entry(&self, key: &str, locale: Option<&str>) -> Option<&'a str> {
-        Self::localized_entry(self.groups.get("Desktop Entry"), key, locale)
+    pub fn desktop_entry(&'a self, key: &str) -> Option<&'a str> {
+        Self::entry(self.groups.get("Desktop Entry"), key)
+    }
+
+    pub fn desktop_entry_localized(
+        &'a self,
+        key: &str,
+        locale: Option<&str>,
+    ) -> Option<Cow<'a, str>> {
+        Self::localized_entry(
+            self.ubuntu_gettext_domain,
+            self.groups.get("Desktop Entry"),
+            key,
+            locale,
+        )
     }
 
-    pub fn exec(&self) -> Option<&'a str> {
-        self.desktop_entry("Exec", None)
+    pub fn exec(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Exec")
     }
 
-    pub fn icon(&self) -> Option<&'a str> {
-        self.desktop_entry("Icon", None)
+    pub fn icon(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Icon")
     }
 
-    pub fn id(&self) -> &str {
+    pub fn id(&'a self) -> &str {
         self.appid
     }
 
-    pub fn keywords(&self) -> Option<&'a str> {
-        self.desktop_entry("Keywords", None)
+    pub fn keywords(&'a self) -> Option<Cow<'a, str>> {
+        self.desktop_entry_localized("Keywords", None)
     }
 
-    pub fn mime_type(&self) -> Option<&'a str> {
-        self.desktop_entry("MimeType", None)
+    pub fn mime_type(&'a self) -> Option<&'a str> {
+        self.desktop_entry("MimeType")
     }
 
-    pub fn name(&self, locale: Option<&str>) -> Option<&'a str> {
-        self.desktop_entry("Name", locale)
+    pub fn name(&'a self, locale: Option<&str>) -> Option<Cow<'a, str>> {
+        self.desktop_entry_localized("Name", locale)
     }
 
-    pub fn no_display(&self) -> bool {
+    pub fn no_display(&'a self) -> bool {
         self.desktop_entry_bool("NoDisplay")
     }
 
-    pub fn only_show_in(&self) -> Option<&'a str> {
-        self.desktop_entry("OnlyShowIn", None)
+    pub fn only_show_in(&'a self) -> Option<&'a str> {
+        self.desktop_entry("OnlyShowIn")
     }
 
-    pub fn prefers_non_default_gpu(&self) -> bool {
+    pub fn prefers_non_default_gpu(&'a self) -> bool {
         self.desktop_entry_bool("PrefersNonDefaultGPU")
     }
 
-    pub fn startup_notify(&self) -> bool {
+    pub fn startup_notify(&'a self) -> bool {
         self.desktop_entry_bool("StartupNotify")
     }
 
-    pub fn terminal(&self) -> bool {
+    pub fn terminal(&'a self) -> bool {
         self.desktop_entry_bool("Terminal")
     }
 
-    pub fn type_(&self) -> Option<&'a str> {
-        self.desktop_entry("Type", None)
+    pub fn type_(&'a self) -> Option<&'a str> {
+        self.desktop_entry("Type")
+    }
+
+    fn desktop_entry_bool(&'a self, key: &str) -> bool {
+        self.desktop_entry(key).map_or(false, |v| v == "true")
     }
 
-    fn desktop_entry_bool(&self, key: &str) -> bool {
-        self.desktop_entry(key, None).map_or(false, |v| v == "true")
+    fn entry(group: Option<&'a KeyMap<'a>>, key: &str) -> Option<&'a str> {
+        group.and_then(|group| group.get(key)).map(|key| key.0)
     }
 
     fn localized_entry(
-        group: Option<&KeyMap<'a>>,
+        ubuntu_gettext_domain: Option<&'a str>,
+        group: Option<&'a KeyMap<'a>>,
         key: &str,
         locale: Option<&str>,
-    ) -> Option<&'a str> {
+    ) -> Option<Cow<'a, str>> {
         group.and_then(|group| group.get(key)).and_then(|key| {
             locale
-                .and_then(|locale| match key.1.get(locale) {
-                    Some(value) => Some(*value),
+                .and_then(|locale| match key.1.get(locale).cloned() {
+                    Some(value) => Some(value),
                     None => {
                         if let Some(pos) = locale.find('_') {
                             key.1.get(&locale[..pos]).cloned()
@@ -190,7 +230,9 @@ impl<'a> DesktopEntry<'a> {
                         }
                     }
                 })
-                .or(Some(key.0))
+                .map(Cow::Borrowed)
+                .or_else(|| ubuntu_gettext_domain.map(|domain| Cow::Owned(dgettext(domain, key.0))))
+                .or(Some(Cow::Borrowed(key.0)))
         })
     }
 }
@@ -249,3 +291,9 @@ pub fn default_paths() -> Vec<(PathSource, PathBuf)> {
         (PathSource::System, PathBuf::from("/usr/share/applications")),
     ]
 }
+
+fn dgettext(domain: &str, message: &str) -> String {
+    use gettextrs::{setlocale, LocaleCategory};
+    setlocale(LocaleCategory::LcAll, "");
+    gettextrs::dgettext(domain, message)
+}