Add argument to ci for test threads and build jobs

tools/ci/Cargo.toml

@@ -8,7 +8,6 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 argh = "0.1"
 xshell = "0.2"
-bitflags = "2.3"
 
 [lints]
 workspace = true

tools/ci/src/args.rs

@@ -0,0 +1,5 @@
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct Args {
+    pub keep_going: bool,
+    pub test_threads: Option<u8>,
+}

tools/ci/src/ci.rs

@@ -1,6 +1,7 @@
 use crate::{
+    args::Args,
     commands,
-    prepare::{Flag, Prepare, PreparedCommand},
+    prepare::{Prepare, PreparedCommand},
 };
 use argh::FromArgs;
 
@@ -13,6 +14,23 @@ pub struct CI {
     /// continue running commands even if one fails
     #[argh(switch)]
     keep_going: bool,
+
+    /// parallelism of `cargo test`
+    #[argh(option)]
+    test_threads: Option<u8>,
+
+    /// sets `RUST_BUILD_JOBS`
+    #[argh(option)]
+    build_jobs: Option<u8>,
+}
+
+impl From<&CI> for Args {
+    fn from(value: &CI) -> Self {
+        Args {
+            keep_going: value.keep_going,
+            test_threads: value.test_threads,
+        }
+    }
 }
 
 impl CI {
@@ -22,9 +40,14 @@ impl CI {
     /// This is usually related to differing toolchains and configuration.
     pub fn run(self) {
         let sh = xshell::Shell::new().unwrap();
+        let mut prepared_commands = self.prepare(&sh);
 
-        let prepared_commands = self.prepare(&sh);
-
+        if let Some(build_jobs) = self.build_jobs {
+            prepared_commands = prepared_commands
+                .into_iter()
+                .map(|pc| pc.with_env_var("RUST_BUILD_JOBS", build_jobs.to_string().leak()))
+                .collect();
+        }
         let mut failures = vec![];
 
         for command in prepared_commands {
@@ -59,28 +82,23 @@ impl CI {
     }
 
     fn prepare<'a>(&self, sh: &'a xshell::Shell) -> Vec<PreparedCommand<'a>> {
-        let mut flags = Flag::empty();
-
-        if self.keep_going {
-            flags |= Flag::KEEP_GOING;
-        }
-
+        let args = self.into();
         match &self.command {
-            Some(command) => command.prepare(sh, flags),
+            Some(command) => command.prepare(sh, args),
             None => {
                 // Note that we are running the subcommands directly rather than using any aliases
                 let mut cmds = vec![];
-                cmds.append(&mut commands::FormatCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::ClippyCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::TestCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::TestCheckCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::DocCheckCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::DocTestCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::CompileCheckCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::CompileCheckNoStdCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::CompileFailCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::BenchCheckCommand::default().prepare(sh, flags));
-                cmds.append(&mut commands::ExampleCheckCommand::default().prepare(sh, flags));
+                cmds.append(&mut commands::FormatCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::ClippyCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::TestCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::TestCheckCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::DocCheckCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::DocTestCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::CompileCheckCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::CompileCheckNoStdCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::CompileFailCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::BenchCheckCommand::default().prepare(sh, args));
+                cmds.append(&mut commands::ExampleCheckCommand::default().prepare(sh, args));
                 cmds
             }
         }
@@ -110,23 +128,23 @@ enum Commands {
 }
 
 impl Prepare for Commands {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
         match self {
-            Commands::Lints(subcommand) => subcommand.prepare(sh, flags),
-            Commands::Doc(subcommand) => subcommand.prepare(sh, flags),
-            Commands::Compile(subcommand) => subcommand.prepare(sh, flags),
-
-            Commands::Format(subcommand) => subcommand.prepare(sh, flags),
-            Commands::Clippy(subcommand) => subcommand.prepare(sh, flags),
-            Commands::Test(subcommand) => subcommand.prepare(sh, flags),
-            Commands::TestCheck(subcommand) => subcommand.prepare(sh, flags),
-            Commands::DocCheck(subcommand) => subcommand.prepare(sh, flags),
-            Commands::DocTest(subcommand) => subcommand.prepare(sh, flags),
-            Commands::CompileCheck(subcommand) => subcommand.prepare(sh, flags),
-            Commands::CompileCheckNoStd(subcommand) => subcommand.prepare(sh, flags),
-            Commands::CompileFail(subcommand) => subcommand.prepare(sh, flags),
-            Commands::BenchCheck(subcommand) => subcommand.prepare(sh, flags),
-            Commands::ExampleCheck(subcommand) => subcommand.prepare(sh, flags),
+            Commands::Lints(subcommand) => subcommand.prepare(sh, args),
+            Commands::Doc(subcommand) => subcommand.prepare(sh, args),
+            Commands::Compile(subcommand) => subcommand.prepare(sh, args),
+
+            Commands::Format(subcommand) => subcommand.prepare(sh, args),
+            Commands::Clippy(subcommand) => subcommand.prepare(sh, args),
+            Commands::Test(subcommand) => subcommand.prepare(sh, args),
+            Commands::TestCheck(subcommand) => subcommand.prepare(sh, args),
+            Commands::DocCheck(subcommand) => subcommand.prepare(sh, args),
+            Commands::DocTest(subcommand) => subcommand.prepare(sh, args),
+            Commands::CompileCheck(subcommand) => subcommand.prepare(sh, args),
+            Commands::CompileCheckNoStd(subcommand) => subcommand.prepare(sh, args),
+            Commands::CompileFail(subcommand) => subcommand.prepare(sh, args),
+            Commands::BenchCheck(subcommand) => subcommand.prepare(sh, args),
+            Commands::ExampleCheck(subcommand) => subcommand.prepare(sh, args),
         }
     }
 }

tools/ci/src/commands/bench_check.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct BenchCheckCommand {}
 
 impl Prepare for BenchCheckCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(
                 sh,

tools/ci/src/commands/clippy.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct ClippyCommand {}
 
 impl Prepare for ClippyCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(
                 sh,

tools/ci/src/commands/compile.rs

@@ -1,9 +1,10 @@
 use crate::{
+    args::Args,
     commands::{
         BenchCheckCommand, CompileCheckCommand, CompileFailCommand, ExampleCheckCommand,
         TestCheckCommand,
     },
-    Flag, Prepare, PreparedCommand,
+    Prepare, PreparedCommand,
 };
 use argh::FromArgs;
 
@@ -13,13 +14,13 @@ use argh::FromArgs;
 pub struct CompileCommand {}
 
 impl Prepare for CompileCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
         let mut commands = vec![];
-        commands.append(&mut CompileFailCommand::default().prepare(sh, flags));
-        commands.append(&mut BenchCheckCommand::default().prepare(sh, flags));
-        commands.append(&mut ExampleCheckCommand::default().prepare(sh, flags));
-        commands.append(&mut CompileCheckCommand::default().prepare(sh, flags));
-        commands.append(&mut TestCheckCommand::default().prepare(sh, flags));
+        commands.append(&mut CompileFailCommand::default().prepare(sh, args));
+        commands.append(&mut BenchCheckCommand::default().prepare(sh, args));
+        commands.append(&mut ExampleCheckCommand::default().prepare(sh, args));
+        commands.append(&mut CompileCheckCommand::default().prepare(sh, args));
+        commands.append(&mut TestCheckCommand::default().prepare(sh, args));
         commands
     }
 }

tools/ci/src/commands/compile_check.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct CompileCheckCommand {}
 
 impl Prepare for CompileCheckCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(sh, "cargo check --workspace"),
             "Please fix compiler errors in output above.",

tools/ci/src/commands/compile_check_no_std.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -27,7 +27,7 @@ impl Default for CompileCheckNoStdCommand {
 }
 
 impl Prepare for CompileCheckNoStdCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         let target = self.target.as_str();
         let mut commands = Vec::new();
 

tools/ci/src/commands/compile_fail.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,9 +8,9 @@ use xshell::cmd;
 pub struct CompileFailCommand {}
 
 impl Prepare for CompileFailCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
-        let no_fail_fast = flags
-            .contains(Flag::KEEP_GOING)
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
+        let no_fail_fast = args
+            .keep_going
             .then_some("--no-fail-fast")
             .unwrap_or_default();
 

tools/ci/src/commands/doc.rs

@@ -1,6 +1,7 @@
 use crate::{
+    args::Args,
     commands::{DocCheckCommand, DocTestCommand},
-    Flag, Prepare, PreparedCommand,
+    Prepare, PreparedCommand,
 };
 use argh::FromArgs;
 
@@ -10,10 +11,10 @@ use argh::FromArgs;
 pub struct DocCommand {}
 
 impl Prepare for DocCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
         let mut commands = vec![];
-        commands.append(&mut DocTestCommand::default().prepare(sh, flags));
-        commands.append(&mut DocCheckCommand::default().prepare(sh, flags));
+        commands.append(&mut DocTestCommand::default().prepare(sh, args));
+        commands.append(&mut DocCheckCommand::default().prepare(sh, args));
         commands
     }
 }

