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

data/ext/cargo-vendor/codeowners-0.2.7/Cargo.toml

@@ -1,95 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2024"
-name = "codeowners"
-version = "0.2.7"
-build = false
-autolib = false
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-readme = "README.md"
-
-[lib]
-name = "codeowners"
-path = "src/lib.rs"
-
-[[bin]]
-name = "codeowners"
-path = "src/main.rs"
-
-[[test]]
-name = "cache_test"
-path = "tests/cache_test.rs"
-
-[[test]]
-name = "git_stage_test"
-path = "tests/git_stage_test.rs"
-
-[[test]]
-name = "invalid_project_structure_test"
-path = "tests/invalid_project_structure_test.rs"
-
-[[test]]
-name = "invalid_project_test"
-path = "tests/invalid_project_test.rs"
-
-[[test]]
-name = "multiple_directory_owners_test"
-path = "tests/multiple_directory_owners_test.rs"
-
-[[test]]
-name = "valid_project_test"
-path = "tests/valid_project_test.rs"
-
-[dependencies]
-clap_derive = "4.5.18"
-crossbeam-channel = "0.5.15"
-enum_dispatch = "0.3.13"
-error-stack = "0.5.0"
-fast-glob = "1.0.0"
-glob = "0.3.2"
-ignore = "0.4.23"
-itertools = "0.14.0"
-lazy_static = "1.5.0"
-memoize = "0.5.1"
-path-clean = "1.0.1"
-rayon = "1.10.0"
-regex = "1.11.1"
-serde_json = "1.0.132"
-serde_yaml = "0.9.34"
-tempfile = "3.13.0"
-tracing = "0.1.40"
-
-[dependencies.clap]
-version = "4.5.20"
-features = ["derive"]
-
-[dependencies.serde]
-version = "1.0.214"
-features = ["derive"]
-
-[dependencies.tracing-subscriber]
-version = "0.3.18"
-features = ["env-filter"]
-
-[dev-dependencies]
-assert_cmd = "2.0.16"
-indoc = "2.0.5"
-predicates = "3.1.2"
-pretty_assertions = "1.4.1"
-rusty-hook = "^0.11.2"
-
-[profile.release]
-debug = 2

data/ext/cargo-vendor/codeowners-0.2.7/README.md

