xdge 0.1.0

//! # xdge
//!
//! A complete, zero-dependency implementation of the
//! [XDG Base Directory Specification v0.8](https://specifications.freedesktop.org/basedir/latest/)
//! for Linux and Unix systems.
//!
//! ## Quick Start
//!
//! ```rust
//! use xdge::XdgDirs;
//!
//! let xdg = XdgDirs::new();
//!
//! // Where to write user config
//! println!("{}", xdg.config_home().display());   // e.g. /home/alice/.config
//!
//! // Where to write user data
//! println!("{}", xdg.data_home().display());     // e.g. /home/alice/.local/share
//!
//! // Search all config dirs for "myapp/settings.toml"
//! if let Some(path) = xdg.find_config_file("myapp/settings.toml") {
//!     println!("Found config at {}", path.display());
//! }
//! ```
//!
//! ## XDG Variables Implemented
//!
//! | Variable            | Default                      | Method                   |
//! |---------------------|------------------------------|--------------------------|
//! | `$XDG_DATA_HOME`    | `$HOME/.local/share`         | [`XdgDirs::data_home`]   |
//! | `$XDG_CONFIG_HOME`  | `$HOME/.config`              | [`XdgDirs::config_home`] |
//! | `$XDG_STATE_HOME`   | `$HOME/.local/state`         | [`XdgDirs::state_home`]  |
//! | `$XDG_CACHE_HOME`   | `$HOME/.cache`               | [`XdgDirs::cache_home`]  |
//! | `$XDG_RUNTIME_DIR`  | *(none — warn if unset)*     | [`XdgDirs::runtime_dir`] |
//! | `$XDG_DATA_DIRS`    | `/usr/local/share:/usr/share`| [`XdgDirs::data_dirs`]   |
//! | `$XDG_CONFIG_DIRS`  | `/etc/xdg`                   | [`XdgDirs::config_dirs`] |
//! | *(user bin)*        | `$HOME/.local/bin`           | [`XdgDirs::user_bin_dir`]|

#![warn(missing_docs, missing_debug_implementations)]

use std::{env, fs, io, path::{Path, PathBuf}};

// ─── Error type ─────────────────────────────────────────────────────────────

/// Errors that can be returned by directory-creation helpers.
#[derive(Debug)]
pub enum XdgError {
    /// The `$HOME` environment variable is not set, making it impossible to
    /// compute any default path.
    HomeDirNotFound,
    /// A filesystem operation failed.
    Io(io::Error),
    /// `$XDG_RUNTIME_DIR` is not set.
    RuntimeDirNotSet,
}

impl std::fmt::Display for XdgError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            XdgError::HomeDirNotFound => write!(f, "The $HOME environment variable is not set"),
            XdgError::Io(e) => write!(f, "I/O error: {e}"),
            XdgError::RuntimeDirNotSet => write!(f, "$XDG_RUNTIME_DIR is not set"),
        }
    }
}

impl std::error::Error for XdgError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        if let XdgError::Io(e) = self { Some(e) } else { None }
    }
}

impl From<io::Error> for XdgError {
    fn from(e: io::Error) -> Self { XdgError::Io(e) }
}

// ─── Core struct ─────────────────────────────────────────────────────────────

/// Resolved XDG Base Directory paths.
///
/// Construct with [`XdgDirs::new`] (reads the current environment) or
/// [`XdgDirs::new_with_home`] (useful for testing).
///
/// All paths are **absolute** — relative values in environment variables are
/// silently ignored per the spec.
#[derive(Debug, Clone)]
pub struct XdgDirs {
    home: PathBuf,
}

impl XdgDirs {
    // ── Constructors ─────────────────────────────────────────────────────────

    /// Build an [`XdgDirs`] from the real process environment.
    ///
    /// # Panics
    ///
    /// Panics if `$HOME` is not set. Use [`XdgDirs::try_new`] for graceful handling.
    pub fn new() -> Self {
        Self::try_new().expect(
            "xdge: $HOME is not set; cannot determine any XDG base directory",
        )
    }