tools/ci/src/commands/doc_check.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct DocCheckCommand {}
 
 impl Prepare for DocCheckCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(
                 sh,

tools/ci/src/commands/doc_test.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,14 +8,22 @@ use xshell::cmd;
 pub struct DocTestCommand {}
 
 impl Prepare for DocTestCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
-        let no_fail_fast = flags
-            .contains(Flag::KEEP_GOING)
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
+        let no_fail_fast = args
+            .keep_going
             .then_some("--no-fail-fast")
             .unwrap_or_default();
 
+        let test_threads = args
+            .test_threads
+            .map(|test_threads| format!("--test-threads={test_threads}"))
+            .unwrap_or_default();
+
         vec![PreparedCommand::new::<Self>(
-            cmd!(sh, "cargo test --workspace --doc {no_fail_fast}"),
+            cmd!(
+                sh,
+                "cargo test --workspace --doc {no_fail_fast} -- {test_threads}"
+            ),
             "Please fix failing doc tests in output above.",
         )]
     }

tools/ci/src/commands/example_check.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct ExampleCheckCommand {}
 
 impl Prepare for ExampleCheckCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(sh, "cargo check --workspace --examples"),
             "Please fix compiler errors for examples in output above.",

tools/ci/src/commands/format.rs

@@ -1,4 +1,4 @@
-use crate::{Flag, Prepare, PreparedCommand};
+use crate::{args::Args, Prepare, PreparedCommand};
 use argh::FromArgs;
 use xshell::cmd;
 
