Use etcetera instead of directories

It provides more flexibility and it has a better default for cli tools.

Fixes #1107.

Author: lu-zero

Cargo.lock

@@ -52,7 +52,7 @@ chrono-humanize = "0.2.3"
 clap = { version = "4.2", features = ["derive"] }
 colors-transform = "0.2.11"
 criterion = "0.5"
-directories = "4.0"
+etcetera = "0.8.0"
 futures = "0.3"
 fuzzy-matcher = "0.3"
 grep-matcher = "0.1"

Cargo.toml

@@ -4,4 +4,4 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-directories = { workspace = true }
+etcetera = { workspace = true }

crates/dirs/Cargo.toml

@@ -1,5 +1,6 @@
-use directories::{BaseDirs, ProjectDirs};
-use std::path::PathBuf;
+use etcetera::app_strategy::Xdg;
+use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
+use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 
 pub struct Dirs;
@@ -8,26 +9,43 @@ impl Dirs {
     /// Project directory specifically for Vim Clap.
     ///
     /// All the files created by vim-clap are stored there.
-    pub fn project() -> &'static ProjectDirs {
-        static CELL: OnceLock<ProjectDirs> = OnceLock::new();
+    pub fn project() -> &'static Xdg {
+        static CELL: OnceLock<Xdg> = OnceLock::new();
 
         CELL.get_or_init(|| {
-            ProjectDirs::from("org", "vim", "Vim Clap")
-                .expect("Couldn't create project directory for vim-clap")
+            choose_app_strategy(AppStrategyArgs {
+                top_level_domain: "org".to_string(),
+                author: "vim".to_owned(),
+                app_name: "Vim Clap".to_owned(),
+            })
+            .expect("Couldn't create project directory for vim-clap")
         })
     }
 
-    /// Provides access to the standard directories that the operating system uses.
-    pub fn base() -> &'static BaseDirs {
-        static CELL: OnceLock<BaseDirs> = OnceLock::new();
+    /// Get the home directory
+    pub fn home_dir() -> &'static Path {
+        Self::project().home_dir()
+    }
+
+    /// Get the config directory
+    pub fn config_dir() -> PathBuf {
+        Self::project().config_dir()
+    }
+
+    /// Get the cache directory
+    pub fn cache_dir() -> PathBuf {
+        Self::project().cache_dir()
+    }
 
-        CELL.get_or_init(|| BaseDirs::new().expect("Failed to construct BaseDirs"))
+    /// Get the data directory
+    pub fn data_dir() -> PathBuf {
+        Self::project().data_dir()
     }
 
     /// Cache directory for Vim Clap project.
     pub fn clap_cache_dir() -> std::io::Result<PathBuf> {
         let cache_dir = Self::project().cache_dir();
-        std::fs::create_dir_all(cache_dir)?;
-        Ok(cache_dir.to_path_buf())
+        std::fs::create_dir_all(&cache_dir)?;
+        Ok(cache_dir)
     }
 }

crates/dirs/src/lib.rs

@@ -14,10 +14,9 @@ fn load_config(
     specified_config_file: Option<PathBuf>,
 ) -> (Config, PathBuf, Option<toml::de::Error>) {
     let config_file = specified_config_file.unwrap_or_else(|| {
-        // Linux: ~/.config/vimclap/config.toml
-        // macOS: ~/Library/Application\ Support/org.vim.Vim-Clap/config.toml
+        // Linuxi & macOS: ~/.config/vimclap/config.toml
         // Windows: ~\AppData\Roaming\Vim\Vim Clap\config\config.toml
-        let config_file_path = Dirs::project().config_dir().join("config.toml");
+        let config_file_path = Dirs::config_dir().join("config.toml");
 
         if !config_file_path.exists() {
             std::fs::create_dir_all(&config_file_path).ok();

crates/maple_config/src/lib.rs

@@ -69,15 +69,15 @@ pub fn cache_metadata_path() -> Option<&'static PathBuf> {
 
 /// Returns a `PathBuf` using given file name under the project data directory.
 pub fn generate_data_file_path(filename: &str) -> std::io::Result<PathBuf> {
-    let data_dir = Dirs::project().data_dir();
-    std::fs::create_dir_all(data_dir)?;
+    let data_dir = Dirs::data_dir();
+    std::fs::create_dir_all(&data_dir)?;
     Ok(data_dir.join(filename))
 }
 
 /// Returns a `PathBuf` using given file name under the project cache directory.
 pub fn generate_cache_file_path(filename: impl AsRef<Path>) -> std::io::Result<PathBuf> {
-    let cache_dir = Dirs::project().cache_dir();
-    std::fs::create_dir_all(cache_dir)?;
+    let cache_dir = Dirs::cache_dir();
+    std::fs::create_dir_all(&cache_dir)?;
     Ok(cache_dir.join(filename))
 }
 

crates/maple_core/src/datastore/mod.rs

@@ -34,7 +34,7 @@ impl TagItem {
         let mut home_path = PathBuf::new();
         let path = Path::new(&self.path);
         let path = path.strip_prefix(cwd).unwrap_or({
-            path.strip_prefix(Dirs::base().home_dir())
+            path.strip_prefix(Dirs::home_dir())
                 .map(|path| {
                     home_path.push("~");
                     home_path = home_path.join(path);

crates/maple_core/src/searcher/tagfiles.rs

@@ -68,7 +68,7 @@ pub async fn update_winbar(
                 }
                 None => winwidth,
             };
-            let path = if let Some(home) = dirs::Dirs::base().home_dir().to_str() {
+            let path = if let Some(home) = dirs::Dirs::home_dir().to_str() {
                 path.replacen(home, "~", 1)
             } else {
                 path

crates/maple_core/src/stdio_server/winbar.rs

@@ -33,7 +33,7 @@ pub static DEFAULT_EXCLUDE_OPT: Lazy<String> = Lazy::new(|| {
 
 /// Directory for the `tags` files.
 pub static CTAGS_TAGS_DIR: Lazy<PathBuf> = Lazy::new(|| {
-    let tags_dir = Dirs::project().data_dir().join("tags");
+    let tags_dir = Dirs::data_dir().join("tags");
 
     std::fs::create_dir_all(&tags_dir).expect("Couldn't create tags directory for vim-clap");
 

crates/maple_core/src/tools/ctags/mod.rs

@@ -6,7 +6,7 @@ pub static GTAGS_EXISTS: Lazy<bool> = Lazy::new(|| gtags_executable_exists().unw
 
 /// Directory for `GTAGS`/`GRTAGS`.
 pub static GTAGS_DIR: Lazy<PathBuf> = Lazy::new(|| {
-    let gtags_dir = Dirs::project().data_dir().join("gtags");
+    let gtags_dir = Dirs::data_dir().join("gtags");
 
     std::fs::create_dir_all(&gtags_dir).expect("Couldn't create gtags directory for vim-clap");