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

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

@@ -0,0 +1,90 @@
+use std::path::Path;
+
+use crate::{
+    cache::Cache,
+    config::Config,
+    ownership::file_owner_resolver::find_file_owners,
+    project::Project,
+    project_builder::ProjectBuilder,
+    runner::{RunConfig, RunResult, config_from_path, team_for_file_from_codeowners},
+};
+
+pub fn crosscheck_owners(run_config: &RunConfig, cache: &Cache) -> RunResult {
+    match do_crosscheck_owners(run_config, cache) {
+        Ok(mismatches) if mismatches.is_empty() => RunResult {
+            info_messages: vec!["Success! All files match between CODEOWNERS and for-file command.".to_string()],
+            ..Default::default()
+        },
+        Ok(mismatches) => RunResult {
+            validation_errors: mismatches,
+            ..Default::default()
+        },
+        Err(err) => RunResult {
+            io_errors: vec![err],
+            ..Default::default()
+        },
+    }
+}
+
+fn do_crosscheck_owners(run_config: &RunConfig, cache: &Cache) -> Result<Vec<String>, String> {
+    let config = load_config(run_config)?;
+    let project = build_project(&config, run_config, cache)?;
+
+    let mut mismatches: Vec<String> = Vec::new();
+    for file in &project.files {
+        let (codeowners_team, fast_display) = owners_for_file(&file.path, run_config, &config)?;
+        let codeowners_display = codeowners_team.clone().unwrap_or_else(|| "Unowned".to_string());
+        if !is_match(codeowners_team.as_deref(), &fast_display) {
+            mismatches.push(format_mismatch(&project, &file.path, &codeowners_display, &fast_display));
+        }
+    }
+
+    Ok(mismatches)
+}
+
+fn load_config(run_config: &RunConfig) -> Result<Config, String> {
+    config_from_path(&run_config.config_path).map_err(|e| e.to_string())
+}
+
+fn build_project(config: &Config, run_config: &RunConfig, cache: &Cache) -> Result<Project, String> {
+    let mut project_builder = ProjectBuilder::new(
+        config,
+        run_config.project_root.clone(),
+        run_config.codeowners_file_path.clone(),
+        cache,
+    );
+    project_builder.build().map_err(|e| e.to_string())
+}
+
+fn owners_for_file(path: &Path, run_config: &RunConfig, config: &Config) -> Result<(Option<String>, String), String> {
+    let file_path_str = path.to_string_lossy().to_string();
+
+    let codeowners_team = team_for_file_from_codeowners(run_config, &file_path_str)
+        .map_err(|e| e.to_string())?
+        .map(|t| t.name);
+
+    let fast_owners = find_file_owners(&run_config.project_root, config, Path::new(&file_path_str))?;
+    let fast_display = match fast_owners.len() {
+        0 => "Unowned".to_string(),
+        1 => fast_owners[0].team.name.clone(),
+        _ => {
+            let names: Vec<String> = fast_owners.into_iter().map(|fo| fo.team.name).collect();
+            format!("Multiple: {}", names.join(", "))
+        }
+    };
+
+    Ok((codeowners_team, fast_display))
+}
+
+fn is_match(codeowners_team: Option<&str>, fast_display: &str) -> bool {
+    match (codeowners_team, fast_display) {
+        (None, "Unowned") => true,
+        (Some(t), fd) if fd == t => true,
+        _ => false,
+    }
+}
+
+fn format_mismatch(project: &Project, file_path: &Path, codeowners_display: &str, fast_display: &str) -> String {
+    let rel = project.relative_path(file_path).to_string_lossy().to_string();
+    format!("- {}: CODEOWNERS={} fast={}", rel, codeowners_display, fast_display)
+}

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

@@ -0,0 +1,11 @@
+pub mod cache;
+pub(crate) mod common_test;
+pub mod config;
+pub mod crosscheck;
+pub mod ownership;
+pub mod path_utils;
+pub(crate) mod project;
+pub mod project_builder;
+pub mod project_file_builder;
+pub mod runner;
+pub(crate) mod tracked_files;

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

