taski 0.5.0 → 0.7.0

data/lib/taski/execution/scheduler.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Taski
+  module Execution
+    # Scheduler manages task dependency state and determines execution order.
+    # It tracks which tasks are pending, enqueued, or completed, and provides
+    # methods to determine which tasks are ready to execute.
+    #
+    # == Responsibilities
+    #
+    # - Build dependency graph from root task via static analysis
+    # - Track task states: pending, enqueued, completed
+    # - Determine which tasks are ready to execute (all dependencies completed)
+    # - Provide next_ready_tasks for the Executor's event loop
+    # - Build reverse dependency graph for clean operations
+    # - Track clean states independently from run states
+    # - Provide next_ready_clean_tasks for reverse dependency order execution
+    #
+    # == API
+    #
+    # Run operations:
+    # - {#build_dependency_graph} - Initialize dependency graph from root task
+    # - {#next_ready_tasks} - Get tasks ready for execution
+    # - {#mark_enqueued} - Mark task as sent to worker pool
+    # - {#mark_completed} - Mark task as finished
+    # - {#completed?} - Check if task is completed
+    # - {#running_tasks?} - Check if any tasks are currently executing
+    #
+    # Clean operations:
+    # - {#build_reverse_dependency_graph} - Build reverse graph for clean order
+    # - {#next_ready_clean_tasks} - Get tasks ready for clean (reverse order)
+    # - {#mark_clean_enqueued} - Mark task as sent for clean
+    # - {#mark_clean_completed} - Mark task as clean finished
+    # - {#clean_completed?} - Check if task clean is completed
+    # - {#running_clean_tasks?} - Check if any clean tasks are currently executing
+    #
+    # == Thread Safety
+    #
+    # Scheduler is only accessed from the main thread in Executor,
+    # so no synchronization is needed. The Executor serializes all
+    # access to the Scheduler through its event loop.
+    class Scheduler
+      # Task execution states
+      STATE_PENDING = :pending
+      STATE_ENQUEUED = :enqueued
+      STATE_COMPLETED = :completed
+
+      # Clean execution states (independent from run states)
+      CLEAN_STATE_PENDING = :clean_pending
+      CLEAN_STATE_ENQUEUED = :clean_enqueued
+      CLEAN_STATE_COMPLETED = :clean_completed
+
+      ##
+      # Initializes internal data structures used to track normal and clean task execution.
+      #
+      # Sets up:
+      # - @dependencies: map from task class to its dependency task classes.
+      # - @task_states: map from task class to its normal execution state.
+      # - @completed_tasks: set of task classes that have completed normal execution.
+      # - @reverse_dependencies: map from task class to dependent task classes (used for clean ordering).
+      # - @clean_task_states: map from task class to its clean execution state.
+      # - @clean_completed_tasks: set of task classes that have completed clean execution.
+      def initialize
+        # Run execution state
+        @dependencies = {}
+        @task_states = {}
+        @completed_tasks = Set.new
+
+        # Clean execution state (independent tracking)
+        @reverse_dependencies = {}
+        @clean_task_states = {}
+        @clean_completed_tasks = Set.new
+      end
+
+      # Build dependency graph by traversing from root task.
+      # Populates internal state with all tasks and their dependencies.
+      #
+      # @param root_task_class [Class] The root task class to start from
+      def build_dependency_graph(root_task_class)
+        # @type var queue: Array[singleton(Taski::Task)]
+        queue = [root_task_class]
+
+        while (task_class = queue.shift)
+          next if @task_states.key?(task_class)
+
+          deps = task_class.cached_dependencies
+          @dependencies[task_class] = deps.dup
+          @task_states[task_class] = STATE_PENDING
+
+          deps.each { |dep| queue << dep }
+        end
+      end
+
+      # Get all tasks that are ready to execute.
+      # A task is ready when all its dependencies are completed.
+      #
+      # @return [Array<Class>] Array of task classes ready for execution
+      def next_ready_tasks
+        ready = []
+        @task_states.each_key do |task_class|
+          next unless @task_states[task_class] == STATE_PENDING
+          next unless ready_to_execute?(task_class)
+          ready << task_class
+        end
+        ready
+      end
+
+      # Mark a task as enqueued for execution.
+      #
+      # @param task_class [Class] The task class to mark
+      def mark_enqueued(task_class)
+        @task_states[task_class] = STATE_ENQUEUED
+      end
+
+      # Mark a task as completed.
+      #
+      # @param task_class [Class] The task class to mark
+      def mark_completed(task_class)
+        @task_states[task_class] = STATE_COMPLETED
+        @completed_tasks.add(task_class)
+      end
+
+      # Check if a task is completed.
+      #
+      # @param task_class [Class] The task class to check
+      # @return [Boolean] true if the task is completed
+      def completed?(task_class)
+        @completed_tasks.include?(task_class)
+      end
+
+      # Check if there are any running (enqueued) tasks.
+      #
+      ##
+      # Indicates whether any tasks are currently enqueued for execution.
+      # @return [Boolean] `true` if any task is enqueued, `false` otherwise.
+      def running_tasks?
+        @task_states.values.any? { |state| state == STATE_ENQUEUED }
+      end
+
+      # ========================================
+      # Runtime Dependency Merging
+      # ========================================
+
+      # Merge runtime dependencies into the dependency graph.
+      # Used to incorporate dynamically selected dependencies (e.g., Section implementations)
+      # that were determined during the run phase.
+      #
+      # This method also updates reverse dependencies if they exist (for clean operations).
+      # This method is idempotent - calling it multiple times with the same data is safe.
+      #
+      # @param runtime_deps [Hash{Class => Set<Class>}] Runtime dependencies from ExecutionContext
+      def merge_runtime_dependencies(runtime_deps)
+        runtime_deps.each do |from_class, to_classes|
+          # Ensure the from_class exists in the graph
+          @dependencies[from_class] ||= Set.new
+          @task_states[from_class] ||= STATE_PENDING
+
+          to_classes.each do |to_class|
+            # Add the dependency relationship
+            @dependencies[from_class].add(to_class)
+
+            # Add the to_class to the graph if not present
+            unless @dependencies.key?(to_class)
+              @dependencies[to_class] = to_class.cached_dependencies
+              @task_states[to_class] = STATE_PENDING
+            end
+
+            # Update reverse dependencies if they exist (for clean operations)
+            # If A depends on B (from_class→to_class), then B→[A] in reverse graph
+            if @reverse_dependencies.any?
+              @reverse_dependencies[to_class] ||= Set.new
+              @reverse_dependencies[to_class].add(from_class)
+
+              # Ensure to_class has clean state initialized
+              @clean_task_states[to_class] ||= CLEAN_STATE_PENDING
+            end
+          end
+        end
+      end
+
+      # ========================================
+      # Clean Operations (Reverse Dependency Order)
+      # ========================================
+
+      # Build reverse dependency graph for clean operations.
+      # Clean operations run in reverse order: if A depends on B, then B must
+      # be cleaned after A (so A→[B] in reverse graph means B depends on A's clean).
+      #
+      # Also initializes clean states for all tasks to CLEAN_STATE_PENDING.
+      #
+      ##
+      # Builds the reverse dependency graph and initializes per-task clean execution state starting from the given root task.
+      #
+      # Ensures the forward dependency graph is present, clears prior clean-state data, initializes each discovered task with
+      # an empty reverse-dependency set and `CLEAN_STATE_PENDING`, and populates reverse mappings so a task's clean run
+      # depends on the clean completion of tasks that depend on it.
+      # @param [Class] root_task_class The root task class from which to discover tasks and their dependencies.
+      def build_reverse_dependency_graph(root_task_class)
+        # First, ensure we have the forward dependency graph
+        build_dependency_graph(root_task_class) if @dependencies.empty?
+
+        # Clear previous clean state
+        @reverse_dependencies.clear
+        @clean_task_states.clear
+        @clean_completed_tasks.clear
+
+        # Initialize all tasks with empty reverse dependency sets
+        @dependencies.each_key do |task_class|
+          @reverse_dependencies[task_class] = Set.new
+          @clean_task_states[task_class] = CLEAN_STATE_PENDING
+        end
+
+        # Build reverse mappings: if A depends on B, then B→[A] in reverse graph
+        # This means B's clean depends on A's clean completing first
+        @dependencies.each do |task_class, deps|
+          deps.each do |dep_class|
+            @reverse_dependencies[dep_class].add(task_class)
+          end
+        end
+      end
+
+      # Get all tasks that are ready to clean.
+      # A task is ready to clean when all its reverse dependencies (dependents)
+      # have completed their clean operation.
+      #
+      ##
+      # Lists task classes that are ready for clean execution.
+      # A task is considered ready when its clean state is `CLEAN_STATE_PENDING` and all of its reverse dependencies have completed their clean execution.
+      # @return [Array<Class>] Array of task classes ready for clean execution.
+      def next_ready_clean_tasks
+        ready = []
+        @clean_task_states.each_key do |task_class|
+          next unless @clean_task_states[task_class] == CLEAN_STATE_PENDING
+          next unless ready_to_clean?(task_class)
+          ready << task_class
+        end
+        ready
+      end
+
+      # Mark a task as enqueued for clean execution.
+      #
+      ##
+      # Marks the given task class as enqueued for clean execution.
+      # @param [Class] task_class The task class to mark as enqueued for clean execution.
+      def mark_clean_enqueued(task_class)
+        @clean_task_states[task_class] = CLEAN_STATE_ENQUEUED
+      end
+
+      # Mark a task as clean completed.
+      #
+      ##
+      # Marks the clean execution of the given task class as completed and records it.
+      # @param [Class] task_class - The task class to mark as clean completed.
+      def mark_clean_completed(task_class)
+        @clean_task_states[task_class] = CLEAN_STATE_COMPLETED
+        @clean_completed_tasks.add(task_class)
+      end
+
+      # Check if a task's clean is completed.
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Checks whether a task class has completed its clean execution.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if the task's clean is completed, `false` otherwise.
+      def clean_completed?(task_class)
+        @clean_completed_tasks.include?(task_class)
+      end
+
+      # Check if there are any running (enqueued) clean tasks.
+      #
+      ##
+      # Indicates whether any clean tasks are currently enqueued for execution.
+      # @return [Boolean] `true` if at least one clean task is enqueued, `false` otherwise.
+      def running_clean_tasks?
+        @clean_task_states.values.any? { |state| state == CLEAN_STATE_ENQUEUED }
+      end
+
+      private
+
+      # Check if a task is ready to execute (all dependencies completed).
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Determines whether a task's dependencies have all completed.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if every dependency of `task_class` is in the set of completed tasks, `false` otherwise.
+      def ready_to_execute?(task_class)
+        task_deps = @dependencies[task_class] || Set.new
+        task_deps.subset?(@completed_tasks)
+      end
+
+      # Check if a task is ready to clean (all reverse dependencies completed).
+      # Reverse dependencies are tasks that depend on this task, which must
+      # be cleaned before this task can be cleaned.
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Determines whether a task is ready for clean execution.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if all tasks that depend on `task_class` have completed their clean execution, `false` otherwise.
+      def ready_to_clean?(task_class)
+        reverse_deps = @reverse_dependencies[task_class] || Set.new
+        reverse_deps.subset?(@clean_completed_tasks)
+      end
+    end
+  end
+end

