Rename struct.

Author: milesj

crates/task-runner/src/command_builder.rs

@@ -18,7 +18,7 @@ use tracing::{debug, instrument, trace};
 
 pub struct CommandBuilder<'task> {
     app: &'task AppContext,
-    node: &'task ActionNode,
+    node: Option<&'task ActionNode>,
     project: &'task Project,
     task: &'task Task,
     working_dir: &'task Path,
@@ -29,12 +29,7 @@ pub struct CommandBuilder<'task> {
 }
 
 impl<'task> CommandBuilder<'task> {
-    pub fn new(
-        app: &'task AppContext,
-        project: &'task Project,
-        task: &'task Task,
-        node: &'task ActionNode,
-    ) -> Self {
+    pub fn new(app: &'task AppContext, project: &'task Project, task: &'task Task) -> Self {
         let working_dir = if task.options.run_from_workspace_root {
             &app.workspace_root
         } else {
@@ -43,7 +38,7 @@ impl<'task> CommandBuilder<'task> {
 
         Self {
             app,
-            node,
+            node: None,
             project,
             task,
             working_dir,
@@ -57,7 +52,14 @@ impl<'task> CommandBuilder<'task> {
     }
 
     #[instrument(name = "build_command", skip_all)]
-    pub async fn build(mut self, context: &ActionContext, hash: &str) -> miette::Result<Command> {
+    pub async fn build(
+        mut self,
+        context: &ActionContext,
+        node: &'task ActionNode,
+        hash: &str,
+    ) -> miette::Result<Command> {
+        self.node = Some(node);
+
         debug!(
             task_target = self.task.target.as_str(),
             working_dir = ?self.working_dir,
@@ -116,7 +118,7 @@ impl<'task> CommandBuilder<'task> {
     #[instrument(skip_all)]
     fn inject_args(&mut self, context: &ActionContext) {
         // Must be first!
-        if let ActionNode::RunTask(inner) = &self.node
+        if let Some(ActionNode::RunTask(inner)) = &self.node
             && !inner.args.is_empty()
         {
             trace!(
@@ -148,7 +150,7 @@ impl<'task> CommandBuilder<'task> {
         let mut moon_env = FxHashMap::<String, Option<String>>::default();
 
         // Inherit task dependent variables
-        if let ActionNode::RunTask(inner) = &self.node
+        if let Some(ActionNode::RunTask(inner)) = &self.node
             && !inner.env.is_empty()
         {
             trace!(

crates/task-runner/src/lib.rs

@@ -1,10 +1,11 @@
 // Public for tests
+mod checks_runner;
 pub mod command_builder;
-pub mod command_executor;
 pub mod manifest_compat;
 pub mod output_archiver;
 pub mod output_hydrater;
 mod run_state;
+pub mod task_executor;
 mod task_runner;
 mod task_runner_error;
 

…ates/task-runner/src/command_executor.rs crates/task-runner/src/task_executor.rscrates/task-runner/src/command_executor.rs renamed to crates/task-runner/src/task_executor.rs crates/task-runner/src/command_executor.rs renamed to crates/task-runner/src/task_executor.rs

@@ -14,15 +14,15 @@ use tokio_util::sync::CancellationToken;
 use tracing::{debug, instrument};
 
 #[derive(Debug)]
-pub struct CommandExecuteResult {
+pub struct TaskExecuteResult {
     pub attempts: OperationList,
     pub error: Option<miette::Report>,
     pub run_state: TargetState,
 }
 
 /// Run the command as a child process and capture its output. If the process fails
 /// and `retry_count` is greater than 0, attempt the process again in case it passes.
-pub struct CommandExecutor<'task> {
+pub struct TaskExecutor<'task> {
     app: &'task AppContext,
     task: &'task Task,
     project: &'task Project,
@@ -40,7 +40,7 @@ pub struct CommandExecutor<'task> {
     stream: bool,
 }
 
-impl<'task> CommandExecutor<'task> {
+impl<'task> TaskExecutor<'task> {
     pub fn new(
         app: &'task AppContext,
         project: &'task Project,
@@ -70,7 +70,7 @@ impl<'task> CommandExecutor<'task> {
         mut self,
         context: &ActionContext,
         report_item: &mut TaskReportItem,
-    ) -> miette::Result<CommandExecuteResult> {
+    ) -> miette::Result<TaskExecuteResult> {
         // Prepare state for the executor, and each attempt
         let mut run_state = TargetState::Failed;
 
@@ -237,7 +237,7 @@ impl<'task> CommandExecutor<'task> {
 
         self.stop_monitoring();
 
-        Ok(CommandExecuteResult {
+        Ok(TaskExecuteResult {
             attempts: self.attempts.take(),
             error: execution_error,
             run_state,
@@ -342,7 +342,7 @@ impl<'task> CommandExecutor<'task> {
     }
 }
 
-impl Drop for CommandExecutor<'_> {
+impl Drop for TaskExecutor<'_> {
     fn drop(&mut self) {
         self.stop_monitoring();
     }

crates/task-runner/src/task_runner.rs

@@ -1,8 +1,8 @@
 use crate::command_builder::CommandBuilder;
-use crate::command_executor::CommandExecutor;
 use crate::output_archiver::{ArchiveOutcome, OutputArchiver};
 use crate::output_hydrater::{HydrateFrom, HydrateOutcome, OutputHydrater};
 use crate::run_state::*;
+use crate::task_executor::TaskExecutor;
 use crate::task_runner_error::TaskRunnerError;
 use moon_action::{ActionNode, ActionStatus, Operation, OperationList, OperationMeta};
 use moon_action_context::{ActionContext, TargetState};
@@ -432,13 +432,16 @@ impl<'task> TaskRunner<'task> {
         );
 
         // Build the command from the current task
-        let command = CommandBuilder::new(self.app_context, self.project, self.task, node)
-            .build(context, self.report.hash.as_deref().unwrap_or_default())
+        let command = CommandBuilder::new(self.app_context, self.project, self.task)
+            .build(
+                context,
+                node,
+                self.report.hash.as_deref().unwrap_or_default(),
+            )
             .await?;
 
         // Execute the command and gather all attempts made
-        let executor =
-            CommandExecutor::new(self.app_context, self.project, self.task, node, command);
+        let executor = TaskExecutor::new(self.app_context, self.project, self.task, node, command);
 
         let result = if let Some(mutex_name) = &self.task.options.mutex {
             let mut operation = Operation::mutex_acquisition();

crates/task-runner/tests/utils.rs

@@ -13,9 +13,9 @@ use moon_task::Task;
 use moon_task_runner::TaskRunState;
 use moon_task_runner::TaskRunner;
 use moon_task_runner::command_builder::CommandBuilder;
-use moon_task_runner::command_executor::CommandExecutor;
 use moon_task_runner::output_archiver::OutputArchiver;
 use moon_task_runner::output_hydrater::OutputHydrater;
+use moon_task_runner::task_executor::TaskExecutor;
 use moon_test_utils::{WorkspaceGraph, WorkspaceMocker};
 use starbase_archive::Archiver;
 use starbase_sandbox::{Sandbox, create_sandbox};
@@ -179,10 +179,10 @@ impl TaskRunnerContainer {
         self.internal_create_command(&context, &task, &node).await
     }
 
-    pub async fn create_command_executor(&self, context: &ActionContext) -> CommandExecutor<'_> {
+    pub async fn create_command_executor(&self, context: &ActionContext) -> TaskExecutor<'_> {
         let node = create_node(&self.task);
 
-        CommandExecutor::new(
+        TaskExecutor::new(
             &self.app_context,
             &self.project,
             &self.task,
@@ -236,9 +236,8 @@ impl TaskRunnerContainer {
 
     pub async fn create_check_command(&self, check: &moon_task::TaskCheckEntry) -> Command {
         let task = self.task.as_ref();
-        let node = create_node(task);
 
-        let mut builder = CommandBuilder::new(&self.app_context, &self.project, task, &node);
+        let mut builder = CommandBuilder::new(&self.app_context, &self.project, task);
         builder.set_env_bag(&self.env_bag);
         builder.build_check(check).await.unwrap()
     }
@@ -249,8 +248,8 @@ impl TaskRunnerContainer {
         task: &Task,
         node: &ActionNode,
     ) -> Command {
-        let mut builder = CommandBuilder::new(&self.app_context, &self.project, task, node);
+        let mut builder = CommandBuilder::new(&self.app_context, &self.project, task);
         builder.set_env_bag(&self.env_bag);
-        builder.build(context, "abc123").await.unwrap()
+        builder.build(context, node, "abc123").await.unwrap()
     }
 }