feat: add test subcommand to vite_task_bin (#98)

feat: add test subcommand to vite_task_bin

print <empty> for empty task call stack

Author: branchseer

crates/vite_task_bin/src/lib.rs

@@ -20,10 +20,17 @@ use vite_task::{
 #[derive(Debug, Subcommand)]
 pub enum CustomTaskSubcommand {
     /// oxlint
+    #[clap(disable_help_flag = true)]
     Lint {
         #[clap(allow_hyphen_values = true, trailing_var_arg = true)]
         args: Vec<Str>,
     },
+    /// vitest
+    #[clap(disable_help_flag = true)]
+    Test {
+        #[clap(allow_hyphen_values = true, trailing_var_arg = true)]
+        args: Vec<Str>,
+    },
     /// Test command for testing additional_envs feature
     EnvTest {
         /// Environment variable name
@@ -72,21 +79,30 @@ impl vite_task::TaskSynthesizer<CustomTaskSubcommand> for TaskSynthesizer {
     async fn synthesize_task(
         &mut self,
         subcommand: CustomTaskSubcommand,
-
         envs: &Arc<HashMap<Arc<OsStr>, Arc<OsStr>>>,
         cwd: &Arc<AbsolutePath>,
     ) -> anyhow::Result<SyntheticPlanRequest> {
+        let synthesize_node_modules_bin_task = |subcommand_name: &str,
+                                                executable_name: &str,
+                                                args: Vec<Str>|
+         -> anyhow::Result<SyntheticPlanRequest> {
+            let direct_execution_cache_key: Arc<[Str]> =
+                iter::once(Str::from(subcommand_name)).chain(args.iter().cloned()).collect();
+            Ok(SyntheticPlanRequest {
+                program: find_executable(get_path_env(envs), &*cwd, executable_name)?,
+                args: args.into(),
+                task_options: Default::default(),
+                direct_execution_cache_key,
+                envs: Arc::clone(envs),
+            })
+        };
+
         match subcommand {
             CustomTaskSubcommand::Lint { args } => {
-                let direct_execution_cache_key: Arc<[Str]> =
-                    iter::once(Str::from("lint")).chain(args.iter().cloned()).collect();
-                Ok(SyntheticPlanRequest {
-                    program: find_executable(get_path_env(envs), &*cwd, "oxlint")?,
-                    args: args.into(),
-                    task_options: Default::default(),
-                    direct_execution_cache_key,
-                    envs: Arc::clone(envs),
-                })
+                synthesize_node_modules_bin_task("lint", "oxlint", args)
+            }
+            CustomTaskSubcommand::Test { args } => {
+                synthesize_node_modules_bin_task("test", "vitest", args)
             }
             CustomTaskSubcommand::EnvTest { name, value } => {
                 let direct_execution_cache_key: Arc<[Str]> =

crates/vite_task_bin/src/main.rs

@@ -8,14 +8,9 @@ use vite_task::{
 use vite_task_bin::{CustomTaskSubcommand, NonTaskSubcommand, OwnedSessionCallbacks};
 
 #[tokio::main]
-async fn main() -> ExitCode {
-    match run().await {
-        Ok(exit_status) => exit_status.0.into(),
-        Err(err) => {
-            eprintln!("Error: {err}");
-            ExitCode::FAILURE
-        }
-    }
+async fn main() -> anyhow::Result<ExitCode> {
+    let exit_status = run().await?;
+    Ok(exit_status.0.into())
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {

crates/vite_task_plan/src/context.rs

@@ -66,6 +66,10 @@ pub struct TaskCallStackDisplay {
 
 impl Display for TaskCallStackDisplay {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.frames.is_empty() {
+            write!(f, "<empty>")?;
+            return Ok(());
+        }
         for (i, frame) in self.frames.iter().enumerate() {
             if i > 0 {
                 write!(f, " -> ")?;