use std::path::{Path, PathBuf};
use crate::error::Error;
#[derive(Debug, Clone)]
pub struct AppPaths {
pub config_dir: PathBuf,
pub cache_dir: PathBuf,
pub state_dir: PathBuf,
}
impl AppPaths {
pub fn resolve(config_dir: Option<&Path>, cache_dir: Option<&Path>) -> Result<Self, Error> {
let dirs = directories::ProjectDirs::from("dev", "aguiar", "whisper-nvidia-cli");
let config_dir = match config_dir {
Some(p) => p.to_path_buf(),
None => dirs
.as_ref()
.map(|d| d.config_dir().to_path_buf())
.ok_or_else(|| Error::Config("cannot resolve config directory".into()))?,
};
let cache_dir = match cache_dir {
Some(p) => p.to_path_buf(),
None => dirs
.as_ref()
.map(|d| d.data_local_dir().to_path_buf())
.ok_or_else(|| Error::Config("cannot resolve cache directory".into()))?,
};
let state_dir = cache_dir.join("state");
Ok(Self {
config_dir,
cache_dir,
state_dir,
})
}
pub fn config_file(&self) -> PathBuf {
self.config_dir.join("config.toml")
}
pub fn catalog_file(&self) -> PathBuf {
self.cache_dir.join("catalog.toml")
}
pub fn models_dir(&self) -> PathBuf {
self.cache_dir.join("models")
}
pub fn work_dir(&self) -> PathBuf {
self.cache_dir.join("work")
}
pub fn active_target_file(&self) -> PathBuf {
self.state_dir.join("active-target")
}
pub fn ensure(&self) -> Result<(), Error> {
std::fs::create_dir_all(&self.config_dir)?;
std::fs::create_dir_all(&self.cache_dir)?;
std::fs::create_dir_all(self.models_dir())?;
std::fs::create_dir_all(self.work_dir())?;
std::fs::create_dir_all(&self.state_dir)?;
Ok(())
}
}
pub fn write_atomic(path: &Path, body: &str) -> Result<(), Error> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let tmp = path.with_extension("toml.tmp");
crate::signal::register_temp(&tmp);
std::fs::write(&tmp, body)?;
std::fs::rename(&tmp, path)?;
crate::signal::release_temp(&tmp);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn write_atomic_leaves_no_temporary() {
let dir = tempfile::tempdir().expect("tmpdir");
let target = dir.path().join("nested").join("thing.toml");
write_atomic(&target, "key = 1\n").expect("write");
assert_eq!(
std::fs::read_to_string(&target).expect("read back"),
"key = 1\n"
);
assert!(
!target.with_extension("toml.tmp").exists(),
"the temporary outlived a successful write"
);
}
#[test]
fn explicit_flags_win() {
let p = AppPaths::resolve(Some(Path::new("/tmp/cfg")), Some(Path::new("/tmp/cache")))
.expect("resolve");
assert_eq!(p.config_file(), PathBuf::from("/tmp/cfg/config.toml"));
assert_eq!(p.models_dir(), PathBuf::from("/tmp/cache/models"));
}
#[test]
fn default_resolve_is_absolute_platform_dir() {
let p = AppPaths::resolve(None, None).expect("resolve platform dirs");
assert!(
p.config_dir.is_absolute(),
"config_dir must be absolute: {}",
p.config_dir.display()
);
assert!(
p.cache_dir.is_absolute(),
"cache_dir must be absolute: {}",
p.cache_dir.display()
);
assert!(
p.state_dir.is_absolute(),
"state_dir must be absolute: {}",
p.state_dir.display()
);
assert!(p.config_file().ends_with("config.toml"));
assert!(p.catalog_file().ends_with("catalog.toml"));
assert!(p.models_dir().ends_with("models"));
assert!(p.active_target_file().ends_with("active-target"));
assert!(p.state_dir.starts_with(&p.cache_dir));
#[cfg(target_os = "linux")]
{
let config = p.config_dir.to_string_lossy();
let cache = p.cache_dir.to_string_lossy();
assert!(
config.contains(".config") || cache.contains(".local"),
"expected an XDG layout, got config={config} cache={cache}"
);
}
}
}