extracting project-file-builder

Author: perryqh

Cargo.lock

@@ -6,16 +6,18 @@ edition = "2021"
 [profile.release]
 debug = true
 
+[lib]
+path = "src/lib.rs"
+
 [dependencies]
 clap = { version = "4.5.20", features = ["derive"] }
 clap_derive = "4.5.18"
 error-stack = "0.5.0"
 fast-glob = "0.4.0"
 ignore = "0.4.23"
 itertools = "0.13.0"
-path-clean = "1.0.1"
 lazy_static = "1.5.0"
-num_cpus = "1.16.0"
+path-clean = "1.0.1"
 rayon = "1.10.0"
 regex = "1.11.1"
 serde = { version = "1.0.214", features = ["derive"] }

Cargo.toml

@@ -0,0 +1,6 @@
+pub(crate) mod common_test;
+pub(crate) mod config;
+pub mod ownership;
+pub(crate) mod project;
+pub mod project_builder;
+pub(crate) mod project_file_builder;

src/lib.rs

@@ -1,7 +1,7 @@
-use ownership::{FileOwner, Ownership};
+use codeowners::ownership::{self, FileOwner, Ownership};
 
-use crate::project_builder::ProjectBuilder;
 use clap::{Parser, Subcommand};
+use codeowners::project_builder::ProjectBuilder;
 use core::fmt;
 use error_stack::{Context, Result, ResultExt};
 use path_clean::PathClean;
@@ -11,12 +11,6 @@ use std::{
     process,
 };
 
