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

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

@@ -1,220 +0,0 @@
-use std::sync::Arc;
-
-use super::{Entry, Source};
-use super::{Mapper, OwnerMatcher};
-use crate::project::{Package, PackageType, Project};
-use itertools::Itertools;
-
-pub struct RubyPackageMapper {
-    project: Arc<Project>,
-}
-
-pub struct JavascriptPackageMapper {
-    project: Arc<Project>,
-}
-
-struct PackageMapper {
-    project: Arc<Project>,
-}
-
-impl RubyPackageMapper {
-    pub fn build(project: Arc<Project>) -> Self {
-        Self { project }
-    }
-}
-
-impl Mapper for RubyPackageMapper {
-    fn entries(&self) -> Vec<Entry> {
-        PackageMapper::build(self.project.clone()).entries(&PackageType::Ruby)
-    }
-
-    fn owner_matchers(&self) -> Vec<OwnerMatcher> {
-        PackageMapper::build(self.project.clone()).owner_matchers(&PackageType::Ruby)
-    }
-
-    fn name(&self) -> String {
-        "Owner metadata key in package.yml".to_owned()
-    }
-}
-
-impl JavascriptPackageMapper {
-    pub fn build(project: Arc<Project>) -> Self {
-        Self { project }
-    }
-}
-
-impl Mapper for JavascriptPackageMapper {
-    fn entries(&self) -> Vec<Entry> {
-        PackageMapper::build(self.project.clone()).entries(&PackageType::Javascript)
-    }
-
-    fn owner_matchers(&self) -> Vec<OwnerMatcher> {
-        PackageMapper::build(self.project.clone()).owner_matchers(&PackageType::Javascript)
-    }
-
-    fn name(&self) -> String {
-        "Owner metadata key in package.json".to_owned()
-    }
-}
-
-impl PackageMapper {
-    pub fn build(project: Arc<Project>) -> Self {
-        Self { project }
-    }
-}
-
-impl PackageMapper {
-    fn entries(&self, package_type: &PackageType) -> Vec<Entry> {
-        let mut entries: Vec<Entry> = Vec::new();
-        let team_by_name = self.project.teams_by_name.clone();
-
-        for package in self.project.packages.iter().filter(|package| &package.package_type == package_type) {
-            if let Some(package_root) = package.package_root() {
-                let package_root = package_root.to_string_lossy();
-                let team = team_by_name.get(&package.owner);
-
-                if let Some(team) = team {
-                    entries.push(Entry {
-                        path: format!("{}/**/**", package_root),
-                        github_team: team.github_team.to_owned(),
-                        team_name: team.name.to_owned(),
-                        disabled: team.avoid_ownership,
-                    });
-                }
-            }
-        }
-
-        entries
-    }
-
-    fn owner_matchers(&self, package_type: &PackageType) -> Vec<OwnerMatcher> {
-        let mut owner_matchers: Vec<OwnerMatcher> = Vec::new();
-        let team_by_name = self.project.teams_by_name.clone();
-
-        let packages = &self.project.packages;
-        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
-        let packages = remove_nested_packages(&packages);
-
-        for package in packages {
-            if let Some(package_root) = package.package_root() {
-                let package_root = package_root.to_string_lossy();
-                let team = team_by_name.get(&package.owner);
-
-                if let Some(team) = team {
-                    owner_matchers.push(OwnerMatcher::new_glob(
-                        format!("{}/**/**", package_root),
-                        team.name.to_owned(),
-                        Source::Package(package.path.to_string_lossy().to_string(), format!("{}/**/**", package_root)),
-                    ));
-                }
-            }
-        }
-
-        owner_matchers
-    }
-}
-
-fn remove_nested_packages<'a>(packages: &'a [&'a Package]) -> Vec<&'a Package> {
-    let mut top_level_packages: Vec<&Package> = Vec::new();
-
-    for package in packages.iter().sorted_by_key(|package| package.package_root()) {
-        if let Some(last_package) = top_level_packages.last() {
-            if let (Some(current_root), Some(last_root)) = (package.package_root(), last_package.package_root()) {
-                if !current_root.starts_with(last_root) {
-                    top_level_packages.push(package);
-                }
-            }
-        } else {
-            top_level_packages.push(package);
-        }
-    }
-
-    top_level_packages
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        common_test::tests::{build_ownership_with_all_mappers, build_ownership_with_package_codeowners, vecs_match},
-        ownership::mapper::RubyPackageMapper,
-        project::{Package, PackageType},
-    };
-    use itertools::Itertools;
-    use std::{error::Error, path::Path};
-    #[test]
-    fn test_remove_nested_packages() {
-        let packages = vec![
-            Package {
-                path: Path::new("packs/a/package.yml").to_owned(),
-                package_type: PackageType::Ruby,
-                owner: "owner_a".to_owned(),
-            },
-            Package {
-                path: Path::new("packs/a/b/e/package.yml").to_owned(),
-                package_type: PackageType::Ruby,
-                owner: "owner_b".to_owned(),
-            },
-            Package {
-                path: Path::new("packs/a/b/c/e/d/f/package.yml").to_owned(),
-                package_type: PackageType::Ruby,
-                owner: "owner_b".to_owned(),
-            },
-            Package {
-                path: Path::new("packs/c/package.yml").to_owned(),
-                package_type: PackageType::Ruby,
-                owner: "owner_a".to_owned(),
-            },
-        ];
-
-        let packages = packages.iter().collect_vec();
-
-        let package_paths = super::remove_nested_packages(&packages)
-            .iter()
-            .map(|package| package.path.to_str().unwrap())
-            .collect_vec();
-
-        assert_eq!(package_paths, vec!["packs/a/package.yml", "packs/c/package.yml"]);
-    }
-
-    #[test]
-    fn test_entries() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_all_mappers()?;
-        let mapper = RubyPackageMapper::build(ownership.project.clone());
-        vecs_match(
-            &mapper.entries(),
-            &vec![Entry {
-                path: "packs/foo/**/**".to_owned(),
-                github_team: "@Baz".to_owned(),
-                team_name: "Baz".to_owned(),
-                disabled: false,
-            }],
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_owner_matchers() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_package_codeowners()?;
-        let mapper = PackageMapper::build(ownership.project.clone());
-        vecs_match(
-            &mapper.owner_matchers(&PackageType::Ruby),
-            &vec![
-                OwnerMatcher::new_glob(
-                    "packs/bam/**/**".to_owned(),
-                    "Bam".to_owned(),
-                    Source::Package("packs/bam/package.yml".to_owned(), "packs/bam/**/**".to_owned()),
-                ),
-                OwnerMatcher::new_glob(
-                    "packs/foo/**/**".to_owned(),
-                    "Baz".to_owned(),
-                    Source::Package("packs/foo/package.yml".to_owned(), "packs/foo/**/**".to_owned()),
-                ),
-            ],
-        );
-        Ok(())
-    }
-}

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

