code_ownership 2.1.4 → 2.2.0

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

@@ -2,10 +2,9 @@ use crate::project::{Project, ProjectFile};
 use core::fmt;
 use std::collections::HashSet;
 use std::fmt::Display;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-use error_stack::Context;
 use itertools::Itertools;
 use rayon::prelude::IntoParallelRefIterator;
 use rayon::prelude::ParallelIterator;
@@ -27,17 +26,38 @@ pub struct Validator {
 
 #[derive(Debug)]
 enum Error {
-    InvalidTeam { name: String, path: PathBuf },
-    FileWithoutOwner { path: PathBuf },
-    FileWithMultipleOwners { path: PathBuf, owners: Vec<Owner> },
-    CodeownershipFileIsStale { executable_name: String, diff: String },
+    InvalidTeam {
+        name: String,
+        path: PathBuf,
+    },
+    /// A `.codeowner` naming a team that isn't registered. Distinct from `InvalidTeam` only
+    /// so the message can name the ancestor the directory now silently inherits from, which
+    /// is the part a reader needs in order to understand what happened. `category()`
+    /// deliberately matches `InvalidTeam` so one typo'd team name across an annotation, a
+    /// `package.yml`, and a `.codeowner` still groups under a single headline.
+    InvalidDirectoryTeam {
+        name: String,
+        path: PathBuf,
+        inherits_from: Option<PathBuf>,
+    },
+    FileWithoutOwner {
+        path: PathBuf,
+    },
+    FileWithMultipleOwners {
+        path: PathBuf,
+        owners: Vec<Owner>,
+    },
+    CodeownershipFileIsStale {
+        executable_name: String,
+        diff: String,
+    },
 }
 
 #[derive(Debug)]
 pub struct Errors(Vec<Error>);
 
 impl Validator {
-    #[instrument(level = "debug", skip_all)]
+    #[instrument(name = "validator_validate", level = "debug", skip_all)]
     pub fn validate(&self) -> Result<(), Errors> {
         let mut validation_errors = Vec::new();
 
@@ -57,6 +77,7 @@ impl Validator {
         }
     }
 
+    #[instrument(name = "validate_invalid_team", level = "debug", skip_all)]
     fn validate_invalid_team(&self) -> Vec<Error> {
         debug!("validating project");
         let mut errors: Vec<Error> = Vec::new();
@@ -65,6 +86,7 @@ impl Validator {
 
         errors.append(&mut self.invalid_team_annotation(&team_names));
         errors.append(&mut self.invalid_package_ownership(&team_names));
+        errors.append(&mut self.invalid_directory_ownership());
 
         errors
     }
@@ -107,6 +129,42 @@ impl Validator {
             .collect()
     }
 
+    /// `DirectoryMapper::entries` skips unresolvable owners, so the directory silently
+    /// inherits its ancestor's owner and nothing else reports the bad name.
+    ///
+    /// Resolves through `teams_by_name` rather than `teams[].name` so the predicate is
+    /// identical to the mapper's lookup: that map is keyed by both `name` and
+    /// `github_team`, and a `.codeowner` holding either one generates a correct line.
+    fn invalid_directory_ownership(&self) -> Vec<Error> {
+        let resolvable_roots: HashSet<&Path> = self
+            .project
+            .directory_codeowner_files
+            .iter()
+            .filter(|directory_codeowner_file| self.project.teams_by_name.contains_key(&directory_codeowner_file.owner))
+            .filter_map(|directory_codeowner_file| directory_codeowner_file.directory_root())
+            .collect();
+
+        self.project
+            .directory_codeowner_files
+            .iter()
+            .flat_map(|directory_codeowner_file| {
+                if !self.project.teams_by_name.contains_key(&directory_codeowner_file.owner) {
+                    Some(Error::InvalidDirectoryTeam {
+                        name: directory_codeowner_file.owner.clone(),
+                        path: self.project.relative_path(&directory_codeowner_file.path).to_owned(),
+                        inherits_from: directory_codeowner_file
+                            .directory_root()
+                            .and_then(|root| root.ancestors().skip(1).find(|ancestor| resolvable_roots.contains(ancestor)))
+                            .map(|ancestor| self.project.relative_path(ancestor).to_owned()),
+                    })
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    #[instrument(name = "validate_file_ownership", level = "debug", skip_all)]
     fn validate_file_ownership(&self) -> Vec<Error> {
         let mut validation_errors = Vec::new();
 
@@ -126,6 +184,7 @@ impl Validator {
         validation_errors
     }
 
+    #[instrument(name = "validate_codeowners_file", level = "debug", skip_all)]
     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();
@@ -140,6 +199,7 @@ impl Validator {
         }
     }
 
+    #[instrument(name = "file_to_owners", level = "debug", skip_all)]
     fn file_to_owners(&self) -> Vec<(&ProjectFile, Vec<Owner>)> {
         let owner_matchers: Vec<OwnerMatcher> = self.mappers.iter().flat_map(|mapper| mapper.owner_matchers()).collect();
         let file_owner_finder = FileOwnerFinder {
@@ -187,7 +247,8 @@ impl Error {
                 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 references".to_owned(),
+                Error::InvalidDirectoryTeam { .. } => "Found invalid team references".to_owned(),
             }
     }
 
@@ -208,18 +269,50 @@ impl Error {
 
                 vec![messages.join("\n")]
             }
-            Error::CodeownershipFileIsStale { executable_name: _, diff } => {
-                if diff.is_empty() {
-                    vec![]
+            // The diff is intentionally *not* rendered as part of the error. It is
+            // surfaced separately as an informational message (see `Errors::info_messages`)
+            // so that a long diff doesn't bury the actionable headline.
+            Error::CodeownershipFileIsStale { .. } => vec![],
+            Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
+            Error::InvalidDirectoryTeam { name, path, inherits_from } => {
+                // `owner` is `content.trim()`, so an empty or whitespace-only file yields "".
+                // Reporting that as `an invalid team - ''` gives no hint the file is empty.
+                let mut message = if name.is_empty() {
+                    format!("- {} is empty and names no team", path.to_string_lossy())
                 } else {
-                    vec![format!("The following changes are required (- current, + expected):\n{diff}")]
+                    format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)
+                };
+                if let Some(inherits_from) = inherits_from {
+                    message.push_str(&format!(
+                        "; this directory is currently inheriting its owner from {}",
+                        inherits_from.to_string_lossy()
+                    ));
                 }
+                vec![message]
             }
-            Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
         }
     }
 }
 
+impl Errors {
+    /// Supplementary detail that explains *what* is wrong without itself being an error.
+    /// The stale-CODEOWNERS diff is surfaced here, as informational output, rather than
+    /// inline with the error so that a long diff doesn't bury the actionable headline in
+    /// CI logs (and so the wrapping `code_ownership` gem raises only the headline rather
+    /// than the entire diff).
+    pub fn info_messages(&self) -> Vec<String> {
+        self.0
+            .iter()
+            .filter_map(|error| match error {
+                Error::CodeownershipFileIsStale { diff, .. } if !diff.is_empty() => {
+                    Some(format!("The following changes are required (- current, + expected):\n{diff}"))
+                }
+                _ => None,
+            })
+            .collect()
+    }
+}
+
 impl Display for Errors {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let grouped_errors = self.0.iter().into_group_map_by(|error| error.category());
@@ -232,7 +325,7 @@ impl Display for Errors {
             let messages = errors.iter().flat_map(|error| error.messages()).sorted().join("\n");
             if !messages.is_empty() {
                 writeln!(f)?;
-                write!(f, "{}", &messages)?;
+                write!(f, "{}", messages)?;
             }
 
             writeln!(f)?;
@@ -242,7 +335,7 @@ impl Display for Errors {
     }
 }
 
-impl Context for Errors {}
+impl core::error::Error for Errors {}
 
 #[cfg(test)]
 mod tests {

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

@@ -116,13 +116,15 @@ impl Ownership {
         }
     }
 
-    #[instrument(level = "debug", skip_all)]
+    #[instrument(name = "ownership_validate", level = "debug", skip_all)]
     pub fn validate(&self) -> Result<(), ValidatorErrors> {
         info!("validating file ownership");
         let validator = Validator {
             project: self.project.clone(),
             mappers: self.mappers(),
-            file_generator: FileGenerator { mappers: self.mappers() },
+            file_generator: FileGenerator {
+                mappers: self.codeowners_file_mappers(),
+            },
             executable_name: self.project.executable_name.clone(),
         };
 
@@ -166,10 +168,13 @@ impl Ownership {
     #[instrument(level = "debug", skip_all)]
     pub fn generate_file(&self) -> String {
         info!("generating codeowners file");
-        let file_generator = FileGenerator { mappers: self.mappers() };
+        let file_generator = FileGenerator {
+            mappers: self.codeowners_file_mappers(),
+        };
         file_generator.generate_file()
     }
 
+    #[instrument(name = "mapper_build", level = "debug", skip_all)]
     fn mappers(&self) -> Vec<Box<dyn Mapper>> {
         vec![
             Box::new(TeamFileMapper::build(self.project.clone())),
@@ -181,6 +186,20 @@ impl Ownership {
             Box::new(TeamGemMapper::build(self.project.clone())),
         ]
     }
+
+    // GitHub applies the last matching CODEOWNERS line, so annotations are written last: an annotated
+    // file can still match a broader team glob that excludes it through unowned_globs.
+    fn codeowners_file_mappers(&self) -> Vec<Box<dyn Mapper>> {
+        vec![
+            Box::new(TeamGlobMapper::build(self.project.clone())),
+            Box::new(DirectoryMapper::build(self.project.clone())),
+            Box::new(RubyPackageMapper::build(self.project.clone())),
+            Box::new(JavascriptPackageMapper::build(self.project.clone())),
+            Box::new(TeamYmlMapper::build(self.project.clone())),
+            Box::new(TeamGemMapper::build(self.project.clone())),
+            Box::new(TeamFileMapper::build(self.project.clone())),
+        ]
+    }
 }
 
 #[cfg(test)]

data/ext/cargo-vendor/{codeowners-0.3.3 → codeowners-0.5.0}/src/project.rs

@@ -6,7 +6,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use error_stack::{Context, Result, ResultExt};
+use error_stack::{Report, ResultExt};
 
 pub struct Project {
     pub base_path: PathBuf,
@@ -44,7 +44,7 @@ pub struct Team {
 }
 
 impl Team {
-    pub fn from_team_file_path(absolute_path: PathBuf) -> Result<Self, Error> {
+    pub fn from_team_file_path(absolute_path: PathBuf) -> Result<Self, Report<Error>> {
         let file = File::open(&absolute_path).change_context(Error::Io)?;
         let deserializer: deserializers::Team = serde_yaml::from_reader(file).change_context(Error::SerdeYaml)?;
         Ok(Self {
@@ -167,10 +167,10 @@ impl fmt::Display for Error {
     }
 }
 
-impl Context for Error {}
+impl core::error::Error for Error {}
 
 impl Project {
-    pub fn get_codeowners_file(&self) -> Result<String, Error> {
+    pub fn get_codeowners_file(&self) -> Result<String, Report<Error>> {
         let codeowners_file: String = if self.codeowners_file_path.exists() {
             std::fs::read_to_string(&self.codeowners_file_path).change_context(Error::Io)?
         } else {

data/ext/cargo-vendor/{codeowners-0.3.3 → codeowners-0.5.0}/src/project_builder.rs

@@ -4,7 +4,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use error_stack::{Report, Result, ResultExt};
+use error_stack::{Report, ResultExt};
 use fast_glob::glob_match;
 use ignore::{DirEntry, WalkBuilder, WalkParallel, WalkState};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
@@ -52,25 +52,51 @@ impl<'a> ProjectBuilder<'a> {
         }
     }
 
-    #[instrument(level = "debug", skip_all, fields(base_path = %self.base_path.display()))]
-    pub fn build(&mut self) -> Result<Project, Error> {
+    #[instrument(name = "project_build", level = "debug", skip_all, fields(base_path = %self.base_path.display()))]
+    pub fn build(&mut self) -> Result<Project, Report<Error>> {
         tracing::info!("Starting project build");
         let mut builder = WalkBuilder::new(&self.base_path);
         builder.hidden(false);
         builder.follow_links(false);
+        // Inclusion is determined by `tracked_files` (git ls-files) below, not by
+        // git's own ignore semantics. Without disabling these, a *global*
+        // .gitignore (core.excludesFile), local .gitignore, or .git/info/exclude
+        // rule can prune a whole directory from the walk even when its contents
+        // are force-tracked in git, silently dropping otherwise-owned files from
+        // the generated CODEOWNERS depending on the machine's git config.
+        // `.ignore` files are left enabled: they're this tool's own opt-in
+        // exclusion mechanism (see tests/fixtures/valid_project/.ignore) and are
+        // unrelated to git tracking status.
+        builder.git_global(false);
+        builder.git_ignore(false);
+        builder.git_exclude(false);
 
         // Prune traversal early: skip heavy and irrelevant directories
         let ignore_dirs = self.config.ignore_dirs.clone();
+        let team_file_glob = self.config.team_file_glob.clone();
         let base_path = self.base_path.clone();
         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("");
+            // Team config files are exempt from the tracked-files check below: a
+            // freshly-created team.yml defines real ownership rules the moment it
+            // exists, not scratch work someone might never commit, so requiring
+            // `git add` before a new team is considered would silently produce
+            // "unowned file" errors for anything that should now belong to it
+            // (rubyatscale/code_ownership#149). Ordinary source files are left
+            // subject to the tracked-files check, preserving the original,
+            // intentional behavior of not forcing ownership onto untracked
+            // scratch files a developer has no plan to commit (#46/#74/#76).
+            let is_team_file = path
+                .strip_prefix(&base_path)
+                .is_ok_and(|relative_path| matches_globs(relative_path, &team_file_glob));
             if let Some(tracked_files) = &tracked_files
                 && let Some(ft) = entry.file_type()
                 && ft.is_file()
                 && !tracked_files.contains_key(path)
+                && !is_team_file
             {
                 return false;
             }
@@ -136,7 +162,7 @@ impl<'a> ProjectBuilder<'a> {
         self.build_project_from_entry_types(entry_types)
     }
 
-    fn build_entry_type(&self, entry: ignore::DirEntry) -> Result<EntryType, Error> {
+    fn build_entry_type(&self, entry: ignore::DirEntry) -> Result<EntryType, Report<Error>> {
         let absolute_path = entry.path();
 
         let is_dir = entry.file_type().ok_or(Error::Io).change_context(Error::Io)?.is_dir();
@@ -177,7 +203,7 @@ impl<'a> ProjectBuilder<'a> {
         }
     }
 
-    fn build_project_from_entry_types(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Error> {
+    fn build_project_from_entry_types(&mut self, entry_types: Vec<EntryType>) -> Result<Project, Report<Error>> {
         type Accumulator = (
             Vec<ProjectFile>,
             Vec<Package>,
@@ -206,8 +232,8 @@ impl<'a> ProjectBuilder<'a> {
                         EntryType::Directory(absolute_path, relative_path) => {
                             if relative_path.parent() == Some(Path::new(&self.config.vendored_gems_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()))
+                                    Report::new(Error::Io)
+                                        .attach(format!("Vendored gem path has no file name: {}", relative_path.display()))
                                 })?;
                                 gems.push(VendoredGem {
                                     path: absolute_path,
@@ -217,7 +243,7 @@ impl<'a> ProjectBuilder<'a> {
                         }
                         EntryType::RubyPackage(absolute_path, relative_path) => {
                             match ruby_package_owner(&absolute_path)
-                                .attach_printable_lazy(|| format!("Failed to read ruby package: {}", absolute_path.display()))
+                                .attach_with(|| format!("Failed to read ruby package: {}", absolute_path.display()))
                             {
                                 Ok(Some(owner)) => {
                                     pkgs.push(Package {
@@ -232,7 +258,7 @@ impl<'a> ProjectBuilder<'a> {
                         }
                         EntryType::JavascriptPackage(absolute_path, relative_path) => {
                             match javascript_package_owner(&absolute_path)
-                                .attach_printable_lazy(|| format!("Failed to read javascript package: {}", absolute_path.display()))
+                                .attach_with(|| format!("Failed to read javascript package: {}", absolute_path.display()))
                             {
                                 Ok(Some(owner)) => {
                                     pkgs.push(Package {
@@ -248,7 +274,7 @@ impl<'a> ProjectBuilder<'a> {
                         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()))?;
+                                .attach_with(|| format!("Failed to read codeowner file: {}", absolute_path.display()))?;
                             let owner = owner.trim().to_owned();
                             codeowners.push(DirectoryCodeownersFile {
                                 path: relative_path.clone(),
@@ -258,7 +284,7 @@ impl<'a> ProjectBuilder<'a> {
                         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()))?;
+                                .attach_with(|| format!("Failed to read team file: {}", absolute_path.display()))?;
                             team_files.push(team);
                         }
                         EntryType::NullEntry() => {}
@@ -310,7 +336,7 @@ fn matches_globs(path: &Path, globs: &[String]) -> bool {
     }
 }
 
-fn ruby_package_owner(path: &Path) -> Result<Option<String>, Error> {
+pub(crate) fn ruby_package_owner(path: &Path) -> Result<Option<String>, Report<Error>> {
     let file = File::open(path).change_context(Error::Io)?;
     let deserializer: deserializers::RubyPackage = serde_yaml::from_reader(file).change_context(Error::SerdeYaml)?;
 
@@ -319,7 +345,7 @@ fn ruby_package_owner(path: &Path) -> Result<Option<String>, Error> {
 
     // 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!(
+        (Some(top), Some(meta)) if top != meta => Err(Report::new(Error::Io).attach(format!(
             "Package at {} has conflicting owners: 'owner: {}' vs 'metadata.owner: {}'. Please use only one.",
             path.display(),
             top,
@@ -329,7 +355,7 @@ fn ruby_package_owner(path: &Path) -> Result<Option<String>, Error> {
     }
 }
 
-fn javascript_package_owner(path: &Path) -> Result<Option<String>, Error> {
+fn javascript_package_owner(path: &Path) -> Result<Option<String>, Report<Error>> {
     let file = File::open(path).change_context(Error::Io)?;
     let deserializer: deserializers::JavascriptPackage = serde_json::from_reader(file).change_context(Error::SerdeJson)?;
 

data/ext/cargo-vendor/{codeowners-0.3.3 → codeowners-0.5.0}/src/project_file_builder.rs

@@ -1,4 +1,4 @@
-use error_stack::Result;
+use error_stack::Report;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::path::{Path, PathBuf};
@@ -34,7 +34,7 @@ impl<'a> ProjectFileBuilder<'a> {
         project_file
     }
 
-    fn get_project_file_from_cache(&self, path: &Path) -> Result<Option<ProjectFile>, Error> {
+    fn get_project_file_from_cache(&self, path: &Path) -> Result<Option<ProjectFile>, Report<Error>> {
         self.global_cache.get_file_owner(path).map(|entry| {
             entry.map(|e| ProjectFile {
                 path: path.to_path_buf(),

data/ext/cargo-vendor/{codeowners-0.3.3 → codeowners-0.5.0}/src/runner/api.rs

@@ -2,9 +2,12 @@ use std::collections::HashMap;
 
 use crate::project::Team;
 use crate::{ownership::FileOwner, runner::config_from_run_config};
+use error_stack::Report;
 
 use super::{Error, ForFileResult, RunConfig, RunResult, run};
 
+pub use crate::ownership::file_owner_resolver::clear_team_cache;
+
 pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool, json: bool) -> RunResult {
     if from_codeowners {
         return for_file_codeowners_only_fast(run_config, file_path, json);
@@ -37,7 +40,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> {
+pub fn owners_for_file(run_config: &RunConfig, file_path: &str) -> Result<Vec<FileOwner>, Report<Error>> {
     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)?;
@@ -45,12 +48,12 @@ pub fn owners_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::
 }
 
 // Returns the highest priority owner for a file. More to come here.
-pub fn file_owner_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<FileOwner>, Error> {
+pub fn file_owner_for_file(run_config: &RunConfig, file_path: &str) -> Result<Option<FileOwner>, Report<Error>> {
     let owners = owners_for_file(run_config, file_path)?;
     Ok(owners.first().cloned())
 }
 
-pub fn team_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<Team>, Error> {
+pub fn team_for_file(run_config: &RunConfig, file_path: &str) -> Result<Option<Team>, Report<Error>> {
     let owner = file_owner_for_file(run_config, file_path)?;
     Ok(owner.map(|fo| fo.team.clone()))
 }
@@ -59,7 +62,7 @@ pub fn team_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Re
 pub fn teams_for_files_from_codeowners(
     run_config: &RunConfig,
     file_paths: &[String],
-) -> error_stack::Result<HashMap<String, Option<Team>>, Error> {
+) -> Result<HashMap<String, Option<Team>>, Report<Error>> {
     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(
@@ -72,7 +75,7 @@ pub fn teams_for_files_from_codeowners(
     Ok(res)
 }
 
-pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<Team>, Error> {
+pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) -> Result<Option<Team>, Report<Error>> {
     let result = teams_for_files_from_codeowners(run_config, &[file_path.to_string()])?;
     // Since we only passed one file, there should be exactly one result
     debug_assert_eq!(result.len(), 1);

data/ext/cargo-vendor/{codeowners-0.3.3 → codeowners-0.5.0}/src/runner/types.rs

@@ -1,7 +1,6 @@
 use core::fmt;
 use std::path::PathBuf;
 
-use error_stack::Context;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Default, Serialize, Deserialize)]
@@ -26,7 +25,7 @@ pub enum Error {
     ValidationFailed,
 }
 
-impl Context for Error {}
+impl core::error::Error for Error {}
 
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {