imp(cache): load cache

Author: omarabid

core/src/cache.rs

@@ -1,4 +1,4 @@
-use std::io::Write;
+use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
 use crate::common::{find_owners_for_file, find_tags_for_file};
@@ -8,8 +8,8 @@ use utils::error::{Error, Result};
 /// Create a cache from parsed CODEOWNERS entries and files
 pub fn build_cache(entries: Vec<CodeownersEntry>, files: Vec<PathBuf>) -> Result<CodeownersCache> {
     let mut file_entries = Vec::new();
-    let mut owners_map = std::collections::HashMap::new();
-    let mut tags_map = std::collections::HashMap::new();
+    let owners_map = std::collections::HashMap::new();
+    let tags_map = std::collections::HashMap::new();
 
     // Process each file to find owners and tags
     for file_path in files {
@@ -59,9 +59,47 @@ pub fn store_cache(cache: &CodeownersCache, path: &Path, encoding: CacheEncoding
     Ok(())
 }
 
-// Load cache from a file
-// pub fn load_cache(path: &Path) -> Result<CodeownersCache> {
-//     let file = std::fs::File::open(path)?;
-//     bincode::deserialize_from(file)
-//         .map_err(|e| Error::new(&format!("Failed to deserialize cache: {}", e)))
-// }
+/// Load Cache from file, automatically detecting whether it's JSON or Bincode format
+pub fn load_cache(path: &Path) -> Result<CodeownersCache> {
+    // Read the first byte to make an educated guess about the format
+    let mut file = std::fs::File::open(path)
+        .map_err(|e| Error::new(&format!("Failed to open cache file: {}", e)))?;
+
+    let mut first_byte = [0u8; 1];
+    let read_result = file.read_exact(&mut first_byte);
+
+    // Close the file handle and reopen for full reading
+    drop(file);
+
+    if read_result.is_ok() && first_byte[0] == b'{' {
+        // First byte is '{', likely JSON
+        let file = std::fs::File::open(path)
+            .map_err(|e| Error::new(&format!("Failed to open cache file: {}", e)))?;
+        let reader = std::io::BufReader::new(file);
+
+        return serde_json::from_reader(reader)
+            .map_err(|e| Error::new(&format!("Failed to deserialize JSON cache: {}", e)));
+    }
+
+    // Try bincode first since it's not JSON
+    let file = std::fs::File::open(path)
+        .map_err(|e| Error::new(&format!("Failed to open cache file: {}", e)))?;
+    let mut reader = std::io::BufReader::new(file);
+
+    match bincode::serde::decode_from_std_read(&mut reader, bincode::config::standard()) {
+        Ok(cache) => Ok(cache),
+        Err(_) => {
+            // If bincode fails and it's not obviously JSON, still try JSON as a fallback
+            let file = std::fs::File::open(path)
+                .map_err(|e| Error::new(&format!("Failed to open cache file: {}", e)))?;
+            let reader = std::io::BufReader::new(file);
+
+            serde_json::from_reader(reader).map_err(|e| {
+                Error::new(&format!(
+                    "Failed to deserialize cache in any supported format: {}",
+                    e
+                ))
+            })
+        }
+    }
+}

core/src/commands.rs

@@ -1,4 +1,4 @@
-use crate::cache::{build_cache, store_cache};
+use crate::cache::{build_cache, load_cache, store_cache};
 use crate::common::find_files;
 use crate::types::{CacheEncoding, CodeownersEntry, OutputFormat};
 
@@ -39,7 +39,11 @@ pub fn codeowners_parse(
     //dbg!(&files);
     let cache = build_cache(parsed_codeowners, files)?;
 
-    store_cache(&cache, cache_file.unwrap(), encoding)?;
+    //store_cache(&cache, cache_file.unwrap(), encoding)?;
+
+    let cache = load_cache(cache_file.unwrap())?;
+
+    dbg!(cache);
 
     println!("CODEOWNERS parsing completed successfully");
     Ok(())