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

data/ext/cargo-vendor/codeowners-0.2.17/src/cli.rs

@@ -0,0 +1,129 @@
+use clap::{Parser, Subcommand};
+use codeowners::runner::RunConfig;
+use codeowners::runner::{self, Error as RunnerError, RunResult};
+use error_stack::{Result, ResultExt};
+use path_clean::PathClean;
+use std::path::{Path, PathBuf};
+
+#[derive(Subcommand, Debug)]
+#[command(version)]
+enum Command {
+    #[clap(about = "Finds the owner of a given file.", visible_alias = "f")]
+    ForFile {
+        #[arg(
+            short,
+            long,
+            default_value = "false",
+            help = "Find the owner from the CODEOWNERS file and just return the team name and yml path"
+        )]
+        from_codeowners: bool,
+        #[arg(short, long, default_value = "false", help = "Output the result in JSON format")]
+        json: bool,
+        name: String,
+    },
+
+    #[clap(about = "Finds code ownership information for a given team", visible_alias = "t")]
+    ForTeam { name: String },
+
+    #[clap(
+        about = "Generate the CODEOWNERS file and save it to '--codeowners-file-path'.",
+        visible_alias = "g"
+    )]
+    Generate {
+        #[arg(long, short, default_value = "false", help = "Skip staging the CODEOWNERS file")]
+        skip_stage: bool,
+    },
+
+    #[clap(
+        about = "Validate the validity of the CODEOWNERS file. A validation failure will exit with a failure code and a detailed output of the validation errors.",
+        visible_alias = "v"
+    )]
+    Validate,
+
+    #[clap(about = "Chains both `generate` and `validate` commands.", visible_alias = "gv")]
+    GenerateAndValidate {
+        #[arg(long, short, default_value = "false", help = "Skip staging the CODEOWNERS file")]
+        skip_stage: bool,
+    },
+
+    #[clap(about = "Delete the cache file.", visible_alias = "d")]
+    DeleteCache,
+
+    #[clap(about = "Compare the CODEOWNERS file to the for-file command.", hide = true)]
+    CrosscheckOwners,
+}
+
+/// A CLI to validate and generate Github's CODEOWNERS file.
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    #[command(subcommand)]
+    command: Command,
+
+    /// Path for the CODEOWNERS file.
+    #[arg(long, default_value = "./.github/CODEOWNERS")]
+    codeowners_file_path: PathBuf,
+    /// Path for the configuration file
+    #[arg(long, default_value = "./config/code_ownership.yml")]
+    config_path: PathBuf,
+
+    /// Path for the root of the project
+    #[arg(long, default_value = ".")]
+    project_root: PathBuf,
+
+    /// Run without the cache (good for CI, testing)
+    #[arg(long)]
+    no_cache: bool,
+}
+
+impl Args {
+    fn absolute_project_root(&self) -> Result<PathBuf, RunnerError> {
+        self.project_root.canonicalize().change_context(RunnerError::Io(format!(
+            "Can't canonicalize project root: {}",
+            &self.project_root.to_string_lossy()
+        )))
+    }
+
+    fn absolute_config_path(&self) -> Result<PathBuf, RunnerError> {
+        Ok(self.absolute_path(&self.config_path)?.clean())
+    }
+
+    fn absolute_codeowners_path(&self) -> Result<PathBuf, RunnerError> {
+        Ok(self.absolute_path(&self.codeowners_file_path)?.clean())
+    }
+
+    fn absolute_path(&self, path: &Path) -> Result<PathBuf, RunnerError> {
+        Ok(self.absolute_project_root()?.join(path))
+    }
+}
+
+pub fn cli() -> Result<RunResult, RunnerError> {
+    let args = Args::parse();
+
+    let config_path = args.absolute_config_path()?;
+    let codeowners_file_path = args.absolute_codeowners_path()?;
+    let project_root = args.absolute_project_root()?;
+
+    let run_config = RunConfig {
+        config_path,
+        codeowners_file_path,
+        project_root,
+        no_cache: args.no_cache,
+    };
+
+    let runner_result = match args.command {
+        Command::Validate => runner::validate(&run_config, vec![]),
+        Command::Generate { skip_stage } => runner::generate(&run_config, !skip_stage),
+        Command::GenerateAndValidate { skip_stage } => runner::generate_and_validate(&run_config, vec![], !skip_stage),
+        Command::ForFile {
+            name,
+            from_codeowners,
+            json,
+        } => runner::for_file(&run_config, &name, from_codeowners, json),
+        Command::ForTeam { name } => runner::for_team(&run_config, &name),
+        Command::DeleteCache => runner::delete_cache(&run_config),
+        Command::CrosscheckOwners => runner::crosscheck_owners(&run_config),
+    };
+
+    Ok(runner_result)
+}

