Use locale from LC_MESSAGES

Author: l4l

Cargo.lock

@@ -34,6 +34,7 @@ itertools = "0.9.0"
 euclid = "0.22.1"
 nom = { version = "6.0.1", default-features = false, features = ["std", "regexp"] }
 regex = "1.4.2"
+libc = "0.2.81"
 
 [profile.release]
 lto = true

Cargo.toml

@@ -6,6 +6,8 @@ use xdg::BaseDirectories;
 
 use crate::icon::Icon;
 
+mod locale;
+
 pub static XDG_DIRS: OnceCell<BaseDirectories> = OnceCell::new();
 
 pub struct Entry {
@@ -83,8 +85,19 @@ fn traverse_dir_entry(mut entries: &mut Vec<Entry>, dir_entry: DirEntry) {
             return;
         }
     };
+
     let main_section = entry.section("Desktop Entry");
-    match (main_section.attr("Name"), main_section.attr("Exec")) {
+    let locale = locale::Locale::current();
+
+    let localized_entry = |attr_name: &str| {
+        locale
+            .keys()
+            .filter_map(|key| main_section.attr_with_param(attr_name, key))
+            .next()
+            .or_else(|| main_section.attr(attr_name))
+    };
+
+    match (localized_entry("Name"), main_section.attr("Exec")) {
         (Some(n), Some(e)) => {
             entries.push(Entry {
                 name: n.to_owned(),
@@ -96,14 +109,12 @@ fn traverse_dir_entry(mut entries: &mut Vec<Entry>, dir_entry: DirEntry) {
                     .to_owned(),
                 path: dir_entry_path,
                 exec: e.to_owned(),
-                // TODO: use `attr_with_param` with locale first
-                name_with_keywords: n.to_owned()
-                    + main_section.attr("Keywords").unwrap_or_default(),
+                name_with_keywords: n.to_owned() + localized_entry("Keywords").unwrap_or_default(),
                 is_terminal: main_section
                     .attr("Terminal")
                     .map(|s| s == "true")
                     .unwrap_or(false),
-                icon: main_section.attr("Icon").and_then(|name| {
+                icon: localized_entry("Icon").and_then(|name| {
                     let icon_path = Path::new(name);
 
                     if icon_path.is_absolute() {

src/desktop.rs

@@ -0,0 +1,77 @@
+use std::ffi::CStr;
+
+use once_cell::sync::OnceCell;
+use regex::Regex;
+
+pub struct Locale<'a> {
+    lang: Option<&'a str>,
+    country: Option<&'a str>,
+    modifier: Option<&'a str>,
+}
+
+impl Locale<'static> {
+    pub fn current<'a>() -> &'a Self {
+        static LOCALE: OnceCell<Option<Locale<'static>>> = OnceCell::new();
+        LOCALE
+            .get_or_init(|| {
+                let s = unsafe {
+                    let ptr = libc::setlocale(libc::LC_MESSAGES, b"\0".as_ptr().cast());
+                    if ptr.is_null() {
+                        return None;
+                    }
+                    CStr::from_ptr(ptr)
+                }
+                .to_str()
+                .ok()?;
+
+                let re = Regex::new(
+                    r#"(?x)
+                      ^
+                      ([[:alpha:]]+) # lang
+                      (?:_([[:alpha:]]+))? # country
+                      (?:\.[^@]*)? # encoding
+                      (?:@(.*))? # modifier
+                      $"#,
+                )
+                .unwrap();
+
+                let c = re.captures(s)?;
+
+                Some(Self {
+                    lang: c.get(1).map(|m| &s[m.range()]),
+                    country: c.get(2).map(|m| &s[m.range()]),
+                    modifier: c.get(3).map(|m| &s[m.range()]),
+                })
+            })
+            .as_ref()
+            .unwrap_or(&Self {
+                lang: None,
+                country: None,
+                modifier: None,
+            })
+    }
+
+    pub fn keys(&self) -> impl Iterator<Item = impl AsRef<str>> + '_ {
+        static LOCALE_ITERS: OnceCell<Vec<String>> = OnceCell::new();
+        LOCALE_ITERS
+            .get_or_init(|| {
+                let mut v = vec![];
+                if let Some(((l, c), m)) = self.lang.zip(self.country).zip(self.modifier) {
+                    v.push(format!("{}_{}@{}", l, c, m));
+                }
+                if let Some((l, c)) = self.lang.zip(self.country) {
+                    v.push(format!("{}_{}", l, c));
+                }
+                if let Some((l, m)) = self.lang.zip(self.modifier) {
+                    v.push(format!("{}@{}", l, m));
+                }
+                if let Some(l) = self.lang {
+                    v.push(l.to_string());
+                }
+
+                v
+            })
+            .clone()
+            .into_iter()
+    }
+}