wip: combine owner and tag resolvers

Author: omarabid

.gitignore

@@ -6,3 +6,4 @@ custom_config.toml
 .DS_Store
 example-repo
 .codeowners.cache
+perf.*

src/core/cache.rs

@@ -1,37 +1,49 @@
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
+use rayon::prelude::*;
+use rayon::slice::ParallelSlice;
+
 use super::common::{collect_owners, collect_tags, get_repo_hash};
 use super::owner_resolver::find_owners_for_file;
 use super::parse::parse_repo;
 use super::tag_resolver::find_tags_for_file;
 use super::types::{CacheEncoding, CodeownersCache, CodeownersEntry, FileEntry};
+use crate::core::owner_resolver::find_owners_and_tags_for_file;
 use crate::utils::error::{Error, Result};
 
 /// Create a cache from parsed CODEOWNERS entries and files
 pub fn build_cache(
     entries: Vec<CodeownersEntry>, files: Vec<PathBuf>, hash: [u8; 32],
 ) -> Result<CodeownersCache> {
-    let mut file_entries = Vec::new();
     let mut owners_map = std::collections::HashMap::new();
     let mut tags_map = std::collections::HashMap::new();
 
     println!("start building cache");
 
     // 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(),
-        };
-        dbg!(&file_entry);
-        file_entries.push(file_entry);
-    }
+    let file_entries: Vec<FileEntry> = files
+        .par_chunks(10)
+        .flat_map(|chunk| {
+            chunk
+                .iter()
+                .map(|file_path| {
+                    println!("Processing file: {}", file_path.display());
+
+                    let (owners, tags) =
+                        find_owners_and_tags_for_file(file_path, &entries).unwrap();
+                    //let tags = find_tags_for_file(file_path, &entries).unwrap();
+
+                    // Build file entry
+                    FileEntry {
+                        path: file_path.clone(),
+                        owners: owners.clone(),
+                        tags: tags.clone(),
+                    }
+                })
+                .collect::<Vec<FileEntry>>()
+        })
+        .collect();
 
     println!("file entry done");
 

src/core/owner_resolver.rs

@@ -1,4 +1,4 @@
-use super::smart_iter::SmartIter;
+use super::{smart_iter::SmartIter, types::Tag};
 use crate::utils::error::{Error, Result};
 use ignore::overrides::{Override, OverrideBuilder};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
@@ -32,8 +32,8 @@ pub fn find_owners_for_file<'a>(
         .ok_or_else(|| Error::new("file path has no parent directory"))?;
 
     // CodeownersEntry candidates
-    let mut candidates = entries
-        .smart_iter(3)
+    let mut candidates: Vec<_> = entries
+        .iter()
         .filter_map(|entry| {
             let codeowners_dir = match entry.source_file.parent() {
                 Some(dir) => dir,
@@ -402,3 +402,92 @@ mod tests {
         assert_eq!(result[0].identifier, "@rust-team");
     }
 }
+
+/// Find both owners and tags for a specific file based on all parsed CODEOWNERS entries
+pub fn find_owners_and_tags_for_file(
+    file_path: &Path, entries: &[CodeownersEntry],
+) -> Result<(Vec<Owner>, Vec<Tag>)> {
+    let target_dir = file_path.parent().ok_or_else(|| {
+        std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            "file path has no parent directory",
+        )
+    })?;
+
+    let mut candidates: Vec<_> = entries
+        .iter()
+        .filter_map(|entry| {
+            let codeowners_dir = match entry.source_file.parent() {
+                Some(dir) => dir,
+                None => {
+                    eprintln!(
+                        "CODEOWNERS entry has no parent directory: {}",
+                        entry.source_file.display()
+                    );
+                    return None;
+                }
+            };
+
+            // Check if the CODEOWNERS directory is an ancestor of the target directory
+            if !target_dir.starts_with(codeowners_dir) {
+                return None;
+            }
+
+            // Calculate the depth as the number of components in the relative path from codeowners_dir to target_dir
+            let rel_path = match target_dir.strip_prefix(codeowners_dir) {
+                Ok(p) => p,
+                Err(_) => return None, // Should not happen due to starts_with check
+            };
+            let depth = rel_path.components().count();
+
+            // Check if the pattern matches the target file
+            let matches = {
+                let mut builder = OverrideBuilder::new(codeowners_dir);
+                if let Err(e) = builder.add(&entry.pattern) {
+                    eprintln!(
+                        "Invalid pattern '{}' in {}: {}",
+                        entry.pattern,
+                        entry.source_file.display(),
+                        e
+                    );
+                    return None;
+                }
+                let over: Override = match builder.build() {
+                    Ok(o) => o,
+                    Err(e) => {
+                        eprintln!(
+                            "Failed to build override for pattern '{}': {}",
+                            entry.pattern, e
+                        );
+                        return None;
+                    }
+                };
+                over.matched(file_path, false).is_whitelist()
+            };
+
+            if matches { Some((entry, depth)) } else { None }
+        })
+        .collect();
+
+    // Sort the candidates by depth, source file, and line number
+    candidates.sort_unstable_by(|a, b| {
+        let a_entry = a.0;
+        let a_depth = a.1;
+        let b_entry = b.0;
+        let b_depth = b.1;
+
+        // Primary sort by depth (ascending)
+        a_depth
+            .cmp(&b_depth)
+            // Then by source file (to group entries from the same CODEOWNERS file)
+            .then_with(|| a_entry.source_file.cmp(&b_entry.source_file))
+            // Then by line number (descending) to prioritize later entries in the same file
+            .then_with(|| b_entry.line_number.cmp(&a_entry.line_number))
+    });
+
+    // Extract both owners and tags from the highest priority entry, if any
+    Ok(candidates
+        .first()
+        .map(|(entry, _)| (entry.owners.clone(), entry.tags.clone()))
+        .unwrap_or_default())
+}

src/core/tag_resolver.rs

@@ -31,8 +31,8 @@ pub fn find_tags_for_file(file_path: &Path, entries: &[CodeownersEntry]) -> Resu
         )
     })?;
 
-    let mut candidates = entries
-        .smart_iter(3)
+    let mut candidates: Vec<_> = entries
+        .iter()
         .filter_map(|entry| {
             let codeowners_dir = match entry.source_file.parent() {
                 Some(dir) => dir,