Use raw executor by default, skip intermediate shell

This adds a new "raw executor" (next to the "shell executor") that
allows hyperfine to execute commands directly without any intermediate
shell.

The command line is split into tokens (using the `shell-words` crate),
and according to POSIX rules. The first token is taken as the executable,
and the rest as arguments.

The new executor is enabled by default. In order to select the shell
executor, users will have to pass `--shell=default`.

This allows us to reduce measurement noise and to benchmark very quick
commands. It also decreases the time to run benchmarks, as we don't need
the calibration phase.

Also, it allows one to make sure that the executed command is not
implemented as a shell builtin. For example `hyperfine true`
and `hyperfine --shell=default true` return different times due
to the fact that `bash` executes `true` as a NOP.

Co-authored: Ciprian Dorin Craciun <ciprian@volution.ro>

src/command.rs

@@ -15,7 +15,7 @@ use clap::ArgMatches;
 use crate::parameter::tokenize::tokenize;
 use crate::parameter::ParameterValue;
 
-use anyhow::{bail, Result};
+use anyhow::{bail, Context, Result};
 use clap::Values;
 use rust_decimal::Decimal;
 
@@ -64,6 +64,21 @@ impl<'a> Command<'a> {
         self.replace_parameters_in(self.expression)
     }
 
+    pub fn get_command(&self) -> Result<std::process::Command> {
+        let command_line = self.get_command_line();
+        let mut tokens = shell_words::split(&command_line)
+            .with_context(|| format!("Failed to parse command '{}'", command_line))?
+            .into_iter();
+
+        if let Some(program_name) = tokens.next() {
+            let mut command_builder = std::process::Command::new(program_name);
+            command_builder.args(tokens);
+            Ok(command_builder)
+        } else {
+            bail!("Can not execute empty command")
+        }
+    }
+
     pub fn get_parameters(&self) -> &[(&'a str, ParameterValue)] {
         &self.parameters
     }