@@ -0,0 +1,43 @@
+mod cli;
+use std::process;
+
+use codeowners::runner::{Error as RunnerError, RunResult};
+use error_stack::Result;
+
+use crate::cli::cli;
+
+fn main() -> Result<(), RunnerError> {
+    install_logger();
+    maybe_print_errors(cli()?)?;
+
+    Ok(())
+}
+
+fn maybe_print_errors(result: RunResult) -> Result<(), RunnerError> {
+    if !result.info_messages.is_empty() {
+        for msg in result.info_messages {
+            println!("{}", msg);
+        }
+    }
+    if !result.io_errors.is_empty() || !result.validation_errors.is_empty() {
+        for msg in result.io_errors {
+            eprintln!("{}", msg);
+        }
+        for msg in result.validation_errors {
+            println!("{}", msg);
+        }
+        process::exit(1);
+    }
+
+    Ok(())
+}
+
+fn install_logger() {
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .with_target(true)
+        .with_timer(tracing_subscriber::fmt::time::uptime())
+        .with_level(true)
+        .with_writer(std::io::stderr)
+        .init();
+}

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

@@ -0,0 +1,504 @@
+use crate::{
+    ownership::{FileGenerator, TeamOwnership},
+    project::Team,
+};
+use fast_glob::glob_match;
+use memoize::memoize;
+use rayon::prelude::*;
+use regex::Regex;
+use std::{collections::HashMap, error::Error, fs, io::Error as IoError, path::PathBuf};
+
+use super::file_generator::compare_lines;
+
+pub struct Parser {
+    pub project_root: PathBuf,
+    pub codeowners_file_path: PathBuf,
+    pub team_file_globs: Vec<String>,
+}
+
+impl Parser {
+    pub fn teams_from_files_paths(&self, file_paths: &[PathBuf]) -> Result<HashMap<String, Option<Team>>, Box<dyn Error>> {
+        let file_inputs: Vec<(String, String)> = file_paths
+            .iter()
+            .map(|path| {
+                let file_path_str = path
+                    .to_str()
+                    .ok_or(IoError::new(std::io::ErrorKind::InvalidInput, "Invalid file path"))?;
+                let original = file_path_str.to_string();
+                let prefixed = if file_path_str.starts_with('/') {
+                    original.clone()
+                } else {
+                    format!("/{}", file_path_str)
+                };
+                Ok((original, prefixed))
+            })
+            .collect::<Result<Vec<_>, IoError>>()?;
+
+        if file_inputs.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let codeowners_entries = parse_codeowners_entries(self.codeowners_file_path.to_string_lossy().into_owned());
+
+        let teams_by_name = teams_by_github_team_name(self.absolute_team_files_globs());
+
+        let result: HashMap<String, Option<Team>> = file_inputs
+            .par_iter()
+            .map(|(key, prefixed)| {
+                let team = codeowners_entries
+                    .iter()
+                    .find(|(glob, _)| glob_match(glob, prefixed))
+                    .and_then(|(_, team_name)| teams_by_name.get(team_name).cloned());
+                (key.clone(), team)
+            })
+            .collect();
+
+        Ok(result)
+    }
+
+    fn absolute_team_files_globs(&self) -> Vec<String> {
+        self.team_file_globs
+            .iter()
+            .map(|glob| format!("{}/{}", self.project_root.display(), glob))
+            .collect()
+    }
+}
+
+#[memoize]
+fn teams_by_github_team_name(team_file_glob: Vec<String>) -> HashMap<String, Team> {
+    let mut teams = HashMap::new();
+    for glob in team_file_glob {
+        match glob::glob(&glob) {
+            Ok(paths) => {
+                for path in paths.filter_map(Result::ok) {
+                    let team = match Team::from_team_file_path(path) {
+                        Ok(team) => team,
+                        Err(e) => {
+                            eprintln!("Error parsing team file: {}", e);
+                            continue;
+                        }
+                    };
+                    teams.insert(team.github_team.clone(), team);
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to read glob pattern '{}': {}", glob, e);
+                continue;
+            }
+        }
+    }
+
+    teams
+}
+
+fn build_codeowners_lines_in_priority(codeowners_file_path: String) -> Vec<String> {
+    let codeowners_file = match fs::read_to_string(codeowners_file_path) {
+        Ok(codeowners_file) => codeowners_file,
+        Err(e) => {
+            // we can't return the error because it's not clonable
+            eprintln!("Error reading codeowners file: {}", e);
+            return vec![];
+        }
+    };
+    stripped_lines_by_priority(&codeowners_file)
+}
+
+fn parse_codeowners_entries(codeowners_file_path: String) -> Vec<(String, String)> {
+    build_codeowners_lines_in_priority(codeowners_file_path)
+        .iter()
+        .filter_map(|line| {
+            line.split_once(' ')
+                .map(|(glob, team_name)| (glob.to_string(), team_name.to_string()))
+        })
+        .collect()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Section {
+    heading: String,
+    lines: Vec<String>,
+}
+
+impl Section {
+    fn new(heading: String, lines: Vec<String>) -> Self {
+        let mut sorted_lines = lines.clone();
+        sorted_lines.sort_by(compare_lines);
+        Self {
+            heading,
+            lines: sorted_lines,
+        }
+    }
+}
+
+fn codeowner_sections(codeowners_file: &str) -> Result<Vec<Section>, Box<dyn Error>> {
+    let un_ignore = Regex::new(r"^# \/")?;
+    let mut iter = codeowners_file.lines().peekable();
+    let mut sections = Vec::new();
+    let mut current_section = None;
+    let mut current_lines = Vec::new();
+
+    while let Some(line) = iter.next() {
+        let line = un_ignore.replace(line, "/").to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        if line.starts_with('#') {
+            if iter
+                .peek()
+                .map(|next| next.starts_with('/') || next.starts_with("# /"))
+                .unwrap_or(false)
+            {
+                if let Some(section_name) = current_section.take() {
+                    sections.push(Section::new(section_name, std::mem::take(&mut current_lines)));
+                }
+                current_section = Some(line);
+            }
+        } else {
+            current_lines.push(line);
+        }
+    }
+
+    if let Some(section_name) = current_section {
+        sections.push(Section::new(section_name, current_lines));
+    }
+
+    Ok(sections)
+}
+
+fn stripped_lines_by_priority(codeowners_file: &str) -> Vec<String> {
+    let mut lines = Vec::new();
+    let sections = codeowner_sections(codeowners_file).unwrap_or_default();
+    for section in sections {
+        lines.extend(section.lines);
+    }
+    lines.reverse();
+    lines
+}
+
+pub fn parse_for_team(team_name: String, codeowners_file: &str) -> Result<Vec<TeamOwnership>, Box<dyn Error>> {
+    let mut output = vec![];
+    let mut current_section: Option<TeamOwnership> = None;
+    let input: String = codeowners_file.replace(&FileGenerator::disclaimer().join("\n"), "");
+    let error_message = "CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file";
+
+    for line in input.trim_start().lines() {
+        match line {
+            comment if comment.starts_with("#") => {
+                if let Some(section) = current_section.take() {
+                    output.push(section);
+                }
+                current_section = Some(TeamOwnership::new(comment.to_string()));
+            }
+            "" => {
+                if let Some(section) = current_section.take() {
+                    output.push(section);
+                }
+            }
+            team_line if team_line.ends_with(&team_name) => {
+                let section = current_section.as_mut().ok_or(error_message)?;
+
+                let glob = line.split_once(' ').ok_or(error_message)?.0.to_string();
+                section.globs.push(glob);
+            }
+            _ => {}
+        }
+    }
+
+    if let Some(cs) = current_section {
+        output.push(cs.clone());
+    }
+
+    Ok(output)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::common_test::tests::vecs_match;
+
+    use super::*;
+    use indoc::indoc;
+
+    #[test]
+    fn test_parse_for_team_trims_header() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # STOP! - DO NOT EDIT THIS FILE MANUALLY
+            # This file was automatically generated by \"bin/codeownership validate\".
+            #
+            # CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+            # teams. This is useful when developers create Pull Requests since the
+            # code/file owner is notified. Reference GitHub docs for more details:
+            # https://help.github.com/en/articles/about-code-owners
+
+
+        "};
+
+        let team_ownership = parse_for_team("@Bar".to_string(), codeownership_file)?;
+        assert!(team_ownership.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_includes_owned_globs() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+            /path/to/not/owned @Bar
+
+            # Last Section
+            /another/owned/path @Foo
+        "};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file)?;
+        vecs_match(
+            &team_ownership,
+            &vec![
+                TeamOwnership {
+                    heading: "# First Section".to_string(),
+                    globs: vec!["/path/to/owned".to_string()],
+                },
+                TeamOwnership {
+                    heading: "# Last Section".to_string(),
+                    globs: vec!["/another/owned/path".to_string()],
+                },
+            ],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_with_partial_team_match() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+            /path/to/not/owned @FooBar
+        "};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file)?;
+        vecs_match(
+            &team_ownership,
+            &vec![TeamOwnership {
+                heading: "# First Section".to_string(),
+                globs: vec!["/path/to/owned".to_string()],
+            }],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_with_trailing_newlines() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+
+            # Last Section
+            /another/owned/path @Foo
+
+
+
+        "};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file)?;
+        vecs_match(
+            &team_ownership,
+            &vec![
+                TeamOwnership {
+                    heading: "# First Section".to_string(),
+                    globs: vec!["/path/to/owned".to_string()],
+                },
+                TeamOwnership {
+                    heading: "# Last Section".to_string(),
+                    globs: vec!["/another/owned/path".to_string()],
+                },
+            ],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_without_trailing_newline() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo"};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file)?;
+        vecs_match(
+            &team_ownership,
+            &vec![TeamOwnership {
+                heading: "# First Section".to_string(),
+                globs: vec!["/path/to/owned".to_string()],
+            }],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_with_missing_section_header() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+
+            /another/owned/path @Foo
+        "};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file);
+        assert!(
+            team_ownership
+                .is_err_and(|e| e.to_string() == "CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file")
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_with_malformed_team_line() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            @Foo
+        "};
+
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file);
+        assert!(
+            team_ownership
+                .is_err_and(|e| e.to_string() == "CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file")
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_for_team_with_invalid_file() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            # Second Section
+            path/to/owned @Foo
+        "};
+        let team_ownership = parse_for_team("@Foo".to_string(), codeownership_file)?;
+        vecs_match(
+            &team_ownership,
+            &vec![
+                TeamOwnership {
+                    heading: "# First Section".to_string(),
+                    globs: vec![],
+                },
+                TeamOwnership {
+                    heading: "# Second Section".to_string(),
+                    globs: vec!["path/to/owned".to_string()],
+                },
+            ],
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_stripped_lines_by_priority() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+        "};
+
+        let stripped_lines = stripped_lines_by_priority(codeownership_file);
+        assert_eq!(stripped_lines, vec!["/path/to/owned @Foo"]);
+        Ok(())
+    }
+
+    #[test]
+    fn test_stripped_lines_by_priority_with_multiple_sections() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # First Section
+            /path/to/owned @Foo
+
+            # Second Section
+            /another/path/to/owned @Bar
+        "};
+
+        let stripped_lines = stripped_lines_by_priority(codeownership_file);
+        assert_eq!(stripped_lines, vec!["/another/path/to/owned @Bar", "/path/to/owned @Foo"]);
+        Ok(())
+    }
+
+    #[test]
+    fn test_stripped_lines_by_priority_with_ignored_teams() -> Result<(), Box<dyn Error>> {
+        let codeownership_file = indoc! {"
+            # STOP! - DO NOT EDIT THIS FILE MANUALLY
+            # This file was automatically generated by \"bin/codeownership validate\".
+            #
+            # CODEOWNERS is used for GitHub to suggest code/file owners to various GitHub
+            # teams. This is useful when developers create Pull Requests since the
+            # code/file owner is notified. Reference GitHub docs for more details:
+            # https://help.github.com/en/articles/about-code-owners
+
+
+            # Annotations at the top of file
+            # /app/assets/config/manifest.js @Prefix/team-foo
+            # /config/application.rb @Prefix/team-bar
+            /config/i18n-tasks.yml.erb @Prefix/language-team
+
+            # Team-specific owned globs
+            # /.github/workflows/pull-translations.yml @Prefix/infra
+            # /.github/workflows/push-sources.yml @Prefix/infra
+            # /Dockerfile @Prefix/docker-team
+            # /components/create.rb @Prefix/component-team
+            /.codeclimate.yml @Prefix/climate-team
+            /.vscode/extensions/z/**/* @Prefix/zteam
+            /bin/brakeman @Prefix/psecurity
+            /config/brakeman.ignore @Prefix/security
+        "};
+
+        // build up each sections lines
+        // resort the lines without the '#'
+        // re-assemble the sections
+        // reverse sort
+        let codeowner_sections = codeowner_sections(codeownership_file)?;
+        assert_eq!(
+            codeowner_sections,
+            vec![
+                Section {
+                    heading: "# Annotations at the top of file".to_string(),
+                    lines: vec![
+                        "/app/assets/config/manifest.js @Prefix/team-foo".to_string(),
+                        "/config/application.rb @Prefix/team-bar".to_string(),
+                        "/config/i18n-tasks.yml.erb @Prefix/language-team".to_string()
+                    ]
+                },
+                Section {
+                    heading: "# Team-specific owned globs".to_string(),
+                    lines: vec![
+                        "/.codeclimate.yml @Prefix/climate-team".to_string(),
+                        "/.github/workflows/pull-translations.yml @Prefix/infra".to_string(),
+                        "/.github/workflows/push-sources.yml @Prefix/infra".to_string(),
+                        "/.vscode/extensions/z/**/* @Prefix/zteam".to_string(),
+                        "/Dockerfile @Prefix/docker-team".to_string(),
+                        "/bin/brakeman @Prefix/psecurity".to_string(),
+                        "/components/create.rb @Prefix/component-team".to_string(),
+                        "/config/brakeman.ignore @Prefix/security".to_string()
+                    ]
+                },
+            ]
+        );
+        let stripped_lines = stripped_lines_by_priority(codeownership_file);
+        assert_eq!(
+            stripped_lines,
+            vec![
+                "/config/brakeman.ignore @Prefix/security",
+                "/components/create.rb @Prefix/component-team",
+                "/bin/brakeman @Prefix/psecurity",
+                "/Dockerfile @Prefix/docker-team",
+                "/.vscode/extensions/z/**/* @Prefix/zteam",
+                "/.github/workflows/push-sources.yml @Prefix/infra",
+                "/.github/workflows/pull-translations.yml @Prefix/infra",
+                "/.codeclimate.yml @Prefix/climate-team",
+                "/config/i18n-tasks.yml.erb @Prefix/language-team",
+                "/config/application.rb @Prefix/team-bar",
+                "/app/assets/config/manifest.js @Prefix/team-foo"
+            ]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_unignore_regex() -> Result<(), Box<dyn Error>> {
+        let un_ignore = Regex::new(r"^# \/")?;
+        assert_eq!(un_ignore.replace("# /path/to/owned", "/"), "/path/to/owned");
+        Ok(())
+    }
+}

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

@@ -0,0 +1,32 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use crate::ownership::codeowners_file_parser::Parser;
+use crate::project::Team;
+
+pub(crate) fn teams_for_files_from_codeowners(
+    project_root: &Path,
+    codeowners_file_path: &Path,
+    team_file_globs: &[String],
+    file_paths: &[String],
+) -> Result<HashMap<String, Option<Team>>, String> {
+    let relative_file_paths: Vec<PathBuf> = file_paths
+        .iter()
+        .map(Path::new)
+        .map(|path| {
+            if path.is_absolute() {
+                crate::path_utils::relative_to_buf(project_root, path)
+            } else {
+                path.to_path_buf()
+            }
+        })
+        .collect();
+
+    let parser = Parser {
+        codeowners_file_path: codeowners_file_path.to_path_buf(),
+        project_root: project_root.to_path_buf(),
+        team_file_globs: team_file_globs.to_vec(),
+    };
+
+    parser.teams_from_files_paths(&relative_file_paths).map_err(|e| e.to_string())
+}