imp(core): add sync_cache function

Author: omarabid

cli/src/lib.rs

@@ -129,6 +129,10 @@ enum CodeownersSubcommand {
         /// Output format: text|json|bincode
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
+
+        /// Custom cache file location
+        #[arg(long, value_name = "FILE", default_value = ".codeowners.cache")]
+        cache_file: Option<PathBuf>,
     },
 
     #[clap(
@@ -143,6 +147,10 @@ enum CodeownersSubcommand {
         /// Output format: text|json|bincode
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
+
+        /// Custom cache file location
+        #[arg(long, value_name = "FILE", default_value = ".codeowners.cache")]
+        cache_file: Option<PathBuf>,
     },
     #[clap(
         name = "list-tags",
@@ -156,6 +164,10 @@ enum CodeownersSubcommand {
         /// Output format: text|json|bincode
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
+
+        /// Custom cache file location
+        #[arg(long, value_name = "FILE", default_value = ".codeowners.cache")]
+        cache_file: Option<PathBuf>,
     },
 }
 
@@ -208,19 +220,25 @@ pub(crate) fn codeowners(subcommand: &CodeownersSubcommand) -> Result<()> {
             owners,
             unowned,
             format,
+            cache_file,
         } => commands::codeowners_list_files(
             path.as_deref(),
             tags.as_deref(),
             owners.as_deref(),
             *unowned,
             format,
+            cache_file.as_deref(),
         ),
-        CodeownersSubcommand::ListOwners { path, format } => {
-            commands::codeowners_list_owners(path.as_deref(), format)
-        }
-        CodeownersSubcommand::ListTags { path, format } => {
-            commands::codeowners_list_tags(path.as_deref(), format)
-        }
+        CodeownersSubcommand::ListOwners {
+            path,
+            format,
+            cache_file,
+        } => commands::codeowners_list_owners(path.as_deref(), format, cache_file.as_deref()),
+        CodeownersSubcommand::ListTags {
+            path,
+            format,
+            cache_file,
+        } => commands::codeowners_list_tags(path.as_deref(), format, cache_file.as_deref()),
     }
 }
 

core/src/cache.rs

@@ -125,3 +125,29 @@ pub fn load_cache(path: &Path) -> Result<CodeownersCache> {
         }
     }
 }
+
+pub fn sync_cache(
+    repo: &std::path::Path, cache_file: Option<&std::path::Path>,
+) -> Result<CodeownersCache> {
+    let config_cache_file = utils::app_config::AppConfig::fetch()?.cache_file.clone();
+
+    let cache_file: &std::path::Path = match cache_file {
+        Some(file) => file.into(),
+        None => std::path::Path::new(&config_cache_file),
+    };
+
+    // Verify that the cache file exists
+    if !repo.join(cache_file).exists() {
+        // parse the codeowners files and build the cache
+        return parse_repo(&repo, &cache_file);
+    }
+
+    // Load the cache from the specified file
+    load_cache(&repo.join(cache_file)).map_err(|e| {
+        utils::error::Error::new(&format!(
+            "Failed to load cache from {}: {}",
+            cache_file.display(),
+            e
+        ))
+    })
+}

core/src/commands.rs

@@ -1,8 +1,9 @@
 use std::io::{self, Write};
 
-use crate::cache::{build_cache, load_cache, store_cache};
+use crate::cache::{build_cache, load_cache, store_cache, sync_cache};
 use crate::common::find_files;
-use crate::types::{CacheEncoding, CodeownersEntry, OutputFormat};
+use crate::parse::parse_repo;
+use crate::types::{CacheEncoding, CodeownersCache, CodeownersEntry, OutputFormat};
 
 use utils::app_config::AppConfig;
 use utils::error::Result;
