memoize codeowners

Author: perryqh

Cargo.lock

@@ -15,9 +15,11 @@ clap_derive = "4.5.18"
 error-stack = "0.5.0"
 enum_dispatch = "0.3.13"
 fast-glob = "0.4.0"
+glob = "0.3.2"
 ignore = "0.4.23"
 itertools = "0.14.0"
 lazy_static = "1.5.0"
+memoize = "0.5.1"
 path-clean = "1.0.1"
 rayon = "1.10.0"
 regex = "1.11.1"
@@ -30,7 +32,6 @@ tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 
 [dev-dependencies]
 assert_cmd = "2.0.16"
-glob = "0.3.1"
 rusty-hook = "^0.11.2"
 predicates = "3.1.2"
 pretty_assertions = "1.4.1" # Shows a more readable diff when comparing objects

Cargo.toml

@@ -4,15 +4,15 @@ use mapper::{OwnerMatcher, Source, TeamName};
 use std::{
     error::Error,
     fmt::{self, Display},
-    path::{Path, PathBuf},
+    path::Path,
     sync::Arc,
 };
 use tracing::{info, instrument};
 
 mod file_generator;
 mod file_owner_finder;
 pub(crate) mod mapper;
-mod parser;
+pub(crate) mod parser;
 mod validator;
 
 use crate::{
@@ -178,10 +178,6 @@ impl Ownership {
     }
 }
 
-pub fn fast_team_name_from_file_path(file_path: &str, code_owners_file_path: &PathBuf) -> Result<Option<String>, Box<dyn Error>> {
-    parser::team_name_from_file_path(Path::new(file_path), code_owners_file_path)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/ownership.rs

@@ -1,40 +1,76 @@
-use crate::ownership::{FileGenerator, TeamOwnership};
+use crate::{
+    ownership::{FileGenerator, TeamOwnership},
+    project::Team,
+};
 use fast_glob::glob_match;
+use memoize::memoize;
 use std::{
+    collections::HashMap,
     error::Error,
     fs,
     io::Error as IoError,
     path::{Path, PathBuf},
 };
 
-pub fn team_name_from_file_path(file_path: &Path, codeowners_file_path: &PathBuf) -> Result<Option<String>, 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(codeowners_file_path)?;
-
-    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) {
-            return Ok(Some(team_name.to_string()));
+pub struct Parser {
+    pub project_root: PathBuf,
+    pub codeowners_file_path: PathBuf,
+    pub team_file_globs: Vec<String>,
+}
+
+impl Parser {
+    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);
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn absolute_team_files_globs(&self) -> Vec<String> {
+        self.team_file_globs
+            .iter()
+            .map(|glob| format!("{}/{}", self.project_root.display(), glob))
+            .collect()
+    }
+}
+
+#[memoize]
+fn teams_by_github_team_name(team_file_glob: Vec<String>) -> HashMap<String, Team> {
+    let mut teams = HashMap::new();
+    for glob in team_file_glob {
+        let paths = glob::glob(&glob).expect("Failed to read glob pattern").filter_map(Result::ok);
+
+        for path in paths {
+            let team = Team::from_team_file_path(path).unwrap();
+            teams.insert(team.github_team.clone(), team);
         }
     }
 
-    Ok(None)
+    teams
 }
 
-fn build_codeowners_lines_in_priority(codeowners_file_path: &PathBuf) -> Result<Vec<String>, Box<dyn Error>> {
-    let codeowners_file = fs::read_to_string(codeowners_file_path)?;
-    let stripped_lines = stripped_lines_by_priority(&codeowners_file);
-    Ok(stripped_lines)
+#[memoize]
+fn build_codeowners_lines_in_priority(codeowners_file_path: String) -> Vec<String> {
+    let codeowners_file = fs::read_to_string(codeowners_file_path).unwrap();
+    stripped_lines_by_priority(&codeowners_file)
 }
 
 fn stripped_lines_by_priority(codeowners_file: &str) -> Vec<String> {

src/ownership/parser.rs

@@ -1,13 +1,16 @@
 use core::fmt;
-use std::{fs::File, path::PathBuf};
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
 
 use error_stack::{Context, Result, ResultExt};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     cache::{Cache, Caching, file::GlobalCache, noop::NoopCache},
     config::Config,
-    ownership::{FileOwner, Ownership, fast_team_name_from_file_path},
+    ownership::{FileOwner, Ownership},
     project_builder::ProjectBuilder,
 };
 
@@ -35,12 +38,33 @@ pub fn for_file(run_config: &RunConfig, file_path: &str, verbose: bool) -> RunRe
     if verbose {
         run_with_runner(run_config, |runner| runner.for_file(file_path))
     } else {
-        let result = fast_team_name_from_file_path(file_path, &run_config.codeowners_file_path);
+        let config = match config_from_path(&run_config.config_path) {
+            Ok(config) => config,
+            Err(err) => {
+                return RunResult {
+                    io_errors: vec![err.to_string()],
+                    ..Default::default()
+                };
+            }
+        };
+        let parser = crate::ownership::parser::Parser {
+            project_root: run_config.project_root.clone(),
+            codeowners_file_path: run_config.codeowners_file_path.clone(),
+            team_file_globs: config.team_file_glob.clone(),
+        };
+        let result = parser.team_from_file_path(Path::new(file_path));
         match result {
-            Ok(Some(team_name)) => RunResult {
-                info_messages: vec![format!("{}", team_name)],
-                ..Default::default()
-            },
+            Ok(Some(team)) => {
+                let relative_team_yml_path = team.path.strip_prefix(&run_config.project_root).unwrap_or(&team.path);
+
+                RunResult {
+                    info_messages: vec![
+                        format!("Team: {}", team.name),
+                        format!("Team YML: {}", relative_team_yml_path.display()),
+                    ],
+                    ..Default::default()
+                }
+            }
             Ok(None) => RunResult {
                 info_messages: vec!["No team found".to_string()],
                 ..Default::default()