[x] add bench command

x/src/bench.rs

@@ -0,0 +1,72 @@
+use crate::{
+    cargo::{CargoArgs, CargoCommand},
+    config::Config,
+    utils, Result,
+};
+use std::ffi::OsString;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct Args {
+    #[structopt(long, short, number_of_values = 1)]
+    /// Run test on the provided packages
+    package: Vec<String>,
+    #[structopt(name = "BENCHNAME", parse(from_os_str))]
+    benchname: Option<OsString>,
+    #[structopt(name = "ARGS", parse(from_os_str), last = true)]
+    args: Vec<OsString>,
+}
+
+pub fn run(mut args: Args, config: Config) -> Result<()> {
+    args.args.extend(args.benchname.clone());
+
+    let cmd = CargoCommand::Bench(&args.args);
+    let base_args = CargoArgs {
+        all_features: true,
+        ..CargoArgs::default()
+    };
+
+    if !args.package.is_empty() {
+        let run_together = args.package.iter().filter(|p| !config.is_exception(p));
+        let run_separate = args.package.iter().filter_map(|p| {
+            config.package_exceptions().get(p).map(|e| {
+                (
+                    p,
+                    CargoArgs {
+                        all_features: e.all_features,
+                        ..base_args
+                    },
+                )
+            })
+        });
+        cmd.run_on_packages_together(run_together, &base_args)?;
+        cmd.run_on_packages_separate(run_separate)?;
+    } else if utils::project_is_root()? {
+        cmd.run_with_exclusions(
+            config.package_exceptions().iter().map(|(p, _)| p),
+            &base_args,
+        )?;
+        cmd.run_on_packages_separate(config.package_exceptions().iter().map(|(name, pkg)| {
+            (
+                name,
+                CargoArgs {
+                    all_features: pkg.all_features,
+                    ..base_args
+                },
+            )
+        }))?;
+    } else {
+        let package = utils::get_local_package()?;
+        let all_features = config
+            .package_exceptions()
+            .get(&package)
+            .map(|pkg| pkg.all_features)
+            .unwrap_or(true);
+
+        cmd.run_on_local_package(&CargoArgs {
+            all_features,
+            ..base_args
+        })?;
+    }
+    Ok(())
+}

x/src/cargo.rs

@@ -105,6 +105,7 @@ pub struct CargoArgs {
 }
 
 pub enum CargoCommand<'a> {
+    Bench(&'a [OsString]),
     Check,
     Clippy(&'a [OsString]),
     Test(&'a [OsString]),
@@ -170,6 +171,7 @@ impl<'a> CargoCommand<'a> {
 
     pub fn as_str(&self) -> &'static str {
         match self {
+            CargoCommand::Bench(_) => "bench",
             CargoCommand::Check => "check",
             CargoCommand::Clippy(_) => "clippy",
             CargoCommand::Test(_) => "test",
@@ -178,6 +180,7 @@ impl<'a> CargoCommand<'a> {
 
     fn pass_through_args(&self) -> &[OsString] {
         match self {
+            CargoCommand::Bench(args) => args,
             CargoCommand::Check => &[],
             CargoCommand::Clippy(args) => args,
             CargoCommand::Test(args) => args,

x/src/main.rs

@@ -1,5 +1,6 @@
 use structopt::StructOpt;
 
+mod bench;
 mod cargo;
 mod check;
 mod clippy;
@@ -17,6 +18,9 @@ struct Args {
 
 #[derive(Debug, StructOpt)]
 enum Command {
+    #[structopt(name = "bench")]
+    /// Run `cargo bench`
+    Bench(bench::Args),
     #[structopt(name = "check")]
     /// Run `cargo check`
     Check(check::Args),
@@ -36,5 +40,6 @@ fn main() -> Result<()> {
         Command::Test(args) => test::run(args, config),
         Command::Check(args) => check::run(args, config),
         Command::Clippy(args) => clippy::run(args, config),
+        Command::Bench(args) => bench::run(args, config),
     }
 }