taski 0.7.0 → 0.8.0

data/lib/taski/execution/base_progress_display.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Taski
+  module Execution
+    # Base class for progress display implementations.
+    # Provides common task tracking and lifecycle management.
+    # Subclasses override template methods for custom rendering.
+    class BaseProgressDisplay
+      # Shared task progress tracking
+      class TaskProgress
+        # Run lifecycle tracking
+        attr_accessor :run_state, :run_start_time, :run_end_time, :run_error, :run_duration
+        # Clean lifecycle tracking
+        attr_accessor :clean_state, :clean_start_time, :clean_end_time, :clean_error, :clean_duration
+        # Display properties
+        attr_accessor :is_impl_candidate
+        # Group tracking
+        attr_accessor :groups, :current_group_index
+
+        def initialize
+          # Run lifecycle
+          @run_state = :pending
+          @run_start_time = nil
+          @run_end_time = nil
+          @run_error = nil
+          @run_duration = nil
+          # Clean lifecycle
+          @clean_state = nil # nil means clean hasn't started
+          @clean_start_time = nil
+          @clean_end_time = nil
+          @clean_error = nil
+          @clean_duration = nil
+          # Display
+          @is_impl_candidate = false
+          # Groups
+          @groups = []
+          @current_group_index = nil
+        end
+
+        # Returns the most relevant state for display
+        def state
+          @clean_state || @run_state
+        end
+
+        # Legacy accessors for backward compatibility
+        def start_time
+          @clean_start_time || @run_start_time
+        end
+
+        def end_time
+          @clean_end_time || @run_end_time
+        end
+
+        def error
+          @clean_error || @run_error
+        end
+
+        def duration
+          @clean_duration || @run_duration
+        end
+      end
+
+      # Tracks the progress of a group within a task
+      class GroupProgress
+        attr_accessor :name, :state, :start_time, :end_time, :duration, :error, :last_message
+
+        def initialize(name)
+          @name = name
+          @state = :pending
+          @start_time = nil
+          @end_time = nil
+          @duration = nil
+          @error = nil
+          @last_message = nil
+        end
+      end
+
+      def initialize(output: $stdout)
+        @output = output
+        @tasks = {}
+        @monitor = Monitor.new
+        @nest_level = 0
+        @root_task_class = nil
+        @output_capture = nil
+        @start_time = nil
+      end
+
+      # Set the output capture for getting task output
+      # @param capture [ThreadOutputCapture] The output capture instance
+      def set_output_capture(capture)
+        @monitor.synchronize do
+          @output_capture = capture
+        end
+      end
+
+      # Set the root task to build tree structure
+      # Only sets root task if not already set (prevents nested executor overwrite)
+      # @param root_task_class [Class] The root task class
+      def set_root_task(root_task_class)
+        @monitor.synchronize do
+          return if @root_task_class # Don't overwrite existing root task
+          @root_task_class = root_task_class
+          on_root_task_set
+        end
+      end
+
+      # Register which impl was selected for a section
+      # @param section_class [Class] The section class
+      # @param impl_class [Class] The selected implementation class
+      def register_section_impl(section_class, impl_class)
+        @monitor.synchronize do
+          on_section_impl_registered(section_class, impl_class)
+        end
+      end
+
+      # @param task_class [Class] The task class to register
+      def register_task(task_class)
+        @monitor.synchronize do
+          return if @tasks.key?(task_class)
+          @tasks[task_class] = TaskProgress.new
+          on_task_registered(task_class)
+        end
+      end
+
+      # @param task_class [Class] The task class to check
+      # @return [Boolean] true if the task is registered
+      def task_registered?(task_class)
+        @monitor.synchronize do
+          @tasks.key?(task_class)
+        end
+      end
+
+      # @param task_class [Class] The task class to update
+      # @param state [Symbol] The new state
+      # @param duration [Float] Duration in milliseconds (for completed tasks)
+      # @param error [Exception] Error object (for failed tasks)
+      def update_task(task_class, state:, duration: nil, error: nil)
+        @monitor.synchronize do
+          progress = @tasks[task_class]
+          # Register task if not already registered (for late-registered tasks)
+          progress ||= @tasks[task_class] = TaskProgress.new
+
+          apply_state_transition(progress, state, duration, error)
+          on_task_updated(task_class, state, duration, error)
+        end
+      end
+
+      # @param task_class [Class] The task class
+      # @return [Symbol] The task state
+      def task_state(task_class)
+        @monitor.synchronize do
+          @tasks[task_class]&.state
+        end
+      end
+
+      # Update group state for a task.
+      # @param task_class [Class] The task class containing the group
+      # @param group_name [String] The name of the group
+      # @param state [Symbol] The new state (:running, :completed, :failed)
+      # @param duration [Float, nil] Duration in milliseconds (for completed groups)
+      # @param error [Exception, nil] Error object (for failed groups)
+      def update_group(task_class, group_name, state:, duration: nil, error: nil)
+        @monitor.synchronize do
+          progress = @tasks[task_class]
+          return unless progress
+
+          apply_group_state_transition(progress, group_name, state, duration, error)
+          on_group_updated(task_class, group_name, state, duration, error)
+        end
+      end
+
+      def start
+        should_start = false
+        @monitor.synchronize do
+          @nest_level += 1
+          return if @nest_level > 1 # Already running from outer executor
+          return unless should_activate?
+
+          @start_time = Time.now
+          should_start = true
+        end
+
+        return unless should_start
+
+        on_start
+      end
+
+      def stop
+        should_stop = false
+        @monitor.synchronize do
+          @nest_level -= 1 if @nest_level > 0
+          return unless @nest_level == 0
+
+          should_stop = true
+        end
+
+        return unless should_stop
+
+        on_stop
+      end
+
+      protected
+
+      # Template methods - override in subclasses
+
+      # Called when root task is set. Override to build tree structure.
+      def on_root_task_set
+        # Default: no-op
+      end
+
+      # Called when a section impl is registered.
+      def on_section_impl_registered(section_class, impl_class)
+        # Default: no-op
+      end
+
+      # Called when a task is registered.
+      def on_task_registered(task_class)
+        # Default: no-op
+      end
+
+      # Called when a task state is updated.
+      def on_task_updated(task_class, state, duration, error)
+        # Default: no-op
+      end
+
+      # Called when a group state is updated.
+      def on_group_updated(task_class, group_name, state, duration, error)
+        # Default: no-op
+      end
+
+      # Called to determine if display should activate.
+      # @return [Boolean] true if display should start
+      def should_activate?
+        true
+      end
+
+      # Called when display starts.
+      def on_start
+        # Default: no-op
+      end
+
+      # Called when display stops.
+      def on_stop
+        # Default: no-op
+      end
+
+      # Shared tree traversal for subclasses
+
+      # Register all tasks from a tree structure recursively
+      def register_tasks_from_tree(node)
+        return unless node
+
+        task_class = node[:task_class]
+        @tasks[task_class] ||= TaskProgress.new
+        @tasks[task_class].is_impl_candidate = true if node[:is_impl_candidate]
+
+        node[:children].each { |child| register_tasks_from_tree(child) }
+      end
+
+      # Utility methods for subclasses
+
+      # Get short name of a task class
+      def short_name(task_class)
+        return "Unknown" unless task_class
+        task_class.name&.split("::")&.last || task_class.to_s
+      end
+
+      # Format duration for display
+      def format_duration(ms)
+        if ms >= 1000
+          "#{(ms / 1000.0).round(1)}s"
+        else
+          "#{ms.round(1)}ms"
+        end
+      end
+
+      # Check if output is a TTY
+      def tty?
+        @output.tty?
+      end
+
+      private
+
+      # Apply state transition to TaskProgress
+      def apply_state_transition(progress, state, duration, error)
+        case state
+        # Run lifecycle states
+        when :pending
+          progress.run_state = :pending
+        when :running
+          progress.run_state = :running
+          progress.run_start_time = Time.now
+        when :completed
+          progress.run_state = :completed
+          progress.run_end_time = Time.now
+          progress.run_duration = duration if duration
+        when :failed
+          progress.run_state = :failed
+          progress.run_end_time = Time.now
+          progress.run_error = error if error
+        # Clean lifecycle states
+        when :cleaning
+          progress.clean_state = :cleaning
+          progress.clean_start_time = Time.now
+        when :clean_completed
+          progress.clean_state = :clean_completed
+          progress.clean_end_time = Time.now
+          progress.clean_duration = duration if duration
+        when :clean_failed
+          progress.clean_state = :clean_failed
+          progress.clean_end_time = Time.now
+          progress.clean_error = error if error
+        end
+      end
+
+      # Apply state transition to GroupProgress
+      def apply_group_state_transition(progress, group_name, state, duration, error)
+        case state
+        when :running
+          group = GroupProgress.new(group_name)
+          group.state = :running
+          group.start_time = Time.now
+          progress.groups << group
+          progress.current_group_index = progress.groups.size - 1
+        when :completed
+          group = progress.groups.find { |g| g.name == group_name && g.state == :running }
+          if group
+            group.state = :completed
+            group.end_time = Time.now
+            group.duration = duration
+          end
+          progress.current_group_index = nil
+        when :failed
+          group = progress.groups.find { |g| g.name == group_name && g.state == :running }
+          if group
+            group.state = :failed
+            group.end_time = Time.now
+            group.duration = duration
+            group.error = error
+          end
+          progress.current_group_index = nil
+        end
+      end
+    end
+  end
+end

