code_ownership 2.1.0 → 2.1.2

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/ownership/validator.rs

@@ -21,6 +21,7 @@ pub struct Validator {
     pub project: Arc<Project>,
     pub mappers: Vec<Box<dyn Mapper>>,
     pub file_generator: FileGenerator,
+    pub executable_name: String,
 }
 
 #[derive(Debug)]
@@ -28,7 +29,7 @@ enum Error {
     InvalidTeam { name: String, path: PathBuf },
     FileWithoutOwner { path: PathBuf },
     FileWithMultipleOwners { path: PathBuf, owners: Vec<Owner> },
-    CodeownershipFileIsStale,
+    CodeownershipFileIsStale { executable_name: String },
 }
 
 #[derive(Debug)]
@@ -130,12 +131,16 @@ impl Validator {
         match self.project.get_codeowners_file() {
             Ok(current_file) => {
                 if generated_file != current_file {
-                    vec![Error::CodeownershipFileIsStale]
+                    vec![Error::CodeownershipFileIsStale {
+                        executable_name: self.executable_name.to_string(),
+                    }]
                 } else {
                     vec![]
                 }
             }
-            Err(_) => vec![Error::CodeownershipFileIsStale], // Treat any read error as stale file
+            Err(_) => vec![Error::CodeownershipFileIsStale {
+                executable_name: self.executable_name.to_string(),
+            }],
         }
     }
 
