json for-file

Author: perryqh

Cargo.lock

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

Cargo.toml

@@ -62,7 +62,7 @@ impl Caching for GlobalCache {
 
     fn delete_cache(&self) -> Result<(), Error> {
         let cache_path = self.get_cache_path();
-        dbg!("deleting", &cache_path);
+        tracing::debug!("Deleting cache file: {}", cache_path.display());
         fs::remove_file(cache_path).change_context(Error::Io)
     }
 }

src/cache/file.rs

@@ -17,10 +17,12 @@ enum Command {
             help = "Find the owner from the CODEOWNERS file and just return the team name and yml path"
         )]
         from_codeowners: bool,
+        #[arg(short, long, default_value = "false", help = "Output the result in JSON format")]
+        json: bool,
         name: String,
     },
 
-    #[clap(about = "Finds code ownership information for a given team ", visible_alias = "t")]
+    #[clap(about = "Finds code ownership information for a given team", visible_alias = "t")]
     ForTeam { name: String },
 
     #[clap(
@@ -113,7 +115,11 @@ pub fn cli() -> Result<RunResult, RunnerError> {
         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, from_codeowners } => runner::for_file(&run_config, &name, from_codeowners),
+        Command::ForFile {
+            name,
+            from_codeowners,
+            json,
+        } => runner::for_file(&run_config, &name, from_codeowners, json),
         Command::ForTeam { name } => runner::for_team(&run_config, &name),
         Command::DeleteCache => runner::delete_cache(&run_config),
         Command::CrosscheckOwners => runner::crosscheck_owners(&run_config),

src/cli.rs

@@ -26,7 +26,7 @@ fn maybe_print_errors(result: RunResult) -> Result<(), RunnerError> {
         for msg in result.validation_errors {
             println!("{}", msg);
         }
-        process::exit(-1);
+        process::exit(1);
     }
 
     Ok(())

src/main.rs

@@ -59,19 +59,21 @@ impl TeamOwnership {
 impl Display for FileOwner {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let sources = if self.sources.is_empty() {
-            "Unowned".to_string()
+            "".to_string()
         } else {
-            self.sources
+            let sources_str = self
+                .sources
                 .iter()
                 .sorted_by_key(|source| source.to_string())
                 .map(|source| source.to_string())
                 .collect::<Vec<_>>()
-                .join("\n- ")
+                .join("\n- ");
+            format!("\n- {}", sources_str)
         };
 
         write!(
             f,
-            "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- {}",
+            "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:{}",
             self.team.name, self.team.github_team, self.team_config_file_path, sources
         )
     }

src/ownership.rs

@@ -158,9 +158,9 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::Io => fmt.write_str("Error::Io"),
-            Error::SerdeYaml => fmt.write_str("Error::SerdeYaml"),
-            Error::SerdeJson => fmt.write_str("Error::SerdeJson"),
+            Error::Io => fmt.write_str("IO operation failed"),
+            Error::SerdeYaml => fmt.write_str("YAML serialization/deserialization failed"),
+            Error::SerdeJson => fmt.write_str("JSON serialization/deserialization failed"),
         }
     }
 }

src/project.rs

@@ -52,8 +52,9 @@ impl<'a> ProjectBuilder<'a> {
         }
     }
 