@@ -1,123 +0,0 @@
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use super::Entry;
-use super::escaper::escape_brackets;
-use super::{Mapper, OwnerMatcher};
-use crate::ownership::mapper::Source;
-use crate::project::Project;
-
-pub struct TeamFileMapper {
-    project: Arc<Project>,
-}
-
-impl TeamFileMapper {
-    pub fn build(project: Arc<Project>) -> Self {
-        Self { project }
-    }
-}
-
-impl Mapper for TeamFileMapper {
-    fn entries(&self) -> Vec<Entry> {
-        let mut entries: Vec<Entry> = Vec::new();
-        let team_by_name = self.project.teams_by_name.clone();
-
-        for owned_file in &self.project.files {
-            if let Some(ref owner) = owned_file.owner {
-                let team = team_by_name.get(owner);
-
-                if let Some(team) = team {
-                    let relative_path = self.project.relative_path(&owned_file.path);
-
-                    entries.push(Entry {
-                        path: escape_brackets(&relative_path.to_string_lossy()),
-                        github_team: team.github_team.to_owned(),
-                        team_name: team.name.to_owned(),
-                        disabled: team.avoid_ownership,
-                    });
-                }
-            }
-        }
-
-        entries
-    }
-
-    fn owner_matchers(&self) -> Vec<OwnerMatcher> {
-        let team_by_name = self.project.teams_by_name.clone();
-
-        let mut path_to_team: HashMap<PathBuf, String> = HashMap::new();
-
-        for owned_file in &self.project.files {
-            if let Some(ref owner) = owned_file.owner {
-                let team = team_by_name.get(owner);
-
-                if let Some(team) = team {
-                    let relative_path = self.project.relative_path(&owned_file.path);
-                    path_to_team.insert(relative_path.to_owned(), team.name.clone());
-                }
-            }
-        }
-
-        vec![OwnerMatcher::ExactMatches(path_to_team, Source::TeamFile)]
-    }
-
-    fn name(&self) -> String {
-        "Annotations at the top of file".to_owned()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::error::Error;
-
-    use crate::common_test::tests::{build_ownership_with_team_file_codeowners, vecs_match};
-
-    use super::*;
-    #[test]
-    fn test_entries() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_team_file_codeowners()?;
-        let mapper = TeamFileMapper::build(ownership.project.clone());
-        vecs_match(
-            &mapper.entries(),
-            &vec![
-                Entry {
-                    path: "packs/\\[admin\\]/comp.ts".to_owned(),
-                    github_team: "@Bar".to_owned(),
-                    team_name: "Bar".to_owned(),
-                    disabled: false,
-                },
-                Entry {
-                    path: "packs/jscomponents/comp.ts".to_owned(),
-                    github_team: "@Foo".to_owned(),
-                    team_name: "Foo".to_owned(),
-                    disabled: false,
-                },
-                Entry {
-                    path: "packs/bar/comp.rb".to_owned(),
-                    github_team: "@Bar".to_owned(),
-                    team_name: "Bar".to_owned(),
-                    disabled: false,
-                },
-            ],
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_owner_matchers() -> Result<(), Box<dyn Error>> {
-        let ownership = build_ownership_with_team_file_codeowners()?;
-        let mapper = TeamFileMapper::build(ownership.project.clone());
-        let owner_matchers = mapper.owner_matchers();
-        let expected_owner_matchers = vec![OwnerMatcher::ExactMatches(
-            HashMap::from([
-                (PathBuf::from("packs/[admin]/comp.ts"), "Bar".to_owned()),
-                (PathBuf::from("packs/bar/comp.rb"), "Bar".to_owned()),
-                (PathBuf::from("packs/jscomponents/comp.ts"), "Foo".to_owned()),
-            ]),
-            Source::TeamFile,
-        )];
-        assert_eq!(owner_matchers, expected_owner_matchers);
-        Ok(())
-    }
-}

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

@@ -1,249 +0,0 @@
-use fast_glob::glob_match;
-use std::{
-    collections::HashMap,
-    fmt::{self, Display},
-    path::{Path, PathBuf},
-};
-
-pub(crate) mod directory_mapper;
-mod escaper;
-mod package_mapper;
-mod team_file_mapper;
-mod team_gem_mapper;
-mod team_glob_mapper;
-mod team_yml_mapper;
-
-pub use directory_mapper::DirectoryMapper;
-pub use package_mapper::JavascriptPackageMapper;
-pub use package_mapper::RubyPackageMapper;
-pub use team_file_mapper::TeamFileMapper;
-pub use team_gem_mapper::TeamGemMapper;
-pub use team_glob_mapper::TeamGlobMapper;
-pub use team_yml_mapper::TeamYmlMapper;
-
-use super::Entry;
-
-pub trait Mapper {
-    fn name(&self) -> String;
-    fn entries(&self) -> Vec<Entry>;
-    fn owner_matchers(&self) -> Vec<OwnerMatcher>;
-}
-pub type TeamName = String;
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum Source {
-    Directory(String),
-    TeamFile,
-    TeamGem,
-    TeamGlob(String),
-    Package(String, String),
-    TeamYml,
-}
-
-impl Display for Source {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Source::Directory(path) => write!(f, "Owner specified in `{}/.codeowner`", path),
-            Source::TeamFile => write!(f, "Owner annotation at the top of the file"),
-            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)
-            }
-            Source::TeamYml => write!(f, "Teams own their configuration files"),
-        }
-    }
-}
-
-impl Source {
-    pub fn len(&self) -> usize {
-        match self {
-            Source::Directory(path) => path.matches('/').count(),
-            _ => 0,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum OwnerMatcher {
-    ExactMatches(HashMap<PathBuf, TeamName>, Source),
-    Glob {
-        glob: String,
-        subtracted_globs: Vec<String>,
-        team_name: TeamName,
-        source: Source,
-    },
-}
-
-impl OwnerMatcher {
-    pub fn new_glob_with_candidate_subtracted_globs(
-        glob: String,
-        candidate_subtracted_globs: &[String],
-        team_name: TeamName,
-        source: Source,
-    ) -> Self {
-        let subtracted_globs = candidate_subtracted_globs
-            .iter()
-            .filter(|candidate_subtracted_glob| {
-                glob_match(candidate_subtracted_glob, &glob) || glob_match(&glob, candidate_subtracted_glob)
-            })
-            .cloned()
-            .collect();
-        OwnerMatcher::Glob {
-            glob,
-            subtracted_globs,
-            team_name,
-            source,
-        }
-    }
-
-    pub fn new_glob(glob: String, team_name: TeamName, source: Source) -> Self {
-        OwnerMatcher::Glob {
-            glob,
-            subtracted_globs: vec![],
-            team_name,
-            source,
-        }
-    }
-
-    pub fn owner_for(&self, relative_path: &Path) -> (Option<&TeamName>, &Source) {
-        match self {
-            OwnerMatcher::Glob {
-                glob,
-                subtracted_globs,
-                team_name,
-                source,
-            } => relative_path
-                .to_str()
-                .filter(|path| glob_match(glob, path) && !subtracted_globs.iter().any(|subtracted| glob_match(subtracted, path)))
-                .map_or((None, source), |_| (Some(team_name), source)),
-            OwnerMatcher::ExactMatches(path_to_team, source) => (path_to_team.get(relative_path), source),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn assert_owner_for(glob: &str, subtracted_globs: &[&str], relative_path: &str, expect_match: bool) {
-        let source = Source::Directory("packs/bam".to_string());
-        let team_name = "team1".to_string();
-        let owner_matcher = OwnerMatcher::new_glob_with_candidate_subtracted_globs(
-            glob.to_string(),
-            &subtracted_globs.iter().map(|s| s.to_string()).collect::<Vec<String>>(),
-            team_name.clone(),
-            source.clone(),
-        );
-        let response = owner_matcher.owner_for(Path::new(relative_path));
-        if expect_match {
-            assert_eq!(response, (Some(&team_name), &source));
-        } else {
-            assert_eq!(response, (None, &source));
-        }
-    }
-
-    #[test]
-    fn owner_for_without_brackets_in_glob() {
-        assert_owner_for("packs/bam/**/**", &[], "packs/bam/app/components/sidebar.jsx", true);
-        assert_owner_for("packs/bam/**/**", &[], "packs/baz/app/components/sidebar.jsx", false);
-        assert_owner_for("packs/bam/**/**", &[], "packs/bam/app/[components]/gadgets/sidebar.jsx", true);
-        assert_owner_for("packs/bam/**/**", &[], "packs/bam/app/sidebar_[component].jsx", true);
-        assert_owner_for(
-            "packs/bam/**/**",
-            &["packs/bam/app/excluded/**"],
-            "packs/bam/app/excluded/sidebar_[component].jsx",
-            false,
-        );
-    }
-
-    #[test]
-    fn subtracted_globs() {
-        assert_owner_for(
-            "packs/bam/**/**",
-            &["packs/bam/app/excluded/**"],
-            "packs/bam/app/excluded/some_file.rb",
-            false,
-        );
-        assert_owner_for(
-            "packs/bam/**/**",
-            &["packs/bam/app/excluded/**"],
-            "packs/bam/app/not_excluded/some_file.rb",
-            true,
-        );
-    }
-
-    #[test]
-    fn owner_for_with_brackets_in_glob() {
-        assert_owner_for(
-            "packs/bam/app/\\[components\\]/**/**",
-            &[],
-            "packs/bam/app/[components]/gadgets/sidebar.jsx",
-            true,
-        );
-        assert_owner_for("packs/\\[bam\\]/**/**", &[], "packs/[bam]/app/components/sidebar.jsx", true);
-    }
-
-    #[test]
-    fn owner_for_with_multiple_brackets_in_glob() {
-        assert_owner_for(
-            "packs/\\[bam\\]/bar/\\[foo\\]/**/**",
-            &[],
-            "packs/[bam]/bar/[foo]/app/components/sidebar.jsx",
-            true,
-        );
-    }
-
-    #[test]
-    fn display_source() {
-        assert_eq!(
-            Source::Directory("packs/bam".to_string()).to_string(),
-            "Owner specified in `packs/bam/.codeowner`"
-        );
-        assert_eq!(Source::TeamFile.to_string(), "Owner annotation at the top of the file");
-        assert_eq!(Source::TeamGem.to_string(), "Owner specified in Team YML's `owned_gems`");
-        assert_eq!(
-            Source::TeamGlob("a/glob/**".to_string()).to_string(),
-            "Owner specified in Team YML as an owned_glob `a/glob/**`"
-        );
-        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/**/**`"
-        );
-        assert_eq!(Source::TeamYml.to_string(), "Teams own their configuration files");
-    }
-
-    #[test]
-    fn test_new_glob_with_candidate_subtracted_globs() {
-        assert_new_glob_with_candidate_subtracted_globs("packs/bam/**/**", &[], &[]);
-        assert_new_glob_with_candidate_subtracted_globs("packs/bam/**/**", &["packs/bam/app/**/**"], &["packs/bam/app/**/**"]);
-        assert_new_glob_with_candidate_subtracted_globs(
-            "packs/bam/**/**",
-            &["packs/bam/app/an/exceptional/path/it.rb"],
-            &["packs/bam/app/an/exceptional/path/it.rb"],
-        );
-        assert_new_glob_with_candidate_subtracted_globs("packs/bam/**/**", &["packs/bam.rb"], &[]);
-        assert_new_glob_with_candidate_subtracted_globs("packs/bam/**/**", &["packs/nope/app/**/**"], &[]);
-        assert_new_glob_with_candidate_subtracted_globs("packs/**", &["packs/yep/app/**/**"], &["packs/yep/app/**/**"]);
-        assert_new_glob_with_candidate_subtracted_globs("packs/foo.yml", &["packs/foo/**/**"], &[]);
-    }
-
-    fn assert_new_glob_with_candidate_subtracted_globs(
-        glob: &str,
-        candidate_subtracted_globs: &[&str],
-        expected_subtracted_globs: &[&str],
-    ) {
-        let owner_matcher = OwnerMatcher::new_glob_with_candidate_subtracted_globs(
-            glob.to_string(),
-            &candidate_subtracted_globs.iter().map(|s| s.to_string()).collect::<Vec<String>>(),
-            "team1".to_string(),
-            Source::TeamGlob(glob.to_string()),
-        );
-
-        if let OwnerMatcher::Glob { subtracted_globs, .. } = owner_matcher {
-            assert_eq!(subtracted_globs, expected_subtracted_globs);
-        } else {
-            panic!("Expected a Glob matcher");
-        }
-    }
-}