@@ -161,13 +166,13 @@ impl Validator {
 impl Error {
     pub fn category(&self) -> String {
         match self {
-            Error::FileWithoutOwner { path: _ } => "Some files are missing ownership".to_owned(),
-            Error::FileWithMultipleOwners { path: _, owners: _ } => "Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways".to_owned(),
-            Error::CodeownershipFileIsStale => {
-                "CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file".to_owned()
+                Error::FileWithoutOwner { path: _ } => "Some files are missing ownership".to_owned(),
+                Error::FileWithMultipleOwners { path: _, owners: _ } => "Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways".to_owned(),
+                Error::CodeownershipFileIsStale { executable_name } => {
+                    format!("CODEOWNERS out of date. Run `{}` to update the CODEOWNERS file", executable_name)
+                }
+                Error::InvalidTeam { name: _, path: _ } => "Found invalid team annotations".to_owned(),
             }
-            Error::InvalidTeam { name: _, path: _ } => "Found invalid team annotations".to_owned(),
-        }
     }
 
     pub fn messages(&self) -> Vec<String> {
@@ -187,7 +192,7 @@ impl Error {
 
                 vec![messages.join("\n")]
             }
-            Error::CodeownershipFileIsStale => vec![],
+            Error::CodeownershipFileIsStale { executable_name: _ } => vec![],
             Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
         }
     }

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/ownership.rs

@@ -123,6 +123,7 @@ impl Ownership {
             project: self.project.clone(),
             mappers: self.mappers(),
             file_generator: FileGenerator { mappers: self.mappers() },
+            executable_name: self.project.executable_name.clone(),
         };
 
         validator.validate()

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/project.rs

@@ -17,6 +17,7 @@ pub struct Project {
     pub codeowners_file_path: PathBuf,
     pub directory_codeowner_files: Vec<DirectoryCodeownersFile>,
     pub teams_by_name: HashMap<String, Team>,
+    pub executable_name: String,
 }
 
 #[derive(Clone, Debug)]
@@ -111,6 +112,7 @@ pub mod deserializers {
     #[derive(Deserialize)]
     pub struct RubyPackage {
         pub owner: Option<String>,
+        pub metadata: Option<Metadata>,
     }
 
     #[derive(Deserialize)]
@@ -219,6 +221,7 @@ mod tests {
             codeowners_file_path: PathBuf::from(".github/CODEOWNERS"),
             directory_codeowner_files: vec![],
             teams_by_name: HashMap::new(),
+            executable_name: "codeowners generate".to_string(),
         };
 
         let map = project.vendored_gem_by_name();

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/project_builder.rs

@@ -8,7 +8,7 @@ use error_stack::{Report, Result, ResultExt};
 use fast_glob::glob_match;
 use ignore::{DirEntry, WalkBuilder, WalkParallel, WalkState};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use tracing::{instrument, warn};
+use tracing::instrument;
 
 use crate::{
     cache::Cache,
@@ -178,9 +178,17 @@ impl<'a> ProjectBuilder<'a> {
     }
 
     fn build_project_from_entry_types(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Error> {
-        let (project_files, packages, vendored_gems, directory_codeowners, teams): (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = entry_types
+        type Accumulator = (
+            Vec<ProjectFile>,
+            Vec<Package>,
+            Vec<VendoredGem>,
+            Vec<DirectoryCodeownersFile>,
+            Vec<Team>,
+        );
+
+        let (project_files, packages, vendored_gems, directory_codeowners, teams): Accumulator = entry_types
             .into_par_iter()
-            .fold(
+            .try_fold(
                 || {
                     (
                         Vec::<ProjectFile>::with_capacity(INITIAL_VECTOR_CAPACITY),
@@ -197,18 +205,20 @@ impl<'a> ProjectBuilder<'a> {
                         }
                         EntryType::Directory(absolute_path, relative_path) => {
                             if relative_path.parent() == Some(Path::new(&self.config.vendored_gems_path)) {
-                                if let Some(file_name) = relative_path.file_name() {
-                                    gems.push(VendoredGem {
-                                        path: absolute_path,
-                                        name: file_name.to_string_lossy().to_string(),
-                                    });
-                                } else {
-                                    warn!("Vendored gem path without file name: {:?}", relative_path);
-                                }
+                                let file_name = relative_path.file_name().ok_or_else(|| {
+                                    error_stack::report!(Error::Io)
+                                        .attach_printable(format!("Vendored gem path has no file name: {}", relative_path.display()))
+                                })?;
+                                gems.push(VendoredGem {
+                                    path: absolute_path,
+                                    name: file_name.to_string_lossy().to_string(),
+                                });
                             }
                         }
                         EntryType::RubyPackage(absolute_path, relative_path) => {
-                            match ruby_package_owner(&absolute_path) {
+                            match ruby_package_owner(&absolute_path)
+                                .attach_printable_lazy(|| format!("Failed to read ruby package: {}", absolute_path.display()))
+                            {
                                 Ok(Some(owner)) => {
                                     pkgs.push(Package {
                                         path: relative_path.clone(),
@@ -217,13 +227,13 @@ impl<'a> ProjectBuilder<'a> {
                                     });
                                 }
                                 Ok(None) => { /* No owner, do nothing */ }
-                                Err(e) => {
-                                    warn!("Error reading ruby package owner for {:?}: {:?}", absolute_path, e);
-                                }
+                                Err(e) => return Err(e),
                             }
                         }
                         EntryType::JavascriptPackage(absolute_path, relative_path) => {
-                            match javascript_package_owner(&absolute_path) {
+                            match javascript_package_owner(&absolute_path)
+                                .attach_printable_lazy(|| format!("Failed to read javascript package: {}", absolute_path.display()))
+                            {
                                 Ok(Some(owner)) => {
                                     pkgs.push(Package {
                                         path: relative_path.clone(),
@@ -232,37 +242,31 @@ impl<'a> ProjectBuilder<'a> {
                                     });
                                 }
                                 Ok(None) => { /* No owner, do nothing */ }
-                                Err(e) => {
-                                    warn!("Error reading javascript package owner for {:?}: {:?}", absolute_path, e);
-                                }
+                                Err(e) => return Err(e),
                             }
                         }
-                        EntryType::CodeownerFile(absolute_path, relative_path) => match std::fs::read_to_string(&absolute_path) {
-                            Ok(owner) => {
-                                let owner = owner.trim().to_owned();
-                                codeowners.push(DirectoryCodeownersFile {
-                                    path: relative_path.clone(),
-                                    owner,
-                                });
-                            }
-                            Err(e) => {
-                                warn!("Error reading codeowner file for {:?}: {:?}", absolute_path, e);
-                            }
-                        },
-                        EntryType::TeamFile(absolute_path, _relative_path) => match Team::from_team_file_path(absolute_path) {
-                            Ok(team) => {
-                                team_files.push(team);
-                            }
-                            Err(e) => {
-                                warn!("Error building team from team file path: {}", e);
-                            }
-                        },
+                        EntryType::CodeownerFile(absolute_path, relative_path) => {
+                            let owner = std::fs::read_to_string(&absolute_path)
+                                .change_context(Error::Io)
+                                .attach_printable_lazy(|| format!("Failed to read codeowner file: {}", absolute_path.display()))?;
+                            let owner = owner.trim().to_owned();
+                            codeowners.push(DirectoryCodeownersFile {
+                                path: relative_path.clone(),
+                                owner,
+                            });
+                        }
+                        EntryType::TeamFile(absolute_path, _relative_path) => {
+                            let team = Team::from_team_file_path(absolute_path.clone())
+                                .change_context(Error::Io)
+                                .attach_printable_lazy(|| format!("Failed to read team file: {}", absolute_path.display()))?;
+                            team_files.push(team);
+                        }
                         EntryType::NullEntry() => {}
                     }
-                    (project_files, pkgs, gems, codeowners, team_files)
+                    Ok((project_files, pkgs, gems, codeowners, team_files))
                 },
             )
-            .reduce(
+            .try_reduce(
                 || (Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new()),
                 |mut acc, item| {
                     acc.0.extend(item.0);
@@ -270,9 +274,9 @@ impl<'a> ProjectBuilder<'a> {
                     acc.2.extend(item.2);
                     acc.3.extend(item.3);
                     acc.4.extend(item.4);
-                    acc
+                    Ok(acc)
                 },
-            );
+            )?;
         let teams_by_name = teams
             .iter()
             .flat_map(|team| vec![(team.name.clone(), team.clone()), (team.github_team.clone(), team.clone())])
@@ -294,6 +298,7 @@ impl<'a> ProjectBuilder<'a> {
             codeowners_file_path: self.codeowners_file_path.to_path_buf(),
             directory_codeowner_files: directory_codeowners,
             teams_by_name,
+            executable_name: self.config.executable_name.clone(),
         })
     }
 }
@@ -309,7 +314,19 @@ 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)?;
 
-    Ok(deserializer.owner)
+    let top_level_owner = deserializer.owner;
+    let metadata_owner = deserializer.metadata.and_then(|metadata| metadata.owner);
+
+    // Error if both are present with different values
+    match (top_level_owner.as_ref(), metadata_owner.as_ref()) {
+        (Some(top), Some(meta)) if top != meta => Err(error_stack::report!(Error::Io).attach_printable(format!(
+            "Package at {} has conflicting owners: 'owner: {}' vs 'metadata.owner: {}'. Please use only one.",
+            path.display(),
+            top,
+            meta
+        ))),
+        _ => Ok(top_level_owner.or(metadata_owner)),
+    }
 }
 
 fn javascript_package_owner(path: &Path) -> Result<Option<String>, Error> {
@@ -334,4 +351,54 @@ mod tests {
     fn test_glob_match() {
         assert!(glob_match(OWNED_GLOB, "script/.eslintrc.js"));
     }
+
+    #[test]
+    fn test_ruby_package_owner_top_level() {
+        let yaml = "owner: TeamA\n";
+        let temp_file = tempfile::NamedTempFile::new().unwrap();
+        std::fs::write(temp_file.path(), yaml).unwrap();
+
+        let owner = ruby_package_owner(temp_file.path()).unwrap();
+        assert_eq!(owner, Some("TeamA".to_string()));
+    }
+
+    #[test]
+    fn test_ruby_package_owner_metadata() {
+        let yaml = "metadata:\n  owner: TeamB\n";
+        let temp_file = tempfile::NamedTempFile::new().unwrap();
+        std::fs::write(temp_file.path(), yaml).unwrap();
+
+        let owner = ruby_package_owner(temp_file.path()).unwrap();
+        assert_eq!(owner, Some("TeamB".to_string()));
+    }
+
+    #[test]
+    fn test_ruby_package_owner_errors_when_both_present_and_different() {
+        let yaml = "owner: TeamA\nmetadata:\n  owner: TeamB\n";
+        let temp_file = tempfile::NamedTempFile::new().unwrap();
+        std::fs::write(temp_file.path(), yaml).unwrap();
+
+        let result = ruby_package_owner(temp_file.path());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_ruby_package_owner_allows_both_when_same() {
+        let yaml = "owner: TeamA\nmetadata:\n  owner: TeamA\n";
+        let temp_file = tempfile::NamedTempFile::new().unwrap();
+        std::fs::write(temp_file.path(), yaml).unwrap();
+
+        let owner = ruby_package_owner(temp_file.path()).unwrap();
+        assert_eq!(owner, Some("TeamA".to_string()));
+    }
+
+    #[test]
+    fn test_ruby_package_owner_no_owner() {
+        let yaml = "name: my_package\n";
+        let temp_file = tempfile::NamedTempFile::new().unwrap();
+        std::fs::write(temp_file.path(), yaml).unwrap();
+
+        let owner = ruby_package_owner(temp_file.path()).unwrap();
+        assert_eq!(owner, None);
+    }
 }

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/runner/api.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 
-use crate::ownership::FileOwner;
 use crate::project::Team;
+use crate::{ownership::FileOwner, runner::config_from_run_config};
 
-use super::{Error, ForFileResult, RunConfig, RunResult, config_from_path, run};
+use super::{Error, ForFileResult, RunConfig, RunResult, run};
 
 pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool, json: bool) -> RunResult {
     if from_codeowners {
@@ -38,7 +38,7 @@ pub fn crosscheck_owners(run_config: &RunConfig) -> RunResult {
 
 // Returns all owners for a file without creating a Runner (performance optimized)
 pub fn owners_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Vec<FileOwner>, Error> {
-    let config = config_from_path(&run_config.config_path)?;
+    let config = config_from_run_config(run_config)?;
     use crate::ownership::file_owner_resolver::find_file_owners;
     let owners = find_file_owners(&run_config.project_root, &config, std::path::Path::new(file_path)).map_err(Error::Io)?;
     Ok(owners)
@@ -60,10 +60,11 @@ pub fn teams_for_files_from_codeowners(
     run_config: &RunConfig,
     file_paths: &[String],
 ) -> error_stack::Result<HashMap<String, Option<Team>>, Error> {
-    let config = config_from_path(&run_config.config_path)?;
+    let config = config_from_run_config(run_config)?;
+    let codeowners_file_path = super::resolve_codeowners_file_path(run_config, &config);
     let res = crate::ownership::codeowners_query::teams_for_files_from_codeowners(
         &run_config.project_root,
-        &run_config.codeowners_file_path,
+        &codeowners_file_path,
         &config.team_file_glob,
         file_paths,
     )
@@ -80,7 +81,7 @@ pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) ->
 
 // Fast path that avoids creating a full Runner for single file queries
 fn for_file_optimized(run_config: &RunConfig, file_path: &str, json: bool) -> RunResult {
-    let config = match config_from_path(&run_config.config_path) {
+    let config = match config_from_run_config(run_config) {
         Ok(c) => c,
         Err(err) => {
             return RunResult::from_io_error(Error::Io(err.to_string()), json);

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/runner/types.rs

@@ -14,9 +14,10 @@ pub struct RunResult {
 #[derive(Debug, Clone)]
 pub struct RunConfig {
     pub project_root: PathBuf,
-    pub codeowners_file_path: PathBuf,
+    pub codeowners_file_path: Option<PathBuf>,
     pub config_path: PathBuf,
     pub no_cache: bool,
+    pub executable_name: Option<String>,
 }
 
 #[derive(Debug, Serialize)]

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/runner.rs

@@ -1,6 +1,8 @@
-use std::{path::Path, process::Command};
+use std::path::{Path, PathBuf};
+use std::process::Command;
 
 use error_stack::{Result, ResultExt};
+use fast_glob::glob_match;
 use serde::Serialize;
 
 use crate::{
@@ -20,6 +22,7 @@ pub struct Runner {
     ownership: Ownership,
     cache: Cache,
     config: Config,
+    codeowners_file_path: PathBuf,
 }
 
 pub fn version() -> String {
@@ -36,7 +39,7 @@ where
         Ok(runner) => runner,
         Err(err) => {
             return RunResult {
-                io_errors: vec![err.to_string()],
+                io_errors: vec![format!("{:?}", err)],
                 ..Default::default()
             };
         }
@@ -44,15 +47,41 @@ where
     runnable(runner)
 }
 
-pub(crate) fn config_from_path(path: &Path) -> Result<Config, Error> {
-    match crate::config::Config::load_from_path(path) {
-        Ok(c) => Ok(c),
+pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, Error> {
+    match crate::config::Config::load_from_path(&run_config.config_path) {
+        Ok(mut c) => {
+            if let Some(executable_name) = &run_config.executable_name {
+                c.executable_name = executable_name.clone();
+            }
+            Ok(c)
+        }
         Err(msg) => Err(error_stack::Report::new(Error::Io(msg))),
     }
 }
+
+/// Resolves the CODEOWNERS file path with the following priority:
+/// 1. Explicit `codeowners_file_path` in `RunConfig` (if provided from e.g. CLI flag)
+/// 2. `CODEOWNERS_PATH` environment variable (if set and not empty)
+/// 3. Computed from `codeowners_path` directory path in config + "CODEOWNERS" filename
+/// 4. Default fallback to `.github/CODEOWNERS` (using default codeowners_path from config)
+pub(crate) fn resolve_codeowners_file_path(run_config: &RunConfig, config: &Config) -> PathBuf {
+    if let Some(ref path) = run_config.codeowners_file_path {
+        return path.clone();
+    }
+
+    if let Ok(env_path) = std::env::var("CODEOWNERS_PATH")
+        && !env_path.is_empty()
+    {
+        return run_config.project_root.join(env_path);
+    }
+
+    run_config.project_root.join(&config.codeowners_path).join("CODEOWNERS")
+}
+
 impl Runner {
     pub fn new(run_config: &RunConfig) -> Result<Self, Error> {
-        let config = config_from_path(&run_config.config_path)?;
+        let config = config_from_run_config(run_config)?;
+        let codeowners_file_path = resolve_codeowners_file_path(run_config, &config);
 
         let cache: Cache = if run_config.no_cache {
             NoopCache::default().into()
@@ -66,12 +95,7 @@ impl Runner {
                 .into()
         };
 
-        let mut project_builder = ProjectBuilder::new(
-            &config,
-            run_config.project_root.clone(),
-            run_config.codeowners_file_path.clone(),
-            &cache,
-        );
+        let mut project_builder = ProjectBuilder::new(&config, run_config.project_root.clone(), codeowners_file_path.clone(), &cache);
         let project = project_builder.build().change_context(Error::Io(format!(
             "Can't build project: {}",
             &run_config.config_path.to_string_lossy()
@@ -88,6 +112,7 @@ impl Runner {
             ownership,
             cache,
             config,
+            codeowners_file_path,
         })
     }
 
@@ -113,7 +138,25 @@ impl Runner {
         let mut unowned_files = Vec::new();
         let mut io_errors = Vec::new();
 
-        for file_path in file_paths {
+        // Filter files based on owned_globs and unowned_globs configuration
+        // Only validate files that match owned_globs and don't match unowned_globs
+        let filtered_paths: Vec<String> = file_paths
+            .into_iter()
+            .filter(|file_path| {
+                // Convert to relative path for glob matching
+                let path = Path::new(file_path);
+                let relative_path = if path.is_absolute() {
+                    path.strip_prefix(&self.run_config.project_root).unwrap_or(path)
+                } else {
+                    path
+                };
+
+                // Mirror the filtering applied by ProjectBuilder when walking the project
+                matches_globs(relative_path, &self.config.owned_globs) && !matches_globs(relative_path, &self.config.unowned_globs)
+            })
+            .collect();
+
+        for file_path in filtered_paths {
             match team_for_file_from_codeowners(&self.run_config, &file_path) {
                 Ok(Some(_)) => {}
                 Ok(None) => unowned_files.push(file_path),
@@ -145,10 +188,10 @@ impl Runner {
 
     pub fn generate(&self, git_stage: bool) -> RunResult {
         let content = self.ownership.generate_file();
-        if let Some(parent) = &self.run_config.codeowners_file_path.parent() {
+        if let Some(parent) = &self.codeowners_file_path.parent() {
             let _ = std::fs::create_dir_all(parent);
         }
-        match std::fs::write(&self.run_config.codeowners_file_path, content) {
+        match std::fs::write(&self.codeowners_file_path, content) {
             Ok(_) => {
                 if git_stage {
                     self.git_stage();
@@ -173,7 +216,7 @@ impl Runner {
     fn git_stage(&self) {
         let _ = Command::new("git")
             .arg("add")
-            .arg(&self.run_config.codeowners_file_path)
+            .arg(&self.codeowners_file_path)
             .current_dir(&self.run_config.project_root)
             .output();
     }
@@ -389,6 +432,14 @@ impl RunResult {
     }
 }
 
+/// Returns true if `path` matches any of the provided glob patterns.
+fn matches_globs(path: &Path, globs: &[String]) -> bool {
+    match path.to_str() {
+        Some(s) => globs.iter().any(|glob| glob_match(glob, s)),
+        None => false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.2}/src/tracked_files.rs

@@ -6,7 +6,7 @@ use std::{
 
 pub(crate) fn find_tracked_files(base_path: &Path) -> Option<HashMap<PathBuf, bool>> {
     let output = Command::new("git")
-        .args(["ls-files", "--full-name", "-z", "--", "."])
+        .args(["ls-files", "-z", "--", "."])
         .current_dir(base_path)
         .output()
         .ok()?;
@@ -55,4 +55,32 @@ mod tests {
         assert!(tracked.len() == 1);
         assert!(tracked.get(&tmp_dir.path().join("test.txt")).unwrap());
     }
+
+    #[test]
+    fn test_tracked_files_from_subdirectory() {
+        let tmp_dir = tempfile::tempdir().unwrap();
+        let backend_dir = tmp_dir.path().join("backend");
+        let tracked_file = backend_dir.join("app/models/foo.rb");
+
+        std::process::Command::new("git")
+            .arg("init")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to run git init");
+
+        std::fs::create_dir_all(tracked_file.parent().unwrap()).unwrap();
+        std::fs::write(&tracked_file, "class Foo; end").unwrap();
+        std::fs::write(tmp_dir.path().join("README.md"), "readme").unwrap();
+
+        std::process::Command::new("git")
+            .args(["add", "--all"])
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to add tracked files");
+
+        let tracked = find_tracked_files(&backend_dir).unwrap();
+        assert_eq!(tracked.len(), 1);
+        assert!(tracked.get(&tracked_file).unwrap());
+        assert!(!tracked.contains_key(&backend_dir.join("backend/app/models/foo.rb")));
+    }
 }

data/ext/cargo-vendor/codeowners-0.3.2/tests/codeowners_path_test.rs

@@ -0,0 +1,92 @@
+use predicates::prelude::predicate;
+use std::{error::Error, fs, path::Path};
+
+mod common;
+
+use common::OutputStream;
+use common::git_add_all_files;
+use common::run_codeowners;
+use common::setup_fixture_repo;
+
+#[test]
+fn test_generate_uses_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    let fixture_root = Path::new("tests/fixtures/custom_codeowners_path");
+    let temp_dir = setup_fixture_repo(fixture_root);
+    let project_root = temp_dir.path();
+    git_add_all_files(project_root);
+
+    let mut cmd = assert_cmd::Command::cargo_bin("codeowners")?;
+    cmd.arg("--project-root")
+        .arg(project_root)
+        .arg("--no-cache")
+        .arg("generate")
+        .assert()
+        .success();
+
+    let expected_codeowners: String = std::fs::read_to_string(Path::new("tests/fixtures/custom_codeowners_path/expected/CODEOWNERS"))?;
+    let actual_codeowners: String = std::fs::read_to_string(project_root.join("docs/CODEOWNERS"))?;
+
+    assert_eq!(expected_codeowners, actual_codeowners);
+
+    Ok(())
+}
+
+#[test]
+fn test_cli_overrides_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    fs::create_dir_all("tmp")?;
+    let codeowners_abs = std::env::current_dir()?.join("tmp/CODEOWNERS");
+    let codeowners_str = codeowners_abs.to_str().unwrap();
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "generate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    let expected_codeowners: String = std::fs::read_to_string(Path::new("tests/fixtures/custom_codeowners_path/expected/CODEOWNERS"))?;
+    let actual_codeowners: String = std::fs::read_to_string(Path::new("tmp/CODEOWNERS"))?;
+
+    assert_eq!(expected_codeowners, actual_codeowners);
+
+    Ok(())
+}
+
+#[test]
+fn test_validate_uses_codeowners_path_from_config() -> Result<(), Box<dyn Error>> {
+    run_codeowners(
+        "custom_codeowners_path",
+        &["validate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    Ok(())
+}
+
+#[test]
+fn test_validate_uses_cli_override() -> Result<(), Box<dyn Error>> {
+    fs::create_dir_all("tmp")?;
+    let codeowners_abs = std::env::current_dir()?.join("tmp/CODEOWNERS");
+    let codeowners_str = codeowners_abs.to_str().unwrap();
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "generate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    run_codeowners(
+        "custom_codeowners_path",
+        &["--codeowners-file-path", codeowners_str, "validate"],
+        true,
+        OutputStream::Stdout,
+        predicate::eq(""),
+    )?;
+
+    Ok(())
+}