wip: override builder optimization

Author: omarabid

.gitignore

@@ -7,3 +7,5 @@ custom_config.toml
 example-repo
 .codeowners.cache
 perf.*
+example-repo
+CODEOWNERS

src/core/cache.rs

@@ -10,6 +10,7 @@ use super::parse::parse_repo;
 use super::tag_resolver::find_tags_for_file;
 use super::types::{CacheEncoding, CodeownersCache, CodeownersEntry, FileEntry};
 use crate::core::resolver::find_owners_and_tags_for_file;
+use crate::core::types::{CodeownersEntryMatcher, codeowners_entry_to_matcher};
 use crate::utils::error::{Error, Result};
 
 /// Create a cache from parsed CODEOWNERS entries and files
@@ -21,17 +22,22 @@ pub fn build_cache(
 
     println!("start building cache");
 
+    let matched_entries: Vec<CodeownersEntryMatcher> = entries
+        .iter()
+        .map(|entry| codeowners_entry_to_matcher(entry))
+        .collect();
+
     // Process each file to find owners and tags
     let file_entries: Vec<FileEntry> = files
-        .par_chunks(10)
+        .par_chunks(100)
         .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();
+                        find_owners_and_tags_for_file(file_path, &matched_entries).unwrap();
 
                     // Build file entry
                     FileEntry {

src/core/resolver.rs

@@ -1,25 +1,26 @@
-use super::types::Tag;
+use super::{
+    smart_iter::SmartIter,
+    types::{CodeownersEntryMatcher, Tag},
+};
 use crate::utils::error::{Error, Result};
 use ignore::overrides::{Override, OverrideBuilder};
 
-use std::path::Path;
+use std::{path::Path, time::Instant};
 
 use super::types::{CodeownersEntry, Owner};
 
 /// 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],
+    file_path: &Path, entries: &[CodeownersEntryMatcher],
 ) -> Result<(Vec<Owner>, Vec<Tag>)> {
     // Early return if no entries
     if entries.is_empty() {
         return Ok((Vec::new(), Vec::new()));
     }
-    let target_dir = file_path.parent().ok_or_else(|| {
-        std::io::Error::new(
-            std::io::ErrorKind::InvalidInput,
-            "file path has no parent directory",
-        )
-    })?;
+
+    let target_dir = file_path
+        .parent()
+        .ok_or_else(|| Error::new("file path has no parent directory"))?;
 
     let mut candidates: Vec<_> = entries
         .iter()
@@ -45,31 +46,15 @@ pub fn find_owners_and_tags_for_file(
                 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()
+                entry
+                    .override_matcher
+                    .matched(file_path, false)
+                    .is_whitelist()
             };
 
             if matches { Some((entry, depth)) } else { None }

src/core/types.rs

@@ -1,5 +1,6 @@
 use std::path::PathBuf;
 
+use ignore::overrides::Override;
 use serde::{Deserialize, Serialize};
 
 /// CODEOWNERS entry with source tracking
@@ -12,6 +13,61 @@ pub struct CodeownersEntry {
     pub tags: Vec<Tag>,
 }
 
+/// CODEOWNERS entry with Override matcher
+#[derive(Debug)]
+pub struct CodeownersEntryMatcher {
+    pub source_file: PathBuf,
+    pub line_number: usize,
+    pub pattern: String,
+    pub owners: Vec<Owner>,
+    pub tags: Vec<Tag>,
+    pub override_matcher: Override,
+}
+
+pub fn codeowners_entry_to_matcher(entry: &CodeownersEntry) -> CodeownersEntryMatcher {
+    let codeowners_dir = match entry.source_file.parent() {
+        Some(dir) => dir,
+        None => {
+            eprintln!(
+                "CODEOWNERS entry has no parent directory: {}",
+                entry.source_file.display()
+            );
+            panic!("Invalid CODEOWNERS entry without parent directory");
+        }
+    };
+
+    let mut builder = ignore::overrides::OverrideBuilder::new(codeowners_dir);
+
+    if let Err(e) = builder.add(&entry.pattern) {
+        eprintln!(
+            "Invalid pattern '{}' in {}: {}",
+            entry.pattern,
+            entry.source_file.display(),
+            e
+        );
+        panic!("Invalid CODEOWNERS entry pattern");
+    }
+    let override_matcher: Override = match builder.build() {
+        Ok(o) => o,
+        Err(e) => {
+            eprintln!(
+                "Failed to build override for pattern '{}': {}",
+                entry.pattern, e
+            );
+            panic!("Failed to build CODEOWNERS entry matcher");
+        }
+    };
+
+    CodeownersEntryMatcher {
+        source_file: entry.source_file.clone(),
+        line_number: entry.line_number,
+        pattern: entry.pattern.clone(),
+        owners: entry.owners.clone(),
+        tags: entry.tags.clone(),
+        override_matcher,
+    }
+}
+
 /// Detailed owner representation
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct Owner {