lazy static regex

Author: perryqh

Cargo.lock

@@ -14,6 +14,7 @@ fast-glob = "0.4.0"
 ignore = "0.4.23"
 itertools = "0.13.0"
 jwalk = "0.8.1"
+lazy_static = "1.5.0"
 path-clean = "1.0.1"
 rayon = "1.10.0"
 regex = "1.11.1"

Cargo.toml

@@ -23,7 +23,7 @@ pub struct VendoredGem {
     pub name: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ProjectFile {
     pub owner: Option<String>,
     pub path: PathBuf,

src/project.rs

@@ -1,16 +1,16 @@
 use std::{
     fs::File,
-    io::BufRead,
     path::{Path, PathBuf},
 };
 
 use error_stack::{Result, ResultExt};
 use fast_glob::glob_match;
 use ignore::WalkBuilder;
 use jwalk::{DirEntry, WalkDir};
+use lazy_static::lazy_static;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use regex::Regex;
-use tracing::{info, instrument};
+use tracing::instrument;
 
 use crate::{
     config::Config,
@@ -350,41 +350,35 @@ 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> {
-    let regexp = Regex::new(r#"^(?:#|//) @team (.*)$"#).expect("error compiling regular expression");
-
-    info!("opening files to read ownership annotation");
-
-    owned_file_paths
-        .into_par_iter()
-        .map(|path| {
-            let file = File::open(&path).unwrap_or_else(|_| panic!("Couldn't open {}", path.to_string_lossy()));
-            let first_line = std::io::BufReader::new(file).lines().next().transpose();
-            let first_line = first_line.expect("error reading first line");
+    owned_file_paths.into_par_iter().map(build_project_file).collect()
+}
 
-            if first_line.is_none() {
-                return ProjectFile { path, owner: None };
-            }
+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 },
+    };
 
-            if let Some(first_line) = first_line {
-                let capture = regexp.captures(&first_line);
+    let first_line = content.lines().next();
 
-                if let Some(capture) = capture {
-                    let first_capture = capture.get(1);
+    // Early return if empty file
+    let Some(first_line) = first_line else {
+        return ProjectFile { path, owner: None };
+    };
 
-                    if let Some(first_capture) = first_capture {
-                        return ProjectFile {
-                            path,
-                            owner: Some(first_capture.as_str().to_string()),
-                        };
-                    }
-                }
-            }
+    // Use TEAM_REGEX instead of regexp
+    let owner = TEAM_REGEX
+        .captures(first_line)
+        .and_then(|cap| cap.get(1))
+        .map(|m| m.as_str().to_string());
 
-            ProjectFile { path, owner: None }
-        })
-        .collect()
+    ProjectFile { path, owner }
 }
 
 #[cfg(test)]