    /// Fallible version of [`XdgDirs::new`].
    pub fn try_new() -> Result<Self, XdgError> {
        let home = home_dir().ok_or(XdgError::HomeDirNotFound)?;
        Ok(Self { home })
    }

    /// Construct with an explicit home directory — ideal for unit tests.
    ///
    /// ```rust
    /// use xdge::XdgDirs;
    /// use std::path::PathBuf;
    ///
    /// let xdg = XdgDirs::new_with_home(PathBuf::from("/tmp/fakehome"));
    /// assert_eq!(xdg.data_home(), PathBuf::from("/tmp/fakehome/.local/share"));
    /// ```
    pub fn new_with_home(home: PathBuf) -> Self {
        Self { home }
    }

    // ── Single-directory accessors ────────────────────────────────────────────

    /// `$XDG_DATA_HOME` — base directory for user-specific **data** files.
    ///
    /// Default: `$HOME/.local/share`
    pub fn data_home(&self) -> PathBuf {
        resolve_single("XDG_DATA_HOME", self.home.join(".local/share"))
    }

    /// `$XDG_CONFIG_HOME` — base directory for user-specific **configuration** files.
    ///
    /// Default: `$HOME/.config`
    pub fn config_home(&self) -> PathBuf {
        resolve_single("XDG_CONFIG_HOME", self.home.join(".config"))
    }

    /// `$XDG_STATE_HOME` — base directory for user-specific **state** files.
    ///
    /// State data persists between restarts but is not portable enough for
    /// [`data_home`](Self::data_home). Examples: history, layout, undo stacks.
    ///
    /// Default: `$HOME/.local/state`
    pub fn state_home(&self) -> PathBuf {
        resolve_single("XDG_STATE_HOME", self.home.join(".local/state"))
    }

    /// `$XDG_CACHE_HOME` — base directory for user-specific **non-essential cached** data.
    ///
    /// Default: `$HOME/.cache`
    pub fn cache_home(&self) -> PathBuf {
        resolve_single("XDG_CACHE_HOME", self.home.join(".cache"))
    }

    /// `$HOME/.local/bin` — directory for user-specific **executables**.
    ///
    /// The spec recommends distributions ensure this is on `$PATH`.
    pub fn user_bin_dir(&self) -> PathBuf {
        self.home.join(".local/bin")
    }

    /// `$XDG_RUNTIME_DIR` — base directory for user-specific **runtime files**
    /// (sockets, named pipes, …).
    ///
    /// Per spec this directory MUST be owned by the user with mode `0700`,
    /// on a local filesystem, and removed on full logout.
    ///
    /// Returns:
    /// - `Ok(Some(path))` when the variable is set and absolute
    /// - `Ok(None)` when unset or relative (caller should warn and fall back)
    ///
    /// See also [`runtime_dir_or_fallback`](Self::runtime_dir_or_fallback).
    pub fn runtime_dir(&self) -> Result<Option<PathBuf>, XdgError> {
        match env::var_os("XDG_RUNTIME_DIR") {
            Some(v) => {
                let p = PathBuf::from(v);
                if p.is_absolute() { Ok(Some(p)) } else { Ok(None) }
            }
            None => Ok(None),
        }
    }

    /// Like [`runtime_dir`](Self::runtime_dir) but automatically falls back to
    /// `$XDG_CACHE_HOME/runtime` and emits a spec-required warning to stderr
    /// when `$XDG_RUNTIME_DIR` is not set.
    pub fn runtime_dir_or_fallback(&self) -> PathBuf {
        match self.runtime_dir() {
            Ok(Some(p)) => p,
            _ => {
                let fallback = self.cache_home().join("runtime");
                eprintln!(
                    "xdge WARNING: $XDG_RUNTIME_DIR is not set. \
                     Falling back to '{}'. This directory may lack \
                     the security properties required by the XDG spec.",
                    fallback.display()
                );
                fallback
            }
        }
    }

