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

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

@@ -0,0 +1,111 @@
+# 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.17"
+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 = "crosscheck_owners_test"
+path = "tests/crosscheck_owners_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 = "runner_api"
+path = "tests/runner_api.rs"
+
+[[test]]
+name = "untracked_files_test"
+path = "tests/untracked_files_test.rs"
+
+[[test]]
+name = "valid_project_test"
+path = "tests/valid_project_test.rs"
+
+[[test]]
+name = "valid_project_with_overrides_test"
+path = "tests/valid_project_with_overrides_test.rs"
+
+[dependencies]
+clap_derive = "4.5.45"
+crossbeam-channel = "0.5.15"
+enum_dispatch = "0.3.13"
+error-stack = "0.5.0"
+fast-glob = "1.0.0"
+glob = "0.3.3"
+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.143"
+serde_yaml = "0.9.34"
+tempfile = "3.21.0"
+tracing = "0.1.41"
+
+[dependencies.clap]
+version = "4.5.45"
+features = ["derive"]
+
+[dependencies.serde]
+version = "1.0.219"
+features = ["derive"]
+
+[dependencies.tracing-subscriber]
+version = "0.3.19"
+features = ["env-filter"]
+
+[dev-dependencies]
+assert_cmd = "2.0.17"
+indoc = "2.0.6"
+predicates = "3.1.3"
+pretty_assertions = "1.4.1"
+rusty-hook = "^0.11.2"
+
+[profile.release]
+debug = 2

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

