Fast Team from File (#56)

* team from file

* only build teams by name once

* from_team_file_path for reuse

* 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

@@ -1,14 +1,23 @@
 use clap::{Parser, Subcommand};
-use codeowners::runner::{Error as RunnerError, RunResult};
-use codeowners::runner::{RunConfig, Runner};
+use codeowners::runner::RunConfig;
+use codeowners::runner::{self, Error as RunnerError, RunResult};
 use error_stack::{Result, ResultExt};
 use path_clean::PathClean;
 use std::path::{Path, PathBuf};
 
 #[derive(Subcommand, Debug)]
 enum Command {
     #[clap(about = "Finds the owner of a given file.", visible_alias = "f")]
-    ForFile { name: String },
+    ForFile {
+        #[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,
+    },
 
     #[clap(about = "Finds code ownership information for a given team ", visible_alias = "t")]
     ForTeam { name: String },
@@ -90,15 +99,13 @@ pub fn cli() -> Result<RunResult, RunnerError> {
         no_cache: args.no_cache,
     };
 
-    let runner = Runner::new(&run_config)?;
-
     let runner_result = match args.command {
-        Command::Validate => runner.validate(),
-        Command::Generate => runner.generate(),
-        Command::GenerateAndValidate => runner.generate_and_validate(),
-        Command::ForFile { name } => runner.for_file(&name),
-        Command::ForTeam { name } => runner.for_team(&name),
-        Command::DeleteCache => runner.delete_cache(),
+        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, fast } => runner::for_file(&run_config, &name, fast),
+        Command::ForTeam { name } => runner::for_team(&run_config, &name),
+        Command::DeleteCache => runner::delete_cache(&run_config),
     };
 
     Ok(runner_result)

src/cli.rs

@@ -1,20 +1,22 @@
 use serde::Deserialize;
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct Config {
     pub owned_globs: Vec<String>,
 
     #[serde(default = "ruby_package_paths")]
     pub ruby_package_paths: Vec<String>,
 
-    #[serde(alias = "js_package_paths")]
+    #[serde(alias = "js_package_paths", default = "javascript_package_paths")]
     pub javascript_package_paths: Vec<String>,
 
     #[serde(default = "team_file_glob")]
     pub team_file_glob: Vec<String>,
+
+    #[serde(default = "unowned_globs")]
     pub unowned_globs: Vec<String>,
 
-    #[serde(alias = "unbuilt_gems_path")]
+    #[serde(alias = "unbuilt_gems_path", default = "vendored_gems_path")]
     pub vendored_gems_path: String,
 
     #[serde(default = "default_cache_directory")]
@@ -39,3 +41,58 @@ fn team_file_glob() -> Vec<String> {
 fn default_cache_directory() -> String {
     String::from("tmp/cache/codeowners")
 }
+
+fn javascript_package_paths() -> Vec<String> {
+    vec!["frontend/**/*".to_owned()]
+}
+
+fn unowned_globs() -> Vec<String> {
+    vec![
+        "frontend/**/node_modules/**/*".to_owned(),
+        "frontend/**/__generated__/**/*".to_owned(),
+    ]
+}
+
+fn vendored_gems_path() -> String {
+    "vendored/".to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        error::Error,
+        fs::{self, File},
+    };
+
+    use indoc::indoc;
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn test_parse_config() -> Result<(), Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+        let config_path = temp_dir.path().join("config.yml");
+        let config_str = indoc! {"
+            ---
+            owned_globs:
+              - \"{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}\"
+        "};
+        fs::write(&config_path, config_str)?;
+        let config_file = File::open(&config_path)?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
+        assert_eq!(
+            config.owned_globs,
+            vec!["{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}"]
+        );
+        assert_eq!(config.ruby_package_paths, vec!["packs/**/*", "components/**"]);
+        assert_eq!(config.javascript_package_paths, vec!["frontend/**/*"]);
+        assert_eq!(config.team_file_glob, vec!["config/teams/**/*.yml"]);
+        assert_eq!(
+            config.unowned_globs,
+            vec!["frontend/**/node_modules/**/*", "frontend/**/__generated__/**/*"]
+        );
+        assert_eq!(config.vendored_gems_path, "vendored/");
+        Ok(())
+    }
+}

src/config.rs

@@ -21,7 +21,7 @@ fn maybe_print_errors(result: RunResult) -> Result<(), RunnerError> {
     }
     if !result.io_errors.is_empty() || !result.validation_errors.is_empty() {
         for msg in result.io_errors {
-            println!("{}", msg);
+            eprintln!("{}", msg);
         }
         for msg in result.validation_errors {
             println!("{}", msg);

src/main.rs

@@ -12,7 +12,7 @@ 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::{

src/ownership.rs

@@ -18,7 +18,7 @@ impl DirectoryMapper {
 impl Mapper for DirectoryMapper {
     fn entries(&self) -> Vec<Entry> {
         let mut entries: Vec<Entry> = Vec::new();
-        let team_by_name = self.project.team_by_name();
+        let team_by_name = self.project.teams_by_name.clone();
 
         for directory_codeowner_file in &self.project.directory_codeowner_files {
             let dir_root = directory_codeowner_file.directory_root().to_string_lossy();

src/ownership/mapper/directory_mapper.rs

@@ -66,7 +66,7 @@ impl PackageMapper {
 impl PackageMapper {
     fn entries(&self, package_type: &PackageType) -> Vec<Entry> {
         let mut entries: Vec<Entry> = Vec::new();
-        let team_by_name = self.project.team_by_name();
+        let team_by_name = self.project.teams_by_name.clone();
 
         for package in self.project.packages.iter().filter(|package| &package.package_type == package_type) {
             let package_root = package.package_root().to_string_lossy();
@@ -87,7 +87,7 @@ impl PackageMapper {
 
     fn owner_matchers(&self, package_type: &PackageType) -> Vec<OwnerMatcher> {
         let mut owner_matchers: Vec<OwnerMatcher> = Vec::new();
-        let team_by_name = self.project.team_by_name();
+        let team_by_name = self.project.teams_by_name.clone();
 
         let packages = &self.project.packages;
         let packages: Vec<&Package> = packages.iter().filter(|package| &package.package_type == package_type).collect();