    // ── Multi-directory accessors ─────────────────────────────────────────────

    /// `$XDG_DATA_DIRS` — preference-ordered **system** data directories,
    /// searched after [`data_home`](Self::data_home).
    ///
    /// Default: `[/usr/local/share, /usr/share]`
    pub fn data_dirs(&self) -> Vec<PathBuf> {
        resolve_dirs("XDG_DATA_DIRS", &["/usr/local/share", "/usr/share"])
    }

    /// `$XDG_CONFIG_DIRS` — preference-ordered **system** config directories,
    /// searched after [`config_home`](Self::config_home).
    ///
    /// Default: `[/etc/xdg]`
    pub fn config_dirs(&self) -> Vec<PathBuf> {
        resolve_dirs("XDG_CONFIG_DIRS", &["/etc/xdg"])
    }

    /// Full ordered data search path: [`data_home`](Self::data_home) followed
    /// by every directory in [`data_dirs`](Self::data_dirs).
    pub fn data_search_dirs(&self) -> Vec<PathBuf> {
        let mut dirs = vec![self.data_home()];
        dirs.extend(self.data_dirs());
        dirs
    }

    /// Full ordered config search path: [`config_home`](Self::config_home)
    /// followed by every directory in [`config_dirs`](Self::config_dirs).
    pub fn config_search_dirs(&self) -> Vec<PathBuf> {
        let mut dirs = vec![self.config_home()];
        dirs.extend(self.config_dirs());
        dirs
    }

    // ── File-finding helpers ──────────────────────────────────────────────────

    /// Search for `relative_path` in all data directories (user first, then
    /// system), returning the **first** path that exists.
    ///
    /// ```rust
    /// use xdge::XdgDirs;
    /// let xdg = XdgDirs::new();
    /// if let Some(path) = xdg.find_data_file("myapp/icons/logo.png") {
    ///     println!("Found: {}", path.display());
    /// }
    /// ```
    pub fn find_data_file(&self, relative_path: impl AsRef<Path>) -> Option<PathBuf> {
        find_in_dirs(self.data_search_dirs(), relative_path.as_ref())
    }

    /// Search for `relative_path` in all config directories (user first, then
    /// system), returning the **first** path that exists.
    ///
    /// ```rust
    /// use xdge::XdgDirs;
    /// let xdg = XdgDirs::new();
    /// if let Some(path) = xdg.find_config_file("myapp/config.toml") {
    ///     println!("Found: {}", path.display());
    /// }
    /// ```
    pub fn find_config_file(&self, relative_path: impl AsRef<Path>) -> Option<PathBuf> {
        find_in_dirs(self.config_search_dirs(), relative_path.as_ref())
    }

    /// Return **all** matching paths across every data directory, in precedence
    /// order (most important first). Useful when the caller needs to merge
    /// information from multiple sources.
    pub fn find_all_data_files(&self, relative_path: impl AsRef<Path>) -> Vec<PathBuf> {
        find_all_in_dirs(self.data_search_dirs(), relative_path.as_ref())
    }

    /// Return **all** matching paths across every config directory, in
    /// precedence order.
    pub fn find_all_config_files(&self, relative_path: impl AsRef<Path>) -> Vec<PathBuf> {
        find_all_in_dirs(self.config_search_dirs(), relative_path.as_ref())
    }

    // ── Directory-creation helpers ────────────────────────────────────────────

    /// Ensure `$XDG_DATA_HOME` exists, creating it (mode `0700`) if needed.
    pub fn create_data_home(&self) -> Result<PathBuf, XdgError> {
        create_dir(self.data_home())
    }

    /// Ensure `$XDG_CONFIG_HOME` exists, creating it (mode `0700`) if needed.
    pub fn create_config_home(&self) -> Result<PathBuf, XdgError> {
        create_dir(self.config_home())
    }

    /// Ensure `$XDG_STATE_HOME` exists, creating it (mode `0700`) if needed.
    pub fn create_state_home(&self) -> Result<PathBuf, XdgError> {
        create_dir(self.state_home())
    }

