Make commands cuter

This is a different approach from the previous commit. I zoomed out and considered the over all problem space:

## Desires:

- A representation of the command being run should appear in logs, or the error, or both
- Stdout and Stderr from the command should appear in logs, or the error, but NOT both (if it runs).
- Make non-zero status an error
- Allow for debugging a command that was run after execution (i.e. get command program name, arguments, env, cwd and pass them to something like `WhichProblem`)
- Ideally only have to format `Command` once

## Central std structs:

- `Command` holds all state needed to run a process. Must be `mut` to be run. `&mut` references are exclusive and can be tricky to work with. Cannot be cloned. 
- `Output` holds stdout, stderr, and status if the command could be executed.
- `std::io::Error` holds failure information if the process could not boot (for example, could not find the executable)

## Consequences

- Command must be represented a minimum of 3 times for logging:
  - For logging
  - In the io error state
  - In the Ok state so it can be converted into an Err on invalid status
  - Another time if we need to access it for debugging i.e. WhichProblem
- We need both a Command representation and Output data at the same time
  - Generating an `Output` requires a mutable reference to the command.
- We need both a Command representation and std::io::Err at the same time

## Implementation

I realized that I wanted a flow of data

- Command
- Command w/Name
- Command w/Name & Result<Output, std::io::Error>

This gives us a way to build up a canonical representation of the command as a "name". I chose to implement these three states as structs with functions that allow for transition between structs.

I also need to record if the contents are streamed or not. For this I implemented an enum, but users don't need to see it if they only ever call helper methods like: `stream()` or `run-quietly()`.

Once the final state is achieved, it's still not very ergonomic, so converted it into an enum instead that represents the possible states of the system:

- Command ran, status = 0 
- NonZero status, stderr is not streamed
- NonZero status, stderr is already streamed
- IO Error

If someone wants to take this and use it, they can. It would be very easy to map non-zero status back to an `Ok` state as they share the same inner struct type. 

However that enum cannot be used as an Error as it contains `& mut Command` with a lifetime which makes it not terribly useful.

I provided a default error enum and an easy way to map that status enum into an error via a method. This allows the end user to be able to chain all `cute_cmd` calls and then to `map` or `map_err` if they need more control.


## TODO

Add `which_problem` integration back in. More docs. Get a review.

Author: schneems

buildpacks/ruby/src/layers/bundle_install_layer.rs

@@ -1,6 +1,8 @@
 use crate::{BundleWithout, RubyBuildpack, RubyBuildpackError};
 use commons::{
-    cmd, cmd::CmdError, display::SentenceList, gemfile_lock::ResolvedRubyVersion,
+    cute_cmd::{self, cute_name_with_env, CuteCmd, CuteCmdError},
+    display::SentenceList,
+    gemfile_lock::ResolvedRubyVersion,
     metadata_digest::MetadataDigest,
 };
 use libcnb::{
@@ -10,7 +12,6 @@ use libcnb::{
     layer_env::{LayerEnv, ModificationBehavior, Scope},
     Env,
 };
-use libherokubuildpack::command::CommandExt;
 use libherokubuildpack::log as user;
 use serde::{Deserialize, Serialize};
 use std::path::Path;
@@ -337,32 +338,27 @@ fn layer_env(layer_path: &Path, app_dir: &Path, without_default: &BundleWithout)
 ///
 /// When the 'bundle install' command fails this function returns an error.
 ///
-fn bundle_install(env: &Env) -> Result<(), CmdError> {
+fn bundle_install(env: &Env) -> Result<(), CuteCmdError> {
     // ## Run `$ bundle install`
 
-    let bundle = "bundle";
-    let mut command = cmd::create(bundle, &["install"], env);
-    let command_string = cmd::display_with_keys(
-        &command,
-        env,
-        [
-            "BUNDLE_BIN",
-            "BUNDLE_CLEAN",
-            "BUNDLE_DEPLOYMENT",
-            "BUNDLE_GEMFILE",
-            "BUNDLE_PATH",
-            "BUNDLE_WITHOUT",
-        ],
-    );
-
-    user::log_info(format!("\nRunning command:\n$ {command_string}"));
-
-    command
-        .output_and_write_streams(std::io::stdout(), std::io::stderr())
-        .map_err(|error| cmd::annotate_which_problem(error, bundle.into(), env.get("PATH")))
-        .map_err(cmd::os_command_error)
-        .and_then(|output| cmd::check_non_zero(output, cmd::OutputState::AlreadyStreamed))
-        .map_err(|error| CmdError::new(command_string, error))?;
+    let mut command = cute_cmd::plain("bundle", &["install"], env);
+
+    CuteCmd::new_with(&mut command, |command| {
+        cute_name_with_env(
+            command,
+            [
+                "BUNDLE_BIN",
+                "BUNDLE_CLEAN",
+                "BUNDLE_DEPLOYMENT",
+                "BUNDLE_GEMFILE",
+                "BUNDLE_PATH",
+                "BUNDLE_WITHOUT",
+            ],
+        )
+    })
+    .hello(|name| user::log_info(format!("\nRunning command:\n$ {name}")))
+    .stream()
+    .to_result()?;
 
     Ok(())
 }

buildpacks/ruby/src/main.rs

@@ -3,7 +3,7 @@
 #![allow(clippy::module_name_repetitions)]
 use crate::layers::{RubyInstallError, RubyInstallLayer};
 use commons::cache::CacheError;
-use commons::cmd::CmdError;
+use commons::cute_cmd::CuteCmdError;
 use commons::env_command::CommandError;
 use commons::gem_list::GemList;
 use commons::gemfile_lock::GemfileLock;
@@ -170,7 +170,7 @@ pub(crate) enum RubyBuildpackError {
     MissingGemfileLock(std::io::Error),
     InAppDirCacheError(CacheError),
     BundleInstallDigestError(commons::metadata_digest::DigestError),
-    BundleInstallCommandError(CmdError),
+    BundleInstallCommandError(CuteCmdError),
     RakeAssetsPrecompileFailed(CommandError),
     GemInstallBundlerCommandError(CommandError),
 }