only validate tracked files using tracked files map

Author: perryqh

src/config.rs

@@ -24,9 +24,6 @@ pub struct Config {
 
     #[serde(default = "default_ignore_dirs")]
     pub ignore_dirs: Vec<String>,
-
-    #[serde(default = "default_codeowners_override_config_file_path")]
-    pub codeowners_override_config_file_path: String,
 }
 
 #[allow(dead_code)]
@@ -63,10 +60,6 @@ fn vendored_gems_path() -> String {
     "vendored/".to_string()
 }
 
-fn default_codeowners_override_config_file_path() -> String {
-    ".codeowners.yml".to_string()
-}
-
 fn default_ignore_dirs() -> Vec<String> {
     vec![
         ".cursor".to_owned(),

src/files.rs

@@ -2,9 +2,9 @@ pub mod cache;
 pub(crate) mod common_test;
 pub mod config;
 pub mod crosscheck;
-pub(crate) mod files;
 pub mod ownership;
 pub(crate) mod project;
 pub mod project_builder;
 pub mod project_file_builder;
 pub mod runner;
+pub(crate) mod tracked_files;

src/lib.rs

@@ -303,7 +303,6 @@ mod tests {
             vendored_gems_path: vendored_path.to_string(),
             cache_directory: "tmp/cache/codeowners".to_string(),
             ignore_dirs: vec![],
-            codeowners_override_config_file_path: ".codeowners.yml".to_string(),
         }
     }
 

src/ownership/for_file_fast.rs

@@ -8,15 +8,14 @@ use error_stack::{Report, Result, ResultExt};
 use fast_glob::glob_match;
 use ignore::{DirEntry, WalkBuilder, WalkParallel, WalkState};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use serde::Deserialize;
 use tracing::{instrument, warn};
 
 use crate::{
     cache::Cache,
     config::Config,
-    files,
     project::{DirectoryCodeownersFile, Error, Package, PackageType, Project, ProjectFile, Team, VendoredGem, deserializers},
     project_file_builder::ProjectFileBuilder,
+    tracked_files,
 };
 
 type AbsolutePath = PathBuf;
@@ -62,17 +61,17 @@ impl<'a> ProjectBuilder<'a> {
         // Prune traversal early: skip heavy and irrelevant directories
         let ignore_dirs = self.config.ignore_dirs.clone();
         let base_path = self.base_path.clone();
-        let untracked_files = if should_skip_untracked_files(&self.base_path, &self.config.codeowners_override_config_file_path) {
-            files::untracked_files(&base_path).unwrap_or_default()
-        } else {
-            vec![]
-        };
+        let tracked_files = tracked_files::find_tracked_files(&self.base_path);
 
         builder.filter_entry(move |entry: &DirEntry| {
             let path = entry.path();
             let file_name = entry.file_name().to_str().unwrap_or("");
-            if !untracked_files.is_empty() && untracked_files.contains(&path.to_path_buf()) {
-                return false;
+            if let Some(tracked_files) = &tracked_files {
+                if let Some(ft) = entry.file_type() {
+                    if ft.is_file() && !tracked_files.contains_key(path) {
+                        return false;
+                    }
+                }
             }
             if let Some(ft) = entry.file_type()
                 && ft.is_dir()
@@ -298,29 +297,6 @@ fn matches_globs(path: &Path, globs: &[String]) -> bool {
     }
 }
 
-fn should_skip_untracked_files(base_path: &Path, codeowners_override_config_file_path: &str) -> bool {
-    let path = base_path.join(codeowners_override_config_file_path);
-    if !path.exists() {
-        return false;
-    }
-    if let Ok(file) = File::open(path) {
-        #[derive(Deserialize)]
-        struct OverrideConfig {
-            #[serde(default)]
-            skip_untracked_files: bool,
-        }
-
-        let config: OverrideConfig = match serde_yaml::from_reader(file) {
-            Ok(cfg) => cfg,
-            Err(_) => return false,
-        };
-
-        return config.skip_untracked_files;
-    }
-
-    false
-}
-
 fn ruby_package_owner(path: &Path) -> Result<Option<String>, Error> {
     let file = File::open(path).change_context(Error::Io)?;
     let deserializer: deserializers::RubyPackage = serde_yaml::from_reader(file).change_context(Error::SerdeYaml)?;

src/project_builder.rs

@@ -0,0 +1,58 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+pub(crate) fn find_tracked_files(base_path: &Path) -> Option<HashMap<PathBuf, bool>> {
+    let output = Command::new("git")
+        .args(["ls-files", "--full-name", "-z", "--", "."])
+        .current_dir(base_path)
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let results: HashMap<PathBuf, bool> = output
+        .stdout
+        .split(|&b| b == b'\0')
+        .filter(|chunk| !chunk.is_empty())
+        .map(|rel| std::str::from_utf8(rel).ok().map(|s| (base_path.join(s), true)))
+        .collect::<Option<HashMap<PathBuf, bool>>>()?;
+
+    Some(results)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_untracked_files() {
+        let tmp_dir = tempfile::tempdir().unwrap();
+        assert!(find_tracked_files(tmp_dir.path()).is_none());
+
+        std::process::Command::new("git")
+            .arg("init")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to run git init");
+
+        std::fs::write(tmp_dir.path().join("test.txt"), "test").unwrap();
+        let tracked = find_tracked_files(tmp_dir.path()).unwrap();
+        assert!(tracked.len() == 0);
+
+        std::process::Command::new("git")
+            .arg("add")
+            .arg("test.txt")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to add test.txt");
+
+        let tracked = find_tracked_files(tmp_dir.path()).unwrap();
+        assert!(tracked.len() == 1);
+        assert!(tracked.get(&tmp_dir.path().join("test.txt")).unwrap());
+    }
+}

src/tracked_files.rs

@@ -36,6 +36,35 @@ pub fn copy_dir_recursive(from: &Path, to: &Path) {
     }
 }
 
+#[allow(dead_code)]
+pub fn git_reset_all(path: &Path) {
+    let status = Command::new("git")
+        .arg("reset")
+        .current_dir(path)
+        .output()
+        .expect("failed to run git reset --all");
+    assert!(
+        status.status.success(),
+        "git reset --all failed: {}",
+        String::from_utf8_lossy(&status.stderr)
+    );
+}
+
+#[allow(dead_code)]
+pub fn git_add_all_files(path: &Path) {
+    let status = Command::new("git")
+        .arg("add")
+        .arg("--all")
+        .current_dir(path)
+        .output()
+        .expect("failed to run git add --all");
+    assert!(
+        status.status.success(),
+        "git add --all failed: {}",
+        String::from_utf8_lossy(&status.stderr)
+    );
+}
+
 #[allow(dead_code)]
 pub fn init_git_repo(path: &Path) {
     let status = Command::new("git")

tests/common/mod.rs

@@ -6,6 +6,8 @@ use std::{error::Error, fs, path::Path, process::Command};
 mod common;
 use common::setup_fixture_repo;
 
+use crate::common::git_add_all_files;
+
 const FIXTURE: &str = "tests/fixtures/valid_project";
 
 #[test]
@@ -22,6 +24,7 @@ fn test_crosscheck_owners_reports_team_mismatch() -> Result<(), Box<dyn Error>>
         "/ruby/app/models/payroll.rb @PaymentsTeam",
     );
     fs::write(&codeowners_path, modified)?;
+    git_add_all_files(project_root);
 
     // Act + Assert
     Command::cargo_bin("codeowners")?
@@ -53,6 +56,7 @@ fn test_crosscheck_owners_reports_unowned_mismatch() -> Result<(), Box<dyn Error
         .map(|l| format!("{}\n", l))
         .collect();
     fs::write(&codeowners_path, modified)?;
+    git_add_all_files(project_root);
 
     // Act + Assert
     Command::cargo_bin("codeowners")?