feat: cache flag (#113)

* feat: cache flag

* chore: get or create data dir

* chore: use cache directory to ensure presence of templates

Author: rslangl

src/app_config/app_cache.rs

@@ -0,0 +1,61 @@
+//! src/app_config/app_cache.rs
+
+use serde::Deserialize;
+use std::{fmt, fs, io, path::PathBuf};
+
+#[derive(Debug)]
+pub enum CacheError {
+    Io(io::Error),
+    Invalid(String),
+}
+
+impl From<io::Error> for CacheError {
+    fn from(e: io::Error) -> Self {
+        CacheError::Io(e)
+    }
+}
+
+impl From<String> for CacheError {
+    fn from(e: String) -> Self {
+        CacheError::Invalid(e)
+    }
+}
+
+impl fmt::Display for CacheError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CacheError::Io(e) => {
+                write!(f, "{}", e)
+            }
+            CacheError::Invalid(e) => {
+                write!(f, "{}", e)
+            }
+        }
+    }
+}
+
+#[derive(Deserialize, Debug)]
+pub struct AppCache {
+    pub cache_dir: PathBuf,
+}
+
+pub fn get_cache(file_path: Option<String>) -> Result<AppCache, CacheError> {
+    let cache_path = match file_path {
+        Some(path) => PathBuf::from(path),
+        None => {
+            let xdg = xdg::BaseDirectories::with_prefix("repotools");
+
+            let p = xdg
+                .get_data_home()
+                .ok_or(CacheError::Invalid(String::from("")))?;
+
+            fs::create_dir_all(&p).map_err(CacheError::Io)?;
+
+            p
+        }
+    };
+
+    Ok(AppCache {
+        cache_dir: cache_path,
+    })
+}

src/app_config/app_config.rs