@@ -1,204 +0,0 @@
-# Codeowners
-
-**Codeowners** is a fast, Rust-based CLI for generating and validating [GitHub `CODEOWNERS` files](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners) in large repositories. It supports conventions for Ruby and JavaScript projects, and is a high-performance reimplementation of the [original Ruby CLI](https://github.com/rubyatscale/code_ownership).
-
-## 🚀 Quick Start: Generate & Validate
-
-The most common workflow is to **generate and validate your CODEOWNERS file** in a single step:
-
-```sh
-codeowners gv
-```
-
-- This command will:
-  - Generate a fresh `CODEOWNERS` file (by default at `.github/CODEOWNERS`)
-  - Validate that all files are properly owned and that the file is up to date
-  - Exit with a nonzero code and detailed errors if validation fails
-
-**Why use this tool?**  
-On large projects, `codeowners gv` is _over 10x faster_ than the legacy Ruby implementation:
-
-```
-$ hyperfine 'codeownership validate' 'codeowners validate'
-Benchmark 1: codeownership validate (ruby gem)
-  Time (mean ± σ):     47.991 s ±  1.220 s
-Benchmark 2: codeowners gv (this repo)
-  Time (mean ± σ):      4.263 s ±  0.025 s
-
-Summary
-  codeowners gv ran 11.26 ± 0.29 times faster than codeownership validate
-```
-
-## Table of Contents
-
-- [Quick Start: Generate & Validate](#-quick-start-generate--validate)
-- [Getting Started](#getting-started)
-- [Declaring Ownership](#declaring-ownership)
-  - [Directory-Based Ownership](#1-directory-based-ownership)
-  - [File Annotation](#2-file-annotation)
-  - [Package-Based Ownership](#3-package-based-ownership)
-  - [Glob-Based Ownership](#4-glob-based-ownership)
-  - [JavaScript Package Ownership](#5-javascript-package-ownership)
-- [Other CLI Commands](#other-cli-commands)
-  - [Examples](#examples)
-    - [Find the owner of a file](#find-the-owner-of-a-file)
-    - [Ownership report for a team](#ownership-report-for-a-team)
-- [Validation](#validation)
-- [Development](#development)
-- [Configuration](#configuration)
-
-## Getting Started
-
-1. **Install DotSlash**  
-   [Install DotSlash](https://dotslash-cli.com/docs/installation/)  
-   Releases include a DotSlash text file that will automatically download and run the correct binary for your system.
-
-2. **Download the Latest DotSlash Text File**  
-   Releases contain a DotSlash text file. Example: [codeowners release v0.2.4](https://github.com/rubyatscale/codeowners-rs/releases/download/v0.2.4/codeowners).  
-   Running this file with DotSlash installed will execute `codeowners`.
-
-3. **Configure Ownership**  
-   Create a `config/code_ownership.yml` file. Example:
-
-   ```yaml
-   owned_globs:
-     - '{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx}'
-   js_package_paths: []
-   unowned_globs:
-     - db/**/*
-     - app/services/some_file1.rb
-     - frontend/javascripts/**/__generated__/**/*
-   ```
-
-4. **Declare Teams**  
-   Example: `config/teams/operations.yml`
-
-   ```yaml
-   name: Operations
-   github:
-     team: '@my-org/operations-team'
-   ```
-
-5. **Run the Main Workflow**
-
-   ```sh
-   codeowners gv
-   ```
-
-## Declaring Ownership
-
-You can declare code ownership in several ways:
-
-### 1. Directory-Based Ownership
-
-Add a `.codeowner` file to a directory with the team name as its contents:
-
-```text
-TeamName
-```
-
-### 2. File Annotation
-
-Add an annotation at the top of a file:
-
-```ruby
-# @team MyTeam
-```
-
-### 3. Package-Based Ownership
-
-In `package.yml` (for Ruby Packwerk):
-
-```yaml
-owner: TeamName
-```
-
-### 4. Glob-Based Ownership
-
-In your team's YML:
-
-```yaml
-owned_globs:
-  - app/services/my_team/**/*
-unowned_globs:
-  - app/services/my_team/legacy/*
-```
-
-`unowned_globs` "subtracts" from `owned_globs`
-
-### 5. JavaScript Package Ownership
-
-In `package.json`:
-
-```json
-{
-  "metadata": {
-    "owner": "My Team"
-  }
-}
-```
-
-Configure search paths in `code_ownership.yml`:
-
-```yaml
-js_package_paths:
-  - frontend/javascripts/packages/*
-```
-
-
-## Other CLI Commands
-
-While `codeowners gv` is the main workflow, the CLI also supports:
-
-```text
-Usage: codeowners [OPTIONS] <COMMAND>
-
-Commands:
-  for-file               Finds the owner of a given file. [aliases: f]
-  for-team               Finds code ownership information for a given team [aliases: t]
-  generate               Generate the CODEOWNERS file [aliases: g]
-  validate               Validate the CODEOWNERS file [aliases: v]
-  generate-and-validate  Chains both `generate` and `validate` [aliases: gv]
-  help                   Print this message or the help of the given subcommand(s)
-
-Options:
-      --codeowners-file-path <CODEOWNERS_FILE_PATH>  [default: ./.github/CODEOWNERS]
-      --config-path <CONFIG_PATH>                    [default: ./config/code_ownership.yml]
-      --project-root <PROJECT_ROOT>                  [default: .]
-  -h, --help
-  -V, --version
-```
-
-### Examples
-
-#### Find the owner of a file
-
-```sh
-codeowners for-file path/to/file.rb
-```
-
-#### Ownership report for a team
-
-```sh
-codeowners for-team Payroll
-```
-
-## Validation
-
-`codeowners validate` (or `codeowners gv`) ensures:
-
-1. Only one mechanism defines ownership for any file.
-2. All referenced teams are valid.
-3. All files in `owned_globs` are owned, unless in `unowned_globs`.
-4. The `CODEOWNERS` file is up to date.
-
-## Development
-
-- Written in Rust for speed and reliability.
-- To build locally, install Rust:  
-
-  ```sh
-  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-  ```
-
-- Please update `CHANGELOG.md` and this `README.md` when making changes.

data/ext/cargo-vendor/codeowners-0.2.7/dev/run_benchmarks_for_gv.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-# Check if the file exists before removing it
-if [ -f "tmp/codeowners_benchmarks.md" ]; then
-  rm tmp/codeowners_benchmarks_gv.md
-fi
-
-echo "To run these benchmarks on your application, you can place this repo next to your rails application and run /usr/bin/env bash ../rubyatscale/codeowners-rs/dev/run_benchmarks_for_gv.sh from the root of your application" >> tmp/codeowners_benchmarks_gv.md
-
-hyperfine --warmup=2 --runs=3 --export-markdown tmp/codeowners_benchmarks_gv.md \
-  '../rubyatscale/codeowners-rs/target/release/codeowners gv' \
-  'bin/codeownership validate' \
-  'bin/codeowners-rs gv' 

data/ext/cargo-vendor/codeowners-0.2.7/rust-toolchain.toml

@@ -1,4 +0,0 @@
-[toolchain]
-channel = "1.86.0"
-components = ["clippy", "rustfmt"]
-targets = ["x86_64-apple-darwin", "aarch64-apple-darwin", "x86_64-unknown-linux-gnu"]

data/ext/cargo-vendor/codeowners-0.2.7/src/cache/file.rs

@@ -1,181 +0,0 @@
-use crate::project::Error;
-use error_stack::{Result, ResultExt};
-use std::{
-    collections::HashMap,
-    fs::{self, File, OpenOptions},
-    io::{BufReader, BufWriter},
-    path::{Path, PathBuf},
-    sync::Mutex,
-};
-
-use super::{Caching, FileOwnerCacheEntry};
-
-#[derive(Debug)]
-pub struct GlobalCache {
-    base_path: PathBuf,
-    cache_directory: String,
-    file_owner_cache: Option<Box<Mutex<HashMap<PathBuf, FileOwnerCacheEntry>>>>,
-}
-
-const DEFAULT_CACHE_CAPACITY: usize = 10000;
-
-impl Caching for GlobalCache {
-    fn get_file_owner(&self, path: &Path) -> Result<Option<FileOwnerCacheEntry>, Error> {
-        if let Some(cache_mutex) = self.file_owner_cache.as_ref() {
-            if let Ok(cache) = cache_mutex.lock() {
-                if let Some(cached_entry) = cache.get(path) {
-                    let timestamp = get_file_timestamp(path)?;
-                    if cached_entry.timestamp == timestamp {
-                        return Ok(Some(cached_entry.clone()));
-                    }
-                }
-            }
-        }
-        Ok(None)
-    }
-
-    fn write_file_owner(&self, path: &Path, owner: Option<String>) {
-        if let Some(cache_mutex) = self.file_owner_cache.as_ref() {
-            if let Ok(mut cache) = cache_mutex.lock() {
-                if let Ok(timestamp) = get_file_timestamp(path) {
-                    cache.insert(path.to_path_buf(), FileOwnerCacheEntry { timestamp, owner });
-                }
-            }
-        }
-    }
-
-    fn persist_cache(&self) -> Result<(), Error> {
-        let cache_path = self.get_cache_path();
-        let file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(cache_path)
-            .change_context(Error::Io)?;
-
-        let writer = BufWriter::new(file);
-        if let Some(cache_mutex) = self.file_owner_cache.as_ref() {
-            let cache = cache_mutex.lock().map_err(|_| Error::Io)?;
-            serde_json::to_writer(writer, &*cache).change_context(Error::SerdeJson)
-        } else {
-            Ok(())
-        }
-    }
-
-    fn delete_cache(&self) -> Result<(), Error> {
-        let cache_path = self.get_cache_path();
-        dbg!("deleting", &cache_path);
-        fs::remove_file(cache_path).change_context(Error::Io)
-    }
-}
-
-impl GlobalCache {
-    pub fn new(base_path: PathBuf, cache_directory: String) -> Result<Self, Error> {
-        let mut cache = Self {
-            base_path,
-            cache_directory,
-            file_owner_cache: None,
-        };
-        cache.load_cache().change_context(Error::Io)?;
-        Ok(cache)
-    }
-
-    fn load_cache(&mut self) -> Result<(), Error> {
-        let cache_path = self.get_cache_path();
-        if !cache_path.exists() {
-            self.file_owner_cache = Some(Box::new(Mutex::new(HashMap::with_capacity(DEFAULT_CACHE_CAPACITY))));
-            return Ok(());
-        }
-
-        let file = File::open(cache_path).change_context(Error::Io)?;
-        let reader = BufReader::new(file);
-        let json = serde_json::from_reader(reader);
-        self.file_owner_cache = match json {
-            Ok(cache) => Some(Box::new(Mutex::new(cache))),
-            _ => Some(Box::new(Mutex::new(HashMap::with_capacity(DEFAULT_CACHE_CAPACITY)))),
-        };
-        Ok(())
-    }
-
-    fn get_cache_path(&self) -> PathBuf {
-        let cache_dir = self.base_path.join(PathBuf::from(&self.cache_directory));
-        let _ = fs::create_dir_all(&cache_dir);
-
-        cache_dir.join("project-file-cache.json")
-    }
-}
-fn get_file_timestamp(path: &Path) -> Result<u64, Error> {
-    let metadata = fs::metadata(path).change_context(Error::Io)?;
-    metadata
-        .modified()
-        .change_context(Error::Io)?
-        .duration_since(std::time::UNIX_EPOCH)
-        .change_context(Error::Io)
-        .map(|duration| duration.as_secs())
-}
-
-#[cfg(test)]
-mod tests {
-    use tempfile::tempdir;
-
-    use super::*;
-
-    #[test]
-    fn test_cache_dir() -> Result<(), Error> {
-        let temp_dir = tempdir().change_context(Error::Io)?;
-        let cache_dir = "test-codeowners-cache";
-        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
-
-        let file_path = PathBuf::from("tests/fixtures/valid_project/ruby/app/models/bank_account.rb");
-        assert!(file_path.exists());
-        let timestamp = get_file_timestamp(&file_path)?;
-
-        let cache_entry = cache.get_file_owner(&file_path)?;
-        assert_eq!(cache_entry, None);
-
-        cache.write_file_owner(&file_path, Some("owner 1".to_owned()));
-        let cache_entry = cache.get_file_owner(&file_path)?;
-        assert_eq!(
-            cache_entry,
-            Some(FileOwnerCacheEntry {
-                timestamp,
-                owner: Some("owner 1".to_owned())
-            })
-        );
-
-        cache.persist_cache().change_context(Error::Io)?;
-        let persisted_cache_path = cache.get_cache_path();
-        assert!(persisted_cache_path.exists());
-
-        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
-        let cache_entry = cache.get_file_owner(&file_path)?;
-        assert_eq!(
-            cache_entry,
-            Some(FileOwnerCacheEntry {
-                timestamp,
-                owner: Some("owner 1".to_owned())
-            })
-        );
-
-        cache.delete_cache().change_context(Error::Io)?;
-        assert!(!persisted_cache_path.exists());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_corrupted_cache() -> Result<(), Error> {
-        let temp_dir = tempdir().change_context(Error::Io)?;
-        let cache_dir = "test-codeowners-cache";
-        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
-        let cache_path = cache.get_cache_path();
-        fs::write(cache_path, "corrupted_cache").change_context(Error::Io)?;
-
-        // When the cache is corrupted, it should be ignored and a new cache should be created
-        let cache = GlobalCache::new(temp_dir.path().to_path_buf(), cache_dir.to_owned())?;
-        let file_path = PathBuf::from("tests/fixtures/valid_project/ruby/app/models/bank_account.rb");
-        let cache_entry = cache.get_file_owner(&file_path)?;
-        assert_eq!(cache_entry, None);
-        Ok(())
-    }
-}

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

@@ -1,119 +0,0 @@
-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"
-        )]
-        fast: 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,
-}
-
-/// 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, fast: _ } => runner::for_file(&run_config, &name),
-        Command::ForTeam { name } => runner::for_team(&run_config, &name),
-        Command::DeleteCache => runner::delete_cache(&run_config),
-    };
-
-    Ok(runner_result)
-}