data/lib/taski/execution/execution_context.rb

@@ -98,6 +98,7 @@ module Taski
         @monitor.synchronize do
           @original_stdout = output_io
           @output_capture = TaskOutputRouter.new(@original_stdout)
+          @output_capture.start_polling
           $stdout = @output_capture
         end
 
@@ -106,13 +107,16 @@ module Taski
 
       # Tear down output capture and restore original $stdout.
       def teardown_output_capture
+        capture = nil
         @monitor.synchronize do
           return unless @original_stdout
 
+          capture = @output_capture
           $stdout = @original_stdout
           @output_capture = nil
           @original_stdout = nil
         end
+        capture&.stop_polling
       end
 
       # Get the current output capture instance.

data/lib/taski/execution/executor.rb

@@ -107,32 +107,19 @@ module Taski
         # Build dependency graph from static analysis
         @scheduler.build_dependency_graph(root_task_class)
 
-        # Set up progress display with root task
-        setup_progress_display(root_task_class)
-
-        # Set up output capture (returns true if this executor set it up)
-        should_teardown_capture = setup_output_capture_if_needed
-
-        # Start progress display
-        start_progress_display
-
-        # Start worker threads
-        @worker_pool.start
+        with_display_lifecycle(root_task_class) do
+          # Start worker threads
+          @worker_pool.start
 
