rustvil 0.3.0

Rustvil, a collection of various Rust utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! XDG Base Directory Specification support.
//!
//! Implements cross-platform path resolution following the XDG Base Directory spec,
//! with platform-specific fallbacks for Windows and macOS.

use crate::os::env::Env;
use std::path::PathBuf;

use crate::config_files::home;

/// How macOS XDG should be treated.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum MacOSBehaviour {
    /// Use fallbacks in `~/Library/...`.
    UseLibrary,
    /// Use fallbacks as Linux ones, like `~/.config/...`.
    LinuxFallback,
}

fn config_fallback(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    if cfg!(windows) {
        env.get("LOCALAPPDATA").ok().map(PathBuf::from)
    } else if cfg!(target_os = "macos") && matches!(behaviour, MacOSBehaviour::UseLibrary) {
        home().map(|mut home| {
            home.push("Library");
            home.push("Application Support");
            home
        })
    } else {
        home().map(|mut home| {
            home.push(".config");
            home
        })
    }
}

fn cache_fallback(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    if cfg!(windows) {
        env.get("LOCALAPPDATA").ok().map(|localappdata| {
            let mut buf = PathBuf::from(localappdata);
            buf.push("caches");
            buf
        })
    } else if cfg!(target_os = "macos") && matches!(behaviour, MacOSBehaviour::UseLibrary) {
        home().map(|mut home| {
            home.push("Library");
            home.push("Caches");
            home
        })
    } else {
        home().map(|mut home| {
            home.push(".cache");
            home
        })
    }
}

fn data_fallback(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    if cfg!(windows) {
        env.get("LOCALAPPDATA").ok().map(PathBuf::from)
    } else if cfg!(target_os = "macos") && matches!(behaviour, MacOSBehaviour::UseLibrary) {
        home().map(|mut home| {
            home.push("Library");
            home.push("Application Support");
            home
        })
    } else {
        home().map(|mut home| {
            home.push(".local");
            home.push(".share");
            home
        })
    }
}

fn state_fallback(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    if cfg!(windows) {
        env.get("LOCALAPPDATA").ok().map(PathBuf::from)
    } else if cfg!(target_os = "macos") && matches!(behaviour, MacOSBehaviour::UseLibrary) {
        home().map(|mut home| {
            home.push("Library");
            home.push("Application Support");
            home
        })
    } else {
        home().map(|mut home| {
            home.push(".local");
            home.push(".state");
            home
        })
    }
}

/// Get proper path for `$XDG_CONFIG_HOME`.
///
/// # Returns
///
/// Most of time it should be [`Some`] variant.
/// [`None`] is returned if and only if:
///     1. [`home`] returns `None`.
///     2. `env` has no key `XDG_CONFIG_HOME`.
pub fn config(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    env.get("XDG_CONFIG_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| config_fallback(env, behaviour))
}

/// Get proper path for `$XDG_DATA_HOME`.
///
/// # Returns
///
/// Most of time it should be [`Some`] variant.
/// [`None`] is returned if and only if:
///     1. [`home`] returns `None`.
///     2. `env` has no key `XDG_DATA_HOME`.
pub fn data(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    env.get("XDG_DATA_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| data_fallback(env, behaviour))
}

/// Get proper path for `$XDG_CACHE_HOME`.
///
/// # Returns
///
/// Most of time it should be [`Some`] variant.
/// [`None`] is returned if and only if:
///     1. [`home`] returns `None`.
///     2. `env` has no key `XDG_CACHE_HOME`.
pub fn cache(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    env.get("XDG_CACHE_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| cache_fallback(env, behaviour))
}
/// Get proper path for `$XDG_STATE_HOME`.
///
/// # Returns
///
/// Most of time it should be [`Some`] variant.
/// [`None`] is returned if and only if:
///     1. [`home`] returns `None`.
///     2. `env` has no key `XDG_STATE_HOME`.
pub fn state(env: &Env, behaviour: MacOSBehaviour) -> Option<PathBuf> {
    env.get("XDG_STATE_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| state_fallback(env, behaviour))
}