data/lib/taski/execution/task_output_pipe.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Taski
+  module Execution
+    # Manages a single IO pipe for capturing task output
+    # Each task gets its own dedicated pipe for stdout capture
+    class TaskOutputPipe
+      attr_reader :read_io, :write_io, :task_class
+
+      def initialize(task_class)
+        @task_class = task_class
+        @read_io, @write_io = IO.pipe
+        @write_io.sync = true
+      end
+
+      def close_write
+        @write_io.close unless @write_io.closed?
+      end
+
+      def close_read
+        @read_io.close unless @read_io.closed?
+      end
+
+      def close
+        close_write
+        close_read
+      end
+
+      def write_closed?
+        @write_io.closed?
+      end
+
+      def read_closed?
+        @read_io.closed?
+      end
+
+      def closed?
+        write_closed? && read_closed?
+      end
+    end
+  end
+end

data/lib/taski/execution/task_output_router.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "monitor"
+require_relative "task_output_pipe"
+
+module Taski
+  module Execution
+    # Central coordinator that manages all task pipes and polling.
+    # Also acts as an IO proxy for $stdout, routing writes to the appropriate pipe
+    # based on the current thread.
+    #
+    # Architecture:
+    # - Each task gets a dedicated IO pipe for output capture
+    # - Writes are routed to the appropriate pipe based on Thread.current
+    # - A reader thread polls all pipes using IO.select for efficiency
+    # - When no pipe is registered for a thread, output goes to original stdout
+    class TaskOutputRouter
+      include MonitorMixin
+
+      POLL_TIMEOUT = 0.05 # 50ms timeout for IO.select
+      READ_BUFFER_SIZE = 4096
+
+      def initialize(original_stdout)
+        super()
+        @original = original_stdout
+        @pipes = {}       # task_class => TaskOutputPipe
+        @thread_map = {}  # Thread => task_class
+        @last_lines = {}  # task_class => String
+      end
+
+      # Start capturing output for the current thread
+      # Creates a new pipe for the task and registers the thread mapping
+      # @param task_class [Class] The task class being executed
+      def start_capture(task_class)
+        synchronize do
+          pipe = TaskOutputPipe.new(task_class)
+          @pipes[task_class] = pipe
+          @thread_map[Thread.current] = task_class
+          debug_log("Started capture for #{task_class} on thread #{Thread.current.object_id}")
+        end
+      end
+
+      # Stop capturing output for the current thread
+      # Closes the write end of the pipe
+      def stop_capture
+        synchronize do
+          task_class = @thread_map.delete(Thread.current)
+          unless task_class
+            debug_log("Warning: stop_capture called for unregistered thread #{Thread.current.object_id}")
+            return
+          end
+
+          pipe = @pipes[task_class]
+          pipe&.close_write
+          debug_log("Stopped capture for #{task_class} on thread #{Thread.current.object_id}")
+        end
+      end
+
+      # Poll all open pipes for available data
+      # Should be called periodically from the display thread
+      def poll
+        readable_pipes = synchronize do
+          @pipes.values.reject { |p| p.read_closed? }.map(&:read_io)
+        end
+        return if readable_pipes.empty?
+
+        ready, _, _ = IO.select(readable_pipes, nil, nil, POLL_TIMEOUT)
+        return unless ready
+
+        ready.each do |read_io|
+          pipe = synchronize { @pipes.values.find { |p| p.read_io == read_io } }
+          next unless pipe
+
+          read_from_pipe(pipe)
+        end
+      end
+
+      # Get the last output line for a task
+      # @param task_class [Class] The task class
+      # @return [String, nil] The last output line
+      def last_line_for(task_class)
+        synchronize { @last_lines[task_class] }
+      end
+
+      # Close all pipes and clean up
+      def close_all
+        synchronize do
+          @pipes.each_value(&:close)
+          @pipes.clear
+          @thread_map.clear
+        end
+      end
+
+      # Check if there are any active (not fully closed) pipes
+      # @return [Boolean] true if there are active pipes
+      def active?
+        synchronize do
+          @pipes.values.any? { |p| !p.read_closed? }
+        end
+      end
+
+      # IO interface methods - route to pipe when capturing, otherwise pass through
+
+      def write(str)
+        pipe = current_thread_pipe
+        if pipe && !pipe.write_closed?
+          pipe.write_io.write(str)
+        else
+          # Fallback to original stdout - log why capture failed
+          if @thread_map.empty?
+            debug_log("Output not captured: no threads registered")
+          else
+            debug_log("Output not captured: thread #{Thread.current.object_id} not mapped")
+          end
+          @original.write(str)
+        end
+      end
+
+      def puts(*args)
+        if args.empty?
+          write("\n")
+        else
+          args.each do |arg|
+            str = arg.to_s
+            write(str)
+            write("\n") unless str.end_with?("\n")
+          end
+        end
+        nil
+      end
+
+      def print(*args)
+        args.each { |arg| write(arg.to_s) }
+        nil
+      end
+
+      def <<(str)
+        write(str.to_s)
+        self
+      end
+
+      def flush
+        @original.flush
+      end
+
+      def tty?
+        @original.tty?
+      end
+
+      def isatty
+        @original.isatty
+      end
+
+      def winsize
+        @original.winsize
+      end
+
+      # Get the write IO for the current thread's pipe
+      # Used by Task#system to redirect subprocess output directly to the pipe
+      # @return [IO, nil] The write IO or nil if not capturing
+      def current_write_io
+        synchronize do
+          task_class = @thread_map[Thread.current]
+          return nil unless task_class
+          pipe = @pipes[task_class]
+          return nil if pipe.nil? || pipe.write_closed?
+          pipe.write_io
+        end
+      end
+
+      # Delegate unknown methods to original stdout
+      def method_missing(method, ...)
+        @original.send(method, ...)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @original.respond_to?(method, include_private)
+      end
+
+      private
+
+      def current_thread_pipe
+        synchronize do
+          task_class = @thread_map[Thread.current]
+          return nil unless task_class
+          @pipes[task_class]
+        end
+      end
+
+      def read_from_pipe(pipe)
+        data = pipe.read_io.read_nonblock(READ_BUFFER_SIZE)
+        update_last_line(pipe.task_class, data)
+      rescue IO::WaitReadable
+        # No data available yet
+      rescue EOFError
+        # Pipe closed by writer, close read end
+        synchronize { pipe.close_read }
+      end
+
+      def update_last_line(task_class, data)
+        return if data.nil? || data.empty?
+
+        lines = data.lines
+        last_non_empty = lines.reverse.find { |l| !l.strip.empty? }
+        synchronize do
+          @last_lines[task_class] = last_non_empty&.strip if last_non_empty
+        end
+      end
+
+      def debug_log(message)
+        return unless ENV["TASKI_DEBUG"]
+        @original.puts "[TaskOutputRouter] #{message}"
+      end
+    end
+  end
+end