-        # Enqueue tasks with no dependencies
-        enqueue_ready_tasks
-
-        # Main event loop - continues until root task completes
-        run_main_loop(root_task_class)
-
-        # Shutdown workers
-        @worker_pool.shutdown
+          # Enqueue tasks with no dependencies
+          enqueue_ready_tasks
 
-        # Stop progress display
-        stop_progress_display
+          # Main event loop - continues until root task completes
+          run_main_loop(root_task_class)
 
-        # Restore original stdout (only if this executor set it up)
-        teardown_output_capture if should_teardown_capture
+          # Shutdown workers
+          @worker_pool.shutdown
+        end
 
         # Raise aggregated errors if any tasks failed
         raise_if_any_failures
@@ -156,39 +143,26 @@ module Taski
         runtime_deps = @execution_context.runtime_dependencies
         @scheduler.merge_runtime_dependencies(runtime_deps)
 
-        # Set up progress display with root task (if not already set)
-        setup_progress_display(root_task_class)
-
-        # Set up output capture (returns true if this executor set it up)
-        should_teardown_capture = setup_output_capture_if_needed
+        with_display_lifecycle(root_task_class) do
+          # Create a new worker pool for clean operations
+          # Uses the same worker count as the run phase
+          @clean_worker_pool = WorkerPool.new(
+            registry: @registry,
+            worker_count: @effective_worker_count
+          ) { |task_class, wrapper| execute_clean_task(task_class, wrapper) }
 
-        # Start progress display
-        start_progress_display
+          # Start worker threads
+          @clean_worker_pool.start
 
-        # Create a new worker pool for clean operations
-        # Uses the same worker count as the run phase
-        @clean_worker_pool = WorkerPool.new(
-          registry: @registry,
-          worker_count: @effective_worker_count
-        ) { |task_class, wrapper| execute_clean_task(task_class, wrapper) }
+          # Enqueue tasks ready for clean (no reverse dependencies)
+          enqueue_ready_clean_tasks
 
-        # Start worker threads
-        @clean_worker_pool.start
+          # Main event loop - continues until all tasks are cleaned
+          run_clean_main_loop(root_task_class)
 
-        # Enqueue tasks ready for clean (no reverse dependencies)
-        enqueue_ready_clean_tasks
-
-        # Main event loop - continues until all tasks are cleaned
-        run_clean_main_loop(root_task_class)
-
-        # Shutdown workers
-        @clean_worker_pool.shutdown
-
-        # Stop progress display
-        stop_progress_display
-
-        # Restore original stdout (only if this executor set it up)
-        teardown_output_capture if should_teardown_capture
+          # Shutdown workers
+          @clean_worker_pool.shutdown
+        end
 
         # Raise aggregated errors if any clean tasks failed
         raise_if_any_clean_failures
