imp(common): fetch owners/tags functions

Author: omarabid

core/src/cache.rs

@@ -1,15 +1,15 @@
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
-use crate::common::{find_owners_for_file, find_tags_for_file};
+use crate::common::{collect_owners, collect_tags, find_owners_for_file, find_tags_for_file};
 use crate::types::{CacheEncoding, 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 owners_map = std::collections::HashMap::new();
-    let tags_map = std::collections::HashMap::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 {
@@ -25,6 +25,28 @@ pub fn build_cache(entries: Vec<CodeownersEntry>, files: Vec<PathBuf>) -> Result
         file_entries.push(file_entry);
     }
 
+    // Process each owner
+    let owners = collect_owners(&entries);
+    owners.iter().for_each(|owner| {
+        let paths = owners_map.entry(owner.clone()).or_insert_with(Vec::new);
+        for file_entry in &file_entries {
+            if file_entry.owners.contains(owner) {
+                paths.push(file_entry.path.clone());
+            }
+        }
+    });
+
+    // Process each tag
+    let tags = collect_tags(&entries);
+    tags.iter().for_each(|tag| {
+        let paths = tags_map.entry(tag.clone()).or_insert_with(Vec::new);
+        for file_entry in &file_entries {
+            if file_entry.tags.contains(tag) {
+                paths.push(file_entry.path.clone());
+            }
+        }
+    });
+
     Ok(CodeownersCache {
         entries,
         files: file_entries,

core/src/commands.rs

@@ -39,7 +39,7 @@ 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())?;
 

core/src/common.rs

@@ -5,7 +5,7 @@ use ignore::{
 use std::path::{Path, PathBuf};
 use utils::error::{Error, Result};
 
-use crate::types::{CodeownersEntry, Owner, OwnerType, Tag};
+use crate::types::{CodeownersEntry, FileEntry, Owner, OwnerType, Tag};
 
 /// Find CODEOWNERS files recursively in the given directory and its subdirectories
 pub fn find_codeowners_files<P: AsRef<Path>>(base_path: P) -> Result<Vec<PathBuf>> {
@@ -313,6 +313,50 @@ pub fn find_tags_for_file(file_path: &Path, entries: &[CodeownersEntry]) -> Resu
         .unwrap_or_default())
 }
 
+/// Find all files owned by a specific owner
+pub fn find_files_for_owner(files: &[FileEntry], owner: &Owner) -> Vec<PathBuf> {
+    files
+        .iter()
+        .filter(|file_entry| file_entry.owners.contains(owner))
+        .map(|file_entry| file_entry.path.clone())
+        .collect()
+}
+
+/// Find all files tagged with a specific tag
+pub fn find_files_for_tag(files: &[FileEntry], tag: &Tag) -> Vec<PathBuf> {
+    files
+        .iter()
+        .filter(|file_entry| file_entry.tags.contains(tag))
+        .map(|file_entry| file_entry.path.clone())
+        .collect()
+}
+
+/// Collect all unique owners from CODEOWNERS entries
+pub fn collect_owners(entries: &[CodeownersEntry]) -> Vec<Owner> {
+    let mut owners = std::collections::HashSet::new();
+
+    for entry in entries {
+        for owner in &entry.owners {
+            owners.insert(owner.clone());
+        }
+    }
+
+    owners.into_iter().collect()
+}
+
+/// Collect all unique tags from CODEOWNERS entries
+pub fn collect_tags(entries: &[CodeownersEntry]) -> Vec<Tag> {
+    let mut tags = std::collections::HashSet::new();
+
+    for entry in entries {
+        for tag in &entry.tags {
+            tags.insert(tag.clone());
+        }
+    }
+
+    tags.into_iter().collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;