    /// Ensure `$XDG_CACHE_HOME` exists, creating it (mode `0700`) if needed.
    pub fn create_cache_home(&self) -> Result<PathBuf, XdgError> {
        create_dir(self.cache_home())
    }

    /// Ensure the runtime dir (or fallback) exists, creating it (mode `0700`) if needed.
    pub fn create_runtime_dir(&self) -> Result<PathBuf, XdgError> {
        create_dir(self.runtime_dir_or_fallback())
    }

    /// Create `subdir` inside `$XDG_DATA_HOME` with mode `0700`.
    ///
    /// ```rust
    /// use xdge::XdgDirs;
    /// let xdg = XdgDirs::new();
    /// xdg.create_data_subdir("myapp/plugins").ok();
    /// ```
    pub fn create_data_subdir(&self, subdir: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        create_dir(self.data_home().join(subdir))
    }

    /// Create `subdir` inside `$XDG_CONFIG_HOME` with mode `0700`.
    pub fn create_config_subdir(&self, subdir: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        create_dir(self.config_home().join(subdir))
    }

    /// Create `subdir` inside `$XDG_STATE_HOME` with mode `0700`.
    pub fn create_state_subdir(&self, subdir: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        create_dir(self.state_home().join(subdir))
    }

    /// Create `subdir` inside `$XDG_CACHE_HOME` with mode `0700`.
    pub fn create_cache_subdir(&self, subdir: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        create_dir(self.cache_home().join(subdir))
    }

    /// Create `subdir` inside the runtime dir (or fallback) with mode `0700`.
    pub fn create_runtime_subdir(&self, subdir: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        create_dir(self.runtime_dir_or_fallback().join(subdir))
    }

    // ── place_* helpers ───────────────────────────────────────────────────────

    /// Return the path `$XDG_DATA_HOME/<relative_path>`, creating parent
    /// directories (mode `0700`) as needed. The file itself is not created.
    ///
    /// ```rust
    /// use xdge::XdgDirs;
    /// let xdg = XdgDirs::new();
    /// let path = xdg.place_data_file("myapp/database.db").unwrap();
    /// // path == $XDG_DATA_HOME/myapp/database.db
    /// ```
    pub fn place_data_file(&self, relative_path: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        place_file(self.data_home(), relative_path.as_ref())
    }

    /// Return the path `$XDG_CONFIG_HOME/<relative_path>`, creating parent dirs.
    pub fn place_config_file(&self, relative_path: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        place_file(self.config_home(), relative_path.as_ref())
    }

    /// Return the path `$XDG_STATE_HOME/<relative_path>`, creating parent dirs.
    pub fn place_state_file(&self, relative_path: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        place_file(self.state_home(), relative_path.as_ref())
    }

    /// Return the path `$XDG_CACHE_HOME/<relative_path>`, creating parent dirs.
    pub fn place_cache_file(&self, relative_path: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        place_file(self.cache_home(), relative_path.as_ref())
    }

    /// Return the path `$XDG_RUNTIME_DIR/<relative_path>`, creating parent dirs.
    pub fn place_runtime_file(&self, relative_path: impl AsRef<Path>) -> Result<PathBuf, XdgError> {
        place_file(self.runtime_dir_or_fallback(), relative_path.as_ref())
    }
}

impl Default for XdgDirs {
    fn default() -> Self { Self::new() }
}

// ─── Private helpers ──────────────────────────────────────────────────────────

fn home_dir() -> Option<PathBuf> {
    env::var_os("HOME").map(PathBuf::from).filter(|p| p.is_absolute())
}

/// Read a single XDG variable; fall back if missing, empty, or relative.
fn resolve_single(var: &str, default: PathBuf) -> PathBuf {
    match env::var_os(var) {
        Some(v) if !v.is_empty() => {
            let p = PathBuf::from(v);
            if p.is_absolute() { p } else { default }
        }
        _ => default,
    }
}

