code_ownership 2.1.1 → 2.1.3

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

@@ -49,17 +49,37 @@ impl FileGenerator {
 }
 
 pub fn compare_lines(a: &String, b: &String) -> Ordering {
-    if let Some((prefix, _)) = a.split_once("**")
-        && b.starts_with(prefix)
-    {
-        return Ordering::Less;
+    let path_a = extract_path(a);
+    let path_b = extract_path(b);
+
+    let mut comps_a = path_a.split('/');
+    let mut comps_b = path_b.split('/');
+
+    loop {
+        match (comps_a.next(), comps_b.next()) {
+            (None, None) => return a.cmp(b),
+            (None, Some(_)) => return Ordering::Less,
+            (Some(_), None) => return Ordering::Greater,
+            (Some(ca), Some(cb)) => match compare_component(ca, cb) {
+                Ordering::Equal => continue,
+                ord => return ord,
+            },
+        }
     }
-    if let Some((prefix, _)) = b.split_once("**")
-        && a.starts_with(prefix)
-    {
-        return Ordering::Greater;
+}
+
+fn extract_path(line: &str) -> &str {
+    let stripped = line.strip_prefix("# ").unwrap_or(line);
+    stripped.split_once(' ').map(|(p, _)| p).unwrap_or(stripped)
+}
+
+fn compare_component(a: &str, b: &str) -> Ordering {
+    match (a == "**", b == "**") {
+        (true, true) => Ordering::Equal,
+        (true, false) => Ordering::Less,
+        (false, true) => Ordering::Greater,
+        (false, false) => a.cmp(b),
     }
-    a.cmp(b)
 }
 
 #[cfg(test)]
@@ -181,6 +201,96 @@ mod tests {
         assert_eq!(sorted, vec!["/directory/owner1/** @foo", "/directory/owner2/** @bar"]);
     }
 
+    #[test]
+    fn test_compare_lines_is_antisymmetric_for_shared_double_star_prefix() {
+        let a = "/foo/**/*bar* @org/example-team".to_string();
+        let b = "/foo/**/baz/**/* @org/example-team".to_string();
+
+        assert_eq!(compare_lines(&a, &b), Ordering::Less);
+        assert_eq!(compare_lines(&b, &a), Ordering::Greater);
+
+        let mut forward = vec![a.clone(), b.clone()];
+        let mut reverse = vec![b.clone(), a.clone()];
+        forward.sort_by(compare_lines);
+        reverse.sort_by(compare_lines);
+        assert_eq!(forward, reverse);
+        assert_eq!(forward, vec![a, b]);
+    }
+
+    fn special_character_set() -> Vec<String> {
+        vec![
+            "/directory/** @bop".to_string(),
+            "/directory/owner/** @bar".to_string(),
+            "/directory/owner/(my_folder)/**/** @foo".to_string(),
+            "/directory/owner/(my_folder)/without_glob @zoo".to_string(),
+            "/directory/owner/my_folder/** @baz".to_string(),
+        ]
+    }
+
+    #[test]
+    fn test_compare_lines_is_antisymmetric_across_special_character_set() {
+        let lines = special_character_set();
+        for x in &lines {
+            assert_eq!(compare_lines(x, x), Ordering::Equal);
+            for y in &lines {
+                if x == y {
+                    continue;
+                }
+                let xy = compare_lines(x, y);
+                let yx = compare_lines(y, x);
+                assert_eq!(xy.reverse(), yx, "asymmetric for {x:?} vs {y:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn test_compare_lines_is_transitive_across_special_character_set() {
+        let lines = special_character_set();
+        for x in &lines {
+            for y in &lines {
+                for z in &lines {
+                    let xy = compare_lines(x, y);
+                    let yz = compare_lines(y, z);
+                    let xz = compare_lines(x, z);
+                    if xy != Ordering::Greater && yz != Ordering::Greater {
+                        assert_ne!(xz, Ordering::Greater, "transitivity broken: {x:?} <= {y:?} <= {z:?} but x > z");
+                    }
+                    if xy != Ordering::Less && yz != Ordering::Less {
+                        assert_ne!(xz, Ordering::Less, "transitivity broken: {x:?} >= {y:?} >= {z:?} but x < z");
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_compare_lines_orders_shorter_path_before_longer_extension() {
+        let shorter = "/foo @a".to_string();
+        let longer = "/foo/bar @b".to_string();
+
+        assert_eq!(compare_lines(&shorter, &longer), Ordering::Less);
+        assert_eq!(compare_lines(&longer, &shorter), Ordering::Greater);
+    }
+
+    #[test]
+    fn test_compare_lines_falls_back_to_full_line_when_paths_equal() {
+        let a = "/foo/** @a".to_string();
+        let b = "/foo/** @b".to_string();
+
+        assert_eq!(compare_lines(&a, &b), Ordering::Less);
+        assert_eq!(compare_lines(&b, &a), Ordering::Greater);
+    }
+
+    #[test]
+    fn test_compare_lines_ignores_disabled_comment_prefix() {
+        let enabled = "/foo/owner/** @bar".to_string();
+        let disabled = "# /foo/owner/** @bar".to_string();
+        let other = "/foo/owner/(extra)/file @baz".to_string();
+
+        assert_eq!(compare_lines(&enabled, &other), compare_lines(&disabled, &other));
+        assert_eq!(compare_lines(&other, &enabled), compare_lines(&other, &disabled));
+    }
+
     #[test]
     fn test_sorting_with_special_characters() {
         let entries = vec![

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

@@ -116,7 +116,7 @@ fn load_teams(project_root: &Path, team_file_globs: &[String]) -> std::result::R
             match Team::from_team_file_path(path.clone()) {
                 Ok(team) => teams.push(team),
                 Err(e) => {
-                    eprintln!("Error parsing team file: {}, path: {}", e, path.display());
+                    eprintln!("Error parsing team file: {e:?}, path: {}", path.display());
                     continue;
                 }
             }
@@ -293,6 +293,8 @@ mod tests {
             vendored_gems_path: vendored_path.to_string(),
             cache_directory: "tmp/cache/codeowners".to_string(),
             ignore_dirs: vec![],
+            executable_name: "codeowners".to_string(),
+            codeowners_path: ".github".to_string(),
         }
     }
 

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/src/ownership/mapper/package_mapper.rs

@@ -95,7 +95,7 @@ impl PackageMapper {
         let packages: Vec<&Package> = packages.iter().filter(|package| &package.package_type == package_type).collect();
 
         // Nested packs can create a duplicate ownership false positive.
-        // We avoid it by treating nested packs as a single top level pack for the purpose of validations
+        // We avoid it by treating nested packs as a single top-level pack for the purposes of validation.
         let packages = remove_nested_packages(&packages);
 
         for package in packages {
@@ -147,7 +147,7 @@ mod tests {
     use std::{error::Error, path::Path};
     #[test]
     fn test_remove_nested_packages() {
-        let packages = vec![
+        let packages = [
             Package {
                 path: Path::new("packs/a/package.yml").to_owned(),
                 package_type: PackageType::Ruby,

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

@@ -48,7 +48,7 @@ impl Display for Source {
             Source::TeamGem => write!(f, "Owner specified in Team YML's `owned_gems`"),
             Source::TeamGlob(glob) => write!(f, "Owner specified in Team YML as an owned_glob `{}`", glob),
             Source::Package(package_path, glob) => {
-                write!(f, "Owner defined in `{}` with implicity owned glob: `{}`", package_path, glob)
+                write!(f, "Owner defined in `{}` with implicitly owned glob: `{}`", package_path, glob)
             }
             Source::TeamYml => write!(f, "Teams own their configuration files"),
         }
@@ -208,7 +208,7 @@ mod tests {
         );
         assert_eq!(
             Source::Package("packs/bam/packag.yml".to_string(), "packs/bam/**/**".to_string()).to_string(),
-            "Owner defined in `packs/bam/packag.yml` with implicity owned glob: `packs/bam/**/**`"
+            "Owner defined in `packs/bam/packag.yml` with implicitly owned glob: `packs/bam/**/**`"
         );
         assert_eq!(Source::TeamYml.to_string(), "Teams own their configuration files");
     }

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

@@ -9,6 +9,7 @@ use error_stack::Context;
 use itertools::Itertools;
 use rayon::prelude::IntoParallelRefIterator;
 use rayon::prelude::ParallelIterator;
+use similar::{ChangeTag, TextDiff};
 use tracing::debug;
 use tracing::instrument;
 
@@ -21,6 +22,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 +30,7 @@ enum Error {
     InvalidTeam { name: String, path: PathBuf },
     FileWithoutOwner { path: PathBuf },
     FileWithMultipleOwners { path: PathBuf, owners: Vec<Owner> },
-    CodeownershipFileIsStale,
+    CodeownershipFileIsStale { executable_name: String, diff: String },
 }
 
 #[derive(Debug)]
@@ -126,16 +128,15 @@ impl Validator {
 
     fn validate_codeowners_file(&self) -> Vec<Error> {
         let generated_file = self.file_generator.generate_file();
+        let current_file = self.project.get_codeowners_file().unwrap_or_default();
 
-        match self.project.get_codeowners_file() {
-            Ok(current_file) => {
-                if generated_file != current_file {
-                    vec![Error::CodeownershipFileIsStale]
-                } else {
-                    vec![]
-                }
-            }
-            Err(_) => vec![Error::CodeownershipFileIsStale], // Treat any read error as stale file
+        if generated_file == current_file {
+            vec![]
+        } else {
+            vec![Error::CodeownershipFileIsStale {
+                executable_name: self.executable_name.to_string(),
+                diff: codeowners_diff(&current_file, &generated_file),
+            }]
         }
     }
 
@@ -158,16 +159,36 @@ impl Validator {
     }
 }
 
+/// Builds a line-oriented diff between the current (on-disk) CODEOWNERS file and the
+/// freshly generated one, so that validation failures explain *what* is out of date
+/// rather than just *that* it is. Only changed lines are emitted: removals (present
+/// on disk but no longer expected) are prefixed with `-` and additions (expected but
+/// missing) are prefixed with `+`.
+fn codeowners_diff(current: &str, generated: &str) -> String {
+    let diff = TextDiff::from_lines(current, generated);
+
+    diff.iter_all_changes()
+        .filter_map(|change| {
+            let line = change.value().trim_end_matches('\n');
+            match change.tag() {
+                ChangeTag::Delete => Some(format!("-{line}")),
+                ChangeTag::Insert => Some(format!("+{line}")),
+                ChangeTag::Equal => None,
+            }
+        })
+        .join("\n")
+}
+
 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, diff: _ } => {
+                    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 +208,13 @@ impl Error {
 
                 vec![messages.join("\n")]
             }
-            Error::CodeownershipFileIsStale => vec![],
+            Error::CodeownershipFileIsStale { executable_name: _, diff } => {
+                if diff.is_empty() {
+                    vec![]
+                } else {
+                    vec![format!("The following changes are required (- current, + expected):\n{diff}")]
+                }
+            }
             Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
         }
     }
@@ -216,3 +243,43 @@ impl Display for Errors {
 }
 
 impl Context for Errors {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use indoc::indoc;
+
+    #[test]
+    fn test_codeowners_diff_reports_added_and_removed_lines() {
+        let current = indoc! {"
+            # Team A
+            /app/a.rb @TeamA
+            /app/old.rb @TeamA
+        "};
+        let generated = indoc! {"
+            # Team A
+            /app/a.rb @TeamA
+            /app/b.rb @TeamB
+        "};
+
+        let diff = codeowners_diff(current, generated);
+
+        assert_eq!(diff, "-/app/old.rb @TeamA\n+/app/b.rb @TeamB");
+    }
+
+    #[test]
+    fn test_codeowners_diff_against_empty_file_is_all_additions() {
+        let generated = "# Team A\n/app/a.rb @TeamA\n";
+
+        let diff = codeowners_diff("", generated);
+
+        assert_eq!(diff, "+# Team A\n+/app/a.rb @TeamA");
+    }
+
+    #[test]
+    fn test_codeowners_diff_is_empty_when_identical() {
+        let file = "# Team A\n/app/a.rb @TeamA\n";
+
+        assert_eq!(codeowners_diff(file, file), "");
+    }
+}

data/ext/cargo-vendor/{codeowners-0.3.0 → codeowners-0.3.3}/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.3}/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.3}/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.3}/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.3}/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)]