taski 0.4.2 → 0.7.0

data/lib/taski/execution/worker_pool.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module Taski
+  module Execution
+    # WorkerPool manages a pool of worker threads that execute tasks.
+    # It provides methods to start, stop, and enqueue tasks for execution.
+    #
+    # == Responsibilities
+    #
+    # - Manage worker thread lifecycle (start, shutdown)
+    # - Distribute tasks to worker threads via Queue
+    # - Execute tasks via callback provided by Executor
+    #
+    # == API
+    #
+    # - {#start} - Start all worker threads
+    # - {#enqueue} - Add a task to the execution queue
+    # - {#shutdown} - Gracefully shutdown all worker threads
+    # - {#execution_queue} - Access the underlying Queue (for testing)
+    #
+    # == Thread Safety
+    #
+    # WorkerPool uses Queue for thread-safe task distribution.
+    # The Queue handles synchronization between the main thread
+    # (which enqueues tasks) and worker threads (which pop tasks).
+    class WorkerPool
+      attr_reader :execution_queue
+
+      # @param registry [Registry] The task registry for thread tracking
+      # @param worker_count [Integer, nil] Number of worker threads (defaults to CPU count)
+      # @param on_execute [Proc] Callback to execute a task, receives (task_class, wrapper)
+      def initialize(registry:, worker_count: nil, &on_execute)
+        @worker_count = worker_count || default_worker_count
+        @registry = registry
+        @on_execute = on_execute
+        @execution_queue = Queue.new
+        @workers = []
+      end
+
+      # Start all worker threads.
+      def start
+        @worker_count.times do
+          worker = Thread.new { worker_loop }
+          @workers << worker
+          @registry.register_thread(worker)
+        end
+      end
+
+      # Enqueue a task for execution.
+      #
+      # @param task_class [Class] The task class to execute
+      # @param wrapper [TaskWrapper] The task wrapper
+      def enqueue(task_class, wrapper)
+        @execution_queue.push({task_class: task_class, wrapper: wrapper})
+        debug_log("Enqueued: #{task_class}")
+      end
+
+      # Shutdown all worker threads gracefully.
+      def shutdown
+        enqueue_shutdown_signals
+        @workers.each(&:join)
+      end
+
+      # Enqueue shutdown signals for all workers.
+      def enqueue_shutdown_signals
+        @worker_count.times { @execution_queue.push(:shutdown) }
+      end
+
+      private
+
+      def default_worker_count
+        Etc.nprocessors.clamp(2, 8)
+      end
+
+      def worker_loop
+        loop do
+          work_item = @execution_queue.pop
+          break if work_item == :shutdown
+
+          task_class = work_item[:task_class]
+          wrapper = work_item[:wrapper]
+
+          debug_log("Worker executing: #{task_class}")
+
+          begin
+            @on_execute.call(task_class, wrapper)
+          rescue => e
+            # Log error but don't crash the worker thread.
+            # Task-level errors are handled in the execute callback.
+            # This catches unexpected errors in the callback itself.
+            warn "[WorkerPool] Unexpected error executing #{task_class}: #{e.message}"
+          end
+        end
+      end
+
+      def debug_log(message)
+        return unless ENV["TASKI_DEBUG"]
+        puts "[WorkerPool] #{message}"
+      end
+    end
+  end
+end

data/lib/taski/section.rb

@@ -24,6 +24,12 @@ module Taski
         raise "Section #{self.class} does not have an implementation. Override 'impl' method."
       end
 
+      # Register runtime dependency for clean phase (before register_impl_selection)
+      register_runtime_dependency(implementation_class)
+
+      # Register selected impl for progress display
+      register_impl_selection(implementation_class)
+
       apply_interface_to_implementation(implementation_class)
 
       self.class.exported_methods.each do |method|
@@ -40,6 +46,23 @@ module Taski
 
     private
 
+    # Register the selected implementation as a runtime dependency.
+    # This allows the clean phase to include the dynamically selected impl.
+    # Handles nil ExecutionContext gracefully.
+    #
+    # @param impl_class [Class] The selected implementation class
+    def register_runtime_dependency(impl_class)
+      context = Execution::ExecutionContext.current
+      context&.register_runtime_dependency(self.class, impl_class)
+    end
+
+    def register_impl_selection(implementation_class)
+      context = Execution::ExecutionContext.current
+      return unless context
+
+      context.notify_section_impl_selected(self.class, implementation_class)
+    end
+
     # @param implementation_class [Class] The implementation task class
     def apply_interface_to_implementation(implementation_class)
       interface_methods = self.class.exported_methods

data/lib/taski/static_analysis/analyzer.rb

@@ -7,8 +7,8 @@ module Taski
   module StaticAnalysis
     class Analyzer
       # Analyzes a task class and returns its static dependencies.
-      # For Task: dependencies detected from run method (SomeTask.method calls)
-      # For Section: impl candidates detected from impl method (constants returned)
+      # For Task: dependencies detected from run method and called methods (SomeTask.method calls)
+      # For Section: impl candidates detected from impl method and called methods (constants returned)
       #
       # Static dependencies are used for:
       # - Tree display visualization
