Combine the two execute methods (#437)

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/mod.rs

@@ -205,7 +205,6 @@ impl Apps {
   }
 
   /// provides the app with the given name
-  /// TODO: return the actual Box<dyn App> instead of a reference here
   pub(crate) fn lookup<AS: AsRef<str>>(&self, name: AS) -> Result<&dyn AppDefinition> {
     for app in &self.0 {
       if app.name() == name.as_ref() {

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/run/executable_path.rs

@@ -23,39 +23,13 @@ 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> {
+  // TODO: use ExecutableCall internally?
+  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
     add_paths(&mut cmd, &[self.0.parent().unwrap()]);
+    log(Event::AnalyzeExecutableBegin { cmd: &self.as_str(), args });
     let output = match cmd.output() {
       Ok(output) => output,
       Err(err) => {