wip(core): parse cache

Author: omarabid

core/Cargo.toml

@@ -11,6 +11,8 @@ utils = { path = "../utils" }
 rand = "0.9.1"
 log = "0.4.27"
 ignore = "0.4.23"
+serde = { version = "1.0.219", features = ["derive"] }
+bincode = {version= "2.0.1", features = ["serde"] }
 
 [dev-dependencies]
 tempfile = "3.8"

core/src/cache.rs

@@ -0,0 +1,54 @@
+use std::path::{Path, PathBuf};
+
+use crate::common::{find_owners_for_file, find_tags_for_file};
+use crate::types::{CodeownersCache, CodeownersEntry, FileEntry};
+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();
+
+    // Process each file to find owners and tags
+    for file_path in files {
+        let owners = find_owners_for_file(&file_path, &entries)?;
+        let tags = find_tags_for_file(&file_path, &entries)?;
+
+        // Build file entry
+        let file_entry = FileEntry {
+            path: file_path.clone(),
+            owners: owners.clone(),
+            tags: tags.clone(),
+        };
+        file_entries.push(file_entry);
+    }
+
+    Ok(CodeownersCache {
+        entries,
+        files: file_entries,
+        owners_map,
+        tags_map,
+    })
+}
+
+/// Store Cache
+pub fn store_cache(cache: &CodeownersCache, path: &Path) -> Result<()> {
+    let parent = path
+        .parent()
+        .ok_or_else(|| Error::new("Invalid cache path"))?;
+    std::fs::create_dir_all(parent)?;
+
+    let file = std::fs::File::create(path)?;
+
+    bincode::serialize_into(file, cache)
+        .map_err(|e| Error::new(&format!("Failed to serialize cache: {}", e)))?;
+}
+
+/// 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)))
+}
+

core/src/commands.rs

@@ -1,3 +1,4 @@
+use crate::cache::build_cache;
 use crate::common::find_files;
 use crate::types::{CodeownersEntry, OutputFormat};
 
@@ -20,7 +21,7 @@ pub fn codeowners_parse(
 
     let codeowners_files = crate::common::find_codeowners_files(path)?;
 
-    dbg!(&codeowners_files);
+    //dbg!(&codeowners_files);
 
     let parsed_codeowners: Vec<CodeownersEntry> = codeowners_files
         .iter()
@@ -31,18 +32,12 @@ pub fn codeowners_parse(
         .flatten()
         .collect();
 
-    dbg!(&parsed_codeowners);
+    //dbg!(&parsed_codeowners);
 
     let files = find_files(path)?;
 
-    dbg!(&files);
-
-    for file in files {
-        let owners = crate::common::find_owners_for_file(&file, parsed_codeowners.as_slice());
-        let tags = crate::common::find_tags_for_file(&file, parsed_codeowners.as_slice());
-        println!("File: {} - Owners: {:?}", file.display(), owners);
-        println!("File: {} - Tags: {:?}", file.display(), tags);
-    }
+    //dbg!(&files);
+    build_cache(parsed_codeowners, files)?;
 
     println!("CODEOWNERS parsing completed successfully");
     Ok(())

core/src/lib.rs

@@ -1,6 +1,7 @@
 #[macro_use]
 extern crate log;
 
+pub mod cache;
 pub mod commands;
 pub mod common;
 pub mod types;

core/src/types.rs

@@ -1,7 +1,9 @@
 use std::path::PathBuf;
 
+use serde::{Deserialize, Serialize};
+
 /// CODEOWNERS entry with source tracking
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct CodeownersEntry {
     pub source_file: PathBuf,
     pub line_number: usize,
@@ -11,14 +13,14 @@ pub struct CodeownersEntry {
 }
 
 /// Detailed owner representation
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct Owner {
     pub identifier: String,
     pub owner_type: OwnerType,
 }
 
 /// Owner type classification
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub enum OwnerType {
     User,
     Team,
@@ -28,10 +30,10 @@ pub enum OwnerType {
 }
 
 /// Tag representation
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct Tag(pub String);
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OutputFormat {
     Text,
     Json,
@@ -47,3 +49,22 @@ impl std::fmt::Display for OutputFormat {
         }
     }
 }
+
+// Cache related types
+/// File entry in the ownership cache
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileEntry {
+    pub path: PathBuf,
+    pub owners: Vec<Owner>,
+    pub tags: Vec<Tag>,
+}
+
+/// Cache for storing parsed CODEOWNERS information
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CodeownersCache {
+    pub entries: Vec<CodeownersEntry>,
+    pub files: Vec<FileEntry>,
+    // Derived data for lookups
+    pub owners_map: std::collections::HashMap<Owner, Vec<PathBuf>>,
+    pub tags_map: std::collections::HashMap<Tag, Vec<PathBuf>>,
+}