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

@@ -9,8 +9,13 @@ use std::path::{Path, PathBuf};
 enum Command {
     #[clap(about = "Finds the owner of a given file.", visible_alias = "f")]
     ForFile {
-        #[arg(short, long, default_value = "false")]
-        verbose: bool,
+        #[arg(
+            short,
+            long,
+            default_value = "false",
+            help = "Find the owner from the CODEOWNERS file and just return the team name and yml path"
+        )]
+        fast: bool,
         name: String,
     },
 
@@ -98,7 +103,7 @@ pub fn cli() -> Result<RunResult, RunnerError> {
         Command::Validate => runner::validate(&run_config, vec![]),
         Command::Generate => runner::generate(&run_config),
         Command::GenerateAndValidate => runner::generate_and_validate(&run_config, vec![]),
-        Command::ForFile { name, verbose } => runner::for_file(&run_config, &name, verbose),
+        Command::ForFile { name, fast } => runner::for_file(&run_config, &name, fast),
         Command::ForTeam { name } => runner::for_team(&run_config, &name),
         Command::DeleteCache => runner::delete_cache(&run_config),
     };

src/cli.rs

@@ -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,92 @@
-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)
-    };
+pub struct Parser {
+    pub project_root: PathBuf,
+    pub codeowners_file_path: PathBuf,
+    pub team_file_globs: Vec<String>,
+}
 
-    let codeowners_lines_in_priorty = build_codeowners_lines_in_priority(codeowners_file_path)?;
+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)
+    }
 
-    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()));
+    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> {
+    dbg!("in teams_by_github_team_name");
+    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 = match Team::from_team_file_path(path) {
+                Ok(team) => team,
+                Err(e) => {
+                    eprintln!("Error parsing team file: {}", e);
+                    continue;
+                }
+            };
+            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> {
+    dbg!("in build_codeowners_lines_in_priority");
+    dbg!(&codeowners_file_path);
+    let codeowners_file = match fs::read_to_string(codeowners_file_path) {
+        Ok(codeowners_file) => codeowners_file,
+        Err(e) => {
+            // we can't return the error because it's not clonable
+            eprintln!("Error reading codeowners file: {}", e);
+            return vec![];
+        }
+    };
+    stripped_lines_by_priority(&codeowners_file)
 }
 
 fn stripped_lines_by_priority(codeowners_file: &str) -> Vec<String> {