-mod common_test;
-mod config;
-mod ownership;
-mod project;
-mod project_builder;
-
 #[derive(Subcommand, Debug)]
 enum Command {
     #[clap(about = "Finds the owner of a given file.", visible_alias = "f")]

src/main.rs

@@ -6,14 +6,14 @@ use std::{
 use error_stack::{Result, ResultExt};
 use fast_glob::glob_match;
 use ignore::WalkBuilder;
-use lazy_static::lazy_static;
+use project_file_builder::build_project_file;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use regex::Regex;
 use tracing::instrument;
 
 use crate::{
     config::Config,
     project::{deserializers, DirectoryCodeownersFile, Error, Package, PackageType, Project, ProjectFile, Team, VendoredGem},
+    project_file_builder,
 };
 
 type AbsolutePath = PathBuf;
@@ -57,7 +57,9 @@ impl<'a> ProjectBuilder<'a> {
             let entry = entry.change_context(Error::Io)?;
             entry_types.push(self.build_entry_type(entry)?);
         }
-        self.build_project_from_entry_types(entry_types)
+        let project = self.build_project_from_entry_types(entry_types);
+        project_file_builder::save_cache()?;
+        project
     }
 
     fn build_entry_type(&mut self, entry: ignore::DirEntry) -> Result<EntryType, Error> {
@@ -87,7 +89,7 @@ impl<'a> ProjectBuilder<'a> {
                 Ok(EntryType::TeamFile(absolute_path.to_owned(), relative_path.to_owned()))
             }
             _ if matches_globs(&relative_path, &self.config.owned_globs) && !matches_globs(&relative_path, &self.config.unowned_globs) => {
-                let project_file = build_project_file(absolute_path.to_path_buf());
+                let project_file = build_project_file(absolute_path.to_path_buf(), false);
                 Ok(EntryType::OwnedFile(project_file))
             }
             _ => Ok(EntryType::NullEntry()),
@@ -206,34 +208,6 @@ fn javascript_package_owner(path: &Path) -> Result<Option<String>, Error> {
     Ok(deserializer.metadata.and_then(|metadata| metadata.owner))
 }
 
-lazy_static! {
-    static ref TEAM_REGEX: Regex = Regex::new(r#"^(?:#|//) @team (.*)$"#).expect("error compiling regular expression");
-}
-
-#[instrument(level = "debug", skip_all)]
-fn owned_files(owned_file_paths: Vec<PathBuf>) -> Vec<ProjectFile> {
-    owned_file_paths.into_par_iter().map(build_project_file).collect()
-}
-
-fn build_project_file(path: PathBuf) -> ProjectFile {
-    let content = match std::fs::read_to_string(&path) {
-        Ok(content) => content,
-        Err(_) => return ProjectFile { path, owner: None },
-    };
-
-    let first_line = content.lines().next();
-    let Some(first_line) = first_line else {
-        return ProjectFile { path, owner: None };
-    };
-
-    let owner = TEAM_REGEX
-        .captures(first_line)
-        .and_then(|cap| cap.get(1))
-        .map(|m| m.as_str().to_string());
-
-    ProjectFile { path, owner }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -252,4 +226,11 @@ mod tests {
         // should fail because hidden directories are ignored by glob patterns unless explicitly included
         assert!(glob_match(OWNED_GLOB, "script/.eslintrc.js"));
     }
+
+    #[test]
+    fn test_build_project_file() {
+        let project_file = build_project_file(PathBuf::from("script/.eslintrc.js"), false);
+        assert_eq!(project_file.path, PathBuf::from("script/.eslintrc.js"));
+        assert_eq!(project_file.owner, None);
+    }
 }

src/project_builder.rs

@@ -0,0 +1,106 @@
+use error_stack::{Result, ResultExt};
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::{
+    collections::HashMap,
+    fs::{self, File, OpenOptions},
+    io::{BufReader, BufWriter},
+    path::PathBuf,
+    sync::Mutex,
+};
+
+use crate::project::{Error, ProjectFile};
+
+pub(crate) fn build_project_file(path: PathBuf, use_cache: bool) -> ProjectFile {
+    if !use_cache {
+        return build_project_file_without_cache(&path);
+    }
+
+    if let Ok(Some(cached_project_file)) = get_project_file_cache(&path) {
+        return cached_project_file;
+    }
+
+    let proejct_file = build_project_file_without_cache(&path);
+
+    if let Ok(mut cache) = PROJECT_FILE_CACHE.lock() {
+        cache.insert(path.clone(), None);
+    }
+    proejct_file
+}
+
+pub(crate) fn build_project_file_without_cache(path: &PathBuf) -> ProjectFile {
+    let content = match std::fs::read_to_string(path) {
+        Ok(content) => content,
+        Err(_) => {
+            return ProjectFile {
+                path: path.clone(),
+                owner: None,
+            }
+        }
+    };
+
+    let first_line = content.lines().next();
+    let Some(first_line) = first_line else {
+        return ProjectFile {
+            path: path.clone(),
+            owner: None,
+        };
+    };
+
+    let owner = TEAM_REGEX
+        .captures(first_line)
+        .and_then(|cap| cap.get(1))
+        .map(|m| m.as_str().to_string());
+
+    ProjectFile { path: path.clone(), owner }
+}
+
+lazy_static! {
+    static ref TEAM_REGEX: Regex = Regex::new(r#"^(?:#|//) @team (.*)$"#).expect("error compiling regular expression");
+    static ref PROJECT_FILE_CACHE: Box<Mutex<HashMap<PathBuf, Option<String>>>> =
+        Box::new(Mutex::new(load_cache().unwrap_or_else(|_| HashMap::with_capacity(10000))));
+}
+
+fn load_cache() -> Result<HashMap<PathBuf, Option<String>>, Error> {
+    let cache_path = get_cache_path();
+    if !cache_path.exists() {
+        return Ok(HashMap::with_capacity(10000));
+    }
+
+    let file = File::open(cache_path).change_context(Error::Io)?;
+    let reader = BufReader::new(file);
+    serde_json::from_reader(reader).change_context(Error::SerdeJson)
+}
+
+pub(crate) fn save_cache() -> Result<(), Error> {
+    let cache_path = get_cache_path();
+    let file = OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(cache_path)
+        .change_context(Error::Io)?;
+
+    let writer = BufWriter::new(file);
+    let cache = PROJECT_FILE_CACHE.lock().map_err(|_| Error::Io)?;
+    serde_json::to_writer(writer, &*cache).change_context(Error::SerdeJson)
+}
+
+fn get_cache_path() -> PathBuf {
+    let cache_dir = PathBuf::from("tmp/cache/codeowners");
+    fs::create_dir_all(&cache_dir).unwrap();
+
+    cache_dir.join("project_file_cache.json")
+}
+
+fn get_project_file_cache(path: &PathBuf) -> Result<Option<ProjectFile>, Error> {
+    if let Ok(cache) = PROJECT_FILE_CACHE.lock() {
+        if let Some(cached_owner) = cache.get(path) {
+            return Ok(Some(ProjectFile {
+                path: path.clone(),
+                owner: cached_owner.clone(),
+            }));
+        }
+    }
+    Ok(None)
+}