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

data/ext/cargo-vendor/codeowners-0.2.17/src/runner/api.rs

@@ -0,0 +1,141 @@
+use std::collections::HashMap;
+
+use crate::ownership::FileOwner;
+use crate::project::Team;
+
+use super::{Error, ForFileResult, RunConfig, RunResult, config_from_path, run};
+
+pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool, json: bool) -> RunResult {
+    if from_codeowners {
+        return for_file_codeowners_only_fast(run_config, file_path, json);
+    }
+    for_file_optimized(run_config, file_path, json)
+}
+
+pub fn for_team(run_config: &RunConfig, team_name: &str) -> RunResult {
+    run(run_config, |runner| runner.for_team(team_name))
+}
+
+pub fn validate(run_config: &RunConfig, _file_paths: Vec<String>) -> RunResult {
+    run(run_config, |runner| runner.validate())
+}
+
+pub fn generate(run_config: &RunConfig, git_stage: bool) -> RunResult {
+    run(run_config, |runner| runner.generate(git_stage))
+}
+
+pub fn generate_and_validate(run_config: &RunConfig, _file_paths: Vec<String>, git_stage: bool) -> RunResult {
+    run(run_config, |runner| runner.generate_and_validate(git_stage))
+}
+
+pub fn delete_cache(run_config: &RunConfig) -> RunResult {
+    run(run_config, |runner| runner.delete_cache())
+}
+
+pub fn crosscheck_owners(run_config: &RunConfig) -> RunResult {
+    run(run_config, |runner| runner.crosscheck_owners())
+}
+
+// Returns all owners for a file without creating a Runner (performance optimized)
+pub fn owners_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Vec<FileOwner>, Error> {
+    let config = config_from_path(&run_config.config_path)?;
+    use crate::ownership::file_owner_resolver::find_file_owners;
+    let owners = find_file_owners(&run_config.project_root, &config, std::path::Path::new(file_path)).map_err(Error::Io)?;
+    Ok(owners)
+}
+
+// Returns the highest priority owner for a file. More to come here.
+pub fn file_owner_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<FileOwner>, Error> {
+    let owners = owners_for_file(run_config, file_path)?;
+    Ok(owners.first().cloned())
+}
+
+pub fn team_for_file(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<Team>, Error> {
+    let owner = file_owner_for_file(run_config, file_path)?;
+    Ok(owner.map(|fo| fo.team.clone()))
+}
+
+// For an array of file paths, return a map of file path to its owning team
+pub fn teams_for_files_from_codeowners(
+    run_config: &RunConfig,
+    file_paths: &[String],
+) -> error_stack::Result<HashMap<String, Option<Team>>, Error> {
+    let config = config_from_path(&run_config.config_path)?;
+    let res = crate::ownership::codeowners_query::teams_for_files_from_codeowners(
+        &run_config.project_root,
+        &run_config.codeowners_file_path,
+        &config.team_file_glob,
+        file_paths,
+    )
+    .map_err(Error::Io)?;
+    Ok(res)
+}
+
+pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) -> error_stack::Result<Option<Team>, Error> {
+    let result = teams_for_files_from_codeowners(run_config, &[file_path.to_string()])?;
+    // Since we only passed one file, there should be exactly one result
+    debug_assert_eq!(result.len(), 1);
+    Ok(result.into_values().next().flatten())
+}
+
+// Fast path that avoids creating a full Runner for single file queries
+fn for_file_optimized(run_config: &RunConfig, file_path: &str, json: bool) -> RunResult {
+    let config = match config_from_path(&run_config.config_path) {
+        Ok(c) => c,
+        Err(err) => {
+            return RunResult::from_io_error(Error::Io(err.to_string()), json);
+        }
+    };
+
+    use crate::ownership::file_owner_resolver::find_file_owners;
+    let file_owners = match find_file_owners(&run_config.project_root, &config, std::path::Path::new(file_path)) {
+        Ok(v) => v,
+        Err(err) => {
+            return RunResult::from_io_error(Error::Io(err), json);
+        }
+    };
+
+    match file_owners.as_slice() {
+        [] => RunResult::from_file_owner(&crate::ownership::FileOwner::default(), json),
+        [owner] => RunResult::from_file_owner(owner, json),
+        many => {
+            let mut error_messages = vec!["Error: file is owned by multiple teams!".to_string()];
+            for owner in many {
+                error_messages.push(format!("\n{}", owner));
+            }
+            RunResult::from_validation_errors(error_messages, json)
+        }
+    }
+}
+
+fn for_file_codeowners_only_fast(run_config: &RunConfig, file_path: &str, json: bool) -> RunResult {
+    match team_for_file_from_codeowners(run_config, file_path) {
+        Ok(Some(team)) => {
+            let team_yml = crate::path_utils::relative_to(&run_config.project_root, team.path.as_path())
+                .to_string_lossy()
+                .to_string();
+            let result = ForFileResult {
+                team_name: team.name.clone(),
+                github_team: team.github_team.clone(),
+                team_yml,
+                description: vec!["Owner inferred from codeowners file".to_string()],
+            };
+            if json {
+                RunResult::json_info(result)
+            } else {
+                RunResult {
+                    info_messages: vec![format!(
+                        "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- {}",
+                        result.team_name,
+                        result.github_team,
+                        result.team_yml,
+                        result.description.join("\n- ")
+                    )],
+                    ..Default::default()
+                }
+            }
+        }
+        Ok(None) => RunResult::from_file_owner(&crate::ownership::FileOwner::default(), json),
+        Err(err) => RunResult::from_io_error(Error::Io(format!("{}", err)), json),
+    }
+}