/// Read a colon-separated list XDG variable; silently drop relative entries.
/// Falls back to `defaults` if the result is empty.
fn resolve_dirs(var: &str, defaults: &[&str]) -> Vec<PathBuf> {
    match env::var_os(var) {
        Some(v) if !v.is_empty() => {
            let paths: Vec<PathBuf> = env::split_paths(&v)
                .filter(|p| p.is_absolute())
                .collect();
            if paths.is_empty() {
                defaults.iter().map(PathBuf::from).collect()
            } else {
                paths
            }
        }
        _ => defaults.iter().map(PathBuf::from).collect(),
    }
}

fn find_in_dirs(dirs: Vec<PathBuf>, relative: &Path) -> Option<PathBuf> {
    dirs.into_iter().map(|d| d.join(relative)).find(|p| p.exists())
}

fn find_all_in_dirs(dirs: Vec<PathBuf>, relative: &Path) -> Vec<PathBuf> {
    dirs.into_iter().map(|d| d.join(relative)).filter(|p| p.exists()).collect()
}

/// Create `dir` and all parents with mode `0700`.
/// If `dir` already exists, permissions are left unchanged (per spec).
fn create_dir(dir: PathBuf) -> Result<PathBuf, XdgError> {
    if !dir.exists() {
        fs::create_dir_all(&dir)?;
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            fs::set_permissions(&dir, fs::Permissions::from_mode(0o700))?;
        }
    }
    Ok(dir)
}

fn place_file(base: PathBuf, relative: &Path) -> Result<PathBuf, XdgError> {
    let full = base.join(relative);
    if let Some(parent) = full.parent() {
        create_dir(parent.to_path_buf())?;
    }
    Ok(full)
}

