wip

Author: mxcl

README.md

@@ -8,10 +8,8 @@ It mirrors the convenience of `npx` for the Cargo ecosystem while prioritising
 
 ## Features
 
-- Executes `crate[@version]` binaries, installing them on the fly.
-- Prefers `cargo-binstall` for fast installs and falls back to `cargo install`.
-- Supports `--bin` to pick a specific binary, `--force` to reinstall, and `--quiet`
-  to reduce installer chatter.
+- Executes `crate[@version]` binaries, installing them on demand.
+- Prefers `cargo-binstall` for fast installs falling back to `cargo install`.
 - Passes through additional arguments to the invoked binary via `--`.
 
 ## Usage
@@ -29,23 +27,22 @@ cargox bat ./README.md
 # Install and run a pinned version
 cargox cargo-deny@0.16.3 check
 
-# Force a reinstall using cargo install instead of cargo-binstall
-cargox --force --use-cargo-install cargo-nextest
+# Force a reinstall, building from source instead of using cargo-binstall
+cargox --force --build-from-source cargo-nextest
 ```
 
 > [!TIP]
 >
 > - Arguments before the first positional are passed to `cargox`.
 > - Arguments after `--` are passed to the invoked binary.
 > - Use `--` if necessary to define the separation point.
-> - If the crate exposes multiple binaries, use `--bin <name>` to select one.
 
 ### Flags
 
 - `--bin <name>`: choose a specific binary when a crate exposes several.
 - `-f`, `--force`: reinstall even if the binary already exists on `PATH`.
 - `-q`, `--quiet`: suppress installer output (still prints a short status line).
-- `--use-cargo-install`: skip `cargo-binstall` and always use `cargo install`.
+- `-s`, `--build-from-source`: build from source using `cargo install` instead of `cargo-binstall`.
 
 ### Where binaries are stored
 

src/cli.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use clap::Parser;
 use std::env;
 use std::ffi::OsString;
@@ -15,17 +15,17 @@ pub struct Cli {
     #[arg(long, value_name = "NAME")]
     pub bin: Option<String>,
 
-    /// Force reinstall even if the binary is already on PATH
+    /// Force reinstall; ignore any existing binary
     #[arg(short, long)]
     pub force: bool,
 
     /// Suppress installer output
     #[arg(short, long)]
     pub quiet: bool,
 
-    /// Use `cargo install` instead of `cargo-binstall`
-    #[arg(long)]
-    pub use_cargo_install: bool,
+    /// Build from source using `cargo install` instead of `cargo-binstall`
+    #[arg(short = 's', long)]
+    pub build_from_source: bool,
 
     /// Arguments passed to the executed binary (use `--` to delimit)
     #[arg(trailing_var_arg = true, value_name = "binary-args")]
@@ -90,15 +90,15 @@ impl Cli {
         };
 
         // Parse cargox arguments with clap
-        let mut cli = match Cli::try_parse_from(
-            std::iter::once(OsString::from("cargox")).chain(cargox_args),
-        ) {
-            Ok(cli) => cli,
-            Err(e) => {
-                // Let clap print the error/help message and exit
-                e.exit();
-            }
-        };
+        let mut cli =
+            match Cli::try_parse_from(std::iter::once(OsString::from("cargox")).chain(cargox_args))
+            {
+                Ok(cli) => cli,
+                Err(e) => {
+                    // Let clap print the error/help message and exit
+                    e.exit();
+                }
+            };
 
         // Set the binary arguments
         cli.args = binary_args;

src/installer.rs

@@ -6,7 +6,7 @@ use crate::paths::get_install_dir;
 use crate::target::Target;
 
 pub fn ensure_installed(target: &Target, cli: &Cli) -> Result<()> {
-    if !cli.use_cargo_install && which::which("cargo-binstall").is_ok() {
+    if !cli.build_from_source && which::which("cargo-binstall").is_ok() {
         install_with_binstall(target, cli)
     } else {
         log_fallback_reason(cli, target);
@@ -15,9 +15,9 @@ pub fn ensure_installed(target: &Target, cli: &Cli) -> Result<()> {
 }
 
 fn log_fallback_reason(cli: &Cli, target: &Target) {
-    if cli.use_cargo_install {
+    if cli.build_from_source {
         eprintln!(
-            "cargo-binstall was skipped explicitly; installing {} with cargo install",
+            "Building {} from source with cargo install",
             target.descriptor()
         );
     } else {

src/main.rs

@@ -12,7 +12,7 @@ use anyhow::{Context, Result};
 use cli::Cli;
 use executor::execute_binary;
 use installer::ensure_installed;
-use paths::resolve_binary_path;
+use paths::{resolve_binary_path, resolve_cargox_binary_path};
 use target::{Target, parse_spec};
 
 fn main() {
@@ -49,7 +49,15 @@ fn parse_target_from_cli(cli: &Cli) -> Result<Target> {
 }
 
 fn should_use_existing_binary(cli: &Cli, target: &Target) -> bool {
-    !cli.force && find_existing_binary(&target.binary).is_some()
+    if cli.force {
+        return false;
+    }
+
+    if target.version.is_some() {
+        return false;
+    }
+
+    find_existing_binary(&target.binary).is_some()
 }
 
 fn run_existing_binary(target: &Target, cli: &Cli) -> Result<ExitStatus> {
@@ -60,17 +68,26 @@ fn run_existing_binary(target: &Target, cli: &Cli) -> Result<ExitStatus> {
 
 fn install_and_run_binary(target: &Target, cli: &Cli) -> Result<ExitStatus> {
     ensure_installed(target, cli)?;
-    let binary_path = locate_installed_binary(&target.binary)?;
+    let binary_path = locate_installed_binary(target)?;
     execute_binary(&binary_path, &cli.args)
 }
 
 fn find_existing_binary(name: &str) -> Option<PathBuf> {
     resolve_binary_path(name).ok()
 }
 
-fn locate_installed_binary(binary_name: &str) -> Result<PathBuf> {
-    resolve_binary_path(binary_name)
-        .with_context(|| format!("{binary_name} should be on PATH after installation"))
+fn locate_installed_binary(target: &Target) -> Result<PathBuf> {
+    if target.version.is_some() {
+        return resolve_cargox_binary_path(&target.binary).with_context(|| {
+            format!(
+                "{} should be available in cargox's install directory after installation",
+                target.binary
+            )
+        });
+    }
+
+    resolve_binary_path(&target.binary)
+        .with_context(|| format!("{} should be on PATH after installation", target.binary))
 }
 
 fn exit_with_status(status: ExitStatus) -> ! {

src/paths.rs

@@ -55,6 +55,24 @@ pub fn resolve_binary_path(name: &str) -> Result<PathBuf> {
     Err(anyhow!("cannot find binary path"))
 }
 
+pub fn resolve_cargox_binary_path(name: &str) -> Result<PathBuf> {
+    for dir in candidate_bin_dirs() {
+        let candidate = dir.join(name);
+        if candidate.exists() {
+            return Ok(candidate);
+        }
+        #[cfg(windows)]
+        {
+            let exe_candidate = candidate.with_extension("exe");
+            if exe_candidate.exists() {
+                return Ok(exe_candidate);
+            }
+        }
+    }
+
+    Err(anyhow!("cannot find binary path in cargox install dir"))
+}
+
 fn candidate_bin_dirs() -> Vec<PathBuf> {
     let mut dirs = Vec::new();
 

tests/help_flag.rs

@@ -60,7 +60,10 @@ fn test_cargox_help_still_works() {
         "cargox help should appear when --help is used without a crate spec.\nStdout:\n{}",
         stdout
     );
-    assert!(output.status.success(), "cargox --help should exit successfully");
+    assert!(
+        output.status.success(),
+        "cargox --help should exit successfully"
+    );
 }
 
 /// Test that flags before the crate spec are still parsed by cargox