code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/codeowners-0.2.7/src/ownership/validator.rs

@@ -1,218 +0,0 @@
-use crate::project::{Project, ProjectFile};
-use core::fmt;
-use std::collections::HashSet;
-use std::fmt::Display;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use error_stack::Context;
-use itertools::Itertools;
-use rayon::prelude::IntoParallelRefIterator;
-use rayon::prelude::ParallelIterator;
-use tracing::debug;
-use tracing::instrument;
-
-use super::file_generator::FileGenerator;
-use super::file_owner_finder::FileOwnerFinder;
-use super::file_owner_finder::Owner;
-use super::mapper::{Mapper, OwnerMatcher, TeamName};
-
-pub struct Validator {
-    pub project: Arc<Project>,
-    pub mappers: Vec<Box<dyn Mapper>>,
-    pub file_generator: FileGenerator,
-}
-
-#[derive(Debug)]
-enum Error {
-    InvalidTeam { name: String, path: PathBuf },
-    FileWithoutOwner { path: PathBuf },
-    FileWithMultipleOwners { path: PathBuf, owners: Vec<Owner> },
-    CodeownershipFileIsStale,
-}
-
-#[derive(Debug)]
-pub struct Errors(Vec<Error>);
-
-impl Validator {
-    #[instrument(level = "debug", skip_all)]
-    pub fn validate(&self) -> Result<(), Errors> {
-        let mut validation_errors = Vec::new();
-
-        debug!("validate_invalid_team");
-        validation_errors.append(&mut self.validate_invalid_team());
-
-        debug!("validate_file_ownership");
-        validation_errors.append(&mut self.validate_file_ownership());
-
-        debug!("validate_codeowners_file");
-        validation_errors.append(&mut self.validate_codeowners_file());
-
-        if validation_errors.is_empty() {
-            Ok(())
-        } else {
-            Err(Errors(validation_errors))
-        }
-    }
-
-    fn validate_invalid_team(&self) -> Vec<Error> {
-        debug!("validating project");
-        let mut errors: Vec<Error> = Vec::new();
-
-        let team_names: HashSet<&TeamName> = self.project.teams.iter().map(|team| &team.name).collect();
-
-        errors.append(&mut self.invalid_team_annotation(&team_names));
-        errors.append(&mut self.invalid_package_ownership(&team_names));
-
-        errors
-    }
-
-    fn invalid_team_annotation(&self, team_names: &HashSet<&String>) -> Vec<Error> {
-        let project = self.project.clone();
-
-        self.project
-            .files
-            .par_iter()
-            .flat_map(|file| {
-                if let Some(owner) = &file.owner {
-                    if !team_names.contains(owner) {
-                        return Some(Error::InvalidTeam {
-                            name: owner.clone(),
-                            path: project.relative_path(&file.path).to_owned(),
-                        });
-                    }
-                }
-
-                None
-            })
-            .collect()
-    }
-
-    fn invalid_package_ownership(&self, team_names: &HashSet<&String>) -> Vec<Error> {
-        self.project
-            .packages
-            .iter()
-            .flat_map(|package| {
-                if !team_names.contains(&package.owner) {
-                    Some(Error::InvalidTeam {
-                        name: package.owner.clone(),
-                        path: self.project.relative_path(&package.path).to_owned(),
-                    })
-                } else {
-                    None
-                }
-            })
-            .collect()
-    }
-
-    fn validate_file_ownership(&self) -> Vec<Error> {
-        let mut validation_errors = Vec::new();
-
-        for (file, owners) in self.file_to_owners() {
-            let relative_path = self.project.relative_path(&file.path).to_owned();
-
-            if owners.is_empty() {
-                validation_errors.push(Error::FileWithoutOwner { path: relative_path })
-            } else if owners.len() > 1 {
-                validation_errors.push(Error::FileWithMultipleOwners {
-                    path: relative_path,
-                    owners,
-                })
-            }
-        }
-
-        validation_errors
-    }
-
-    fn validate_codeowners_file(&self) -> Vec<Error> {
-        let generated_file = self.file_generator.generate_file();
-
-        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
-        }
-    }
-
-    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 {
-            owner_matchers: &owner_matchers,
-        };
-        let project = self.project.clone();
-
-        self.project
-            .files
-            .par_iter()
-            .filter_map(|project_file| {
-                let relative_path = project.relative_path(&project_file.path);
-                let owners = file_owner_finder.find(relative_path);
-                Some((project_file, owners))
-            })
-            .collect()
-    }
-}
-
-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::InvalidTeam { name: _, path: _ } => "Found invalid team annotations".to_owned(),
-        }
-    }
-
-    pub fn messages(&self) -> Vec<String> {
-        match self {
-            Error::FileWithoutOwner { path } => vec![format!("- {}", path.to_string_lossy())],
-            Error::FileWithMultipleOwners { path, owners } => {
-                let path_display = path.to_string_lossy();
-                let mut messages = vec![format!("\n{path_display}")];
-
-                owners
-                    .iter()
-                    .sorted_by_key(|owner| owner.team_name.to_lowercase())
-                    .for_each(|owner| {
-                        messages.push(format!(" owner: {}", owner.team_name));
-                        messages.extend(owner.sources.iter().map(|source| format!("  - {source}")));
-                    });
-
-                vec![messages.join("\n")]
-            }
-            Error::CodeownershipFileIsStale => vec![],
-            Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
-        }
-    }
-}
-
-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());
-        let grouped_errors = Vec::from_iter(grouped_errors.iter());
-        let grouped_errors = grouped_errors.iter().sorted_by_key(|(category, _)| category);
-
-        for (category, errors) in grouped_errors {
-            write!(f, "\n{}", category)?;
-
-            let messages = errors.iter().flat_map(|error| error.messages()).sorted().join("\n");
-            if !messages.is_empty() {
-                writeln!(f)?;
-                write!(f, "{}", &messages)?;
-            }
-
-            writeln!(f)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Context for Errors {}

data/ext/cargo-vendor/codeowners-0.2.7/src/ownership.rs

@@ -1,220 +0,0 @@
-use file_owner_finder::FileOwnerFinder;
-use itertools::Itertools;
-use mapper::{OwnerMatcher, Source, TeamName};
-use std::{
-    error::Error,
-    fmt::{self, Display},
-    path::Path,
-    sync::Arc,
-};
-use tracing::{info, instrument};
-
-mod file_generator;
-mod file_owner_finder;
-pub mod for_file_fast;
-pub(crate) mod mapper;
-pub(crate) mod parser;
-mod validator;
-
-use crate::{
-    ownership::mapper::DirectoryMapper,
-    project::{Project, Team},
-};
-
-pub use validator::Errors as ValidatorErrors;
-
-use self::{
-    file_generator::FileGenerator,
-    mapper::{JavascriptPackageMapper, Mapper, RubyPackageMapper, TeamFileMapper, TeamGemMapper, TeamGlobMapper, TeamYmlMapper},
-    parser::parse_for_team,
-    validator::Validator,
-};
-
-pub struct Ownership {
-    project: Arc<Project>,
-}
-#[derive(Debug)]
-pub struct FileOwner {
-    pub team: Team,
-    pub team_config_file_path: String,
-    pub sources: Vec<Source>,
-}
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct TeamOwnership {
-    pub heading: String,
-    pub globs: Vec<String>,
-}
-
-impl TeamOwnership {
-    fn new(heading: String) -> Self {
-        Self {
-            heading,
-            ..Default::default()
-        }
-    }
-}
-
-impl Display for FileOwner {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let sources = if self.sources.is_empty() {
-            "Unowned".to_string()
-        } else {
-            self.sources
-                .iter()
-                .sorted_by_key(|source| source.to_string())
-                .map(|source| source.to_string())
-                .collect::<Vec<_>>()
-                .join("\n- ")
-        };
-
-        write!(
-            f,
-            "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- {}",
-            self.team.name, self.team.github_team, self.team_config_file_path, sources
-        )
-    }
-}
-
-impl Default for FileOwner {
-    fn default() -> Self {
-        Self {
-            team: Team {
-                name: "Unowned".to_string(),
-                github_team: "Unowned".to_string(),
-                ..Default::default()
-            },
-            team_config_file_path: "".to_string(),
-            sources: vec![],
-        }
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Debug, PartialEq)]
-pub struct Entry {
-    pub path: String,
-    pub github_team: String,
-    pub team_name: TeamName,
-    pub disabled: bool,
-}
-
-impl Entry {
-    fn to_row(&self) -> String {
-        let line = format!("/{} {}", self.path, self.github_team);
-        if self.disabled { format!("# {}", line) } else { line }
-    }
-}
-
-impl Ownership {
-    pub fn build(project: Project) -> Self {
-        Self {
-            project: Arc::new(project),
-        }
-    }
-
-    #[instrument(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() },
-        };
-
-        validator.validate()
-    }
-
-    #[instrument(level = "debug", skip_all)]
-    pub fn for_file(&self, file_path: &Path) -> Result<Vec<FileOwner>, ValidatorErrors> {
-        info!("getting file ownership for {}", file_path.display());
-        let owner_matchers: Vec<OwnerMatcher> = self.mappers().iter().flat_map(|mapper| mapper.owner_matchers()).collect();
-        let file_owner_finder = FileOwnerFinder {
-            owner_matchers: &owner_matchers,
-        };
-        let owners = file_owner_finder.find(Path::new(file_path));
-        Ok(owners
-            .iter()
-            .sorted_by_key(|owner| owner.team_name.to_lowercase())
-            .map(|owner| match self.project.get_team(&owner.team_name) {
-                Some(team) => FileOwner {
-                    team: team.clone(),
-                    team_config_file_path: team
-                        .path
-                        .strip_prefix(&self.project.base_path)
-                        .map_or_else(|_| String::new(), |p| p.to_string_lossy().to_string()),
-                    sources: owner.sources.clone(),
-                },
-                None => FileOwner::default(),
-            })
-            .collect())
-    }
-
-    #[instrument(level = "debug", skip_all)]
-    pub fn for_team(&self, team_name: &str) -> Result<Vec<TeamOwnership>, Box<dyn Error>> {
-        info!("getting team ownership for {}", team_name);
-        let team = self.project.get_team(team_name).ok_or("Team not found")?;
-        let codeowners_file = self.project.get_codeowners_file()?;
-
-        parse_for_team(team.github_team, &codeowners_file)
-    }
-
-    #[instrument(level = "debug", skip_all)]
-    pub fn generate_file(&self) -> String {
-        info!("generating codeowners file");
-        let file_generator = FileGenerator { mappers: self.mappers() };
-        file_generator.generate_file()
-    }
-
-    fn mappers(&self) -> Vec<Box<dyn Mapper>> {
-        vec![
-            Box::new(TeamFileMapper::build(self.project.clone())),
-            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())),
-        ]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::common_test::tests::build_ownership_with_all_mappers;
-
-    #[test]
-    fn test_for_file_owner() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_all_mappers()?;
-        let file_owners = ownership.for_file(Path::new("app/consumers/directory_owned.rb")).unwrap();
-        assert_eq!(file_owners.len(), 1);
-        assert_eq!(file_owners[0].team.name, "Bar");
-        assert_eq!(file_owners[0].team_config_file_path, "config/teams/bar.yml");
-        Ok(())
-    }
-
-    #[test]
-    fn test_for_file_no_owner() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_all_mappers()?;
-        let file_owners = ownership.for_file(Path::new("app/madeup/foo.rb")).unwrap();
-        assert_eq!(file_owners.len(), 0);
-        Ok(())
-    }
-
-    #[test]
-    fn test_for_team() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_all_mappers()?;
-        let team_ownership = ownership.for_team("Bar");
-        assert!(team_ownership.is_ok());
-        Ok(())
-    }
-
-    #[test]
-    fn test_for_team_not_found() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_all_mappers()?;
-        let team_ownership = ownership.for_team("Nope");
-        assert!(team_ownership.is_err(), "Team not found");
-        Ok(())
-    }
-}