@@ -21,10 +22,18 @@ pub fn codeowners_parse(
 ) -> Result<()> {
     println!("Parsing CODEOWNERS files at {}", path.display());
 
-    let codeowners_files = crate::common::find_codeowners_files(path)?;
+    let cache_file = match cache_file {
+        Some(file) => path.join(file),
+        None => {
+            let config = utils::app_config::AppConfig::fetch()?;
+            path.join(config.cache_file)
+        }
+    };
 
-    //dbg!(&codeowners_files);
+    // Collect all CODEOWNERS files in the specified path
+    let codeowners_files = crate::common::find_codeowners_files(path)?;
 
+    // Parse each CODEOWNERS file and collect entries
     let parsed_codeowners: Vec<CodeownersEntry> = codeowners_files
         .iter()
         .filter_map(|file| {
@@ -34,18 +43,17 @@ pub fn codeowners_parse(
         .flatten()
         .collect();
 
-    //dbg!(&parsed_codeowners);
-
+    // Collect all files in the specified path
     let files = find_files(path)?;
 
-    //dbg!(&files);
+    // Build the cache from the parsed CODEOWNERS entries and the files
     let cache = build_cache(parsed_codeowners, files)?;
 
-    store_cache(&cache, cache_file.unwrap(), encoding)?;
-
-    let cache = load_cache(cache_file.unwrap())?;
+    // Store the cache in the specified file
+    store_cache(&cache, &cache_file, encoding)?;
 
-    dbg!(cache);
+    // Test the cache by loading it back
+    let _cache = load_cache(&cache_file)?;
 
     println!("CODEOWNERS parsing completed successfully");
 
@@ -54,33 +62,14 @@ pub fn codeowners_parse(
 
 /// Find and list files with their owners based on filter criteria
 pub fn codeowners_list_files(
-    path: Option<&std::path::Path>, tags: Option<&str>, owners: Option<&str>, unowned: bool,
-    format: &OutputFormat,
+    repo: Option<&std::path::Path>, tags: Option<&str>, owners: Option<&str>, unowned: bool,
+    format: &OutputFormat, cache_file: Option<&std::path::Path>,
 ) -> Result<()> {
-    let path_str = path.map_or(".".into(), |p| p.display().to_string());
-    info!("Listing files in {}", path_str);
-    info!("Tags filter: {:?}", tags);
-    info!("Owners filter: {:?}", owners);
-    info!("Unowned only: {}", unowned);
-    info!("Output format: {}", format);
-
-    // Determine the cache file path based on repository path
-    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
-    //let config = utils::app_config::AppConfig::fetch()?;
-    // let cache_dir = config
-    //     .cache_dir
-    //     .unwrap_or_else(|| repo_path.join(".codeowners.cache"));
-    let cache_file = repo_path.join(".codeowners.cache");
-
-    if !cache_file.exists() {
-        return Err(utils::error::Error::new(&format!(
-            "Cache file not found at {}. Please run 'codeowners parse' first.",
-            cache_file.display()
-        )));
-    }
+    // Repository path
+    let repo = repo.unwrap_or_else(|| std::path::Path::new("."));
 
     // Load the cache
-    let cache = load_cache(&cache_file)?;
+    let cache = sync_cache(repo, cache_file)?;
 
     // Filter files based on criteria
     let filtered_files = cache
@@ -179,23 +168,14 @@ pub fn codeowners_list_files(
 }
 
 /// Display aggregated owner statistics and associations
-pub fn codeowners_list_owners(path: Option<&std::path::Path>, format: &OutputFormat) -> Result<()> {
-    info!("Listing owners");
-    info!("Output format: {}", format);
-
-    // Determine the cache file path based on repository path
-    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
-    let cache_file = repo_path.join(".codeowners.cache");
-
-    if !cache_file.exists() {
-        return Err(utils::error::Error::new(&format!(
-            "Cache file not found at {}. Please run 'codeowners parse' first.",
-            cache_file.display()
-        )));
-    }
+pub fn codeowners_list_owners(
+    repo: Option<&std::path::Path>, format: &OutputFormat, cache_file: Option<&std::path::Path>,
+) -> Result<()> {
+    // Repository path
+    let repo = repo.unwrap_or_else(|| std::path::Path::new("."));
 
     // Load the cache
-    let cache = load_cache(&cache_file)?;
+    let cache = sync_cache(repo, cache_file)?;
 
     // Process the owners from the cache
     match format {
@@ -267,23 +247,14 @@ pub fn codeowners_list_owners(path: Option<&std::path::Path>, format: &OutputFor
 }
 
 /// Audit and analyze tag usage across CODEOWNERS files
-pub fn codeowners_list_tags(path: Option<&std::path::Path>, format: &OutputFormat) -> Result<()> {
-    info!("Listing tags");
-    info!("Output format: {}", format);
-
-    // Determine the cache file path based on repository path
-    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
-    let cache_file = repo_path.join(".codeowners.cache");
-
-    if !cache_file.exists() {
-        return Err(utils::error::Error::new(&format!(
-            "Cache file not found at {}. Please run 'codeowners parse' first.",
-            cache_file.display()
-        )));
-    }
+pub fn codeowners_list_tags(
+    repo: Option<&std::path::Path>, format: &OutputFormat, cache_file: Option<&std::path::Path>,
+) -> Result<()> {
+    // Repository path
+    let repo = repo.unwrap_or_else(|| std::path::Path::new("."));
 
     // Load the cache
-    let cache = load_cache(&cache_file)?;
+    let cache = sync_cache(repo, cache_file)?;
 
     // Process the tags from the cache
     match format {

core/src/lib.rs

@@ -4,6 +4,7 @@ extern crate log;
 pub mod cache;
 pub mod commands;
 pub mod common;
+pub mod parse;
 pub mod types;
 
 use utils::error::Result;

core/src/parse.rs

@@ -0,0 +1,37 @@
+use utils::error::Result;
+
+use crate::{
+    cache::{build_cache, store_cache},
+    common::{find_codeowners_files, find_files, parse_codeowners},
+    types::{CacheEncoding, CodeownersCache, CodeownersEntry},
+};
+
+pub fn parse_repo(repo: &std::path::Path, cache_file: &std::path::Path) -> Result<CodeownersCache> {
+    println!("Parsing CODEOWNERS files at {}", repo.display());
+
+    // Collect all CODEOWNERS files in the specified path
+    let codeowners_files = find_codeowners_files(repo)?;
+
+    // Parse each CODEOWNERS file and collect entries
+    let parsed_codeowners: Vec<CodeownersEntry> = codeowners_files
+        .iter()
+        .filter_map(|file| {
+            let parsed = parse_codeowners(file).ok()?;
+            Some(parsed)
+        })
+        .flatten()
+        .collect();
+
+    // Collect all files in the specified path
+    let files = find_files(repo)?;
+
+    // Build the cache from the parsed CODEOWNERS entries and the files
+    let cache = build_cache(parsed_codeowners, files)?;
+
+    // Store the cache in the specified file
+    store_cache(&cache, &repo.join(cache_file), CacheEncoding::Bincode)?;
+
+    println!("CODEOWNERS parsing completed successfully");
+
+    Ok(cache)
+}

src/resources/default_config.toml

@@ -1,6 +1,3 @@
 debug = false
 log_level = "info"
-
-[database]
-url = "custom database url"
-variable = "custom variable"
+cache_file = ".codeowners.cache"

utils/src/app_config.rs

@@ -14,17 +14,11 @@ lazy_static! {
     pub static ref BUILDER: RwLock<ConfigBuilder<DefaultState>> = RwLock::new(Config::builder());
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Database {
-    pub url: String,
-    pub variable: String,
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AppConfig {
     pub debug: bool,
     pub log_level: LogLevel,
-    pub database: Database,
+    pub cache_file: String,
 }
 
 impl AppConfig {
@@ -44,7 +38,7 @@ impl AppConfig {
         }
 
         // Merge settings with env variables
-        builder = builder.add_source(Environment::with_prefix("APP")); // TODO: Merge settings with Clap Settings Arguments
+        builder = builder.add_source(Environment::with_prefix("CODEINPUT")); // TODO: Merge settings with Clap Settings Arguments
 
         // Save Config to RwLoc
         {
@@ -126,7 +120,7 @@ impl TryFrom<Config> for AppConfig {
         Ok(AppConfig {
             debug: config.get_bool("debug")?,
             log_level: config.get::<LogLevel>("log_level")?,
-            database: config.get::<Database>("database")?,
+            cache_file: config.get::<String>("cache_file")?,
         })
     }
 }