@@ -108,7 +108,7 @@ pub fn get_config(file_path: Option<String>) -> Result<AppConfig, ConfigError> {
                 let default_config = include_str!("../../assets/config.toml.j2");
 
                 let mut context = tera::Context::new();
-                context.insert("data_dir", &xdg.get_cache_home());
+                context.insert("data_dir", &xdg.get_data_home());
 
                 let rendered = match Tera::one_off(default_config, &context, false) {
                     Ok(r) => {

src/app_config/mod.rs

@@ -1,5 +1,7 @@
 //! src/app_config/mod.rs
 
+pub mod app_cache;
 pub mod app_config;
 
+pub use app_cache::{AppCache, CacheError, get_cache};
 pub use app_config::{AppConfig, ConfigError, get_config};

src/cli/cli.rs

@@ -18,7 +18,15 @@ pub struct Cli {
 pub struct GlobalOpts {
     #[arg(long, name = "config")]
     pub config_path: Option<String>,
-    // TODO: add data/cache path
+
+    #[arg(long, name = "cache")]
+    pub cache_path: Option<String>,
+
+    #[arg(long, name = "clear-cache")]
+    pub clear_cache: Option<bool>,
+
+    #[arg(long, name = "recreate-config")]
+    pub recreate_config: Option<bool>,
 }
 
 #[derive(Subcommand)]

src/initializers/init_project.rs

@@ -1,23 +1,23 @@
 //! src/initializers/init_project.rs
 
-use std::path::PathBuf;
-use std::{collections::HashMap, fmt, str::FromStr};
+use std::{collections::HashMap, fmt, path::PathBuf, str::FromStr};
 
 use clap::Args;
 
-use crate::utils::file_writer::FileWriteError;
 use crate::{
-    app_config::app_config::AppConfig,
+    app_config::{AppCache, app_config::AppConfig},
     initializers::project_types::{
         ansible::{AnsibleProject, AnsibleProjectError},
         maven::{MavenProject, MavenProjectError},
     },
+    utils::file_writer::FileWriteError,
 };
 
 #[derive(Debug)]
 pub enum InitProjectError {
     Invalid(String),
     FileWrite(FileWriteError),
+    NotFound(PathBuf),
     // Specific project type errors
     MavenProject(MavenProjectError),
     AnsibleProject(AnsibleProjectError),
@@ -50,6 +50,9 @@ impl fmt::Display for InitProjectError {
             InitProjectError::FileWrite(e) => {
                 write!(f, "{}", e)
             }
+            InitProjectError::NotFound(e) => {
+                write!(f, "Template files not found: {}", e.display())
+            }
             InitProjectError::MavenProject(e) => {
                 write!(f, "{}", e)
             }
@@ -126,7 +129,11 @@ impl ProjectFactory {
     }
 }
 
-pub fn handle(args: InitProjectArgs, config: AppConfig) -> Result<(), InitProjectError> {
+pub fn handle(
+    args: InitProjectArgs,
+    config: AppConfig,
+    cache: AppCache,
+) -> Result<(), InitProjectError> {
     // Ensure the passed project type and given profile, if any, is present in the config file
     // before passing it along
     let template: PathBuf = config
@@ -139,8 +146,17 @@ pub fn handle(args: InitProjectArgs, config: AppConfig) -> Result<(), InitProjec
                 p.name == args.project_type && p.profile == "default"
             }
         })
-        .map(|p| p.template_files.clone())
-        .ok_or(InitProjectError::Invalid("Could not find template".into()))?;
+        .ok_or(InitProjectError::Invalid(String::from(
+            "Could not find template",
+        )))
+        .and_then(|p| -> Result<PathBuf, InitProjectError> {
+            println!("CACHE DIR: {}", cache.cache_dir.clone().display());
+            if p.template_files.starts_with(cache.cache_dir) {
+                Ok(p.template_files.clone())
+            } else {
+                Err(InitProjectError::NotFound(p.template_files.clone()))
+            }
+        })?;
 
     // Convert custom key=value settings into map
     // for easier lookup

src/main.rs

@@ -6,14 +6,17 @@ use clap::Parser;
 
 use crate::cli::{Cli, Command};
 
-use repotools::app_config::{ConfigError, app_config};
-use repotools::cli;
-use repotools::features::{ProjectFeatureError, project_feature};
-use repotools::initializers::{InitProjectError, init_project};
+use repotools::{
+    app_config::{CacheError, ConfigError, app_cache, app_config},
+    cli,
+    features::{ProjectFeatureError, project_feature},
+    initializers::{InitProjectError, init_project},
+};
 
 #[derive(Debug)]
 enum AppError {
     Config(ConfigError),
+    Cache(CacheError),
     InitProject(InitProjectError),
     ProjectFeature(ProjectFeatureError),
 }
@@ -24,6 +27,12 @@ impl From<ConfigError> for AppError {
     }
 }
 
+impl From<CacheError> for AppError {
+    fn from(e: CacheError) -> Self {
+        AppError::Cache(e)
+    }
+}
+
 impl From<InitProjectError> for AppError {
     fn from(e: InitProjectError) -> Self {
         AppError::InitProject(e)
@@ -48,6 +57,9 @@ impl fmt::Display for AppError {
             AppError::ProjectFeature(e) => {
                 write!(f, "FeatureErr: {}", e)
             }
+            AppError::Cache(e) => {
+                write!(f, "CacheErr: {}", e)
+            }
         }
     }
 }
@@ -56,10 +68,11 @@ fn main() -> Result<(), AppError> {
     let cli = Cli::parse();
 
     let config = app_config::get_config(cli.global.config_path)?;
+    let cache = app_cache::get_cache(cli.global.cache_path)?;
 
     match cli.command {
         Command::InitProject(args) => {
-            if let Err(e) = init_project::handle(args, config) {
+            if let Err(e) = init_project::handle(args, config, cache) {
                 eprintln!("Could not initialize project: {}", e)
             }
         }