Consider default-members when resolving the binary to run (#477)

# Objective

Fixes #443.

Cargo allows you to use `default-members` to define the default package
to search for binaries in within a workspace.
The Bevy CLI didn't consider this field, resulting in divergent behavior
in comparison to `cargo`. To avoid confusion, we always want to behave
like `cargo` where possible.

# Solution

Now that we use the `cargo_metadata` crate, we can use some helpers to
pick the packages to search the binary in.
We are now respecting the default workspace members.

Note that this also now respects the location where you execute the
command in. If you are located directly in a package, that package is
now picked by default (same as `cargo`) and no longer the other defaults
defined in the workspace.

# Testing

1. Install the CLI from this branch:
    ```
cargo install --git https://github.com/TheBevyFlock/bevy_cli --branch
443-fix-binary-resulution --locked bevy_cli
    ```
3. You can use <https://github.com/TimJentzsch/bevy_complex_repo> for
testing, check the new `default_members` workspace. Compare which
package `cargo run` and `bevy run` executes. They should now match up.

Author: TimJentzsch

src/bin_target.rs

@@ -21,8 +21,8 @@ pub struct BinTarget<'p> {
 /// The `--package` arg narrows down the search space to the given package,
 /// while the `--bin` and `--example` args determine the binary target within the selected packages.
 ///
-/// If the search couldn't be narrowed down to a single binary,
-/// the `default_run` option is taken into account.
+/// From the `Cargo.toml`, the `default-members` workspace option
+/// and the `default-run` package option are taken into account.
 ///
 /// The path to the compiled binary is determined via the compilation target and profile.
 pub(crate) fn select_run_binary<'p>(
@@ -33,29 +33,35 @@ pub(crate) fn select_run_binary<'p>(
     compile_target: Option<&str>,
     compile_profile: &str,
 ) -> anyhow::Result<BinTarget<'p>> {
-    // Determine which packages the binary could be in
+    let workspace_packages = metadata.workspace_packages();
+
+    // Narrow down the packages that the binary could be contained in:
+    // - If `--package=name` is specified, look for that specific package
+    // - If `default-members` is defined in the workspace, consider only these packages
+    // - Otherwise, consider all packages in the current workspace
     let packages = if let Some(package_name) = package_name {
-        let package = metadata
-            .packages
+        let package = workspace_packages
             .iter()
-            .find(|package| {
-                // Only consider packages in the current workspace and with the correct name
-                metadata.workspace_members.contains(&package.id)
-                    && package.name.as_str() == package_name
-            })
+            .find(|package| package.name.as_str() == package_name)
             .ok_or_else(|| anyhow::anyhow!("Failed to find package {package_name}"))?;
-        vec![package]
+        vec![*package]
     } else {
-        metadata
-            .packages
-            .iter()
-            // Only consider packages in the current workspace
-            .filter(|package| metadata.workspace_members.contains(&package.id))
-            .collect()
+        let default_packages = metadata.workspace_default_packages();
+
+        if default_packages.is_empty() {
+            workspace_packages
+        } else {
+            default_packages
+        }
     };
 
     let mut is_example = false;
 
+    // Find the binary in the specified packages:
+    // - If `--bin=name` is specified, look for that specific binary
+    // - If `--example=name` is specified, look for that specific example
+    // - If only one binary is available, take that one
+    // - Otherwise, take the `default-run` binary, if specified
     let (target, package) = if let Some(bin_name) = bin_name {
         // The user specified a concrete binary
         let bins: Vec<_> = packages
@@ -137,19 +143,22 @@ pub(crate) fn select_run_binary<'p>(
 
             if default_runs.is_empty() {
                 anyhow::bail!(
-                    "There are multiple binaries available, try specifying one with --bin or define `default_run` in the Cargo.toml"
+                    "There are multiple binaries available, try one of the following:
+- add `--bin` or `--package` after `bevy run` to specify which binary or package to run,
+- define `default-run` in the Cargo.toml to define the default binary that should be executed in a package,
+- define `default-members` in the Cargo.toml of your workspace to define the default package to pick the binary from."
                 );
             } else if default_runs.len() > 1 {
                 anyhow::bail!(
-                    "Found multiple `default_run` definitions, I don't know which one to pick!"
+                    "Found multiple `default-run` definitions, I don't know which one to pick!"
                 );
             }
 
             let default_run = default_runs[0];
             *bins
                 .iter()
                 .find(|(bin, _)| bin.name == *default_run)
-                .ok_or_else(|| anyhow::anyhow!("Didn't find `default_run` binary {default_run}"))?
+                .ok_or_else(|| anyhow::anyhow!("Didn't find `default-run` binary {default_run}"))?
         }
     };