feat!: Replace hardcoded paths with XDG_DATA_DIRs

Author: Hugo Osvaldo Barrera

Cargo.toml

@@ -16,3 +16,4 @@ dirs = "3"
 gettext-rs = { version = "0.7", features = ["gettext-system"]}
 memchr = "2"
 thiserror = "1"
+xdg = "2.4.0"

examples/example.rs

@@ -3,10 +3,11 @@
 
 use std::fs;
 
-use freedesktop_desktop_entry::{default_paths, DesktopEntry, Iter};
+use freedesktop_desktop_entry::{default_paths, DesktopEntry, Iter, PathSource};
 
 fn main() {
-    for (path_src, path) in Iter::new(default_paths()) {
+    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(&path, &bytes) {
                 println!("{:?}: {}\n---\n{}", path_src, path.display(), entry);

src/iter.rs

@@ -1,16 +1,15 @@
 // Copyright 2021 System76 <[email protected]>
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::PathSource;
 use std::{fs, path::PathBuf};
 
 pub struct Iter {
-    directories_to_walk: Vec<(PathSource, PathBuf)>,
-    actively_walking: Option<(PathSource, fs::ReadDir)>,
+    directories_to_walk: Vec<PathBuf>,
+    actively_walking: Option<fs::ReadDir>,
 }
 
 impl Iter {
-    pub fn new(directories_to_walk: Vec<(PathSource, PathBuf)>) -> Self {
+    pub fn new(directories_to_walk: Vec<PathBuf>) -> Self {
         Self {
             directories_to_walk,
             actively_walking: None,
@@ -19,17 +18,17 @@ impl Iter {
 }
 
 impl Iterator for Iter {
-    type Item = (PathSource, PathBuf);
+    type Item = PathBuf;
 
     fn next(&mut self) -> Option<Self::Item> {
         'outer: loop {
-            let (path_src, mut iterator) = match self.actively_walking.take() {
+            let mut iterator = match self.actively_walking.take() {
                 Some(dir) => dir,
                 None => {
-                    while let Some((path_src, path)) = self.directories_to_walk.pop() {
+                    while let Some(path) = self.directories_to_walk.pop() {
                         match fs::read_dir(&path) {
                             Ok(directory) => {
-                                self.actively_walking = Some((path_src, directory));
+                                self.actively_walking = Some(directory);
                                 continue 'outer;
                             }
 
@@ -48,12 +47,12 @@ impl Iterator for Iter {
 
                     if let Ok(file_type) = entry.file_type() {
                         if file_type.is_dir() {
-                            self.directories_to_walk.push((path_src.clone(), path));
+                            self.directories_to_walk.push(path);
                         } else if (file_type.is_file() || file_type.is_symlink())
                             && path.extension().map_or(false, |ext| ext == "desktop")
                         {
-                            self.actively_walking = Some((path_src.clone(), iterator));
-                            return Some((path_src, path));
+                            self.actively_walking = Some(iterator);
+                            return Some(path);
                         }
                     }
                 }

src/lib.rs

@@ -9,7 +9,9 @@ mod iter;
 pub use self::iter::Iter;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
+
 use std::path::{Path, PathBuf};
+use xdg::BaseDirectories;
 
 pub type Group<'a> = &'a str;
 pub type Groups<'a> = BTreeMap<Group<'a>, KeyMap<'a>>;
@@ -279,42 +281,53 @@ pub enum PathSource {
     LocalNix,
     Nix,
     System,
+    SystemLocal,
     SystemFlatpak,
     SystemSnap,
     Other(String),
 }
 
-pub fn default_paths() -> Vec<(PathSource, PathBuf)> {
-    let home_dir = dirs::home_dir().unwrap();
-
-    vec![
-        (PathSource::LocalDesktop, home_dir.join("Desktop")),
-        (
-            PathSource::LocalFlatpak,
-            home_dir.join(".local/share/flatpak/exports/share/applications"),
-        ),
-        (
-            PathSource::Local,
-            home_dir.join(".local/share/applications"),
-        ),
-        (
-            PathSource::LocalNix,
-            home_dir.join(".nix-profile/share/applications"),
-        ),
-        (
-            PathSource::SystemSnap,
-            PathBuf::from("/var/lib/snapd/desktop/applications"),
-        ),
-        (
-            PathSource::SystemFlatpak,
-            PathBuf::from("/var/lib/flatpak/exports/share/applications"),
-        ),
-        (
-            PathSource::Nix,
-            PathBuf::from("/nix/var/nix/profiles/default/share/applications"),
-        ),
-        (PathSource::System, PathBuf::from("/usr/share/applications")),
-    ]
+impl PathSource {
+
+    /// Attempts to determine the PathSource for a given Path.
+    /// Note that this is a best-effort guesting function, and its results should be treated as
+    /// such (e.g.: non-canonical).
+    pub fn guess_from(path: &Path) -> PathSource {
+        let base_dirs = BaseDirectories::new().unwrap();
+        let data_home = base_dirs.get_data_home();
+
+        if path.starts_with("/usr/share") {
+            PathSource::System
+        } else if path.starts_with("/usr/local/share") {
+            PathSource::SystemLocal
+        } else if path.starts_with("/var/lib/flatpak") {
+            PathSource::SystemFlatpak
+        } else if path.starts_with("/var/lib/snapd") {
+            PathSource::SystemSnap
+        } else if path.starts_with("/nix/var/nix/profiles/default") || path.starts_with("/nix/store") {
+            PathSource::Nix
+        } else if path.to_string_lossy().contains("/flatpak/") {
+            PathSource::LocalFlatpak
+        } else if path.starts_with(&data_home.as_path()) {
+            PathSource::Local
+        } else if path.starts_with("/nix/var/nix/profiles/per-user") || path.to_string_lossy().contains(".nix") {
+            PathSource::LocalNix
+        } else  {
+            PathSource::Other(String::from("unknown"))
+        }
+    }
+}
+
+/// Returns the default paths in which desktop entries should be searched for based on the current
+/// environment.
+///
+/// Panics in case determining the current home directory fails.
+pub fn default_paths() -> Vec<PathBuf> {
+    let base_dirs = BaseDirectories::new().unwrap();
+    let mut data_dirs = base_dirs.get_data_dirs();
+    data_dirs.push(base_dirs.get_data_home());
+
+    data_dirs.iter().map(|d| d.join("applications")).collect()
 }
 
 fn dgettext(domain: &str, message: &str) -> String {