data/ext/cargo-vendor/codeowners-0.2.17/src/runner/types.rs

@@ -0,0 +1,37 @@
+use core::fmt;
+use std::path::PathBuf;
+
+use error_stack::Context;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct RunResult {
+    pub validation_errors: Vec<String>,
+    pub io_errors: Vec<String>,
+    pub info_messages: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct RunConfig {
+    pub project_root: PathBuf,
+    pub codeowners_file_path: PathBuf,
+    pub config_path: PathBuf,
+    pub no_cache: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub enum Error {
+    Io(String),
+    ValidationFailed,
+}
+
+impl Context for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Io(msg) => fmt.write_str(msg),
+            Error::ValidationFailed => fmt.write_str("Error::ValidationFailed"),
+        }
+    }
+}

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

@@ -0,0 +1,390 @@
+use std::{path::Path, process::Command};
+
+use error_stack::{Result, ResultExt};
+use serde::Serialize;
+
+use crate::{
+    cache::{Cache, Caching, file::GlobalCache, noop::NoopCache},
+    config::Config,
+    ownership::{FileOwner, Ownership},
+    project_builder::ProjectBuilder,
+};
+
+mod types;
+pub use self::types::{Error, RunConfig, RunResult};
+mod api;
+pub use self::api::*;
+
+pub struct Runner {
+    run_config: RunConfig,
+    ownership: Ownership,
+    cache: Cache,
+    config: Config,
+}
+
+pub fn version() -> String {
+    env!("CARGO_PKG_VERSION").to_string()
+}
+
+pub type Runnable = fn(Runner) -> RunResult;
+
+pub fn run<F>(run_config: &RunConfig, runnable: F) -> RunResult
+where
+    F: FnOnce(Runner) -> RunResult,
+{
+    let runner = match Runner::new(run_config) {
+        Ok(runner) => runner,
+        Err(err) => {
+            return RunResult {
+                io_errors: vec![err.to_string()],
+                ..Default::default()
+            };
+        }
+    };
+    runnable(runner)
+}
+
+pub(crate) fn config_from_path(path: &Path) -> Result<Config, Error> {
+    match crate::config::Config::load_from_path(path) {
+        Ok(c) => Ok(c),
+        Err(msg) => Err(error_stack::Report::new(Error::Io(msg))),
+    }
+}
+impl Runner {
+    pub fn new(run_config: &RunConfig) -> Result<Self, Error> {
+        let config = config_from_path(&run_config.config_path)?;
+
+        let cache: Cache = if run_config.no_cache {
+            NoopCache::default().into()
+        } else {
+            GlobalCache::new(run_config.project_root.clone(), config.cache_directory.clone())
+                .change_context(Error::Io(format!(
+                    "Can't create cache: {}",
+                    &run_config.config_path.to_string_lossy()
+                )))
+                .attach_printable(format!("Can't create cache: {}", &run_config.config_path.to_string_lossy()))?
+                .into()
+        };
+
+        let mut project_builder = ProjectBuilder::new(
+            &config,
+            run_config.project_root.clone(),
+            run_config.codeowners_file_path.clone(),
+            &cache,
+        );
+        let project = project_builder.build().change_context(Error::Io(format!(
+            "Can't build project: {}",
+            &run_config.config_path.to_string_lossy()
+        )))?;
+        let ownership = Ownership::build(project);
+
+        cache.persist_cache().change_context(Error::Io(format!(
+            "Can't persist cache: {}",
+            &run_config.config_path.to_string_lossy()
+        )))?;
+
+        Ok(Self {
+            run_config: run_config.clone(),
+            ownership,
+            cache,
+            config,
+        })
+    }
+
+    pub fn validate(&self) -> RunResult {
+        match self.ownership.validate() {
+            Ok(_) => RunResult::default(),
+            Err(err) => RunResult {
+                validation_errors: vec![format!("{}", err)],
+                ..Default::default()
+            },
+        }
+    }
+
+    pub fn generate(&self, git_stage: bool) -> RunResult {
+        let content = self.ownership.generate_file();
+        if let Some(parent) = &self.run_config.codeowners_file_path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        match std::fs::write(&self.run_config.codeowners_file_path, content) {
+            Ok(_) => {
+                if git_stage {
+                    self.git_stage();
+                }
+                RunResult::default()
+            }
+            Err(err) => RunResult {
+                io_errors: vec![err.to_string()],
+                ..Default::default()
+            },
+        }
+    }
+
+    pub fn generate_and_validate(&self, git_stage: bool) -> RunResult {
+        let run_result = self.generate(git_stage);
+        if run_result.has_errors() {
+            return run_result;
+        }
+        self.validate()
+    }
+
+    fn git_stage(&self) {
+        let _ = Command::new("git")
+            .arg("add")
+            .arg(&self.run_config.codeowners_file_path)
+            .current_dir(&self.run_config.project_root)
+            .output();
+    }
+
+    pub fn for_team(&self, team_name: &str) -> RunResult {
+        let mut info_messages = vec![];
+        let mut io_errors = vec![];
+        match self.ownership.for_team(team_name) {
+            Ok(team_ownerships) => {
+                info_messages.push(format!("# Code Ownership Report for `{}` Team", team_name));
+                for team_ownership in team_ownerships {
+                    info_messages.push(format!("\n#{}", team_ownership.heading));
+                    match team_ownership.globs.len() {
+                        0 => info_messages.push("This team owns nothing in this category.".to_string()),
+                        _ => info_messages.push(team_ownership.globs.join("\n")),
+                    }
+                }
+            }
+            Err(err) => io_errors.push(format!("{}", err)),
+        }
+        RunResult {
+            info_messages,
+            io_errors,
+            ..Default::default()
+        }
+    }
+
+    pub fn delete_cache(&self) -> RunResult {
+        match self.cache.delete_cache().change_context(Error::Io(format!(
+            "Can't delete cache: {}",
+            &self.run_config.config_path.to_string_lossy()
+        ))) {
+            Ok(_) => RunResult::default(),
+            Err(err) => RunResult {
+                io_errors: vec![err.to_string()],
+                ..Default::default()
+            },
+        }
+    }
+
+    pub fn crosscheck_owners(&self) -> RunResult {
+        crate::crosscheck::crosscheck_owners(&self.run_config, &self.cache)
+    }
+
+    pub fn owners_for_file(&self, file_path: &str) -> Result<Vec<FileOwner>, Error> {
+        use crate::ownership::file_owner_resolver::find_file_owners;
+        let owners = find_file_owners(&self.run_config.project_root, &self.config, std::path::Path::new(file_path)).map_err(Error::Io)?;
+        Ok(owners)
+    }
+
+    pub fn for_file_derived(&self, file_path: &str, json: bool) -> RunResult {
+        let file_owners = match self.owners_for_file(file_path) {
+            Ok(v) => v,
+            Err(err) => {
+                return RunResult::from_io_error(Error::Io(err.to_string()), json);
+            }
+        };
+
+        match file_owners.as_slice() {
+            [] => RunResult::from_file_owner(&FileOwner::default(), json),
+            [owner] => RunResult::from_file_owner(owner, json),
+            many => {
+                let mut error_messages = vec!["Error: file is owned by multiple teams!".to_string()];
+                for owner in many {
+                    error_messages.push(format!("\n{}", owner));
+                }
+                RunResult::from_validation_errors(error_messages, json)
+            }
+        }
+    }
+
+    pub fn for_file_codeowners_only(&self, file_path: &str, json: bool) -> RunResult {
+        match team_for_file_from_codeowners(&self.run_config, file_path) {
+            Ok(Some(team)) => {
+                let team_yml = crate::path_utils::relative_to(&self.run_config.project_root, team.path.as_path())
+                    .to_string_lossy()
+                    .to_string();
+                let result = ForFileResult {
+                    team_name: team.name.clone(),
+                    github_team: team.github_team.clone(),
+                    team_yml,
+                    description: vec!["Owner inferred from codeowners file".to_string()],
+                };
+                if json {
+                    RunResult::json_info(result)
+                } else {
+                    RunResult {
+                        info_messages: vec![format!(
+                            "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- {}",
+                            result.team_name,
+                            result.github_team,
+                            result.team_yml,
+                            result.description.join("\n- ")
+                        )],
+                        ..Default::default()
+                    }
+                }
+            }
+            Ok(None) => RunResult::from_file_owner(&FileOwner::default(), json),
+            Err(err) => {
+                if json {
+                    RunResult::json_io_error(Error::Io(err.to_string()))
+                } else {
+                    RunResult {
+                        io_errors: vec![err.to_string()],
+                        ..Default::default()
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ForFileResult {
+    pub team_name: String,
+    pub github_team: String,
+    pub team_yml: String,
+    pub description: Vec<String>,
+}
+
+impl RunResult {
+    pub fn has_errors(&self) -> bool {
+        !self.validation_errors.is_empty() || !self.io_errors.is_empty()
+    }
+
+    fn from_io_error(error: Error, json: bool) -> Self {
+        if json {
+            Self::json_io_error(error)
+        } else {
+            Self {
+                io_errors: vec![error.to_string()],
+                ..Default::default()
+            }
+        }
+    }
+
+    fn from_file_owner(file_owner: &FileOwner, json: bool) -> Self {
+        if json {
+            let description: Vec<String> = if file_owner.sources.is_empty() {
+                vec![]
+            } else {
+                file_owner.sources.iter().map(|source| source.to_string()).collect()
+            };
+            Self::json_info(ForFileResult {
+                team_name: file_owner.team.name.clone(),
+                github_team: file_owner.team.github_team.clone(),
+                team_yml: file_owner.team_config_file_path.clone(),
+                description,
+            })
+        } else {
+            Self {
+                info_messages: vec![format!("{}", file_owner)],
+                ..Default::default()
+            }
+        }
+    }
+
+    fn from_validation_errors(validation_errors: Vec<String>, json: bool) -> Self {
+        if json {
+            Self::json_validation_error(validation_errors)
+        } else {
+            Self {
+                validation_errors,
+                ..Default::default()
+            }
+        }
+    }
+
+    pub fn json_info(result: ForFileResult) -> Self {
+        let json = match serde_json::to_string_pretty(&result) {
+            Ok(json) => json,
+            Err(e) => return Self::fallback_io_error(&e.to_string()),
+        };
+        Self {
+            info_messages: vec![json],
+            ..Default::default()
+        }
+    }
+
+    pub fn json_io_error(error: Error) -> Self {
+        let message = match error {
+            Error::Io(msg) => msg,
+            Error::ValidationFailed => "Error::ValidationFailed".to_string(),
+        };
+        let json = match serde_json::to_string(&serde_json::json!({"error": message})) {
+            Ok(json) => json,
+            Err(e) => return Self::fallback_io_error(&format!("JSON serialization failed: {}", e)),
+        };
+        Self {
+            io_errors: vec![json],
+            ..Default::default()
+        }
+    }
+
+    pub fn json_validation_error(validation_errors: Vec<String>) -> Self {
+        let json_obj = serde_json::json!({"validation_errors": validation_errors});
+        let json = match serde_json::to_string_pretty(&json_obj) {
+            Ok(json) => json,
+            Err(e) => return Self::fallback_io_error(&format!("JSON serialization failed: {}", e)),
+        };
+        Self {
+            validation_errors: vec![json],
+            ..Default::default()
+        }
+    }
+
+    fn fallback_io_error(message: &str) -> Self {
+        Self {
+            io_errors: vec![format!("{{\"error\": \"{}\"}}", message.replace('"', "\\\""))],
+            ..Default::default()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_version() {
+        assert_eq!(version(), env!("CARGO_PKG_VERSION").to_string());
+    }
+    #[test]
+    fn test_json_info() {
+        let result = ForFileResult {
+            team_name: "team1".to_string(),
+            github_team: "team1".to_string(),
+            team_yml: "config/teams/team1.yml".to_string(),
+            description: vec!["file annotation".to_string()],
+        };
+        let result = RunResult::json_info(result);
+        assert_eq!(result.info_messages.len(), 1);
+        assert_eq!(
+            result.info_messages[0],
+            "{\n  \"team_name\": \"team1\",\n  \"github_team\": \"team1\",\n  \"team_yml\": \"config/teams/team1.yml\",\n  \"description\": [\n    \"file annotation\"\n  ]\n}"
+        );
+    }
+
+    #[test]
+    fn test_json_io_error() {
+        let result = RunResult::json_io_error(Error::Io("unable to find file".to_string()));
+        assert_eq!(result.io_errors.len(), 1);
+        assert_eq!(result.io_errors[0], "{\"error\":\"unable to find file\"}");
+    }
+
+    #[test]
+    fn test_json_validation_error() {
+        let result = RunResult::json_validation_error(vec!["file has multiple owners".to_string()]);
+        assert_eq!(result.validation_errors.len(), 1);
+        assert_eq!(
+            result.validation_errors[0],
+            "{\n  \"validation_errors\": [\n    \"file has multiple owners\"\n  ]\n}"
+        );
+    }
+}

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

@@ -0,0 +1,58 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+pub(crate) fn find_tracked_files(base_path: &Path) -> Option<HashMap<PathBuf, bool>> {
+    let output = Command::new("git")
+        .args(["ls-files", "--full-name", "-z", "--", "."])
+        .current_dir(base_path)
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let results: HashMap<PathBuf, bool> = output
+        .stdout
+        .split(|&b| b == b'\0')
+        .filter(|chunk| !chunk.is_empty())
+        .map(|rel| std::str::from_utf8(rel).ok().map(|s| (base_path.join(s), true)))
+        .collect::<Option<HashMap<PathBuf, bool>>>()?;
+
+    Some(results)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_untracked_files() {
+        let tmp_dir = tempfile::tempdir().unwrap();
+        assert!(find_tracked_files(tmp_dir.path()).is_none());
+
+        std::process::Command::new("git")
+            .arg("init")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to run git init");
+
+        std::fs::write(tmp_dir.path().join("test.txt"), "test").unwrap();
+        let tracked = find_tracked_files(tmp_dir.path()).unwrap();
+        assert!(tracked.is_empty());
+
+        std::process::Command::new("git")
+            .arg("add")
+            .arg("test.txt")
+            .current_dir(tmp_dir.path())
+            .output()
+            .expect("failed to add test.txt");
+
+        let tracked = find_tracked_files(tmp_dir.path()).unwrap();
+        assert!(tracked.len() == 1);
+        assert!(tracked.get(&tmp_dir.path().join("test.txt")).unwrap());
+    }
+}