fallback error

Author: perryqh

src/runner.rs

@@ -304,7 +304,7 @@ impl RunResult {
     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())),
+            Err(e) => return Self::fallback_io_error(&e.to_string()),
         };
         Self {
             info_messages: vec![json],
@@ -317,9 +317,9 @@ impl RunResult {
             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())) {
+        let json = match serde_json::to_string(&serde_json::json!({"error": message})) {
             Ok(json) => json,
-            Err(e) => return Self::json_io_error(Error::Io(e.to_string())),
+            Err(e) => return Self::fallback_io_error(&format!("JSON serialization failed: {}", e)),
         };
         Self {
             io_errors: vec![json],
@@ -331,13 +331,20 @@ impl RunResult {
         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())),
+            Err(e) => return Self::fallback_io_error(&format!("JSON serialization failed: {}", e)),
         };
         Self {
             validation_errors: vec![json],
             ..Default::default()
         }
     }
+
+    fn fallback_io_error(message: &str) -> Self {
+        Self {
+            io_errors: vec![format!("{{\"error\": \"{}\"}}", message.replace('"', "\\\""))],
+            ..Default::default()
+        }
+    }
 }
 
 #[cfg(test)]

src/runner/api.rs

@@ -4,16 +4,13 @@ use std::path::Path;
 use crate::ownership::FileOwner;
 use crate::project::Team;
 
-use super::{Error, RunConfig, RunResult, Runner, config_from_path, run};
+use super::{Error, ForFileResult, RunConfig, RunResult, Runner, config_from_path, run};
 
 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, json)
-        } else {
-            runner.for_file_derived(file_path, json)
-        }
-    })
+    if from_codeowners {
+        return for_file_codeowners_only_fast(run_config, file_path, json);
+    }
+    for_file_optimized(run_config, file_path, json)
 }
 
 pub fn for_team(run_config: &RunConfig, team_name: &str) -> RunResult {
@@ -81,3 +78,65 @@ pub fn team_for_file_from_codeowners(run_config: &RunConfig, file_path: &str) ->
     .map_err(Error::Io)?;
     Ok(res)
 }
+
+// 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) {
+        Ok(c) => c,
+        Err(err) => {
+            return RunResult::from_io_error(Error::Io(err.to_string()), json);
+        }
+    };
+
+    use crate::ownership::file_owner_resolver::find_file_owners;
+    let file_owners = match find_file_owners(&run_config.project_root, &config, std::path::Path::new(file_path)) {
+        Ok(v) => v,
+        Err(err) => {
+            return RunResult::from_io_error(Error::Io(err), json);
+        }
+    };
+
+    match file_owners.as_slice() {
+        [] => RunResult::from_file_owner(&crate::ownership::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 owner in many {
+                error_messages.push(format!("\n{}", owner));
+            }
+            RunResult::from_validation_errors(error_messages, json)
+        }
+    }
+}
+
+fn for_file_codeowners_only_fast(run_config: &RunConfig, file_path: &str, json: bool) -> RunResult {
+    match team_for_file_from_codeowners(run_config, file_path) {
+        Ok(Some(team)) => {
+            let team_yml = crate::path_utils::relative_to(&run_config.project_root, team.path.as_path())
+                .to_string_lossy()
+                .to_string();
+            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(&crate::ownership::FileOwner::default(), json),
+        Err(err) => RunResult::from_io_error(Error::Io(format!("{}", err)), json),
+    }
+}