first try..slow

Author: perryqh

src/ownership/codeowners_file_parser.rs

@@ -5,6 +5,7 @@ use crate::{
 use fast_glob::glob_match;
 use memoize::memoize;
 use regex::Regex;
+use rayon::prelude::*;
 use std::{
     collections::HashMap,
     error::Error,
@@ -23,32 +24,69 @@ pub struct Parser {
 
 impl Parser {
     pub fn teams_from_files_paths(&self, file_paths: &[PathBuf]) -> Result<HashMap<String, Team>, Box<dyn Error>> {
-        todo!()
-    }
-    
-    pub fn team_from_file_path(&self, file_path: &Path) -> Result<Option<Team>, Box<dyn Error>> {
-        let file_path_str = file_path
-            .to_str()
-            .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid file path"))?;
-        let slash_prefixed = if file_path_str.starts_with("/") {
-            file_path_str.to_string()
-        } else {
-            format!("/{}", file_path_str)
-        };
-
-        let codeowners_lines_in_priorty = build_codeowners_lines_in_priority(self.codeowners_file_path.to_string_lossy().into_owned());
-        for line in codeowners_lines_in_priorty {
-            let (glob, team_name) = line
-                .split_once(' ')
-                .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid line"))?;
-            if glob_match(glob, &slash_prefixed) {
-                let tbn = teams_by_github_team_name(self.absolute_team_files_globs());
-                let team: Option<Team> = tbn.get(team_name.to_string().as_str()).cloned();
-                return Ok(team);
-            }
+        let mut file_inputs: Vec<(String, String)> = Vec::with_capacity(file_paths.len());
+        for path in file_paths {
+            let file_path_str = path
+                .to_str()
+                .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid file path"))?;
+            let key = file_path_str.to_string();
+            let slash_prefixed = if file_path_str.starts_with('/') {
+                file_path_str.to_string()
+            } else {
+                format!("/{}", file_path_str)
+            };
+            file_inputs.push((key, slash_prefixed));
+        }
+
+        if file_inputs.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let codeowners_lines_in_priority = build_codeowners_lines_in_priority(
+            self.codeowners_file_path.to_string_lossy().into_owned(),
+        );
+        // Pre-parse lines once to avoid repeated split and to handle malformed lines early
+        let codeowners_entries: Vec<(String, String)> = codeowners_lines_in_priority
+            .iter()
+            .map(|line| {
+                line
+                    .split_once(' ')
+                    .map(|(glob, team_name)| (glob.to_string(), team_name.to_string()))
+                    .ok_or_else(|| IoError::new(std::io::ErrorKind::InvalidInput, "Invalid line"))
+            })
+            .collect::<Result<_, IoError>>()
+            .map_err(|e| Box::new(e) as Box<dyn Error>)?;
+        let teams_by_name = teams_by_github_team_name(self.absolute_team_files_globs());
+
+        // Parallelize across files: for each file, scan lines in priority order
+        let result_pairs: Vec<(String, Team)> = file_inputs
+            .par_iter()
+            .filter_map(|(key, prefixed)| {
+                for (glob, team_name) in &codeowners_entries {
+                    if glob_match(glob, prefixed) {
+                        // Stop at first match (highest priority). If team missing, treat as unowned.
+                        if let Some(team) = teams_by_name.get(team_name) {
+                            return Some((key.clone(), team.clone()));
+                        } else {
+                            return None;
+                        }
+                    }
+                }
+                None
+            })
+            .collect();
+
+        let mut result: HashMap<String, Team> = HashMap::with_capacity(result_pairs.len());
+        for (k, t) in result_pairs {
+            result.insert(k, t);
         }
 
-        Ok(None)
+        Ok(result)
+    }
+
+    pub fn team_from_file_path(&self, file_path: &Path) -> Result<Option<Team>, Box<dyn Error>> {
+        let teams = self.teams_from_files_paths(&[file_path.to_path_buf()])?;
+        Ok(teams.get(file_path.to_string_lossy().into_owned().as_str()).cloned())
     }
 
     fn absolute_team_files_globs(&self) -> Vec<String> {

src/runner.rs

@@ -363,6 +363,7 @@ mod tests {
     use tempfile::tempdir;
 
     use crate::{common_test, ownership::mapper::Source};
+    use ignore::{DirEntry, WalkBuilder, WalkParallel, WalkState};
 
     use super::*;
 
@@ -417,4 +418,45 @@ mod tests {
         assert_eq!(team.github_team, "@b");
         assert!(team.path.to_string_lossy().ends_with("config/teams/b.yml"));
     }
+
+    #[test]
+    fn test_teams_for_files_from_codeowners() {
+       let project_root = Path::new("/Users/perryhertler/workspace/zenpayroll");
+       let codeowners_file_path = project_root.join(".github/CODEOWNERS");
+       let config_path = project_root.join("config/code_ownership.yml");
+       let run_config = RunConfig {
+           project_root: project_root.to_path_buf(),
+           codeowners_file_path: codeowners_file_path.to_path_buf(),
+           config_path: config_path.to_path_buf(),
+           no_cache: false,
+       };
+
+       // Collect all files in packs and frontend directories recursively
+       let mut file_paths = Vec::new();
+       for dir in ["packs", "frontend"] {
+           let dir_path = project_root.join(dir);
+           if dir_path.exists() && dir_path.is_dir() {
+               for entry in WalkBuilder::new(&dir_path)
+                   .filter_entry(|e| {
+                       let name = e.file_name().to_str().unwrap_or("");
+                       !(name == "node_modules" || name == "dist" || name == ".git")
+                   })
+                   .build() 
+                   .filter_map(|e| e.ok())
+                   .filter(|e| e.file_type().map(|t| t.is_file()).unwrap_or(false))
+                   .filter_map(|e| e.path().strip_prefix(project_root).ok().map(|p| p.to_string_lossy().to_string()))
+               {
+                   file_paths.push(entry);
+               }        
+           }
+       }
+
+       let start_time = std::time::Instant::now();
+       let teams = teams_for_files_from_codeowners(&run_config, &file_paths).unwrap();
+       let end_time = std::time::Instant::now();
+       println!("Time taken: {:?}", end_time.duration_since(start_time));
+       println!("Teams: {:?}", teams);
+       assert_eq!(teams.len(), 1);
+
+    }
 }