@@ -210,7 +184,16 @@ module Taski
         @scheduler.mark_enqueued(task_class)
 
         wrapper = get_or_create_wrapper(task_class)
-        return unless wrapper.mark_running
+        unless wrapper.mark_running
+          # Task is either already running or completed in another context (e.g., parent Executor)
+          # Wait for the task to complete if it's running elsewhere
+          wrapper.wait_for_completion
+
+          # Now mark it as completed in the scheduler and enqueue newly ready tasks
+          @scheduler.mark_completed(task_class)
+          enqueue_ready_tasks
+          return
+        end
 
         @execution_context.notify_task_registered(task_class)
         @execution_context.notify_task_started(task_class)
@@ -231,17 +214,7 @@ module Taski
       def execute_task(task_class, wrapper)
         return if @registry.abort_requested?
 
-        output_capture = @execution_context.output_capture
-
-        # Start capturing output for this task
-        output_capture&.start_capture(task_class)
-
-        # Set thread-local execution context for task access (e.g., Section)
-        ExecutionContext.current = @execution_context
-        # Set thread-local registry for dependency resolution
-        Taski.set_current_registry(@registry)
-
-        begin
+        with_task_context(task_class) do
           result = wrapper.task.run
           wrapper.mark_completed(result)
           @completion_queue.push({task_class: task_class, wrapper: wrapper})
@@ -252,13 +225,6 @@ module Taski
         rescue => e
           wrapper.mark_failed(e)
           @completion_queue.push({task_class: task_class, wrapper: wrapper, error: e})
-        ensure
-          # Stop capturing output for this task
-          output_capture&.stop_capture
-          # Clear thread-local execution context
-          ExecutionContext.current = nil
-          # Clear thread-local registry
-          Taski.clear_current_registry
         end
       end
 
@@ -334,17 +300,7 @@ module Taski
       def execute_clean_task(task_class, wrapper)
         return if @registry.abort_requested?
 
-        output_capture = @execution_context.output_capture
-
-        # Start capturing output for this task
-        output_capture&.start_capture(task_class)
-
-        # Set thread-local execution context for task access
-        ExecutionContext.current = @execution_context
-        # Set thread-local registry for dependency resolution
-        Taski.set_current_registry(@registry)
-
-        begin
+        with_task_context(task_class) do
           result = wrapper.task.clean
           wrapper.mark_clean_completed(result)
           @completion_queue.push({task_class: task_class, wrapper: wrapper, clean: true})
@@ -355,13 +311,6 @@ module Taski
         rescue => e
           wrapper.mark_clean_failed(e)
           @completion_queue.push({task_class: task_class, wrapper: wrapper, error: e, clean: true})
-        ensure
-          # Stop capturing output for this task
-          output_capture&.stop_capture
-          # Clear thread-local execution context
-          ExecutionContext.current = nil
-          # Clear thread-local registry
-          Taski.clear_current_registry
         end
       end
 
@@ -434,6 +383,44 @@ module Taski
         @execution_context.notify_stop
       end
 
+      # Execute a block with task-local context set up.
+      # Sets ExecutionContext.current, Taski.current_registry, and output capture.
+      # Cleans up all context in ensure block.
+      #
+      # @param task_class [Class] The task class being executed
+      # @yield The block to execute with context set up
+      def with_task_context(task_class)
+        output_capture = @execution_context.output_capture
+        output_capture&.start_capture(task_class)
+
+        ExecutionContext.current = @execution_context
+        Taski.set_current_registry(@registry)
+
+        yield
+      ensure
+        output_capture&.stop_capture
+        ExecutionContext.current = nil
+        Taski.clear_current_registry
+      end
+
+      # Execute a block with progress display and output capture lifecycle.
+      # Sets up progress display, output capture, starts display, then yields.
+      # Ensures proper cleanup even on interrupt.
+      #
+      # @param root_task_class [Class] The root task class
+      # @yield The block to execute
+      def with_display_lifecycle(root_task_class)
+        setup_progress_display(root_task_class)
+        should_teardown_capture = setup_output_capture_if_needed
+        start_progress_display
+
+        yield
+      ensure
+        stop_progress_display
+        @saved_output_capture = @execution_context.output_capture
+        teardown_output_capture if should_teardown_capture
+      end
+
       def create_default_execution_context
         context = ExecutionContext.new
         progress = Taski.progress_display
@@ -456,15 +443,34 @@ module Taski
       # TaskAbortException: raised directly (abort takes priority)
       # All other errors: raises AggregateError containing all failures
       def raise_if_any_failures