// ─── Tests ────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Mutex;

    static ENV_LOCK: Mutex<()> = Mutex::new(());

    fn fake(home: &str) -> XdgDirs {
        XdgDirs::new_with_home(PathBuf::from(home))
    }

    #[test]
    fn default_data_home() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_HOME");
        assert_eq!(fake("/home/alice").data_home(), PathBuf::from("/home/alice/.local/share"));
    }

    #[test]
    fn default_config_home() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_CONFIG_HOME");
        assert_eq!(fake("/home/alice").config_home(), PathBuf::from("/home/alice/.config"));
    }

    #[test]
    fn default_state_home() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_STATE_HOME");
        assert_eq!(fake("/home/alice").state_home(), PathBuf::from("/home/alice/.local/state"));
    }

    #[test]
    fn default_cache_home() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_CACHE_HOME");
        assert_eq!(fake("/home/alice").cache_home(), PathBuf::from("/home/alice/.cache"));
    }

    #[test]
    fn default_user_bin_dir() {
        assert_eq!(fake("/home/alice").user_bin_dir(), PathBuf::from("/home/alice/.local/bin"));
    }

    #[test]
    fn default_data_dirs() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_DIRS");
        assert_eq!(
            fake("/home/alice").data_dirs(),
            vec![PathBuf::from("/usr/local/share"), PathBuf::from("/usr/share")]
        );
    }

    #[test]
    fn default_config_dirs() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_CONFIG_DIRS");
        assert_eq!(fake("/home/alice").config_dirs(), vec![PathBuf::from("/etc/xdg")]);
    }

    #[test]
    fn override_data_home() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_DATA_HOME", "/opt/data");
        let r = fake("/home/alice").data_home();
        env::remove_var("XDG_DATA_HOME");
        assert_eq!(r, PathBuf::from("/opt/data"));
    }

    #[test]
    fn override_config_dirs() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_CONFIG_DIRS", "/opt/cfg:/srv/cfg");
        let r = fake("/home/alice").config_dirs();
        env::remove_var("XDG_CONFIG_DIRS");
        assert_eq!(r, vec![PathBuf::from("/opt/cfg"), PathBuf::from("/srv/cfg")]);
    }

    #[test]
    fn relative_path_in_var_ignored() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_DATA_HOME", "relative/path");
        let r = fake("/home/alice").data_home();
        env::remove_var("XDG_DATA_HOME");
        assert_eq!(r, PathBuf::from("/home/alice/.local/share"));
    }

    #[test]
    fn relative_entries_in_list_filtered() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_DATA_DIRS", "/good:relative/bad:/also/good");
        let r = fake("/home/alice").data_dirs();
        env::remove_var("XDG_DATA_DIRS");
        assert_eq!(r, vec![PathBuf::from("/good"), PathBuf::from("/also/good")]);
    }

    #[test]
    fn all_relative_entries_falls_back_to_default() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_DATA_DIRS", "bad:also/bad");
        let r = fake("/home/alice").data_dirs();
        env::remove_var("XDG_DATA_DIRS");
        assert_eq!(r, vec![PathBuf::from("/usr/local/share"), PathBuf::from("/usr/share")]);
    }

    #[test]
    fn search_dirs_order() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_HOME");
        env::remove_var("XDG_DATA_DIRS");
        let dirs = fake("/home/alice").data_search_dirs();
        assert_eq!(dirs[0], PathBuf::from("/home/alice/.local/share"));
        assert_eq!(dirs[1], PathBuf::from("/usr/local/share"));
    }

    #[test]
    fn runtime_dir_when_set() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_RUNTIME_DIR", "/run/user/1000");
        let r = fake("/home/alice").runtime_dir().unwrap();
        env::remove_var("XDG_RUNTIME_DIR");
        assert_eq!(r, Some(PathBuf::from("/run/user/1000")));
    }

    #[test]
    fn runtime_dir_when_unset() {
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_RUNTIME_DIR");
        assert_eq!(fake("/home/alice").runtime_dir().unwrap(), None);
    }

    #[test]
    fn runtime_dir_relative_rejected() {
        let _l = ENV_LOCK.lock().unwrap();
        env::set_var("XDG_RUNTIME_DIR", "relative/runtime");
        let r = fake("/home/alice").runtime_dir().unwrap();
        env::remove_var("XDG_RUNTIME_DIR");
        assert_eq!(r, None);
    }

    #[test]
    fn create_data_home_creates_dir() {
        let tmp = tempfile::tempdir().unwrap();
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_HOME");
        let xdg = fake(tmp.path().to_str().unwrap());
        assert!(xdg.create_data_home().unwrap().exists());
    }

    #[test]
    fn create_subdir_creates_nested() {
        let tmp = tempfile::tempdir().unwrap();
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_CONFIG_HOME");
        let xdg = fake(tmp.path().to_str().unwrap());
        assert!(xdg.create_config_subdir("myapp/v2").unwrap().exists());
    }

    #[test]
    fn place_config_file_creates_parent() {
        let tmp = tempfile::tempdir().unwrap();
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_CONFIG_HOME");
        let xdg = fake(tmp.path().to_str().unwrap());
        let path = xdg.place_config_file("myapp/settings.toml").unwrap();
        assert!(path.parent().unwrap().exists());
        assert_eq!(path.file_name().unwrap(), "settings.toml");
    }

    #[test]
    fn find_data_file_returns_first_match() {
        let tmp = tempfile::tempdir().unwrap();
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_HOME");
        env::remove_var("XDG_DATA_DIRS");
        let xdg = fake(tmp.path().to_str().unwrap());
        let file_path = xdg.place_data_file("myapp/icon.png").unwrap();
        std::fs::write(&file_path, b"fake").unwrap();
        assert_eq!(xdg.find_data_file("myapp/icon.png").unwrap(), file_path);
    }

    #[test]
    fn find_data_file_returns_none_when_missing() {
        let tmp = tempfile::tempdir().unwrap();
        let _l = ENV_LOCK.lock().unwrap();
        env::remove_var("XDG_DATA_HOME");
        env::remove_var("XDG_DATA_DIRS");
        let xdg = fake(tmp.path().to_str().unwrap());
        assert!(xdg.find_data_file("does/not/exist.txt").is_none());
    }
}