data/ext/cargo-vendor/codeowners-0.2.17/src/common_test.rs

@@ -0,0 +1,358 @@
+#[cfg(test)]
+pub mod tests {
+    use std::{
+        error::Error,
+        fs::{self, File},
+        path::PathBuf,
+    };
+
+    use indoc::indoc;
+
+    use tempfile::tempdir;
+
+    use crate::{
+        cache::{Cache, noop::NoopCache},
+        config::Config,
+        ownership::Ownership,
+        project_builder::ProjectBuilder,
+    };
+
+    macro_rules! ownership {
+        ($($test_files:expr),+) => {{
+            let temp_dir = tempdir()?;
+            let test_config = TestConfig::new(
+                temp_dir.path().to_path_buf(),
+                vec![$($test_files),+]
+            );
+            build_ownership(test_config)
+        }};
+    }
+
+    pub const DEFAULT_CODE_OWNERSHIP_YML: &str = indoc! {"
+        ---
+        owned_globs:
+          - \"{app,components,config,frontend,lib,packs,spec,ruby}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml,erb}\"
+        unowned_globs:
+          - config/code_ownership.yml
+        javascript_package_paths:
+          - javascript/packages/**
+        vendored_gems_path: gems
+        team_file_glob:
+          - config/teams/**/*.yml
+    "};
+
+    #[derive(Debug)]
+    pub struct TestConfig {
+        pub temp_dir_path: PathBuf,
+        pub team_names: Vec<String>,
+        pub files: Vec<TestProjectFile>,
+
+        pub code_ownership_config_yml: String,
+        pub relative_code_ownership_config_yml_path: String,
+        pub relative_teams_path: String,
+        pub generate_codeowners: bool,
+    }
+
+    impl Default for TestConfig {
+        fn default() -> Self {
+            Self {
+                code_ownership_config_yml: DEFAULT_CODE_OWNERSHIP_YML.to_owned(),
+                relative_code_ownership_config_yml_path: "config/code_ownership.yml".to_owned(),
+                relative_teams_path: "config/teams".to_owned(),
+                generate_codeowners: true,
+                temp_dir_path: PathBuf::default(),
+                team_names: vec!["Bar".to_owned(), "Foo".to_owned(), "Baz".to_owned(), "Bam".to_owned()],
+                files: vec![],
+            }
+        }
+    }
+
+    impl TestConfig {
+        pub fn new(temp_dir_path: PathBuf, files: Vec<TestProjectFile>) -> Self {
+            Self {
+                temp_dir_path,
+                files,
+                ..Default::default()
+            }
+        }
+    }
+
+    #[derive(Debug, Default)]
+    pub struct TestProjectFile {
+        pub relative_path: String,
+        pub content: String,
+    }
+
+    pub fn build_ownership(test_config: TestConfig) -> Result<Ownership, Box<dyn Error>> {
+        fs::create_dir_all(test_config.temp_dir_path.join(".github"))?;
+        fs::create_dir_all(test_config.temp_dir_path.join(&test_config.relative_teams_path))?;
+
+        fs::write(
+            test_config.temp_dir_path.join(&test_config.relative_code_ownership_config_yml_path),
+            test_config.code_ownership_config_yml,
+        )?;
+
+        let relative_teams_path = &test_config.relative_teams_path;
+        for name in test_config.team_names.iter() {
+            let team_yml = format!("name: {}\ngithub:\n  team: \"@{}\"\n  members:\n    - {}member\n", name, name, name);
+            fs::write(
+                test_config
+                    .temp_dir_path
+                    .join(relative_teams_path)
+                    .join(format!("{}.yml", name.to_lowercase())),
+                team_yml,
+            )?;
+        }
+
+        for project_file in test_config.files.iter() {
+            if let Some(parent_dir) = PathBuf::from(&project_file.relative_path).parent() {
+                fs::create_dir_all(test_config.temp_dir_path.join(parent_dir))?;
+            }
+            fs::write(test_config.temp_dir_path.join(&project_file.relative_path), &project_file.content)?;
+        }
+
+        let config_file = File::open(test_config.temp_dir_path.join(test_config.relative_code_ownership_config_yml_path))?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
+
+        let codeowners_file_path = &test_config.temp_dir_path.join(".github/CODEOWNERS");
+        let cache: Cache = NoopCache::default().into();
+        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone(), &cache);
+        let project = builder.build()?;
+        let ownership = Ownership::build(project);
+        if test_config.generate_codeowners {
+            std::fs::write(codeowners_file_path, ownership.generate_file())?;
+        }
+        // rebuild project to ensure new codeowners file is read
+        let mut builder = ProjectBuilder::new(&config, test_config.temp_dir_path.clone(), codeowners_file_path.clone(), &cache);
+        let project = builder.build()?;
+        Ok(Ownership::build(project))
+    }
+
+    pub fn build_ownership_with_directory_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(
+            TestProjectFile {
+                relative_path: "app/consumers/deep/nesting/nestdir/deep_file.rb".to_owned(),
+                content: "class DeepFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/consumers/one_owner.rb".to_owned(),
+                content: "class OneOwner\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/service_file.rb".to_owned(),
+                content: "class ServiceFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/some_other_file.rb".to_owned(),
+                content: "class SomeOtherFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/consumers/.codeowner".to_owned(),
+                content: "Bar\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/.codeowner".to_owned(),
+                content: "Foo\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/exciting/.codeowner".to_owned(),
+                content: "Bar\n".to_owned(),
+            }
+        )
+    }
+
+    pub fn build_ownership_with_directory_codeowners_with_brackets() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(
+            TestProjectFile {
+                relative_path: "app/[consumers]/deep/nesting/[nestdir]/deep_file.rb".to_owned(),
+                content: "class DeepFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/[consumers]/one_owner.rb".to_owned(),
+                content: "class OneOwner\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/service_file.rb".to_owned(),
+                content: "class ServiceFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/services/some_other_file.rb".to_owned(),
+                content: "class SomeOtherFile\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/[consumers]/.codeowner".to_owned(),
+                content: "Bar\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/[consumers]/deep/nesting/[nestdir]/.codeowner".to_owned(),
+                content: "Foo\n".to_owned(),
+            }
+        )
+    }
+
+    pub fn build_ownership_with_all_mappers() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(
+            TestProjectFile {
+                relative_path: "app/consumers/directory_owned.rb".to_owned(),
+                content: "class DirectoryOwned\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "app/consumers/.codeowner".to_owned(),
+                content: "Bar\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/foo/package.yml".to_owned(),
+                content: "owner: Baz\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/foo/app/services/package_owned.rb".to_owned(),
+                content: "class PackageOwned\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/bar/app/services/team_file_owned.rb".to_owned(),
+                content: "class GlobMapperOwned\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "config/teams/baz.yml".to_owned(),
+                content: "name: Baz\ngithub:\n  team: \"@Baz\"\n  members:\n    - Baz member\nowned_globs:\n  - \"packs/bar/**\"\n"
+                    .to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/zebra/app/services/team_file_owned.rb".to_owned(),
+                content: "# @team Foo\nclass TeamFileOwned\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/jscomponents/comp.ts".to_owned(),
+                content: "// @team Foo\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "gems/taco/sauce.rb".to_owned(),
+                content: "class Taco::Sauce\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "config/teams/bam.yml".to_owned(),
+                content: "name: Bam\ngithub:\n  team: \"@Bam\"\n  members:\n    - Bam member\nruby:\n  owned_gems:\n    - taco\n"
+                    .to_owned(),
+            }
+        )
+    }
+    pub fn build_ownership_with_team_file_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+
+        let test_config = TestConfig::new(
+            temp_dir.path().to_path_buf(),
+            vec![
+                TestProjectFile {
+                    relative_path: "packs/jscomponents/comp.ts".to_owned(),
+                    content: "// @team Foo\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "packs/jscomponents/comp-colon.ts".to_owned(),
+                    content: "// @team: Foo\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "packs/[admin]/comp.ts".to_owned(),
+                    content: "// @team Bar\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "packs/bar/comp.rb".to_owned(),
+                    content: "# @team Bar\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "packs/bar/comp_colon.rb".to_owned(),
+                    content: "# @team: Bar\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "ruby/app/views/foos/edit.erb".to_owned(),
+                    content: "<%# @team: Foo %>\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "ruby/app/views/foos/show.html.erb".to_owned(),
+                    content: "<!-- @team: Bar -->\n".to_owned(),
+                },
+                TestProjectFile {
+                    relative_path: "ruby/app/views/foos/_row.html.erb".to_owned(),
+                    content: "<!-- @team Bam -->\n".to_owned(),
+                },
+            ],
+        );
+        build_ownership(test_config)
+    }
+    pub fn build_ownership_with_team_gem_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(
+            TestProjectFile {
+                relative_path: "gems/globbing/globber.rb".to_owned(),
+                content: "class Globbing::Globber\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "config/teams/bam.yml".to_owned(),
+                content: "name: Bam\ngithub:\n  team: \"@Bam\"\n  members:\n    - Bam member\nruby:\n  owned_gems:\n    - globbing\n"
+                    .to_owned(),
+            }
+        )
+    }
+
+    pub fn build_ownership_with_team_glob_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(TestProjectFile {
+            relative_path: "config/teams/baz.yml".to_owned(),
+            content: "name: Baz\ngithub:\n  team: \"@Baz\"\n  members:\n    - Baz member\nowned_globs:\n  - \"packs/bar/**\"\n".to_owned(),
+        })
+    }
+
+    pub fn build_ownership_with_subtracted_globs_team_glob_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(TestProjectFile {
+            relative_path: "config/teams/baz.yml".to_owned(),
+            content: "name: Baz\ngithub:\n  team: \"@Baz\"\n  members:\n    - Baz member\nowned_globs:\n  - \"packs/bar/**\"\nunowned_globs:\n  - \"packs/bar/excluded/**\"\n".to_owned(),
+        })
+    }
+
+    pub fn build_ownership_with_team_yml_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+
+        let test_config = TestConfig::new(temp_dir.path().to_path_buf(), vec![]);
+        build_ownership(test_config)
+    }
+    pub fn build_ownership_with_package_codeowners() -> Result<Ownership, Box<dyn Error>> {
+        ownership!(
+            TestProjectFile {
+                relative_path: "packs/foo/package.yml".to_owned(),
+                content: "owner: Baz\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/foo/app/services/package_owned.rb".to_owned(),
+                content: "class PackageOwned\nend\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/bam/package.yml".to_owned(),
+                content: "owner: Bam\n".to_owned(),
+            },
+            TestProjectFile {
+                relative_path: "packs/bam/app/services/package_owned.rb".to_owned(),
+                content: "class PackageOwned\nend\n".to_owned(),
+            }
+        )
+    }
+
+    pub fn vecs_match<T: PartialEq + std::fmt::Debug>(a: &Vec<T>, b: &Vec<T>) {
+        // First check lengths match
+        assert_eq!(a.len(), b.len(), "Vectors have different lengths");
+
+        // Check each element in a exists in b
+        for elem_a in a {
+            assert!(
+                b.contains(elem_a),
+                "Element {:?} from first vector not found in second vector",
+                elem_a
+            );
+        }
+
+        // Check each element in b exists in a
+        for elem_b in b {
+            assert!(
+                a.contains(elem_b),
+                "Element {:?} from second vector not found in first vector",
+                elem_b
+            );
+        }
+    }
+}

