Show cargo build output when expanding (#358)

Resolves #357

Opted to keep it simple, no progress bar, run expand sequentially.
Just prints the current package and it's index.

```bash
> cargo shear --expand
   Expanding basic-otlp [1/21]
   Compiling proc-macro2 v1.0.103
   Compiling quote v1.0.42
   Compiling unicode-ident v1.0.22
   ...
```

Author: CathalMullan

src/dependency_analyzer.rs

@@ -9,7 +9,12 @@
 //! The analyzer walks through all source files in a package, collects import
 //! statements, and builds a set of used import names.
 
-use std::{env, ffi::OsString, path::PathBuf, process::Command};
+use std::{
+    env,
+    ffi::OsString,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
 
 use anyhow::{Result, anyhow};
 use cargo_metadata::{Package, Target, TargetKind};
@@ -210,20 +215,16 @@ impl DependencyAnalyzer {
                 .arg(&target_arg)
                 .arg("--all-features")
                 .arg("--profile=check")
-                .arg("--color=never")
                 .arg("--")
                 .arg("-Zunpretty=expanded")
                 .current_dir(package.manifest_path.parent().ok_or_else(|| {
                     anyhow!("Failed to get parent path: {}", package.manifest_path)
-                })?);
+                })?)
+                .stderr(Stdio::inherit());
 
             let output = cmd.output()?;
             if !output.status.success() {
-                return Err(anyhow!(
-                    "Cargo expand failed for {}:\n{}",
-                    target.name,
-                    String::from_utf8_lossy(&output.stderr)
-                ));
+                return Err(anyhow!("Cargo expand failed for {}", target.name));
             }
 
             let output_str = String::from_utf8(output.stdout)?;

src/lib.rs

@@ -50,7 +50,8 @@ use std::{
 
 use anyhow::Result;
 use bpaf::Bpaf;
-use cargo_metadata::{CargoOpt, MetadataCommand};
+use cargo_metadata::{CargoOpt, Metadata, MetadataCommand, Package};
+use owo_colors::OwoColorize;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use toml_edit::DocumentMut;
 
@@ -339,24 +340,45 @@ impl<W: Write> CargoShear<W> {
             })
             .collect();
 
-        // Process packages in parallel
-        let results: Vec<_> = packages
-            .par_iter()
-            .map(|package| {
-                let manifest_path = package.manifest_path.as_std_path();
-                let relative_path = manifest_path.strip_prefix(&root).unwrap_or(manifest_path);
-
-                let content = fs::read_to_string(manifest_path)?;
-                let manifest: Manifest = toml::from_str(&content)?;
-                let result = processor.process_package(
-                    &metadata,
-                    package,
-                    &manifest,
-                    &workspace_manifest,
-                )?;
-                Ok::<_, anyhow::Error>((relative_path.to_path_buf(), content, result))
-            })
-            .collect::<Result<Vec<_>>>()?;
+        let total = packages.len();
+        let results: Vec<_> = if self.options.expand {
+            // Process packages sequentially, since expand needs to invoke `cargo build`.
+            packages
+                .iter()
+                .enumerate()
+                .map(|(index, package)| {
+                    eprintln!(
+                        "{:>12} {} [{}/{}]",
+                        "Expanding".bright_cyan().bold(),
+                        package.name,
+                        index + 1,
+                        total
+                    );
+
+                    Self::process_package(
+                        &root,
+                        &processor,
+                        &metadata,
+                        &workspace_manifest,
+                        package,
+                    )
+                })
+                .collect::<Result<Vec<_>>>()?
+        } else {
+            // Process packages in parallel
+            packages
+                .par_iter()
+                .map(|package| {
+                    Self::process_package(
+                        &root,
+                        &processor,
+                        &metadata,
+                        &workspace_manifest,
+                        package,
+                    )
+                })
+                .collect::<Result<Vec<_>>>()?
+        };
 
         for (path, content, result) in results {
             let absolute_path = root.join(&path);
@@ -387,6 +409,23 @@ impl<W: Write> CargoShear<W> {
         Ok(())
     }
 
+    fn process_package(
+        root: &Path,
+        processor: &PackageProcessor,
+        metadata: &Metadata,
+        workspace_manifest: &Manifest,
+        package: &Package,
+    ) -> Result<(PathBuf, String, PackageAnalysis)> {
+        let manifest_path = package.manifest_path.as_std_path();
+        let relative_path = manifest_path.strip_prefix(root).unwrap_or(manifest_path);
+
+        let content = fs::read_to_string(manifest_path)?;
+        let manifest: Manifest = toml::from_str(&content)?;
+        let result = processor.process_package(metadata, package, &manifest, workspace_manifest)?;
+
+        Ok((relative_path.to_path_buf(), content, result))
+    }
+
     fn fix_package_issues(&self, manifest_path: &Path, result: &PackageAnalysis) -> Result<usize> {
         if !self.options.fix {
             return Ok(0);