stubbing out teams_for_files_from_codeowners

Author: perryqh

src/ownership.rs

@@ -9,11 +9,11 @@ use std::{
 };
 use tracing::{info, instrument};
 
-pub(crate) mod codeowners_file_parser;
 mod file_generator;
 mod file_owner_finder;
 pub mod for_file_fast;
 pub(crate) mod mapper;
+pub(crate) mod codeowners_file_parser;
 mod validator;
 
 use crate::{
@@ -24,9 +24,9 @@ use crate::{
 pub use validator::Errors as ValidatorErrors;
 
 use self::{
-    codeowners_file_parser::parse_for_team,
     file_generator::FileGenerator,
     mapper::{JavascriptPackageMapper, Mapper, RubyPackageMapper, TeamFileMapper, TeamGemMapper, TeamGlobMapper, TeamYmlMapper},
+    codeowners_file_parser::parse_for_team,
     validator::Validator,
 };
 

src/ownership/codeowners_file_parser.rs

@@ -4,7 +4,6 @@ use crate::{
 };
 use fast_glob::glob_match;
 use memoize::memoize;
-use rayon::prelude::*;
 use regex::Regex;
 use std::{
     collections::HashMap,
@@ -23,57 +22,33 @@ pub struct Parser {
 }
 
 impl Parser {
-    pub fn teams_from_files_paths(&self, file_paths: &[PathBuf]) -> Result<HashMap<String, Option<Team>>, Box<dyn Error>> {
-        let file_inputs: Vec<(String, String)> = file_paths
-            .iter()
-            .map(|path| {
-                let file_path_str = path
-                    .to_str()
-                    .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid file path"))?;
-                let original = file_path_str.to_string();
-                let prefixed = if file_path_str.starts_with('/') {
-                    original.clone()
-                } else {
-                    format!("/{}", file_path_str)
-                };
-                Ok((original, prefixed))
-            })
-            .collect::<Result<Vec<_>, IoError>>()?;
-
-        if file_inputs.is_empty() {
-            return Ok(HashMap::new());
-        }
-
-        let codeowners_entries: Vec<(String, String)> =
-            build_codeowners_lines_in_priority(self.codeowners_file_path.to_string_lossy().into_owned())
-                .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());
-
-        let result: HashMap<String, Option<Team>> = file_inputs
-            .par_iter()
-            .map(|(key, prefixed)| {
-                let team = codeowners_entries
-                    .iter()
-                    .find(|(glob, _)| glob_match(glob, prefixed))
-                    .and_then(|(_, team_name)| teams_by_name.get(team_name).cloned());
-                (key.clone(), team)
-            })
-            .collect();
-
-        Ok(result)
+    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 teams = self.teams_from_files_paths(&[file_path.to_path_buf()])?;
-        Ok(teams.get(file_path.to_string_lossy().into_owned().as_str()).cloned().flatten())
+        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);
+            }
+        }
+
+        Ok(None)
     }
 
     fn absolute_team_files_globs(&self) -> Vec<String> {

src/runner.rs

@@ -283,7 +283,7 @@ fn for_file_codeowners_only(run_config: &RunConfig, file_path: &str) -> RunResul
 }
 
 // For an array of file paths, return a map of file path to its owning team
-pub fn teams_for_files_from_codeowners(run_config: &RunConfig, file_paths: &[String]) -> Result<HashMap<String, Option<Team>>, Error> {
+pub fn teams_for_files_from_codeowners(run_config: &RunConfig, file_paths: &[String]) -> Result<HashMap<String, Team>, Error> {
     let relative_file_paths: Vec<PathBuf> = file_paths
         .iter()
         .map(|path| Path::new(path).strip_prefix(&run_config.project_root).unwrap_or(Path::new(path)))
@@ -362,9 +362,10 @@ fn for_file_optimized(run_config: &RunConfig, file_path: &str) -> RunResult {
 mod tests {
     use tempfile::tempdir;
 
-    use super::*;
     use crate::{common_test, ownership::mapper::Source};
 
+    use super::*;
+
     #[test]
     fn test_version() {
         assert_eq!(version(), env!("CARGO_PKG_VERSION").to_string());
@@ -416,62 +417,4 @@ 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("tests/fixtures/valid_project");
-        let file_paths = [
-            "javascript/packages/items/item.ts",
-            "config/teams/payroll.yml",
-            "ruby/app/models/bank_account.rb",
-            "made/up/file.rb",
-            "ruby/ignored_files/git_ignored.rb",
-        ];
-        let run_config = RunConfig {
-            project_root: project_root.to_path_buf(),
-            codeowners_file_path: project_root.join(".github/CODEOWNERS").to_path_buf(),
-            config_path: project_root.join("config/code_ownership.yml").to_path_buf(),
-            no_cache: false,
-        };
-        let teams =
-            teams_for_files_from_codeowners(&run_config, &file_paths.iter().map(|s| s.to_string()).collect::<Vec<String>>()).unwrap();
-        assert_eq!(teams.len(), 5);
-        assert_eq!(
-            teams
-                .get("javascript/packages/items/item.ts")
-                .unwrap()
-                .as_ref()
-                .map(|t| t.name.as_str()),
-            Some("Payroll")
-        );
-        assert_eq!(
-            teams.get("config/teams/payroll.yml").unwrap().as_ref().map(|t| t.name.as_str()),
-            Some("Payroll")
-        );
-        assert_eq!(
-            teams
-                .get("ruby/app/models/bank_account.rb")
-                .unwrap()
-                .as_ref()
-                .map(|t| t.name.as_str()),
-            Some("Payments")
-        );
-        assert_eq!(teams.get("made/up/file.rb").unwrap().as_ref().map(|t| t.name.as_str()), None);
-        assert_eq!(
-            teams
-                .get("ruby/ignored_files/git_ignored.rb")
-                .unwrap()
-                .as_ref()
-                .map(|t| t.name.as_str()),
-            None
-        );
-        assert_eq!(
-            teams
-                .get("ruby/ignored_files/git_ignored.rb")
-                .unwrap()
-                .as_ref()
-                .map(|t| t.name.as_str()),
-            None
-        );
-    }
 }