@@ -27,6 +27,8 @@ module Taski
 
         visitor = Visitor.new(task_class, target_method)
         visitor.visit(parse_result.value)
+        # Follow method calls to analyze dependencies in called methods
+        visitor.follow_method_calls
         visitor.dependencies
       end
 

data/lib/taski/static_analysis/visitor.rb

@@ -9,17 +9,34 @@ module Taski
 
       # @param target_task_class [Class] The task class to analyze
       # @param target_method [Symbol] The method name to analyze (:run or :impl)
-      def initialize(target_task_class, target_method = :run)
+      # @param methods_to_analyze [Set<Symbol>] Set of method names to analyze (for following calls)
+      def initialize(target_task_class, target_method = :run, methods_to_analyze = nil)
         super()
         @target_task_class = target_task_class
         @target_method = target_method
         @dependencies = Set.new
         @in_target_method = false
         @current_namespace_path = []
+        # Methods to analyze: starts with just the target method, grows as we find calls
+        @methods_to_analyze = methods_to_analyze || Set.new([@target_method])
+        # Track which methods we've already analyzed to prevent infinite loops
+        @analyzed_methods = Set.new
+        # Collect method calls made within analyzed methods (for following)
+        @method_calls_to_follow = Set.new
+        # Store method definitions found in the class for later analysis
+        @class_method_defs = {}
+        # Track if we're in an impl call chain (for Section constant detection)
+        @in_impl_chain = false
       end
 
       def visit_class_node(node)
-        within_namespace(extract_constant_name(node.constant_path)) { super }
+        within_namespace(extract_constant_name(node.constant_path)) do
+          if in_target_class?
+            # First pass: collect all method definitions in the target class
+            collect_method_definitions(node)
+          end
+          super
+        end
       end
 
       def visit_module_node(node)
@@ -27,17 +44,25 @@ module Taski
       end
 
       def visit_def_node(node)
-        if node.name == @target_method && in_target_class?
+        if in_target_class? && should_analyze_method?(node.name)
+          @analyzed_methods.add(node.name)
           @in_target_method = true
+          @current_analyzing_method = node.name
+          # Start impl chain when entering impl method
+          @in_impl_chain = true if node.name == :impl && @target_method == :impl
           super
           @in_target_method = false
+          @current_analyzing_method = nil
         else
           super
         end
       end
 
       def visit_call_node(node)
-        detect_task_dependency(node) if @in_target_method
+        if @in_target_method
+          detect_task_dependency(node)
+          detect_method_call_to_follow(node)
+        end
         super
       end
 
@@ -53,8 +78,46 @@ module Taski
         super
       end
 
+      # After visiting, follow any method calls that need analysis
+      # @in_impl_chain is preserved because methods called from impl should
+      # also detect constants as impl candidates
+      def follow_method_calls
+        new_methods = @method_calls_to_follow - @analyzed_methods
+        return if new_methods.empty?
+
+        # Add new methods to analyze
+        @methods_to_analyze.merge(new_methods)
+        @method_calls_to_follow.clear
+
+        # Re-analyze the class methods
+        # Preserve impl chain context: methods called from impl should continue
+        # detecting constants as impl candidates
+        @class_method_defs.each do |method_name, method_node|
+          next unless new_methods.include?(method_name)
+
+          @analyzed_methods.add(method_name)
+          @in_target_method = true
+          @current_analyzing_method = method_name
+          visit(method_node)
+          @in_target_method = false
+          @current_analyzing_method = nil
+        end
+
+        # Recursively follow any new calls discovered
+        follow_method_calls
+      end
+
       private
 
+      # Collect all method definitions in the target class for later analysis
+      def collect_method_definitions(class_node)
+        class_node.body&.body&.each do |node|
+          if node.is_a?(Prism::DefNode)
+            @class_method_defs[node.name] = node
+          end
+        end
+      end
+
       def within_namespace(name)
         @current_namespace_path.push(name)
         yield
@@ -70,8 +133,26 @@ module Taski
         node.slice
       end
 
+      def should_analyze_method?(method_name)
+        @methods_to_analyze.include?(method_name) && !@analyzed_methods.include?(method_name)
+      end
+
       def in_impl_method?
-        @in_target_method && @target_method == :impl
+        @in_target_method && @in_impl_chain
+      end
+
+      # Detect method calls that should be followed (calls to methods in the same class)
+      def detect_method_call_to_follow(node)
+        # Only follow calls without explicit receiver (self.method or just method)
+        return if node.receiver && !self_receiver?(node.receiver)
+
+        method_name = node.name
+        # Mark this method for later analysis if it's defined in the class
+        @method_calls_to_follow.add(method_name) if @class_method_defs.key?(method_name)
+      end
+
+      def self_receiver?(receiver)
+        receiver.is_a?(Prism::SelfNode)
       end
 
       def detect_impl_candidate(node)