@@ -0,0 +1,287 @@
+# 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.
+
+Note: For Ruby applications, it's usually easier to use `codeowners-rs` via the [code_ownership](https://github.com/rubyatscale/code_ownership) gem.
+
+## 🚀 Quick Start: Generate & Validate
+
+The most common workflow is to generate and validate in one step:
+
+```sh
+codeowners gv
+```
+
+- Generates a fresh `CODEOWNERS` file (default: `.github/CODEOWNERS`)
+- Validates ownership and that the file is up to date
+- Exits non-zero and prints detailed errors if validation fails
+
+## Table of Contents
+
+- [Quick Start: Generate & Validate](#quick-start-generate--validate)
+- [Installation](#installation)
+- [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)
+- [CLI Reference](#cli-reference)
+  - [Global Flags](#global-flags)
+  - [Commands](#commands)
+  - [Examples](#examples)
+- [Configuration](#configuration)
+- [Cache](#cache)
+- [Validation](#validation)
+- [Library Usage](#library-usage)
+- [Development](#development)
+
+## Installation
+
+You can run `codeowners` without installing a platform-specific binary by using DotSlash, or install from source with Cargo.
+
+### Option A: DotSlash (recommended)
+
+1. Install DotSlash: see [https://dotslash-cli.com/docs/installation/](https://dotslash-cli.com/docs/installation/)
+2. Download the latest DotSlash text file from a release, for example [https://github.com/rubyatscale/codeowners-rs/releases](https://github.com/rubyatscale/codeowners-rs/releases).
+3. Execute the downloaded file with DotSlash; it will fetch and run the correct binary.
+
+### Option B: From source with Cargo
+
+Requires Rust toolchain.
+
+```sh
+cargo install --git https://github.com/rubyatscale/codeowners-rs codeowners
+```
+
+## Getting Started
+
+1. **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__/**/*
+   ```
+
+2. **Declare Teams**  
+   Example: `config/teams/operations.yml`
+
+   ```yaml
+   name: Operations
+   github:
+     team: '@my-org/operations-team'
+   ```
+
+3. **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
+```
+```typescript
+// @team MyTeam
+```
+```html
+<!-- @team MyTeam -->
+```
+```erb
+<%# @team: Foo %>
+```
+### 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/*
+```
+
+## CLI Reference
+
+### Global Flags
+
+- `--codeowners-file-path <path>`: Path for the CODEOWNERS file. Default: `./.github/CODEOWNERS`
+- `--config-path <path>`: Path to `code_ownership.yml`. Default: `./config/code_ownership.yml`
+- `--project-root <path>`: Project root. Default: `.`
+- `--no-cache`: Disable on-disk caching (useful in CI)
+- `-V, --version`, `-h, --help`
+
+### Commands
+
+- `generate` (`g`): Generate the CODEOWNERS file and write it to `--codeowners-file-path`.
+  - Flags: `--skip-stage, -s` to avoid `git add` after writing
+- `validate` (`v`): Validate the CODEOWNERS file and configuration.
+- `generate-and-validate` (`gv`): Run `generate` then `validate`.
+  - Flags: `--skip-stage, -s`
+- `for-file <path>` (`f`): Print the owner of a file.
+  - Flags: `--from-codeowners` to resolve using only the CODEOWNERS rules
+- `for-team <name>` (`t`): Print ownership report for a team.
+- `delete-cache` (`d`): Delete the persisted cache.
+
+### 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
+```
+
+#### Generate but do not stage the file
+
+```sh
+codeowners generate --skip-stage
+```
+
+#### Run without using the cache
+
+```sh
+codeowners gv --no-cache
+```
+
+## Configuration
+
+`config/code_ownership.yml` keys and defaults:
+
+- `owned_globs` (required): Glob patterns that must be owned.
+- `ruby_package_paths` (default: `['packs/**/*', 'components/**']`)
+- `js_package_paths` / `javascript_package_paths` (default: `['frontend/**/*']`)
+- `team_file_glob` (default: `['config/teams/**/*.yml']`)
+- `unowned_globs` (default: `['frontend/**/node_modules/**/*', 'frontend/**/__generated__/**/*']`)
+- `vendored_gems_path` (default: `'vendored/'`)
+- `cache_directory` (default: `'tmp/cache/codeowners'`)
+- `ignore_dirs` (default includes: `.git`, `node_modules`, `tmp`, etc.)
+
+See examples in `tests/fixtures/**/config/` for reference setups.
+
+## Cache
+
+By default, cache is stored under `tmp/cache/codeowners` relative to the project root. This speeds up repeated runs.
+
+- Disable cache for a run: add the global flag `--no-cache`
+- Clear all cache: `codeowners delete-cache`
+
+## 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 matched by `unowned_globs`.
+4. The generated `CODEOWNERS` file is up to date.
+
+Exit status is non-zero on errors.
+
+## Library Usage
+
+Import public APIs from `codeowners::runner::*`.
+
+```rust
+use codeowners::runner::{RunConfig, for_file, teams_for_files_from_codeowners};
+
+fn main() {
+    let run_config = RunConfig {
+        project_root: std::path::PathBuf::from("."),
+        codeowners_file_path: std::path::PathBuf::from(".github/CODEOWNERS"),
+        config_path: std::path::PathBuf::from("config/code_ownership.yml"),
+        no_cache: true, // set false to enable on-disk caching
+    };
+
+    // Find owner for a single file using the optimized path (not just CODEOWNERS)
+    let result = for_file(&run_config, "app/models/user.rb", false);
+    for msg in result.info_messages { println!("{}", msg); }
+    for err in result.io_errors { eprintln!("io: {}", err); }
+    for err in result.validation_errors { eprintln!("validation: {}", err); }
+
+    // Map multiple files to teams using CODEOWNERS rules only
+    let files = vec![
+        "app/models/user.rb".to_string(),
+        "config/teams/payroll.yml".to_string(),
+    ];
+    match teams_for_files_from_codeowners(&run_config, &files) {
+        Ok(map) => println!("{:?}", map),
+        Err(e) => eprintln!("error: {}", e),
+    }
+}
+```
+
+## 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.
+
+### Module layout
+
+- `src/runner.rs`: public façade re-exporting the API and types.
+- `src/runner/api.rs`: externally available functions used by the CLI and other crates.
+- `src/runner/types.rs`: `RunConfig`, `RunResult`, and runner `Error`.
+- `src/ownership/`: all ownership logic (parsing, mapping, validation, generation).
+- `src/ownership/codeowners_query.rs`: CODEOWNERS-only queries consumed by the façade.

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

@@ -0,0 +1,12 @@
+#!/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' 

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

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

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

@@ -0,0 +1,179 @@
+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 = 50000;
+
+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()
+            && let Ok(cache) = cache_mutex.lock()
+            && 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()
+            && let Ok(mut cache) = cache_mutex.lock()
+            && 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();
+        tracing::debug!("Deleting cache file: {}", cache_path.display());
+        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(())
+    }
+}