use std::path::{Path, PathBuf};
use crate::clients::Os;
pub const DIR_NAME: &str = ".memfork";
const APP_NAME: &str = "memfork";
pub const DATA_DIR_ENV: &str = "MEMFORK_DATA_DIR";
pub const FORBID_PER_USER_ENV: &str = "MEMFORK_FORBID_PER_USER_DATA_DIR";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Source {
Policy,
Environment,
Project,
PerUser,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DataDir {
pub path: PathBuf,
pub source: Source,
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum NoDataDir {
#[error("cannot work out where to keep data; set {DATA_DIR_ENV}")]
Unknown,
#[error(
"refusing to use the real per-user data directory {path}.
{FORBID_PER_USER_ENV} is set, which tests do so that a test which forgets to choose a directory fails here instead of writing into somebody's own store. Set {DATA_DIR_ENV} to a temporary directory."
)]
Forbidden {
path: PathBuf,
},
#[error(
"the machine policy pins the data directory to {pinned}, so {asked} cannot be used. \
Drop --data-dir and {DATA_DIR_ENV}: memory for every user on this machine is kept \
where the policy says, and only an administrator can change that."
)]
Pinned {
pinned: String,
asked: String,
},
#[error("{0}")]
Policy(crate::policy::Error),
}
pub trait Env {
fn get(&self, key: &str) -> Option<String>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RealEnv;
impl Env for RealEnv {
fn get(&self, key: &str) -> Option<String> {
std::env::var(key).ok().filter(|v| !v.is_empty())
}
}
#[derive(Debug, Clone, Default)]
pub struct MapEnv(pub std::collections::BTreeMap<String, String>);
impl MapEnv {
pub fn from(pairs: &[(&str, &str)]) -> Self {
MapEnv(
pairs
.iter()
.map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
.collect(),
)
}
}
impl Env for MapEnv {
fn get(&self, key: &str) -> Option<String> {
self.0.get(key).cloned().filter(|v| !v.is_empty())
}
}
pub fn resolve(os: Os, env: &impl Env, working_dir: &std::path::Path) -> Option<DataDir> {
if let Some(explicit) = env.get(DATA_DIR_ENV) {
return Some(DataDir {
path: PathBuf::from(explicit),
source: Source::Environment,
});
}
let project = working_dir.join(DIR_NAME);
if project.is_dir() {
return Some(DataDir {
path: project,
source: Source::Project,
});
}
per_user(os, env).map(|path| DataDir {
path,
source: Source::PerUser,
})
}
pub fn per_user(os: Os, env: &impl Env) -> Option<PathBuf> {
let home = || env.get("HOME").or_else(|| env.get("USERPROFILE"));
let base = match os {
Os::Windows => env
.get("LOCALAPPDATA")
.map(PathBuf::from)
.or_else(|| home().map(|h| PathBuf::from(h).join("AppData").join("Local")))?,
Os::MacOs => PathBuf::from(home()?)
.join("Library")
.join("Application Support"),
Os::Linux => match env.get("XDG_DATA_HOME") {
Some(xdg) => PathBuf::from(xdg),
None => PathBuf::from(home()?).join(".local").join("share"),
},
};
Some(base.join(APP_NAME))
}
pub fn here() -> Result<DataDir, NoDataDir> {
if let Some(pinned) = pinned()? {
return Ok(DataDir {
path: pinned,
source: Source::Policy,
});
}
let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
let resolved = resolve(Os::current(), &RealEnv, &cwd).ok_or(NoDataDir::Unknown)?;
if resolved.source == Source::PerUser && per_user_is_forbidden() {
return Err(NoDataDir::Forbidden {
path: resolved.path,
});
}
Ok(resolved)
}
pub fn choose(explicit: Option<&str>) -> Result<DataDir, NoDataDir> {
match (pinned()?, explicit) {
(Some(pinned), Some(asked)) if Path::new(asked) != pinned => Err(NoDataDir::Pinned {
pinned: crate::style::path(&pinned),
asked: crate::style::path(Path::new(asked)),
}),
(Some(pinned), _) => Ok(DataDir {
path: pinned,
source: Source::Policy,
}),
(None, Some(asked)) => Ok(DataDir {
path: PathBuf::from(asked),
source: Source::Environment,
}),
(None, None) => here(),
}
}
fn pinned() -> Result<Option<PathBuf>, NoDataDir> {
crate::policy::current()
.map(|p| p.data_dir().map(Path::to_path_buf))
.map_err(NoDataDir::Policy)
}
fn per_user_is_forbidden() -> bool {
cfg!(test) || std::env::var_os(FORBID_PER_USER_ENV).is_some()
}
#[cfg(test)]
mod tests {
use super::*;
fn nowhere() -> PathBuf {
PathBuf::from(if cfg!(windows) {
r"C:\no\such\place"
} else {
"/no/such/place"
})
}
#[test]
fn the_environment_wins() {
let env = MapEnv::from(&[(DATA_DIR_ENV, "/somewhere/else"), ("HOME", "/home/ada")]);
for os in Os::all() {
let got = resolve(os, &env, &nowhere()).expect("resolved");
assert_eq!(got.source, Source::Environment);
assert_eq!(got.path, PathBuf::from("/somewhere/else"));
}
}
#[test]
fn an_empty_variable_is_the_same_as_an_unset_one() {
let env = MapEnv::from(&[(DATA_DIR_ENV, ""), ("HOME", "/home/ada")]);
let got = resolve(Os::Linux, &env, &nowhere()).expect("resolved");
assert_eq!(got.source, Source::PerUser);
}
#[test]
fn a_project_directory_is_used_when_it_already_exists() {
let dir = tempfile::tempdir().expect("tempdir");
let env = MapEnv::from(&[("HOME", "/home/ada")]);
assert_eq!(
resolve(Os::Linux, &env, dir.path())
.expect("resolved")
.source,
Source::PerUser
);
std::fs::create_dir(dir.path().join(DIR_NAME)).expect("created");
let got = resolve(Os::Linux, &env, dir.path()).expect("resolved");
assert_eq!(got.source, Source::Project);
assert_eq!(got.path, dir.path().join(DIR_NAME));
}
#[test]
fn a_file_named_like_the_project_directory_is_not_mistaken_for_one() {
let dir = tempfile::tempdir().expect("tempdir");
std::fs::write(dir.path().join(DIR_NAME), "not a directory").expect("written");
let env = MapEnv::from(&[("HOME", "/home/ada")]);
assert_eq!(
resolve(Os::Linux, &env, dir.path())
.expect("resolved")
.source,
Source::PerUser
);
}
#[test]
fn each_platform_uses_its_own_convention() {
let windows = MapEnv::from(&[("LOCALAPPDATA", r"C:\Users\ada\AppData\Local")]);
assert_eq!(
per_user(Os::Windows, &windows).expect("resolved"),
PathBuf::from(r"C:\Users\ada\AppData\Local").join("memfork")
);
let mac = MapEnv::from(&[("HOME", "/Users/ada")]);
assert_eq!(
per_user(Os::MacOs, &mac).expect("resolved"),
PathBuf::from("/Users/ada/Library/Application Support/memfork")
);
let xdg = MapEnv::from(&[("HOME", "/home/ada"), ("XDG_DATA_HOME", "/home/ada/.data")]);
assert_eq!(
per_user(Os::Linux, &xdg).expect("resolved"),
PathBuf::from("/home/ada/.data/memfork")
);
let plain = MapEnv::from(&[("HOME", "/home/ada")]);
assert_eq!(
per_user(Os::Linux, &plain).expect("resolved"),
PathBuf::from("/home/ada/.local/share/memfork")
);
}
#[test]
fn windows_falls_back_to_the_profile_when_localappdata_is_missing() {
let env = MapEnv::from(&[("USERPROFILE", r"C:\Users\ada")]);
assert_eq!(
per_user(Os::Windows, &env).expect("resolved"),
PathBuf::from(r"C:\Users\ada")
.join("AppData")
.join("Local")
.join("memfork")
);
}
#[test]
fn a_test_build_refuses_the_real_per_user_directory() {
match here() {
Err(NoDataDir::Forbidden { path }) => {
assert!(path.ends_with("memfork"), "{path:?}");
}
Err(NoDataDir::Unknown) => {}
Err(NoDataDir::Pinned { .. } | NoDataDir::Policy(_)) => {}
Ok(resolved) => assert_ne!(
resolved.source,
Source::PerUser,
"a test build resolved the real per-user data directory"
),
}
}
#[test]
fn an_explicit_choice_is_still_honoured_under_the_guard() {
let env = MapEnv::from(&[(DATA_DIR_ENV, "/tmp/somewhere"), ("HOME", "/home/ada")]);
let got = resolve(Os::Linux, &env, &nowhere()).expect("resolved");
assert_eq!(got.source, Source::Environment);
}
#[test]
fn with_nothing_at_all_there_is_no_answer_rather_than_a_guess() {
let env = MapEnv::default();
for os in Os::all() {
assert!(
per_user(os, &env).is_none(),
"{os:?} invented a data directory out of nothing"
);
}
}
}