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,78 @@
-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,
+}
+
+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_name(self.absolute_team_files_glob());
+                let team: Option<Team> = tbn.get(team_name.to_string().as_str()).cloned();
+                return Ok(team);
+            }
         }
+
+        Ok(None)
+    }
+
+    fn absolute_team_files_glob(&self) -> String {
+        self.project_root
+            .join(self.codeowners_file_path.to_string_lossy().into_owned())
+            .to_string_lossy()
+            .into_owned()
+    }
+}
+
+#[memoize]
+fn teams_by_name(team_file_glob: String) -> HashMap<String, Team> {
+    let mut teams = HashMap::new();
+
+    // Get all files matching the glob pattern
+    let paths = glob::glob(&team_file_glob)
+        .expect("Failed to read glob pattern")
+        .filter_map(Result::ok);
+
+    // Process each matching file
+    for path in paths {
+        let team = Team::from_team_file_path(path).unwrap();
+        teams.insert(team.name.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,10 +38,14 @@ 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 parser = crate::ownership::parser::Parser {
+            project_root: run_config.project_root.clone(),
+            codeowners_file_path: run_config.codeowners_file_path.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)],
+                info_messages: vec![format!("{}", team_name.name)],
                 ..Default::default()
             },
             Ok(None) => RunResult {