-    #[instrument(level = "debug", skip_all)]
+    #[instrument(level = "debug", skip_all, fields(base_path = %self.base_path.display()))]
     pub fn build(&mut self) -> Result<Project, Error> {
+        tracing::info!("Starting project build");
         let mut builder = WalkBuilder::new(&self.base_path);
         builder.hidden(false);
         builder.follow_links(false);
@@ -277,6 +278,13 @@ impl<'a> ProjectBuilder<'a> {
             .flat_map(|team| vec![(team.name.clone(), team.clone()), (team.github_team.clone(), team.clone())])
             .collect();
 
+        tracing::info!(
+            files_count = %project_files.len(),
+            teams_count = %teams.len(),
+            packages_count = %packages.len(),
+            "Project build completed successfully"
+        );
+
         Ok(Project {
             base_path: self.base_path.to_owned(),
             files: project_files,

src/project_builder.rs

@@ -1,6 +1,7 @@
 use std::{path::Path, process::Command};
 
 use error_stack::{Result, ResultExt};
+use serde::Serialize;
 
 use crate::{
     cache::{Cache, Caching, file::GlobalCache, noop::NoopCache},
@@ -181,61 +182,163 @@ impl Runner {
         Ok(owners)
     }
 
-    pub fn for_file_optimized(&self, file_path: &str) -> RunResult {
+    pub fn for_file_derived(&self, file_path: &str, json: bool) -> RunResult {
         let file_owners = match self.owners_for_file(file_path) {
             Ok(v) => v,
             Err(err) => {
-                return RunResult {
-                    io_errors: vec![err.to_string()],
-                    ..Default::default()
-                };
+                return RunResult::from_io_error(Error::Io(err.to_string()), json);
             }
         };
 
-        let info_messages: Vec<String> = match file_owners.len() {
-            0 => vec![format!("{}", FileOwner::default())],
-            1 => vec![format!("{}", file_owners[0])],
-            _ => {
+        match file_owners.as_slice() {
+            [] => RunResult::from_file_owner(&FileOwner::default(), json),
+            [owner] => RunResult::from_file_owner(owner, json),
+            many => {
                 let mut error_messages = vec!["Error: file is owned by multiple teams!".to_string()];
-                for file_owner in file_owners {
-                    error_messages.push(format!("\n{}", file_owner));
+                for owner in many {
+                    error_messages.push(format!("\n{}", owner));
                 }
-                return RunResult {
-                    validation_errors: error_messages,
-                    ..Default::default()
-                };
+                RunResult::from_validation_errors(error_messages, json)
             }
-        };
-        RunResult {
-            info_messages,
-            ..Default::default()
         }
     }
 
-    pub fn for_file_codeowners_only(&self, file_path: &str) -> RunResult {
+    pub fn for_file_codeowners_only(&self, file_path: &str, json: bool) -> RunResult {
         match team_for_file_from_codeowners(&self.run_config, file_path) {
             Ok(Some(team)) => {
-                let relative_team_path = crate::path_utils::relative_to(&self.run_config.project_root, team.path.as_path())
+                let team_yml = crate::path_utils::relative_to(&self.run_config.project_root, team.path.as_path())
                     .to_string_lossy()
                     .to_string();
-                RunResult {
-                    info_messages: vec![format!(
-                        "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- Owner inferred from codeowners file",
-                        team.name, team.github_team, relative_team_path
-                    )],
-                    ..Default::default()
+                let result = ForFileResult {
+                    team_name: team.name.clone(),
+                    github_team: team.github_team.clone(),
+                    team_yml,
+                    description: vec!["Owner inferred from codeowners file".to_string()],
+                };
+                if json {
+                    RunResult::json_info(result)
+                } else {
+                    RunResult {
+                        info_messages: vec![format!(
+                            "Team: {}\nGithub Team: {}\nTeam YML: {}\nDescription:\n- {}",
+                            result.team_name,
+                            result.github_team,
+                            result.team_yml,
+                            result.description.join("\n- ")
+                        )],
+                        ..Default::default()
+                    }
+                }
+            }
+            Ok(None) => RunResult::from_file_owner(&FileOwner::default(), json),
+            Err(err) => {
+                if json {
+                    RunResult::json_io_error(Error::Io(err.to_string()))
+                } else {
+                    RunResult {
+                        io_errors: vec![err.to_string()],
+                        ..Default::default()
+                    }
                 }
             }
-            Ok(None) => RunResult::default(),
-            Err(err) => RunResult {
-                io_errors: vec![err.to_string()],
-                ..Default::default()
-            },
         }
     }
 }
 
-// removed free functions for for_file_* variants in favor of Runner methods
+#[derive(Debug, Clone, Serialize)]
+pub struct ForFileResult {
+    pub team_name: String,
+    pub github_team: String,
+    pub team_yml: String,
+    pub description: Vec<String>,
+}
+
+impl RunResult {
+    pub fn has_errors(&self) -> bool {
+        !self.validation_errors.is_empty() || !self.io_errors.is_empty()
+    }
+
+    fn from_io_error(error: Error, json: bool) -> Self {
+        if json {
+            Self::json_io_error(error)
+        } else {
+            Self {
+                io_errors: vec![error.to_string()],
+                ..Default::default()
+            }
+        }
+    }
+
+    fn from_file_owner(file_owner: &FileOwner, json: bool) -> Self {
+        if json {
+            let description: Vec<String> = if file_owner.sources.is_empty() {
+                vec![]
+            } else {
+                file_owner.sources.iter().map(|source| source.to_string()).collect()
+            };
+            Self::json_info(ForFileResult {
+                team_name: file_owner.team.name.clone(),
+                github_team: file_owner.team.github_team.clone(),
+                team_yml: file_owner.team_config_file_path.clone(),
+                description,
+            })
+        } else {
+            Self {
+                info_messages: vec![format!("{}", file_owner)],
+                ..Default::default()
+            }
+        }
+    }
+
+    fn from_validation_errors(validation_errors: Vec<String>, json: bool) -> Self {
+        if json {
+            Self::json_validation_error(validation_errors)
+        } else {
+            Self {
+                validation_errors,
+                ..Default::default()
+            }
+        }
+    }
+
+    pub fn json_info(result: ForFileResult) -> Self {
+        let json = match serde_json::to_string_pretty(&result) {
+            Ok(json) => json,
+            Err(e) => return Self::json_io_error(Error::Io(e.to_string())),
+        };
+        Self {
+            info_messages: vec![json],
+            ..Default::default()
+        }
+    }
+
+    pub fn json_io_error(error: Error) -> Self {
+        let message = match error {
+            Error::Io(msg) => msg,
+            Error::ValidationFailed => "Error::ValidationFailed".to_string(),
+        };
+        let json = match serde_json::to_string(&serde_json::json!({"error": message})).map_err(|e| Error::Io(e.to_string())) {
+            Ok(json) => json,
+            Err(e) => return Self::json_io_error(Error::Io(e.to_string())),
+        };
+        Self {
+            io_errors: vec![json],
+            ..Default::default()
+        }
+    }
+
+    pub fn json_validation_error(validation_errors: Vec<String>) -> Self {
+        let json_obj = serde_json::json!({"validation_errors": validation_errors});
+        let json = match serde_json::to_string_pretty(&json_obj) {
+            Ok(json) => json,
+            Err(e) => return Self::json_io_error(Error::Io(e.to_string())),
+        };
+        Self {
+            validation_errors: vec![json],
+            ..Default::default()
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -245,4 +348,36 @@ mod tests {
     fn test_version() {
         assert_eq!(version(), env!("CARGO_PKG_VERSION").to_string());
     }
+    #[test]
+    fn test_json_info() {
+        let result = ForFileResult {
+            team_name: "team1".to_string(),
+            github_team: "team1".to_string(),
+            team_yml: "config/teams/team1.yml".to_string(),
+            description: vec!["file annotation".to_string()],
+        };
+        let result = RunResult::json_info(result);
+        assert_eq!(result.info_messages.len(), 1);
+        assert_eq!(
+            result.info_messages[0],
+            "{\n  \"team_name\": \"team1\",\n  \"github_team\": \"team1\",\n  \"team_yml\": \"config/teams/team1.yml\",\n  \"description\": [\n    \"file annotation\"\n  ]\n}"
+        );
+    }
+
+    #[test]
+    fn test_json_io_error() {
+        let result = RunResult::json_io_error(Error::Io("unable to find file".to_string()));
+        assert_eq!(result.io_errors.len(), 1);
+        assert_eq!(result.io_errors[0], "{\"error\":\"unable to find file\"}");
+    }
+
+    #[test]
+    fn test_json_validation_error() {
+        let result = RunResult::json_validation_error(vec!["file has multiple owners".to_string()]);
+        assert_eq!(result.validation_errors.len(), 1);
+        assert_eq!(
+            result.validation_errors[0],
+            "{\n  \"validation_errors\": [\n    \"file has multiple owners\"\n  ]\n}"
+        );
+    }
 }

src/runner.rs

@@ -6,12 +6,12 @@ use crate::project::Team;
 
 use super::{Error, RunConfig, RunResult, Runner, config_from_path, run};
 
-pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool) -> RunResult {
+pub fn for_file(run_config: &RunConfig, file_path: &str, from_codeowners: bool, json: bool) -> RunResult {
     run(run_config, |runner| {
         if from_codeowners {
-            runner.for_file_codeowners_only(file_path)
+            runner.for_file_codeowners_only(file_path, json)
         } else {
-            runner.for_file_optimized(file_path)
+            runner.for_file_derived(file_path, json)
         }
     })
 }