data/ext/cargo-vendor/codeowners-0.2.7/src/project.rs

@@ -1,229 +0,0 @@
-use core::fmt;
-use std::{
-    collections::HashMap,
-    fmt::Display,
-    fs::File,
-    path::{Path, PathBuf},
-};
-
-use error_stack::{Context, Result, ResultExt};
-
-pub struct Project {
-    pub base_path: PathBuf,
-    pub files: Vec<ProjectFile>,
-    pub packages: Vec<Package>,
-    pub vendored_gems: Vec<VendoredGem>,
-    pub teams: Vec<Team>,
-    pub codeowners_file_path: PathBuf,
-    pub directory_codeowner_files: Vec<DirectoryCodeownersFile>,
-    pub teams_by_name: HashMap<String, Team>,
-}
-
-#[derive(Clone, Debug)]
-pub struct VendoredGem {
-    pub path: PathBuf,
-    pub name: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct ProjectFile {
-    pub owner: Option<String>,
-    pub path: PathBuf,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct Team {
-    pub path: PathBuf,
-    pub name: String,
-    pub github_team: String,
-    pub owned_globs: Vec<String>,
-    pub subtracted_globs: Vec<String>,
-    pub owned_gems: Vec<String>,
-    pub avoid_ownership: bool,
-}
-
-impl Team {
-    pub fn from_team_file_path(absolute_path: PathBuf) -> Result<Self, 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 {
-            path: absolute_path.to_owned(),
-            name: deserializer.name,
-            github_team: deserializer.github.team,
-            owned_globs: deserializer.owned_globs,
-            subtracted_globs: deserializer.subtracted_globs,
-            owned_gems: deserializer.ruby.map(|ruby| ruby.owned_gems).unwrap_or_default(),
-            avoid_ownership: deserializer.github.do_not_add_to_codeowners_file,
-        })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Package {
-    pub path: PathBuf,
-    pub package_type: PackageType,
-    pub owner: String,
-}
-
-impl Package {
-    pub fn package_root(&self) -> Option<&Path> {
-        self.path.parent()
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct DirectoryCodeownersFile {
-    pub path: PathBuf,
-    pub owner: String,
-}
-
-impl DirectoryCodeownersFile {
-    pub fn directory_root(&self) -> Option<&Path> {
-        self.path.parent()
-    }
-}
-
-#[derive(PartialEq, Eq, Debug, Clone)]
-pub enum PackageType {
-    Ruby,
-    Javascript,
-}
-
-impl Display for PackageType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-pub mod deserializers {
-    use serde::Deserialize;
-
-    #[derive(Deserialize)]
-    pub struct Metadata {
-        pub owner: Option<String>,
-    }
-
-    #[derive(Deserialize)]
-    pub struct JavascriptPackage {
-        pub metadata: Option<Metadata>,
-    }
-
-    #[derive(Deserialize)]
-    pub struct RubyPackage {
-        pub owner: Option<String>,
-    }
-
-    #[derive(Deserialize)]
-    pub struct Github {
-        pub team: String,
-        #[serde(default = "bool_false")]
-        pub do_not_add_to_codeowners_file: bool,
-    }
-
-    #[derive(Deserialize)]
-    pub struct Ruby {
-        #[serde(default = "empty_string_vec")]
-        pub owned_gems: Vec<String>,
-    }
-
-    #[derive(Deserialize)]
-    pub struct Team {
-        pub name: String,
-        pub github: Github,
-        pub ruby: Option<Ruby>,
-
-        #[serde(default = "empty_string_vec")]
-        pub owned_globs: Vec<String>,
-
-        #[serde(alias = "unowned_globs", default = "empty_string_vec")]
-        pub subtracted_globs: Vec<String>,
-    }
-
-    fn empty_string_vec() -> Vec<String> {
-        Vec::new()
-    }
-
-    fn bool_false() -> bool {
-        false
-    }
-}
-
-#[derive(Debug)]
-pub enum Error {
-    Io,
-    SerdeYaml,
-    SerdeJson,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::Io => fmt.write_str("Error::Io"),
-            Error::SerdeYaml => fmt.write_str("Error::SerdeYaml"),
-            Error::SerdeJson => fmt.write_str("Error::SerdeJson"),
-        }
-    }
-}
-
-impl Context for Error {}
-
-impl Project {
-    pub fn get_codeowners_file(&self) -> Result<String, 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 {
-            "".to_owned()
-        };
-        Ok(codeowners_file)
-    }
-
-    pub fn relative_path<'a>(&'a self, absolute_path: &'a Path) -> &'a Path {
-        absolute_path.strip_prefix(&self.base_path).unwrap_or(absolute_path)
-    }
-
-    pub fn get_team(&self, name: &str) -> Option<Team> {
-        self.teams_by_name.get(name).cloned()
-    }
-
-    pub fn vendored_gem_by_name(&self) -> HashMap<String, VendoredGem> {
-        let mut result: HashMap<String, VendoredGem> = HashMap::new();
-
-        for vendored_gem in &self.vendored_gems {
-            result.insert(vendored_gem.name.clone(), vendored_gem.clone());
-        }
-
-        result
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_vendored_gem_by_name_maps_all_gems() {
-        let vg1 = VendoredGem {
-            path: PathBuf::from("vendored/a"),
-            name: "a".to_string(),
-        };
-        let vg2 = VendoredGem {
-            path: PathBuf::from("vendored/b"),
-            name: "b".to_string(),
-        };
-        let project = Project {
-            base_path: PathBuf::from("."),
-            files: vec![],
-            packages: vec![],
-            vendored_gems: vec![vg1.clone(), vg2.clone()],
-            teams: vec![],
-            codeowners_file_path: PathBuf::from(".github/CODEOWNERS"),
-            directory_codeowner_files: vec![],
-            teams_by_name: HashMap::new(),
-        };
-
-        let map = project.vendored_gem_by_name();
-        assert_eq!(map.len(), 2);
-        assert_eq!(map.get("a").unwrap().name, vg1.name);
-        assert_eq!(map.get("b").unwrap().name, vg2.name);
-    }
-}