fast_code_owners 0.0.7 → 0.0.8

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

@@ -0,0 +1,94 @@
+# 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.5"
+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"
+
+[[bin]]
+name = "compare_for_file"
+path = "src/bin/compare_for_file.rs"
+
+[[test]]
+name = "cache_test"
+path = "tests/cache_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"
+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.5/README.md

@@ -0,0 +1,204 @@
+# 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.5/ai-prompts/for-file-optimization.md

@@ -0,0 +1,21 @@
+## Re-architect `codeowners-rs`
+
+The CLI behaviors live in `src/cli.rs`.
+
+### What this tool does
+- **Generate CODEOWNERS**: Builds `.github/CODEOWNERS` from multiple ownership sources. See mappers in `src/ownership/mapper/`.
+- **Answer per-file ownership**: The `for-file` command returns the owner of a given file even if the checked-in `CODEOWNERS` is not up to date.
+
+### Current implementations
+- **Fast but potentially inaccurate**: `Runner::for_file_from_codeowners` (in `src/runner.rs`) parses the existing `CODEOWNERS` file to find a file’s owner. It’s very fast, but can be wrong if `CODEOWNERS` is stale.
+- **Accurate but slow**: `Runner::for_file` is correct but can take up to ~4 seconds on large repositories because it effectively determines ownership for many files and then returns the single result needed.
+
+Ownership resolution is complex because definitions often live in other files (packages, team configs, globs, etc.).
+
+## Assignment
+Implement a faster `for_file` that remains accurate.
+
+### Requirements
+- **Performance**: Under 1 second on large codebases (e.g., `$HOME/workspace/large`).
+- **Correctness**: All existing tests must continue to pass.
+- **Compatibility**: No changes to the external behavior of the `for-file` CLI command.

data/ext/cargo-vendor/codeowners-0.2.5/src/bin/compare_for_file.rs

@@ -0,0 +1,179 @@
+// This is a tool to compare the output of the original codeowners CLI with the optimized version.
+// It's useful for verifying that the optimized version is correct.
+//
+// It's not used in CI, but it's useful for debugging.
+//
+// To run it, use `cargo run --bin compare_for_file <absolute_project_root>`
+//
+// It will compare the output of the original codeowners CLI with the optimized version for all files in the project.
+
+use std::{
+    fs::File,
+    io::{self, Write},
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use codeowners::config::Config as OwnershipConfig;
+use codeowners::ownership::{FileOwner, for_file_fast};
+use codeowners::runner::{RunConfig, Runner};
+use ignore::WalkBuilder;
+
+fn main() {
+    let project_root = std::env::args().nth(1).expect("usage: compare_for_file <absolute_project_root>");
+    let project_root = PathBuf::from(project_root);
+    if !project_root.is_absolute() {
+        eprintln!("Project root must be absolute");
+        std::process::exit(2);
+    }
+
+    let codeowners_file_path = project_root.join(".github/CODEOWNERS");
+    let config_path = project_root.join("config/code_ownership.yml");
+
+    let run_config = RunConfig {
+        project_root: project_root.clone(),
+        codeowners_file_path,
+        config_path: config_path.clone(),
+        no_cache: false,
+    };
+
+    // Build the original, accurate-but-slower runner once
+    let runner = match Runner::new(&run_config) {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("Failed to initialize Runner: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    // Load config once for the optimized path
+    let config_file = match File::open(&config_path) {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("Can't open config file {}: {}", config_path.display(), e);
+            std::process::exit(1);
+        }
+    };
+    let optimized_config: OwnershipConfig = match serde_yaml::from_reader(config_file) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("Can't parse config file {}: {}", config_path.display(), e);
+            std::process::exit(1);
+        }
+    };
+
+    let mut total_files: usize = 0;
+    let mut diff_count: usize = 0;
+
+    // Prefer tracked files from git; fall back to walking the FS if git is unavailable
+    let tracked_files_output = Command::new("git").arg("-C").arg(&project_root).arg("ls-files").arg("-z").output();
+
+    match tracked_files_output {
+        Ok(output) if output.status.success() => {
+            let bytes = output.stdout;
+            for rel in bytes.split(|b| *b == 0u8) {
+                if rel.is_empty() {
+                    continue;
+                }
+                let rel_str = match std::str::from_utf8(rel) {
+                    Ok(s) => s,
+                    Err(_) => continue,
+                };
+                let abs_path = project_root.join(rel_str);
+                // Only process regular files that currently exist
+                if !abs_path.is_file() {
+                    continue;
+                }
+
+                total_files += 1;
+                let original = run_original(&runner, &abs_path);
+                let optimized = run_optimized(&project_root, &optimized_config, &abs_path);
+
+                if original != optimized {
+                    diff_count += 1;
+                    println!("\n==== {} ====", abs_path.display());
+                    println!("ORIGINAL:\n{}", original);
+                    println!("OPTIMIZED:\n{}", optimized);
+                    let _ = io::stdout().flush();
+                }
+
+                if total_files % 1000 == 0 {
+                    eprintln!("Processed {} files... diffs so far: {}", total_files, diff_count);
+                }
+            }
+        }
+        _ => {
+            eprintln!("git ls-files failed; falling back to filesystem walk (untracked files may be included)");
+            let walker = WalkBuilder::new(&project_root)
+                .hidden(false)
+                .git_ignore(true)
+                .git_exclude(true)
+                .follow_links(false)
+                .build();
+
+            for result in walker {
+                let entry = match result {
+                    Ok(e) => e,
+                    Err(err) => {
+                        eprintln!("walk error: {}", err);
+                        continue;
+                    }
+                };
+                if !entry.file_type().map(|t| t.is_file()).unwrap_or(false) {
+                    continue;
+                }
+                let path = entry.path();
+                total_files += 1;
+
+                let original = run_original(&runner, path);
+                let optimized = run_optimized(&project_root, &optimized_config, path);
+
+                if original != optimized {
+                    diff_count += 1;
+                    println!("\n==== {} ====", path.display());
+                    println!("ORIGINAL:\n{}", original);
+                    println!("OPTIMIZED:\n{}", optimized);
+                    let _ = io::stdout().flush();
+                }
+
+                if total_files % 1000 == 0 {
+                    eprintln!("Processed {} files... diffs so far: {}", total_files, diff_count);
+                }
+            }
+        }
+    }
+
+    println!("Checked {} files. Diffs: {}", total_files, diff_count);
+    if diff_count > 0 {
+        std::process::exit(3);
+    }
+}
+
+fn run_original(runner: &Runner, file_path: &Path) -> String {
+    let result = runner.for_file(&file_path.to_string_lossy());
+    if !result.validation_errors.is_empty() {
+        return result.validation_errors.join("\n");
+    }
+    if !result.io_errors.is_empty() {
+        return format!("IO_ERROR: {}", result.io_errors.join(" | "));
+    }
+    result.info_messages.join("\n")
+}
+
+fn run_optimized(project_root: &Path, config: &OwnershipConfig, file_path: &Path) -> String {
+    let owners: Vec<FileOwner> = match for_file_fast::find_file_owners(project_root, config, file_path) {
+        Ok(v) => v,
+        Err(e) => return format!("IO_ERROR: {}", e),
+    };
+    match owners.len() {
+        0 => format!("{}", FileOwner::default()),
+        1 => format!("{}", owners[0]),
+        _ => {
+            let mut lines = vec!["Error: file is owned by multiple teams!".to_string()];
+            for owner in owners {
+                lines.push(format!("\n{}", owner));
+            }
+            lines.join("\n")
+        }
+    }
+}

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

@@ -0,0 +1,181 @@
+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(())
+    }
+}