-        failed = @registry.failed_wrappers
-        return if failed.empty?
+        raise_if_any_failures_from(
+          @registry.failed_wrappers,
+          error_accessor: ->(w) { w.error }
+        )
+      end
+
+      # Raise error(s) if any tasks failed during clean execution
+      # TaskAbortException: raised directly (abort takes priority)
+      # All other errors: raises AggregateError containing all failures
+      def raise_if_any_clean_failures
+        raise_if_any_failures_from(
+          @registry.failed_clean_wrappers,
+          error_accessor: ->(w) { w.clean_error }
+        )
+      end
+
+      # Generic method to raise errors from failed wrappers
+      # @param failed_wrappers [Array<TaskWrapper>] Failed wrappers
+      # @param error_accessor [Proc] Lambda to extract error from wrapper
+      def raise_if_any_failures_from(failed_wrappers, error_accessor:)
+        return if failed_wrappers.empty?
 
         # TaskAbortException takes priority - raise the first one directly
-        abort_wrapper = failed.find { |w| w.error.is_a?(TaskAbortException) }
-        raise abort_wrapper.error if abort_wrapper
+        abort_wrapper = failed_wrappers.find { |w| error_accessor.call(w).is_a?(TaskAbortException) }
+        raise error_accessor.call(abort_wrapper) if abort_wrapper
 
         # Flatten nested AggregateErrors and deduplicate by original error object_id
-        failures = flatten_failures(failed)
+        failures = flatten_failures_from(failed_wrappers, error_accessor: error_accessor)
         unique_failures = failures.uniq { |f| error_identity(f.error) }
 
         raise AggregateError.new(unique_failures)
@@ -472,14 +478,20 @@ module Taski
 
       # Flatten AggregateErrors into individual TaskFailure objects
       # Wraps original errors with task-specific Error class for rescue matching
-      def flatten_failures(failed_wrappers)
+      # @param failed_wrappers [Array<TaskWrapper>] Failed wrappers
+      # @param error_accessor [Proc] Lambda to extract error from wrapper
+      def flatten_failures_from(failed_wrappers, error_accessor:)
+        output_capture = @saved_output_capture
+
         failed_wrappers.flat_map do |wrapper|
-          case wrapper.error
+          error = error_accessor.call(wrapper)
+          case error
           when AggregateError
-            wrapper.error.errors
+            error.errors
           else
-            wrapped_error = wrap_with_task_error(wrapper.task.class, wrapper.error)
-            [TaskFailure.new(task_class: wrapper.task.class, error: wrapped_error)]
+            wrapped_error = wrap_with_task_error(wrapper.task.class, error)
+            output_lines = output_capture&.recent_lines_for(wrapper.task.class) || []
+            [TaskFailure.new(task_class: wrapper.task.class, error: wrapped_error, output_lines: output_lines)]
           end
         end
       end
@@ -496,38 +508,6 @@ module Taski
         error_class.new(error, task_class: task_class)
       end
 
-      # Raise error(s) if any tasks failed during clean execution
-      # TaskAbortException: raised directly (abort takes priority)
-      # All other errors: raises AggregateError containing all failures
-      def raise_if_any_clean_failures
-        failed = @registry.failed_clean_wrappers
-        return if failed.empty?
-
-        # TaskAbortException takes priority - raise the first one directly
-        abort_wrapper = failed.find { |w| w.clean_error.is_a?(TaskAbortException) }
-        raise abort_wrapper.clean_error if abort_wrapper
-
-        # Flatten nested AggregateErrors and deduplicate by original error object_id
-        failures = flatten_clean_failures(failed)
-        unique_failures = failures.uniq { |f| error_identity(f.error) }
-
-        raise AggregateError.new(unique_failures)
-      end
-
-      # Flatten AggregateErrors into individual TaskFailure objects for clean errors
-      # Wraps original errors with task-specific Error class for rescue matching
-      def flatten_clean_failures(failed_wrappers)
-        failed_wrappers.flat_map do |wrapper|
-          case wrapper.clean_error
-          when AggregateError
-            wrapper.clean_error.errors
-          else
-            wrapped_error = wrap_with_task_error(wrapper.task.class, wrapper.clean_error)
-            [TaskFailure.new(task_class: wrapper.task.class, error: wrapped_error)]
-          end
-        end
-      end
-
       # Returns a unique identifier for an error, used for deduplication
       # For TaskError, uses the wrapped cause's object_id
       def error_identity(error)