Support executable_name in config and API (#86)

* Add executable_name field to Config with default value

* Include executable name in validator errors and messages

* Add support for custom executable_name in config

* Bump codeowners version to 0.3.1

* Add executable_path to RunConfig and use it in config loading

* Simplify executable_path handling by using String directly

* Rename executable_path to executable_name throughout code and tests

Author: perryqh

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "codeowners"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 
 [profile.release]

Cargo.toml

@@ -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.
 

README.md

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

src/cli.rs

@@ -25,6 +25,9 @@ pub struct Config {
 
     #[serde(default = "default_ignore_dirs")]
     pub ignore_dirs: Vec<String>,
+
+    #[serde(default = "default_executable_name")]
+    pub executable_name: String,
 }
 
 #[allow(dead_code)]
@@ -61,6 +64,10 @@ fn vendored_gems_path() -> String {
     "vendored/".to_string()
 }
 
+fn default_executable_name() -> String {
+    "codeowners".to_string()
+}
+
 fn default_ignore_dirs() -> Vec<String> {
     vec![
         ".git".to_owned(),
@@ -120,6 +127,40 @@ mod tests {
             vec!["frontend/**/node_modules/**/*", "frontend/**/__generated__/**/*"]
         );
         assert_eq!(config.vendored_gems_path, "vendored/");
+        assert_eq!(config.executable_name, "codeowners");
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_config_with_custom_executable_name() -> Result<(), Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+        let config_path = temp_dir.path().join("config.yml");
+        let config_str = indoc! {"
+            ---
+            owned_globs:
+              - \"**/*.rb\"
+            executable_name: my-custom-codeowners
+        "};
+        fs::write(&config_path, config_str)?;
+        let config_file = File::open(&config_path)?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
+        assert_eq!(config.executable_name, "my-custom-codeowners");
+        Ok(())
+    }
+
+    #[test]
+    fn test_executable_name_defaults_when_not_specified() -> Result<(), Box<dyn Error>> {
+        let temp_dir = tempdir()?;
+        let config_path = temp_dir.path().join("config.yml");
+        let config_str = indoc! {"
+            ---
+            owned_globs:
+              - \"**/*.rb\"
+        "};
+        fs::write(&config_path, config_str)?;
+        let config_file = File::open(&config_path)?;
+        let config: Config = serde_yaml::from_reader(config_file)?;
+        assert_eq!(config.executable_name, "codeowners");
         Ok(())
     }
 }

src/config.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/crosscheck.rs

@@ -123,6 +123,7 @@ impl Ownership {
             project: self.project.clone(),
             mappers: self.mappers(),
             file_generator: FileGenerator { mappers: self.mappers() },
+            executable_name: self.project.executable_name.clone(),
         };
 
         validator.validate()

src/ownership.rs

@@ -293,6 +293,7 @@ mod tests {
             vendored_gems_path: vendored_path.to_string(),
             cache_directory: "tmp/cache/codeowners".to_string(),
             ignore_dirs: vec![],
+            executable_name: "codeowners".to_string(),
         }
     }
 

src/ownership/file_owner_resolver.rs

@@ -21,14 +21,15 @@ pub struct Validator {
     pub project: Arc<Project>,
     pub mappers: Vec<Box<dyn Mapper>>,
     pub file_generator: FileGenerator,
+    pub executable_name: String,
 }
 
 #[derive(Debug)]
 enum Error {
     InvalidTeam { name: String, path: PathBuf },
     FileWithoutOwner { path: PathBuf },
     FileWithMultipleOwners { path: PathBuf, owners: Vec<Owner> },
-    CodeownershipFileIsStale,
+    CodeownershipFileIsStale { executable_name: String },
 }
 
 #[derive(Debug)]
@@ -130,12 +131,16 @@ impl Validator {
         match self.project.get_codeowners_file() {
             Ok(current_file) => {
                 if generated_file != current_file {
-                    vec![Error::CodeownershipFileIsStale]
+                    vec![Error::CodeownershipFileIsStale {
+                        executable_name: self.executable_name.to_string(),
+                    }]
                 } else {
                     vec![]
                 }
             }
-            Err(_) => vec![Error::CodeownershipFileIsStale], // Treat any read error as stale file
+            Err(_) => vec![Error::CodeownershipFileIsStale {
+                executable_name: self.executable_name.to_string(),
+            }],
         }
     }
 
@@ -161,13 +166,13 @@ impl Validator {
 impl Error {
     pub fn category(&self) -> String {
         match self {
-            Error::FileWithoutOwner { path: _ } => "Some files are missing ownership".to_owned(),
-            Error::FileWithMultipleOwners { path: _, owners: _ } => "Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways".to_owned(),
-            Error::CodeownershipFileIsStale => {
-                "CODEOWNERS out of date. Run `codeowners generate` to update the CODEOWNERS file".to_owned()
+                Error::FileWithoutOwner { path: _ } => "Some files are missing ownership".to_owned(),
+                Error::FileWithMultipleOwners { path: _, owners: _ } => "Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways".to_owned(),
+                Error::CodeownershipFileIsStale { executable_name } => {
+                    format!("CODEOWNERS out of date. Run `{} generate` to update the CODEOWNERS file", executable_name)
+                }
+                Error::InvalidTeam { name: _, path: _ } => "Found invalid team annotations".to_owned(),
             }
-            Error::InvalidTeam { name: _, path: _ } => "Found invalid team annotations".to_owned(),
-        }
     }
 
     pub fn messages(&self) -> Vec<String> {
@@ -187,7 +192,7 @@ impl Error {
 
                 vec![messages.join("\n")]
             }
-            Error::CodeownershipFileIsStale => vec![],
+            Error::CodeownershipFileIsStale { executable_name: _ } => vec![],
             Error::InvalidTeam { name, path } => vec![format!("- {} is referencing an invalid team - '{}'", path.to_string_lossy(), name)],
         }
     }

src/ownership/validator.rs

@@ -17,6 +17,7 @@ pub struct Project {
     pub codeowners_file_path: PathBuf,
     pub directory_codeowner_files: Vec<DirectoryCodeownersFile>,
     pub teams_by_name: HashMap<String, Team>,
+    pub executable_name: String,
 }
 
 #[derive(Clone, Debug)]
@@ -219,6 +220,7 @@ mod tests {
             codeowners_file_path: PathBuf::from(".github/CODEOWNERS"),
             directory_codeowner_files: vec![],
             teams_by_name: HashMap::new(),
+            executable_name: "codeowners".to_string(),
         };
 
         let map = project.vendored_gem_by_name();