1 files changed, 247 insertions, 23 deletions

diff --git a/src/platform/paths.rs b/src/platform/paths.rs
index b430f09..07313fd 100644
--- a/src/platform/paths.rs
+++ b/src/platform/paths.rs
@@ -1,44 +1,268 @@
 use std::{fs::create_dir_all, path::PathBuf};
 
-use crate::{config::Config, errors::McError};
+use crate::{config::Config, constants::directory, errors::McError};
 
-/// ~/.local/share/dml/minecraft
-pub fn minecraft_root(cfg: &Config) -> PathBuf {
+/// Returns the path to the root Minecraft directory inside the launcher data folder.
+///
+/// This directory acts as the root for all Minecraft-related files within the launcher data.
+/// By default, it joins the `minecraft` directory under the data folder (defined by the launcher).
+///
+/// The returned path does not include any specific assets, versions, or libraries directories.
+/// You can use this as the base path to construct other Minecraft-related paths.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing launcher and Minecraft data folder paths.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the root Minecraft directory.
+pub fn root_directory(cfg: &Config) -> PathBuf {
+    // Remove DEFAULT_LAUNCHER_DIR to avoid duplicate "dml/dml"
     cfg.data_dir.join("minecraft")
 }
 
-pub fn assets_dir(cfg: &Config) -> PathBuf {
-    minecraft_root(cfg).join("assets")
+/// Returns the path to the Minecraft assets directory.
+///
+/// This is where Minecraft assets such as textures, sounds, and other resources are stored.
+/// The assets directory is located inside the root Minecraft directory and can be used
+/// for accessing game assets.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the launcher and Minecraft data.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the assets directory inside the root Minecraft directory.
+pub fn assets_directory(cfg: &Config) -> PathBuf {
+    root_directory(cfg).join(directory::ASSETS)
 }
 
-pub fn game_dir(cfg: &Config) -> PathBuf { minecraft_root(cfg) }
-pub fn ensure_dirs(cfg: &Config) -> Result<(), McError> {
-    let root = minecraft_root(cfg);
-    create_dir_all(&root)?;
-    create_dir_all(root.join("versions"))?;
-    create_dir_all(root.join("libraries"))?;
-    create_dir_all(assets_dir(cfg))?;
-    create_dir_all(assets_dir(cfg).join("indexes"))?;
-    create_dir_all(assets_dir(cfg).join("objects"))?;
-    create_dir_all(root.join("saves"))?;
+/// Returns the path to the game directory (same as root directory for now).
+///
+/// The game directory currently points to the same location as the root directory.
+/// In future iterations, this could be adjusted if game-specific files need to be handled separately.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that holds the paths to the launcher and Minecraft data.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the game directory, which is the same as the root Minecraft directory for now.
+pub fn game_directory(cfg: &Config) -> PathBuf {
+    root_directory(cfg)
+}
+
+/// Ensures that all necessary directories for Minecraft are created.
+///
+/// This function checks if essential directories for Minecraft's file structure exist and creates them
+/// if they do not. This includes directories for versions, libraries, assets, and saves.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the Minecraft data and the required directories.
+///
+/// # Returns
+/// - `Ok(())` if all directories are created successfully.
+/// - `Err(McError)` if an error occurs while creating any directory (such as permission issues).
+///
+/// # Example
+/// ```rust
+/// let cfg = Config { /* configuration values */ };
+/// ensure_directories(&cfg)?;
+/// ```
+///
+/// # Notes
+/// The function creates several directories under the root Minecraft directory, including:
+/// - Root directory
+/// - Versions
+/// - Libraries
+/// - Assets (with subdirectories for `indexes` and `objects`)
+/// - Saves
+///   Each of these directories is essential for managing Minecraft game data and resources.
+pub fn ensure_directories(cfg: &Config) -> Result<(), McError> {
+    let root: PathBuf = root_directory(cfg);
+
+    for dir in [
+        root.clone(),
+        root.join(directory::VERSIONS),
+        root.join(directory::LIBRARIES),
+        assets_directory(cfg),
+        assets_directory(cfg).join(directory::INDEXES),
+        assets_directory(cfg).join(directory::OBJECTS),
+        root.join(directory::SAVES),
+    ] {
+        create_dir_all(dir)?;
+    }
 
     Ok(())
 }
 
+/// Returns the path to a specific version directory inside the root Minecraft directory.
+///
+/// This directory is where the game version-specific files (such as the `.jar` file) are stored.
+/// The path is constructed by joining the `versions` directory with the provided version name.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the directory for the specified version inside the root Minecraft directory.
 pub fn version_dir(cfg: &Config, version: &str) -> PathBuf {
-    minecraft_root(cfg).join("versions").join(version)
+    root_directory(cfg)
+        .join(directory::VERSIONS)
+        .join(version)
 }
 
-pub fn client_jar(cfg: &Config, version: &str) -> Result<PathBuf, McError> {
-    Ok(version_dir(cfg, version).join(format!("{version}.jar")))
+/// Returns the path to the client `.jar` file for a specific Minecraft version.
+///
+/// This file is typically used to run the Minecraft client for a particular version.
+/// The path is constructed by joining the version directory with the name of the `.jar` file.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the `.jar` file for the specified version in the version directory.
+pub fn client_jar(cfg: &Config, version: &str) -> PathBuf {
+    version_dir(cfg, version).join(format!("{version}.jar"))
 }
 
-pub fn library_file(cfg: &Config, rel_path: &str) -> Result<PathBuf, McError> {
-    Ok(minecraft_root(cfg)
-        .join("libraries")
-        .join(rel_path))
+/// Returns the path to a specific library file inside the library directory.
+///
+/// This function is used to access library files required for running Minecraft. The `rel_path`
+/// argument specifies the relative path inside the `libraries` directory. It is useful for handling
+/// dependencies or loading required libraries based on the game version.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the Minecraft data.
+/// - `rel_path`: The relative path of the library file inside the `libraries` directory.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the specified library file inside the `libraries` directory.
+pub fn library_file(cfg: &Config, rel_path: &str) -> PathBuf {
+    root_directory(cfg)
+        .join(directory::LIBRARIES)
+        .join(rel_path)
 }
 
+/// Returns the path to the natives directory for a specific Minecraft version.
+///
+/// The natives directory contains platform-specific native libraries (e.g., `.dll`, `.so`, `.dylib`)
+/// that Minecraft uses to run the game. This function returns the path to the directory for the
+/// specified version.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the natives directory for the specified version.
 pub fn natives_dir(cfg: &Config, version: &str) -> PathBuf {
-    version_dir(cfg, version).join("natives")
+    version_dir(cfg, version).join(directory::NATIVES)
+}
+
+// /// Path to a version’s saves directory.
+// pub fn saves_dir(cfg: &Config) -> PathBuf {
+//     minecraft_root(cfg).join(dirs::SAVES)
+// }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::Path;
+
+    fn test_config(tmp: &Path) -> Config {
+        Config {
+            data_dir: tmp.to_path_buf(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn root_directory_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let root = root_directory(&cfg);
+        assert_eq!(root, tmp.path().join("minecraft"));
+    }
+
+    #[test]
+    fn assets_directory_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let assets = assets_directory(&cfg);
+        assert_eq!(assets, root_directory(&cfg).join(directory::ASSETS));
+    }
+
+    #[test]
+    fn version_paths_are_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let version = "1.20.1";
+        assert_eq!(
+            version_dir(&cfg, version),
+            root_directory(&cfg)
+                .join(directory::VERSIONS)
+                .join(version)
+        );
+
+        assert_eq!(
+            client_jar(&cfg, version),
+            version_dir(&cfg, version).join("1.20.1.jar")
+        );
+    }
+
+    #[test]
+    fn library_file_path_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let rel = "com/example/lib.jar";
+        assert_eq!(
+            library_file(&cfg, rel),
+            root_directory(&cfg)
+                .join(directory::LIBRARIES)
+                .join(rel)
+        );
+    }
+
+    #[test]
+    fn natives_dir_path_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let version = "1.20.1";
+        assert_eq!(
+            natives_dir(&cfg, version),
+            version_dir(&cfg, version).join(directory::NATIVES)
+        );
+    }
+
+    #[test]
+    fn ensure_directories_creates_structure() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        ensure_directories(&cfg).unwrap();
+
+        let root = root_directory(&cfg);
+
+        let expected_dirs = [
+            root.clone(),
+            root.join(directory::VERSIONS),
+            root.join(directory::LIBRARIES),
+            root.join(directory::ASSETS),
+            root.join(directory::ASSETS)
+                .join(directory::INDEXES),
+            root.join(directory::ASSETS)
+                .join(directory::OBJECTS),
+            root.join(directory::SAVES),
+        ];
+
+        for dir in expected_dirs {
+            assert!(dir.exists(), "Missing directory: {:?}", dir);
+            assert!(dir.is_dir());
+        }
+    }
 }