@@ -8,7 +8,7 @@ use xshell::cmd;
 pub struct FormatCommand {}
 
 impl Prepare for FormatCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, _flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, _args: Args) -> Vec<PreparedCommand<'a>> {
         vec![PreparedCommand::new::<Self>(
             cmd!(sh, "cargo fmt --all -- --check"),
             "Please run 'cargo fmt --all' to format your code.",

tools/ci/src/commands/lints.rs

@@ -1,6 +1,7 @@
 use crate::{
+    args::Args,
     commands::{ClippyCommand, FormatCommand},
-    Flag, Prepare, PreparedCommand,
+    Prepare, PreparedCommand,
 };
 use argh::FromArgs;
 
@@ -10,10 +11,10 @@ use argh::FromArgs;
 pub struct LintsCommand {}
 
 impl Prepare for LintsCommand {
-    fn prepare<'a>(&self, sh: &'a xshell::Shell, flags: Flag) -> Vec<PreparedCommand<'a>> {
+    fn prepare<'a>(&self, sh: &'a xshell::Shell, args: Args) -> Vec<PreparedCommand<'a>> {
         let mut commands = vec![];
-        commands.append(&mut FormatCommand::default().prepare(sh, flags));
-        commands.append(&mut ClippyCommand::default().prepare(sh, flags));
+        commands.append(&mut FormatCommand::default().prepare(sh, args));
+        commands.append(&mut ClippyCommand::default().prepare(sh, args));
         commands
     }
 }