data/ext/cargo-vendor/codeowners-0.2.17/src/config.rs

@@ -0,0 +1,126 @@
+use serde::Deserialize;
+use std::{fs::File, path::Path};
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Config {
+    pub owned_globs: Vec<String>,
+
+    #[serde(default = "ruby_package_paths")]
+    pub ruby_package_paths: Vec<String>,
+
+    #[serde(alias = "js_package_paths", default = "javascript_package_paths")]
+    pub javascript_package_paths: Vec<String>,
+
+    #[serde(default = "team_file_glob")]
+    pub team_file_glob: Vec<String>,
+
+    #[serde(default = "unowned_globs")]
+    pub unowned_globs: Vec<String>,
+
+    #[serde(alias = "unbuilt_gems_path", default = "vendored_gems_path")]
+    pub vendored_gems_path: String,
+
+    #[serde(default = "default_cache_directory")]
+    pub cache_directory: String,
+
+    #[serde(default = "default_ignore_dirs")]
+    pub ignore_dirs: Vec<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Deserialize, Debug)]
+pub struct RubyPackageConfig {
+    #[serde(alias = "pack_paths")]
+    pub ruby_package_paths: Vec<String>,
+}
+
+fn ruby_package_paths() -> Vec<String> {
+    vec!["packs/**/*".to_owned(), "components/**".to_owned()]
+}
+
+fn team_file_glob() -> Vec<String> {
+    vec!["config/teams/**/*.yml".to_owned()]
+}
+
+fn default_cache_directory() -> String {
+    String::from("tmp/cache/codeowners")
+}
+
+fn javascript_package_paths() -> Vec<String> {
+    vec!["frontend/**/*".to_owned()]
+}
+
+fn unowned_globs() -> Vec<String> {
+    vec![
+        "frontend/**/node_modules/**/*".to_owned(),
+        "frontend/**/__generated__/**/*".to_owned(),
+    ]
+}
+
+fn vendored_gems_path() -> String {
+    "vendored/".to_string()
+}
+
+fn default_ignore_dirs() -> Vec<String> {
+    vec![
+        ".cursor".to_owned(),
+        ".git".to_owned(),
+        ".idea".to_owned(),
+        ".vscode".to_owned(),
+        ".yarn".to_owned(),
+        "ar_doc".to_owned(),
+        "db".to_owned(),
+        "helm".to_owned(),
+        "log".to_owned(),
+        "node_modules".to_owned(),
+        "sorbet".to_owned(),
+        "tmp".to_owned(),
+    ]
+}
+
+impl Config {
+    pub fn load_from_path(path: &Path) -> std::result::Result<Self, String> {
+        let file = File::open(path).map_err(|e| format!("Can't open config file: {} ({})", path.to_string_lossy(), e))?;
+        serde_yaml::from_reader(file).map_err(|e| format!("Can't parse config file: {} ({})", path.to_string_lossy(), e))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        error::Error,
+        fs::{self, File},
+    };
+
+    use indoc::indoc;
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn test_parse_config() -> Result<(), Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+        let config_path = temp_dir.path().join("config.yml");
+        let config_str = indoc! {"
+            ---
+            owned_globs:
+              - \"{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}\"
+        "};
+        fs::write(&config_path, config_str)?;
+        let config_file = File::open(&config_path)?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
+        assert_eq!(
+            config.owned_globs,
+            vec!["{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx,json,yml}"]
+        );
+        assert_eq!(config.ruby_package_paths, vec!["packs/**/*", "components/**"]);
+        assert_eq!(config.javascript_package_paths, vec!["frontend/**/*"]);
+        assert_eq!(config.team_file_glob, vec!["config/teams/**/*.yml"]);
+        assert_eq!(
+            config.unowned_globs,
+            vec!["frontend/**/node_modules/**/*", "frontend/**/__generated__/**/*"]
+        );
+        assert_eq!(config.vendored_gems_path, "vendored/");
+        Ok(())
+    }
+}