Merge dev audit Into dev check

Author: daxpedda

host/dev/src/client/check.rs

@@ -1,6 +1,6 @@
 use std::env;
 use std::process::Command;
-use std::time::Duration;
+use std::time::Instant;
 
 use anyhow::Result;
 use clap::{Args, ValueEnum};
@@ -24,6 +24,7 @@ pub enum Tool {
 	#[default]
 	Clippy,
 	CargoJsSys,
+	RustSec,
 	Tombi,
 }
 
@@ -50,7 +51,7 @@ impl Check {
 
 	pub fn execute(self, verbose: bool) -> Result<()> {
 		let tools = Tool::from_tools(self.tools)?;
-		let mut duration = Duration::ZERO;
+		let start = Instant::now();
 
 		for tool in tools {
 			match tool {
@@ -65,7 +66,7 @@ impl Check {
 						CargoCommand {
 							title: "Check Tests",
 							sub_command: "clippy",
-							args: &["--tests", "--benches", "--", "-D", "warnings"],
+							args: &["--tests", "--benches", "--examples", "--", "-D", "warnings"],
 							envs: &[],
 						},
 						CargoCommand {
@@ -75,7 +76,7 @@ impl Check {
 							envs: &[("RUSTDOCFLAGS", "-D warnings")],
 						},
 					];
-					duration += metadata::run(self.args.clone(), &commands, verbose)?;
+					metadata::run(self.args.clone(), &commands, verbose)?;
 				}
 				Tool::CargoJsSys => {
 					let tools_installed =
@@ -88,26 +89,31 @@ impl Check {
 						command::run("Build `cargo-js-sys`", command, verbose)?;
 					}
 
-					duration += Self::cargo_js_sys("js-sys", tools_installed, verbose)?;
-					duration += Self::cargo_js_sys("web-sys", tools_installed, verbose)?;
+					Self::cargo_js_sys("js-sys", tools_installed, verbose)?;
+					Self::cargo_js_sys("web-sys", tools_installed, verbose)?;
+				}
+				Tool::RustSec => {
+					let mut command = Command::new("cargo");
+					command.current_dir("../client").arg("audit");
+					command::run("RustSec", command, verbose)?;
 				}
 				Tool::Tombi => {
 					let mut command = Command::new("tombi");
 					command
 						.current_dir("../client")
 						.args(["lint", "--error-on-warnings", "."]);
-					duration += command::run("Tombi Lint", command, verbose)?;
+					command::run("Tombi Lint", command, verbose)?;
 				}
 			}
 		}
 
 		println!("-------------------------");
-		println!("Total Time: {:.2}s", duration.as_secs_f32());
+		println!("Total Time: {:.2}s", start.elapsed().as_secs_f32());
 
 		Ok(())
 	}
 
-	fn cargo_js_sys(pkg: &str, tools_installed: bool, verbose: bool) -> Result<Duration> {
+	fn cargo_js_sys(pkg: &str, tools_installed: bool, verbose: bool) -> Result<()> {
 		let mut command = if tools_installed {
 			Command::new("cargo-js-sys")
 		} else {
@@ -125,6 +131,8 @@ impl Check {
 			command.arg("-v");
 		}
 
-		command::run(&format!("Check `cargo-js-sys` - `{pkg}`"), command, verbose)
+		command::run(&format!("Check `cargo-js-sys` - `{pkg}`"), command, verbose)?;
+
+		Ok(())
 	}
 }

host/dev/src/client/fmt.rs

@@ -0,0 +1,57 @@
+use std::process::Command;
+use std::time::Instant;
+
+use anyhow::Result;
+use clap::Args;
+
+use crate::{FmtTool, FmtTools, command};
+
+#[derive(Args)]
+pub struct Fmt {
+	#[arg(long, value_delimiter = ',', default_value = FmtTools::default_arg())]
+	tools: Vec<FmtTools>,
+}
+
+impl Default for Fmt {
+	fn default() -> Self {
+		Self {
+			tools: vec![FmtTools::default()],
+		}
+	}
+}
+
+impl Fmt {
+	pub fn new(tools: Vec<FmtTools>) -> Self {
+		Self { tools }
+	}
+
+	pub fn execute(self, verbose: bool) -> Result<()> {
+		let tools = FmtTool::from_tools(self.tools)?;
+		let start = Instant::now();
+
+		for tool in tools {
+			match tool {
+				FmtTool::Rustfmt => {
+					let mut command = Command::new("cargo");
+					command.current_dir("../client").args(["+nightly", "fmt"]);
+					command::run("Rustfmt", command, verbose)?;
+				}
+				FmtTool::Tombi => {
+					let mut command = Command::new("tombi");
+					command.current_dir("../client").args(["format", "."]);
+					command::run("Tombi Format", command, verbose)?;
+				}
+				FmtTool::Prettier => {
+					let mut command = Command::new("prettier");
+					command.current_dir("..").args(["client", "-w"]);
+					command::run("Prettier", command, verbose)?;
+				}
+			}
+		}
+
+		println!("-------------------------");
+		println!("Total Time: {:.2}s", start.elapsed().as_secs_f32());
+
+		Ok(())
+	}
+}

host/dev/src/client/mod.rs

@@ -1,25 +1,24 @@
 mod check;
+mod fmt;
 mod metadata;
 mod permutation;
 mod process;
 mod test;
 mod util;
 
-use std::fmt;
 use std::fmt::{Display, Formatter};
-use std::process::Command;
-use std::time::Duration;
 
 use anyhow::Result;
 use clap::{Args, Subcommand, ValueEnum};
 use strum::EnumIter;
 
 use self::check::{Check, Tools};
+use self::fmt::Fmt;
 use self::permutation::Toolchain;
 use self::test::Test;
 use self::util::ToolchainParser;
-use crate::command::{self, CargoCommand};
-use crate::{FmtTool, FmtTools};
+use crate::FmtTools;
+use crate::command::CargoCommand;
 
 #[derive(Subcommand)]
 pub enum Client {
@@ -31,17 +30,13 @@ pub enum Client {
 		#[command(flatten)]
 		test: Test,
 	},
-	Fmt {
-		#[arg(long, value_delimiter = ',', default_value = FmtTools::default_arg())]
-		tools: Vec<FmtTools>,
-	},
+	Fmt(Fmt),
 	Build {
 		#[command(flatten)]
 		args: ClientArgs,
 	},
 	Check(Check),
 	Test(Test),
-	Audit,
 }
 
 #[derive(Args, Clone)]
@@ -56,9 +51,7 @@ pub struct ClientArgs {
 
 impl Client {
 	pub fn fmt() -> Self {
-		Self::Fmt {
-			tools: vec![FmtTools::default()],
-		}
+		Self::Fmt(Fmt::default())
 	}
 
 	pub fn build(all: bool) -> Self {
@@ -96,7 +89,7 @@ impl Client {
 				check_tools,
 				test,
 			} => {
-				Self::Fmt { tools: fmt_tools }.execute(verbose)?;
+				Self::Fmt(Fmt::new(fmt_tools)).execute(verbose)?;
 				println!("-------------------------");
 				println!();
 				Self::Build {
@@ -112,35 +105,7 @@ impl Client {
 
 				Ok(())
 			}
-			Self::Fmt { tools } => {
-				let tools = FmtTool::from_tools(tools)?;
-				let mut duration = Duration::ZERO;
-
-				for tool in tools {
-					match tool {
-						FmtTool::Rustfmt => {
-							let mut command = Command::new("cargo");
-							command.current_dir("../client").args(["+nightly", "fmt"]);
-							duration += command::run("Rustfmt", command, verbose)?;
-						}
-						FmtTool::Tombi => {
-							let mut command = Command::new("tombi");
-							command.current_dir("../client").args(["format", "."]);
-							duration += command::run("Tombi Format", command, verbose)?;
-						}
-						FmtTool::Prettier => {
-							let mut command = Command::new("prettier");
-							command.current_dir("..").args(["client", "-w"]);
-							duration += command::run("Prettier", command, verbose)?;
-						}
-					}
-				}
-
-				println!("-------------------------");
-				println!("Total Time: {:.2}s", duration.as_secs_f32());
-
-				Ok(())
-			}
+			Self::Fmt(fmt) => fmt.execute(verbose),
 			Self::Build { args } => {
 				let command = CargoCommand {
 					title: "Build",
@@ -157,16 +122,6 @@ impl Client {
 			}
 			Self::Check(check) => check.execute(verbose),
 			Self::Test(test) => test.execute(verbose),
-			Self::Audit => {
-				let mut command = Command::new("cargo");
-				command.current_dir("../client").arg("audit");
-				let duration = command::run("RustSec", command, verbose)?;
-
-				println!("-------------------------");
-				println!("Total Time: {:.2}s", duration.as_secs_f32());
-
-				Ok(())
-			}
 		}
 	}
 }
@@ -249,7 +204,7 @@ impl Target {
 }
 
 impl Display for Target {
-	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
 			Self::Wasm32 => f.write_str("Wasm32"),
 			Self::Wasm64 => f.write_str("Wasm64"),
@@ -274,7 +229,7 @@ impl TargetFeature {
 }
 
 impl Display for TargetFeature {
-	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
 			Self::Default => Ok(()),
 			Self::Atomics => f.write_str("Atomics"),