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

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

@@ -0,0 +1,158 @@
+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 relative_path = self.project.relative_path(&owned_file.path);
+                let team_name = team_by_name
+                    .get(owner)
+                    .map(|team| team.name.clone())
+                    .unwrap_or_else(|| owner.clone());
+                path_to_team.insert(relative_path.to_owned(), team_name);
+            }
+        }
+
+        vec![OwnerMatcher::ExactMatches(path_to_team, Source::AnnotatedFile)]
+    }
+
+    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,
+                },
+                Entry {
+                    path: "packs/bar/comp_colon.rb".to_owned(),
+                    github_team: "@Bar".to_owned(),
+                    team_name: "Bar".to_owned(),
+                    disabled: false,
+                },
+                Entry {
+                    path: "packs/jscomponents/comp-colon.ts".to_owned(),
+                    github_team: "@Foo".to_owned(),
+                    team_name: "Foo".to_owned(),
+                    disabled: false,
+                },
+                Entry {
+                    path: "ruby/app/views/foos/edit.erb".to_owned(),
+                    github_team: "@Foo".to_owned(),
+                    team_name: "Foo".to_owned(),
+                    disabled: false,
+                },
+                Entry {
+                    path: "ruby/app/views/foos/show.html.erb".to_owned(),
+                    github_team: "@Bar".to_owned(),
+                    team_name: "Bar".to_owned(),
+                    disabled: false,
+                },
+                Entry {
+                    path: "ruby/app/views/foos/_row.html.erb".to_owned(),
+                    github_team: "@Bam".to_owned(),
+                    team_name: "Bam".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()),
+                (PathBuf::from("packs/jscomponents/comp-colon.ts"), "Foo".to_owned()),
+                (PathBuf::from("packs/bar/comp_colon.rb"), "Bar".to_owned()),
+                (PathBuf::from("ruby/app/views/foos/edit.erb"), "Foo".to_owned()),
+                (PathBuf::from("ruby/app/views/foos/show.html.erb"), "Bar".to_owned()),
+                (PathBuf::from("ruby/app/views/foos/_row.html.erb"), "Bam".to_owned()),
+            ]),
+            Source::AnnotatedFile,
+        )];
+        assert_eq!(owner_matchers, expected_owner_matchers);
+        Ok(())
+    }
+}

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

@@ -0,0 +1,220 @@
+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())
+                && !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.17/src/ownership/mapper.rs

@@ -0,0 +1,249 @@
+use fast_glob::glob_match;
+use std::{
+    collections::HashMap,
+    fmt::{self, Display},
+    path::{Path, PathBuf},
+};
+
+mod annotated_file_mapper;
+pub(crate) mod directory_mapper;
+mod escaper;
+mod package_mapper;
+mod team_gem_mapper;
+mod team_glob_mapper;
+mod team_yml_mapper;
+
+pub use annotated_file_mapper::TeamFileMapper;
+pub use directory_mapper::DirectoryMapper;
+pub use package_mapper::JavascriptPackageMapper;
+pub use package_mapper::RubyPackageMapper;
+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),
+    AnnotatedFile,
+    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::AnnotatedFile => 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::AnnotatedFile.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");
+        }
+    }
+}