Combine the two execute methods

src/applications/actionlint.rs

@@ -58,11 +58,11 @@ impl AppDefinition for ActionLint {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("actionlint is a linter for GitHub Actions workflow files") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    let output = executable.run_output("--version", log)?;
+    let output = executable.run_output(&["--version"], log)?;
     match extract_version(&output) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::NotIdentified { output }),

src/applications/alphavet.rs

@@ -39,7 +39,7 @@ impl AppDefinition for Alphavet {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Checks that functions are ordered alphabetically within packages") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/deadcode.rs

@@ -35,7 +35,7 @@ impl AppDefinition for Deadcode {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("The deadcode command reports unreachable functions in Go programs") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/depth.rs

@@ -57,7 +57,7 @@ impl AppDefinition for Depth {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("resolves dependencies of internal (stdlib) packages.") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/dprint.rs

@@ -55,11 +55,11 @@ impl AppDefinition for Dprint {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Auto-formats source code based on the specified plugins") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/exhaustruct.rs

@@ -39,7 +39,7 @@ impl AppDefinition for Exhaustruct {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("exhaustruct: Checks if all structure fields are initialized") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/gh.rs

@@ -58,11 +58,11 @@ impl AppDefinition for Gh {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Work seamlessly with GitHub from the command line") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/ghokin.rs

@@ -53,7 +53,7 @@ impl AppDefinition for Ghokin {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Clean and/or apply transformation on gherkin files") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/go.rs

@@ -71,10 +71,10 @@ impl AppDefinition for Go {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    if let Ok(version) = extract_version(&executable.run_output("version", log)?) {
+    if let Ok(version) = extract_version(&executable.run_output(&["version"], log)?) {
       return Ok(AnalyzeResult::IdentifiedWithVersion(version.into()));
     }
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if output.contains("Go is a tool for managing Go source code") {
       Ok(AnalyzeResult::IdentifiedButUnknownVersion)
     } else {

src/applications/goda.rs

@@ -39,7 +39,7 @@ impl AppDefinition for Goda {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("help", log)?;
+    let output = executable.run_output(&["help"], log)?;
     if !output.contains("Print dependency graph") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/gofmt.rs

@@ -33,7 +33,7 @@ impl AppDefinition for Gofmt {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("report all errors (not just the first 10 on different lines)") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/gofumpt.rs

@@ -57,11 +57,11 @@ impl AppDefinition for Gofumpt {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("display diffs instead of rewriting files") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/golangci_lint.rs

@@ -53,7 +53,7 @@ impl AppDefinition for GolangCiLint {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/goreleaser.rs

@@ -52,7 +52,7 @@ impl AppDefinition for Goreleaser {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-v", log)?;
+    let output = executable.run_output(&["-v"], log)?;
     if !output.contains("https://goreleaser.com") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/govulnchec.rs

@@ -35,7 +35,7 @@ impl AppDefinition for Govulncheck {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Govulncheck reports known vulnerabilities in dependencies") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/ireturn.rs

@@ -58,7 +58,7 @@ impl AppDefinition for Ireturn {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("ireturn: Accept Interfaces, Return Concrete Types") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/mdbook.rs

@@ -60,11 +60,11 @@ impl AppDefinition for MdBook {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Creates a book from markdown files") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("-V", log)?) {
+    match extract_version(&executable.run_output(&["-V"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/mdbook_linkcheck.rs

@@ -56,11 +56,11 @@ impl AppDefinition for MdBookLinkCheck {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("mdbook-linkcheck") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("-V", log)?) {
+    match extract_version(&executable.run_output(&["-V"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/node_prune.rs

@@ -58,7 +58,7 @@ impl AppDefinition for NodePrune {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Glob of files that should not be pruned") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/nodejs.rs

@@ -46,11 +46,11 @@ impl AppDefinition for NodeJS {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Documentation can be found at https://nodejs.org") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/npm.rs

@@ -35,7 +35,7 @@ impl AppDefinition for Npm {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output_args(&["help", "npm"], log)?;
+    let output = executable.run_output(&["help", "npm"], log)?;
     if !output.contains("javascript package manager") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/npx.rs

@@ -35,7 +35,7 @@ impl AppDefinition for Npx {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Run a command from a local or remote npm package") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/ripgrep.rs

@@ -60,7 +60,7 @@ impl AppDefinition for RipGrep {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("ripgrep") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/scc.rs

@@ -54,11 +54,11 @@ impl AppDefinition for Scc {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Count lines of code in a directory with complexity estimation") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/shellcheck.rs

@@ -54,7 +54,7 @@ impl AppDefinition for ShellCheck {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("--version", log)?;
+    let output = executable.run_output(&["--version"], log)?;
     if !output.contains("ShellCheck - shell script analysis tool") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/shfmt.rs

@@ -57,11 +57,11 @@ impl AppDefinition for Shfmt {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("shfmt formats shell programs") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/applications/staticcheck.rs

@@ -54,7 +54,7 @@ impl AppDefinition for StaticCheck {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Usage: staticcheck [flags] [packages]") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }

src/applications/tikibase.rs

@@ -53,11 +53,11 @@ impl AppDefinition for Tikibase {
   }
 
   fn analyze_executable(&self, executable: &ExecutablePath, log: Log) -> Result<AnalyzeResult> {
-    let output = executable.run_output("-h", log)?;
+    let output = executable.run_output(&["-h"], log)?;
     if !output.contains("Linter for Markdown-based knowledge databases") {
       return Ok(AnalyzeResult::NotIdentified { output });
     }
-    match extract_version(&executable.run_output("--version", log)?) {
+    match extract_version(&executable.run_output(&["--version"], log)?) {
       Ok(version) => Ok(AnalyzeResult::IdentifiedWithVersion(version.into())),
       Err(_) => Ok(AnalyzeResult::IdentifiedButUnknownVersion),
     }

src/logging/event.rs

@@ -7,10 +7,6 @@ use std::path::Path;
 
 /// the different events that can result in CLI output
 pub(crate) enum Event<'a> {
-  AnalyzeExecutableBegin {
-    cmd: &'a str,
-    args: &'a [&'a str],
-  },
   AnalyzeExecutableError {
     err: String,
   },

src/logging/normal.rs

@@ -6,7 +6,6 @@ use std::io::{self, Write};
 pub(crate) fn log(event: Event) {
   #[allow(clippy::match_same_arms)]
   match event {
-    Event::AnalyzeExecutableBegin { cmd: _, args: _ } => {}
     Event::AnalyzeExecutableError { err: _ } => {}
 
     Event::ArchiveExtractBegin { archive_type: _ } => eprintf!("extracting ... "),

src/logging/verbose.rs

@@ -6,7 +6,6 @@ use std::io::{self, Write};
 pub(crate) fn log(event: Event) {
   #[allow(clippy::match_same_arms)]
   match event {
-    Event::AnalyzeExecutableBegin { cmd, args } => eprintln!("{}", format!("{cmd} {}", args.join(" ")).bold()),
     Event::AnalyzeExecutableError { err } => eprintln!("{}", err.red()),
 
     Event::ArchiveExtractBegin { archive_type } => eprintf!("extracting {} ... ", archive_type.cyan()),

src/run/executable_path.rs

@@ -24,34 +24,7 @@ impl ExecutablePath {
 
   /// runs this executable with the given args and returns the output it produced
   // TODO: move this into ExecutableCall
-  pub(crate) fn run_output(&self, arg: &str, log: Log) -> Result<String> {
-    let mut cmd = Command::new(self);
-    cmd.arg(arg);
-    #[allow(clippy::unwrap_used)] // there is always a parent here since this is a location inside the yard
-    add_paths(&mut cmd, &[self.0.parent().unwrap()]);
-    log(Event::AnalyzeExecutableBegin {
-      cmd: &self.as_str(),
-      args: &[arg],
-    });
-    let output = match cmd.output() {
-      Ok(output) => output,
-      Err(err) => {
-        log(Event::AnalyzeExecutableError { err: err.to_string() });
-        return Err(UserError::ExecutableCannotExecute {
-          executable: self.clone(),
-          err: err.to_string(),
-        });
-      }
-    };
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let output = format!("{stdout}{stderr}");
-    Ok(output)
-  }
-
-  /// runs this executable with the given args and returns the output it produced
-  // TODO: move this into ExecutableCall
-  pub(crate) fn run_output_args(&self, args: &[&str], log: Log) -> Result<String> {
+  pub(crate) fn run_output(&self, args: &[&str], log: Log) -> Result<String> {
     let mut cmd = Command::new(self);
     cmd.args(args);
     #[allow(clippy::unwrap_used)] // there is always a parent here since this is a location inside the yard