pub mod user_dirs;
use std::path::PathBuf;
pub fn config_home() -> PathBuf {
if let Some(dir) = std::env::var_os("XDG_CONFIG_HOME") {
let dir = PathBuf::from(dir);
if dir.is_absolute() {
return dir;
}
}
let home = std::env::var_os("HOME").expect("HOME must be set");
PathBuf::from(home).join(".config")
}
pub fn hyprforge_config_dir() -> PathBuf {
config_home().join("hyprforge")
}
pub fn data_home() -> PathBuf {
if let Some(dir) = std::env::var_os("XDG_DATA_HOME") {
let dir = PathBuf::from(dir);
if dir.is_absolute() {
return dir;
}
}
let home = std::env::var_os("HOME").expect("HOME must be set");
PathBuf::from(home).join(".local").join("share")
}
pub fn lock_toml_path() -> PathBuf {
hyprforge_config_dir().join("lock.toml")
}
pub fn appearance_toml_path() -> PathBuf {
hyprforge_config_dir().join("appearance.toml")
}
pub fn tray_toml_path() -> PathBuf {
hyprforge_config_dir().join("tray.toml")
}
pub fn emojimenu_toml_path() -> PathBuf {
hyprforge_config_dir().join("emojimenu.toml")
}
pub fn files_toml_path() -> PathBuf {
hyprforge_config_dir().join("files.toml")
}
pub fn files_session_toml_path() -> PathBuf {
hyprforge_config_dir().join("files-session.toml")
}
pub fn files_config_toml_path() -> PathBuf {
hyprforge_config_dir().join("files-config.toml")
}
pub fn media_toml_path() -> PathBuf {
hyprforge_config_dir().join("media.toml")
}
pub fn media_config_toml_path() -> PathBuf {
hyprforge_config_dir().join("media-config.toml")
}
pub fn clipboard_dir() -> PathBuf {
hyprforge_config_dir().join("clipboard")
}
pub fn clipboard_index_path() -> PathBuf {
clipboard_dir().join("history.toml")
}
pub fn clipboard_images_dir() -> PathBuf {
clipboard_dir().join("images")
}
pub fn clipboard_image_path(id: &str) -> PathBuf {
clipboard_images_dir().join(format!("{id}.bin"))
}
pub fn write_atomic(path: &std::path::Path, contents: &str) -> std::io::Result<()> {
write_atomic_bytes(path, contents.as_bytes())
}
pub fn write_atomic_bytes(path: &std::path::Path, contents: &[u8]) -> std::io::Result<()> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let unique = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let stem = path.file_name().and_then(|n| n.to_str()).unwrap_or("hyprforge");
let tmp = path.with_file_name(format!(".{stem}.{}.{unique}.tmp", std::process::id()));
struct Cleanup<'a>(Option<&'a std::path::Path>);
impl Drop for Cleanup<'_> {
fn drop(&mut self) {
if let Some(path) = self.0 {
let _ = std::fs::remove_file(path);
}
}
}
let mut cleanup = Cleanup(Some(&tmp));
{
let file = std::fs::File::create(&tmp)?;
{
use std::io::Write as _;
let mut writer = std::io::BufWriter::new(&file);
writer.write_all(contents)?;
writer.flush()?;
}
file.sync_all()?;
}
std::fs::rename(&tmp, path)?;
cleanup.0 = None;
if let Some(parent) = path.parent() {
if let Ok(dir) = std::fs::File::open(parent) {
let _ = dir.sync_all();
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Mutex, MutexGuard};
static ENV_LOCK: Mutex<()> = Mutex::new(());
struct EnvGuard {
_lock: MutexGuard<'static, ()>,
xdg: Option<std::ffi::OsString>,
home: Option<std::ffi::OsString>,
}
impl EnvGuard {
fn set(xdg: Option<&str>, home: Option<&str>) -> Self {
let guard = EnvGuard {
_lock: ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner()),
xdg: std::env::var_os("XDG_CONFIG_HOME"),
home: std::env::var_os("HOME"),
};
unsafe {
match xdg {
Some(v) => std::env::set_var("XDG_CONFIG_HOME", v),
None => std::env::remove_var("XDG_CONFIG_HOME"),
}
match home {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
}
}
guard
}
}
impl Drop for EnvGuard {
fn drop(&mut self) {
unsafe {
match &self.xdg {
Some(v) => std::env::set_var("XDG_CONFIG_HOME", v),
None => std::env::remove_var("XDG_CONFIG_HOME"),
}
match &self.home {
Some(v) => std::env::set_var("HOME", v),
None => std::env::remove_var("HOME"),
}
}
}
}
#[test]
fn absolute_xdg_config_home_is_used_as_is() {
let _g = EnvGuard::set(Some("/custom/config"), Some("/home/someone"));
assert_eq!(config_home(), PathBuf::from("/custom/config"));
}
#[test]
fn unset_xdg_config_home_falls_back_to_home_dot_config() {
let _g = EnvGuard::set(None, Some("/home/someone"));
assert_eq!(config_home(), PathBuf::from("/home/someone/.config"));
}
#[test]
fn relative_xdg_config_home_is_ignored_per_the_xdg_spec() {
let _g = EnvGuard::set(Some("relative/path"), Some("/home/someone"));
assert_eq!(config_home(), PathBuf::from("/home/someone/.config"));
}
#[test]
fn empty_xdg_config_home_falls_back_too() {
let _g = EnvGuard::set(Some(""), Some("/home/someone"));
assert_eq!(config_home(), PathBuf::from("/home/someone/.config"));
}
#[test]
fn write_atomic_creates_parent_directories() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("a").join("b").join("file.toml");
write_atomic(&path, "hello").unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "hello");
}
#[test]
fn a_failed_write_leaves_no_temp_file_behind() {
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("occupied.toml");
std::fs::create_dir(&target).unwrap();
assert!(write_atomic(&target, "anything").is_err());
let leftovers: Vec<_> = std::fs::read_dir(dir.path())
.unwrap()
.filter_map(|e| e.ok())
.map(|e| e.file_name().to_string_lossy().into_owned())
.filter(|name| name.ends_with(".tmp"))
.collect();
assert!(leftovers.is_empty(), "left behind: {leftovers:?}");
}
#[test]
fn concurrent_writers_to_one_path_never_share_a_temp_file() {
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("monitors.lua");
let a = std::thread::spawn({
let target = target.clone();
move || {
for _ in 0..50 {
write_atomic(&target, &"a".repeat(4096)).unwrap();
}
}
});
let b = std::thread::spawn({
let target = target.clone();
move || {
for _ in 0..50 {
write_atomic(&target, &"b".repeat(4096)).unwrap();
}
}
});
a.join().unwrap();
b.join().unwrap();
let got = std::fs::read_to_string(&target).unwrap();
assert!(
got == "a".repeat(4096) || got == "b".repeat(4096),
"torn write: {} bytes, starts {:?}",
got.len(),
&got[..got.len().min(8)]
);
}
#[test]
fn write_atomic_overwrites_and_leaves_no_temp_file() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("file.toml");
write_atomic(&path, "first").unwrap();
write_atomic(&path, "second").unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "second");
let leftovers: Vec<_> = std::fs::read_dir(dir.path())
.unwrap()
.map(|e| e.unwrap().file_name())
.filter(|n| n.to_string_lossy().contains(".tmp"))
.collect();
assert!(leftovers.is_empty(), "temp file left behind: {leftovers:?}");
}
#[test]
fn write_atomic_handles_an_extensionless_path() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("noext");
write_atomic(&path, "body").unwrap();
assert_eq!(std::fs::read_to_string(&path).unwrap(), "body");
}
#[test]
fn the_app_config_files_hang_off_the_hyprforge_dir() {
let _g = EnvGuard::set(Some("/custom/config"), Some("/home/someone"));
assert_eq!(
lock_toml_path(),
PathBuf::from("/custom/config/hyprforge/lock.toml")
);
assert_eq!(
appearance_toml_path(),
PathBuf::from("/custom/config/hyprforge/appearance.toml")
);
}
#[test]
fn the_emojimenu_config_hangs_off_the_hyprforge_dir_too() {
let _g = EnvGuard::set(Some("/custom/config"), Some("/home/someone"));
assert_eq!(
emojimenu_toml_path(),
PathBuf::from("/custom/config/hyprforge/emojimenu.toml")
);
}
#[test]
fn clipboard_paths_hang_off_their_own_subdirectory() {
let _g = EnvGuard::set(Some("/custom/config"), Some("/home/someone"));
assert_eq!(
clipboard_dir(),
PathBuf::from("/custom/config/hyprforge/clipboard")
);
assert_eq!(
clipboard_index_path(),
PathBuf::from("/custom/config/hyprforge/clipboard/history.toml")
);
assert_eq!(
clipboard_images_dir(),
PathBuf::from("/custom/config/hyprforge/clipboard/images")
);
assert_eq!(
clipboard_image_path("abc123"),
PathBuf::from("/custom/config/hyprforge/clipboard/images/abc123.bin")
);
}
#[test]
fn write_atomic_bytes_round_trips_binary_content() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("image.bin");
let bytes: Vec<u8> = (0..=255).collect();
write_atomic_bytes(&path, &bytes).unwrap();
assert_eq!(std::fs::read(&path).unwrap(), bytes);
}
}