Add executable_path to RunConfig and use it in config loading

Author: perryqh

README.md

@@ -213,6 +213,15 @@ codeowners gv --no-cache
 - `vendored_gems_path` (default: `'vendored/'`)
 - `cache_directory` (default: `'tmp/cache/codeowners'`)
 - `ignore_dirs` (default includes: `.git`, `node_modules`, `tmp`, etc.)
+- `executable_name` (default: `'codeowners'`): Customize the command name shown in validation error messages. Useful when using `codeowners-rs` via wrappers like the [code_ownership](https://github.com/rubyatscale/code_ownership) Ruby gem.
+
+Example configuration with custom executable name:
+
+```yaml
+owned_globs:
+  - '{app,components,config,frontend,lib,packs,spec}/**/*.{rb,rake,js,jsx,ts,tsx}'
+executable_name: 'bin/codeownership'  # For Ruby gem wrapper
+```
 
 See examples in `tests/fixtures/**/config/` for reference setups.
 

src/cli.rs

@@ -114,6 +114,7 @@ pub fn cli() -> Result<RunResult, RunnerError> {
         codeowners_file_path,
         project_root,
         no_cache: args.no_cache,
+        executable_path: None,
     };
 
     let runner_result = match args.command {

src/crosscheck.rs

@@ -6,7 +6,7 @@ use crate::{
     ownership::file_owner_resolver::find_file_owners,
     project::Project,
     project_builder::ProjectBuilder,
-    runner::{RunConfig, RunResult, config_from_path, team_for_file_from_codeowners},
+    runner::{RunConfig, RunResult, config_from_run_config, team_for_file_from_codeowners},
 };
 
 pub fn crosscheck_owners(run_config: &RunConfig, cache: &Cache) -> RunResult {
@@ -43,7 +43,7 @@ fn do_crosscheck_owners(run_config: &RunConfig, cache: &Cache) -> Result<Vec<Str
 }
 
 fn load_config(run_config: &RunConfig) -> Result<Config, String> {
-    config_from_path(&run_config.config_path).map_err(|e| e.to_string())
+    config_from_run_config(run_config).map_err(|e| e.to_string())
 }
 
 fn build_project(config: &Config, run_config: &RunConfig, cache: &Cache) -> Result<Project, String> {

src/runner.rs

@@ -1,4 +1,4 @@
-use std::{path::Path, process::Command};
+use std::process::Command;
 
 use error_stack::{Result, ResultExt};
 use serde::Serialize;
@@ -44,15 +44,20 @@ where
     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),
+pub(crate) fn config_from_run_config(run_config: &RunConfig) -> Result<Config, Error> {
+    match crate::config::Config::load_from_path(&run_config.config_path) {
+        Ok(mut c) => {
+            if let Some(executable_name) = &run_config.executable_name() {
+                c.executable_name = executable_name.clone();
+            }
+            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 config = config_from_run_config(run_config)?;
 
         let cache: Cache = if run_config.no_cache {
             NoopCache::default().into()

src/runner/api.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 
-use crate::ownership::FileOwner;
 use crate::project::Team;
+use crate::{ownership::FileOwner, runner::config_from_run_config};
 
-use super::{Error, ForFileResult, RunConfig, RunResult, config_from_path, run};
+use super::{Error, ForFileResult, RunConfig, RunResult, run};
 
 pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool, json: bool) -> RunResult {
     if from_codeowners {
@@ -38,7 +38,7 @@ pub fn crosscheck_owners(run_config: &RunConfig) -> RunResult {
 
 // 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)?;
+    let config = config_from_run_config(run_config)?;
     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)
@@ -60,7 +60,7 @@ 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 config = config_from_run_config(run_config)?;
     let res = crate::ownership::codeowners_query::teams_for_files_from_codeowners(
         &run_config.project_root,
         &run_config.codeowners_file_path,
@@ -80,7 +80,7 @@ pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) ->
 
 // 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) {
+    let config = match config_from_run_config(run_config) {
         Ok(c) => c,
         Err(err) => {
             return RunResult::from_io_error(Error::Io(err.to_string()), json);

src/runner/types.rs

@@ -4,6 +4,8 @@ use std::path::PathBuf;
 use error_stack::Context;
 use serde::{Deserialize, Serialize};
 
+use crate::path_utils::relative_to_buf;
+
 #[derive(Debug, Default, Serialize, Deserialize)]
 pub struct RunResult {
     pub validation_errors: Vec<String>,
@@ -17,6 +19,15 @@ pub struct RunConfig {
     pub codeowners_file_path: PathBuf,
     pub config_path: PathBuf,
     pub no_cache: bool,
+    pub executable_path: Option<PathBuf>,
+}
+
+impl RunConfig {
+    pub fn executable_name(&self) -> Option<String> {
+        self.executable_path
+            .as_ref()
+            .map(|path| relative_to_buf(&self.project_root, path).to_string_lossy().to_string())
+    }
 }
 
 #[derive(Debug, Serialize)]

tests/common/mod.rs

@@ -157,6 +157,7 @@ pub fn build_run_config(project_root: &Path, codeowners_rel_path: &str) -> RunCo
         codeowners_file_path,
         config_path,
         no_cache: true,
+        executable_path: None,
     }
 }
 

tests/custom_executable_name_test.rs

@@ -0,0 +1,67 @@
+use indoc::indoc;
+use predicates::prelude::*;
+use std::error::Error;
+
+mod common;
+use common::OutputStream;
+use common::run_codeowners;
+
+#[test]
+fn test_validate_with_custom_executable_name() -> Result<(), Box<dyn Error>> {
+    // When executable_name is configured, error should show that command
+    run_codeowners(
+        "custom_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains("Run `bin/codeownership generate`"),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_validate_with_default_executable_name() -> Result<(), Box<dyn Error>> {
+    // When executable_name is not configured, error should show default "codeowners"
+    run_codeowners(
+        "default_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::str::contains("Run `codeowners generate`"),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_custom_executable_name_full_error_message() -> Result<(), Box<dyn Error>> {
+    // Verify the complete error message format with custom executable
+    run_codeowners(
+        "custom_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::eq(indoc! {"
+
+    CODEOWNERS out of date. Run `bin/codeownership generate` to update the CODEOWNERS file
+
+    "}),
+    )?;
+    Ok(())
+}
+
+#[test]
+fn test_default_executable_name_full_error_message() -> Result<(), Box<dyn Error>> {
+    // Verify the complete error message format with default executable
+    run_codeowners(
+        "default_executable_name",
+        &["validate"],
+        false,
+        OutputStream::Stdout,
+        predicate::eq(indoc! {"
+
+    CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file
+
+    "}),
+    )?;
+    Ok(())
+}

tests/executable_name_config_test.rs

@@ -1,3 +1,10 @@
-# This is a stale CODEOWNERS file - it's intentionally wrong to trigger the error
-ruby/app/payments/bar.rb @PaymentTeam
+# STOP! - DO NOT EDIT THIS FILE MANUALLY
+# This file was automatically generated by "codeowners".
+#
+# 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
 
+# Outdated content to trigger validation error
+/app/old.rb @FooTeam