taski 0.8.2 → 0.9.0

data/lib/taski/static_analysis/analyzer.rb

@@ -7,41 +7,29 @@ module Taski
   module StaticAnalysis
     class Analyzer
       # Analyzes a task class and returns its static dependencies.
-      # 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)
+      # Dependencies are detected from the run method and called methods (SomeTask.method calls).
       #
       # Static dependencies are used for:
       # - Tree display visualization
       # - Circular dependency detection
-      # - Task execution (for Task only; Section resolves impl at runtime)
+      # - Task execution ordering
       #
       # @param task_class [Class] The task class to analyze
       # @return [Set<Class>] Set of task classes that are static dependencies
       def self.analyze(task_class)
-        target_method = target_method_for(task_class)
-        source_location = extract_method_location(task_class, target_method)
+        source_location = extract_method_location(task_class, :run)
         return Set.new unless source_location
 
         file_path, _line_number = source_location
         parse_result = Prism.parse_file(file_path)
 
-        visitor = Visitor.new(task_class, target_method)
+        visitor = Visitor.new(task_class, :run)
         visitor.visit(parse_result.value)
         # Follow method calls to analyze dependencies in called methods
         visitor.follow_method_calls
         visitor.dependencies
       end
 
-      # @param task_class [Class] The task class
-      # @return [Symbol] The method name to analyze (:run for Task, :impl for Section)
-      def self.target_method_for(task_class)
-        if defined?(Taski::Section) && task_class < Taski::Section
-          :impl
-        else
-          :run
-        end
-      end
-
       # @param task_class [Class] The task class
       # @param method_name [Symbol] The method name to extract location for
       # @return [Array<String, Integer>, nil] File path and line number, or nil
@@ -51,7 +39,7 @@ module Taski
         nil
       end
 
-      private_class_method :target_method_for, :extract_method_location
+      private_class_method :extract_method_location
     end
   end
 end

data/lib/taski/static_analysis/dependency_graph.rb

@@ -13,7 +13,7 @@ module Taski
         @graph = {}
       end
 
-      # Build dependency graph starting from root task class
+      # Build dependency graph starting from root task class using static analysis
       # @param root_task_class [Class] The root task class to analyze
       # @return [DependencyGraph] self for method chaining
       def build_from(root_task_class)
@@ -21,6 +21,14 @@ module Taski
         self
       end
 
+      # Build dependency graph using cached_dependencies (runtime) instead of AST analysis
+      # @param root_task_class [Class] The root task class
+      # @return [DependencyGraph] self for method chaining
+      def build_from_cached(root_task_class)
+        collect_cached_dependencies(root_task_class)
+        self
+      end
+
       # Get topologically sorted task classes (dependencies first)
       # @return [Array<Class>] Sorted task classes
       # @raise [TSort::Cyclic] If circular dependency is detected
@@ -85,6 +93,16 @@ module Taski
           collect_dependencies(dep_class)
         end
       end
+
+      # Recursively collect dependencies using cached_dependencies
+      def collect_cached_dependencies(task_class)
+        return if @graph.key?(task_class)
+
+        deps = task_class.cached_dependencies
+        @graph[task_class] = deps.to_set
+
+        deps.each { |dep| collect_cached_dependencies(dep) }
+      end
     end
   end
 end

data/lib/taski/static_analysis/visitor.rb

@@ -25,8 +25,6 @@ module Taski
         @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)
@@ -48,8 +46,6 @@ module Taski
           @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
@@ -66,21 +62,7 @@ module Taski
         super
       end
 
-      def visit_constant_read_node(node)
-        # For Section.impl, detect constants as impl candidates (static dependencies)
-        detect_impl_candidate(node) if in_impl_method?
-        super
-      end
-
-      def visit_constant_path_node(node)
-        # For Section.impl, detect constants as impl candidates (static dependencies)
-        detect_impl_candidate(node) if in_impl_method?
-        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?
@@ -90,8 +72,6 @@ module Taski
         @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
         # Set namespace path from target class name for constant resolution
         @current_namespace_path = @target_task_class.name.split("::")
 
@@ -140,10 +120,6 @@ module Taski
         @methods_to_analyze.include?(method_name) && !@analyzed_methods.include?(method_name)
       end
 
-      def in_impl_method?
-        @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)
@@ -158,11 +134,6 @@ module Taski
         receiver.is_a?(Prism::SelfNode)
       end
 
-      def detect_impl_candidate(node)
-        constant_name = node.slice
-        resolve_and_add_dependency(constant_name)
-      end
-
       def detect_task_dependency(node)
         return unless node.receiver
 
@@ -206,16 +177,7 @@ module Taski
       end
 
       def valid_dependency?(klass)
-        klass.is_a?(Class) &&
-          (is_parallel_task?(klass) || is_parallel_section?(klass))
-      end
-
-      def is_parallel_task?(klass)
-        defined?(Taski::Task) && klass < Taski::Task
-      end
-
-      def is_parallel_section?(klass)
-        defined?(Taski::Section) && klass < Taski::Section
+        klass.is_a?(Class) && defined?(Taski::Task) && klass < Taski::Task
       end
     end
   end

data/lib/taski/task.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require "stringio"
 require_relative "static_analysis/analyzer"
 require_relative "execution/registry"
 require_relative "execution/task_wrapper"
+require_relative "progress/layout/tree"
+require_relative "progress/theme/plain"
 
 module Taski
   # Base class for all tasks in the Taski framework.
@@ -49,26 +52,7 @@ module Taski
         @exported_methods ||= []
       end
 
-      ##
-      # Creates a task instance for manual execution control.
-      # Use class methods (e.g., MyTask.run) for simple execution.
-      # @param args [Hash] User-defined arguments accessible via Taski.args.
-      # @param workers [Integer, nil] Number of worker threads for parallel execution.
-      # @return [Execution::TaskWrapper] A new wrapper for this task.
-      def new(args: {}, workers: nil)
-        validate_workers!(workers)
-        fresh_registry = Execution::Registry.new
-        task_instance = allocate
-        task_instance.__send__(:initialize)
-        wrapper = Execution::TaskWrapper.new(
-          task_instance,
-          registry: fresh_registry,
-          execution_context: Execution::ExecutionContext.current,
-          args: args.merge(_workers: workers)
-        )
-        fresh_registry.register(self, wrapper)
-        wrapper
-      end
+      private :new
 
       ##
       # Returns cached static dependencies for this task class.
@@ -98,30 +82,21 @@ module Taski
         with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.run }
       end
 
-      ##
-      # Executes the clean phase for the task and all its dependencies.
-      # Clean is executed in reverse dependency order.
-      # Creates a fresh registry each time for independent execution.
-      # @param args [Hash] User-defined arguments accessible via Taski.args.
-      # @param workers [Integer, nil] Number of worker threads for parallel execution.
-      #   Must be a positive integer or nil.
-      # @raise [ArgumentError] If workers is not a positive integer or nil.
-      def clean(args: {}, workers: nil)
-        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.clean }
-      end
-
       ##
       # Execute run followed by clean in a single operation.
-      # If run fails, clean is still executed for resource release.
-      # Creates a fresh registry for both operations to share.
+      # By default, clean is skipped when run fails.
+      # Use clean_on_failure: true to always execute clean for resource release.
+      # An optional block is executed between run and clean phases.
       #
       # @param args [Hash] User-defined arguments accessible via Taski.args.
       # @param workers [Integer, nil] Number of worker threads for parallel execution.
       #   Must be a positive integer or nil.
+      # @param clean_on_failure [Boolean] When true, clean runs even if run raises (default: false).
       # @raise [ArgumentError] If workers is not a positive integer or nil.
       # @return [Object] The result of task execution
-      def run_and_clean(args: {}, workers: nil)
-        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.run_and_clean }
+      # @yield Optional block executed between run and clean phases
+      def run_and_clean(args: {}, workers: nil, clean_on_failure: false, &block)
+        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.run_and_clean(clean_on_failure: clean_on_failure, &block) }
       end
 
       ##
@@ -137,7 +112,13 @@ module Taski
       # Renders a static tree representation of the task dependencies.
       # @return [String] The rendered tree string.
       def tree
-        Execution::TreeProgressDisplay.render_static_tree(self)
+        output = StringIO.new
+        theme = Progress::Theme::Plain.new
+        layout = Progress::Layout::Tree.new(output: output, theme: theme)
+        context = Execution::ExecutionFacade.new(root_task_class: self)
+        layout.context = context
+        layout.on_ready
+        layout.render_tree
       end
 
       private
@@ -170,7 +151,7 @@ module Taski
         wrapper = Execution::TaskWrapper.new(
           task_instance,
           registry: fresh_registry,
-          execution_context: Execution::ExecutionContext.current
+          execution_facade: Execution::ExecutionFacade.current
         )
         fresh_registry.register(self, wrapper)
         wrapper
@@ -197,21 +178,28 @@ module Taski
         singleton_class.undef_method(method) if singleton_class.method_defined?(method)
 
         define_singleton_method(method) do
-          # Check if running inside an execution with a registry
           registry = Taski.current_registry
           if registry
-            # Inside execution - get or create wrapper in current registry
-            # This handles both pre-registered dependencies and dynamic ones (like Section impl)
-            wrapper = registry.get_or_create(self) do
-              task_instance = allocate
-              task_instance.__send__(:initialize)
-              Execution::TaskWrapper.new(
-                task_instance,
-                registry: registry,
-                execution_context: Execution::ExecutionContext.current
-              )
+            if Thread.current[:taski_fiber_context]
+              # Fiber-based lazy resolution - yield to the worker loop
+              result = Fiber.yield([:need_dep, self, method])
+              if result.is_a?(Array) && result[0] == :_taski_error
+                raise result[1]
+              end
+              result
+            else
+              # Synchronous resolution (clean phase, outside Fiber)
+              wrapper = registry.get_or_create(self) do
+                task_instance = allocate
+                task_instance.__send__(:initialize)
+                Execution::TaskWrapper.new(
+                  task_instance,
+                  registry: registry,
+                  execution_facade: Execution::ExecutionFacade.current
+                )
+              end
+              wrapper.get_exported_value(method)
             end
-            wrapper.get_exported_value(method)
           else
             # Outside execution - fresh execution (top-level call)
             Taski.send(:with_env, root_task: self) do
@@ -305,18 +293,16 @@ module Taski
     #     end
     #   end
     def group(name)
-      context = Execution::ExecutionContext.current
-      context&.notify_group_started(self.class, name)
-      start_time = Time.now
+      context = Execution::ExecutionFacade.current
+      phase = Thread.current[:taski_current_phase] || :run
+      context&.notify_group_started(self.class, name, phase: phase, timestamp: Time.now)
 
       begin
         result = yield
-        duration_ms = ((Time.now - start_time) * 1000).round(0)
-        context&.notify_group_completed(self.class, name, duration: duration_ms)
+        context&.notify_group_completed(self.class, name, phase: phase, timestamp: Time.now)
         result
-      rescue => e
-        duration_ms = ((Time.now - start_time) * 1000).round(0)
-        context&.notify_group_completed(self.class, name, duration: duration_ms, error: e)
+      rescue
+        context&.notify_group_completed(self.class, name, phase: phase, timestamp: Time.now)
         raise
       end
     end

data/lib/taski/test_helper/errors.rb

@@ -2,7 +2,7 @@
 
 module Taski
   module TestHelper
-    # Raised when attempting to mock a class that is not a Taski::Task or Taski::Section subclass.
+    # Raised when attempting to mock a class that is not a Taski::Task subclass.
     class InvalidTaskError < ArgumentError
     end
 

data/lib/taski/test_helper.rb

@@ -19,37 +19,18 @@ module Taski
   #   end
   module TestHelper
     # Module prepended to Task's singleton class to intercept define_class_accessor.
+    # Wraps the original accessor with a mock check.
     # @api private
     module TaskExtension
       def define_class_accessor(method)
-        singleton_class.undef_method(method) if singleton_class.method_defined?(method)
+        super
+        original_method = self.method(method)
 
         define_singleton_method(method) do
-          # Check for mock first
           mock = MockRegistry.mock_for(self)
           return mock.get_exported_value(method) if mock
 
-          # No mock - call original implementation via registry lookup
-          registry = Taski.current_registry
-          if registry
-            wrapper = registry.get_or_create(self) do
-              task_instance = allocate
-              task_instance.__send__(:initialize)
-              Execution::TaskWrapper.new(
-                task_instance,
-                registry: registry,
-                execution_context: Execution::ExecutionContext.current
-              )
-            end
-            wrapper.get_exported_value(method)
-          else
-            Taski.send(:with_env, root_task: self) do
-              Taski.send(:with_args, options: {}) do
-                validate_no_circular_dependencies!
-                fresh_wrapper.get_exported_value(method)
-              end
-            end
-          end
+          original_method.call
         end
       end
     end
@@ -57,7 +38,7 @@ module Taski
     # Module prepended to Scheduler to skip dependencies of mocked tasks.
     # @api private
     module SchedulerExtension
-      def build_dependency_graph(root_task_class)
+      def load_graph(dependency_graph, root_task_class)
         queue = [root_task_class]
 
         while (task_class = queue.shift)
@@ -65,24 +46,29 @@ module Taski
 
           # Mocked tasks have no dependencies (isolates indirect dependencies)
           mock = MockRegistry.mock_for(task_class)
-          deps = mock ? Set.new : task_class.cached_dependencies
+          deps = mock ? Set.new : dependency_graph.dependencies_for(task_class)
           @dependencies[task_class] = deps.dup
           @task_states[task_class] = Taski::Execution::Scheduler::STATE_PENDING
+          @run_reverse_deps[task_class] ||= Set.new
 
-          deps.each { |dep| queue << dep }
+          deps.each do |dep|
+            @run_reverse_deps[dep] ||= Set.new
+            @run_reverse_deps[dep].add(task_class)
+            log_dependency_resolved(task_class, dep)
+            queue << dep
+          end
         end
       end
     end
 
-    # Module prepended to Executor to skip execution of mocked tasks.
+    # Module prepended to WorkerPool to skip execution of mocked tasks.
     # @api private
-    module ExecutorExtension
-      def execute_task(task_class, wrapper)
+    module WorkerPoolExtension
+      def drive_fiber(task_class, wrapper, queue)
         return if @registry.abort_requested?
 
-        # Skip execution if task is mocked
         if MockRegistry.mock_for(task_class)
-          wrapper.mark_completed(nil)
+          wrapper.mark_completed(nil) unless wrapper.completed?
           @completion_queue.push({task_class: task_class, wrapper: wrapper})
           return
         end
@@ -143,10 +129,10 @@ module Taski
     end
 
     # Registers a mock for a task class with specified return values.
-    # @param task_class [Class] A Taski::Task or Taski::Section subclass
+    # @param task_class [Class] A Taski::Task subclass
     # @param values [Hash{Symbol => Object}] Method names mapped to return values
     # @return [MockWrapper] The created mock wrapper
-    # @raise [InvalidTaskError] If task_class is not a Taski::Task/Section subclass
+    # @raise [InvalidTaskError] If task_class is not a Taski::Task subclass
     # @raise [InvalidMethodError] If any method name is not an exported method
     #
     # @example
@@ -213,7 +199,7 @@ module Taski
       return if valid
 
       raise InvalidTaskError,
-        "Cannot mock #{task_class}: not a Taski::Task or Taski::Section subclass"
+        "Cannot mock #{task_class}: not a Taski::Task subclass"
     end
 
     def validate_exported_methods!(task_class, method_names)
@@ -243,4 +229,4 @@ end
 # Prepend extensions when test helper is loaded
 Taski::Task.singleton_class.prepend(Taski::TestHelper::TaskExtension)
 Taski::Execution::Scheduler.prepend(Taski::TestHelper::SchedulerExtension)
-Taski::Execution::Executor.prepend(Taski::TestHelper::ExecutorExtension)
+Taski::Execution::WorkerPool.prepend(Taski::TestHelper::WorkerPoolExtension)

data/lib/taski/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taski
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/lib/taski.rb

@@ -5,16 +5,18 @@ require_relative "taski/static_analysis/analyzer"
 require_relative "taski/static_analysis/visitor"
 require_relative "taski/static_analysis/dependency_graph"
 require_relative "taski/execution/registry"
-require_relative "taski/execution/execution_context"
+require_relative "taski/execution/task_observer"
+require_relative "taski/execution/execution_facade"
 require_relative "taski/execution/task_wrapper"
 require_relative "taski/execution/scheduler"
 require_relative "taski/execution/worker_pool"
 require_relative "taski/execution/executor"
-require_relative "taski/execution/tree_progress_display"
-require_relative "taski/execution/simple_progress_display"
-require_relative "taski/execution/plain_progress_display"
+require_relative "taski/progress/layout/log"
+require_relative "taski/progress/layout/simple"
+require_relative "taski/progress/layout/tree"
 require_relative "taski/args"
 require_relative "taski/env"
+require_relative "taski/logging"
 
 module Taski
   class TaskAbortException < StandardError
@@ -47,8 +49,25 @@ module Taski
   end
 
   # Mixin for exception classes to enable transparent rescue matching with AggregateError.
-  # When extended by an exception class, `rescue ThatError` will also match
-  # an AggregateError that contains ThatError.
+  #
+  # == How it works
+  #
+  # Ruby's +rescue+ clause uses the +===+ operator to match exceptions.
+  # This module overrides +===+ so that when the rescued class is compared
+  # against an AggregateError, it checks whether the AggregateError *contains*
+  # an error of that type. This means +rescue TaskError+ will match an
+  # AggregateError that wraps one or more TaskError instances, even though
+  # AggregateError does not inherit from TaskError.
+  #
+  # == Why this exists
+  #
+  # Taski's Executor always raises AggregateError (even for a single failure)
+  # to provide a uniform error interface. Without AggregateAware, callers would
+  # always need to rescue AggregateError and inspect its contents. With this
+  # module, callers can rescue the specific error class they care about:
+  #
+  #   rescue MyTask::Error => e  # matches AggregateError containing MyTask::Error
+  #   rescue Taski::TaskError    # matches AggregateError containing any TaskError
   #
   # @note TaskError and all TaskClass::Error classes already extend this module.
   #
@@ -141,6 +160,19 @@ module Taski
   @args_monitor = Monitor.new
   @env_monitor = Monitor.new
   @message_monitor = Monitor.new
+  @logger_monitor = Monitor.new
+
+  # Get the current logger for structured logging
+  # @return [Logger, nil] The configured logger or nil (disabled by default)
+  def self.logger
+    @logger_monitor.synchronize { @logger }
+  end
+
+  # Set the logger for structured logging
+  # @param logger [Logger, nil] A Ruby Logger instance or nil to disable logging
+  def self.logger=(logger)
+    @logger_monitor.synchronize { @logger = logger }
+  end
 
   # Get the current runtime arguments
   # @return [Args, nil] The current args or nil if no task is running
@@ -233,66 +265,34 @@ module Taski
     reset_args! if created_args
   end
 
-  # Progress display is enabled by default (tree-style).
-  # Environment variables:
-  # - TASKI_PROGRESS_DISABLE=1: Disable progress display entirely
-  # - TASKI_PROGRESS_MODE=simple|tree: Set display mode (default: tree)
-  def self.progress_display
-    return nil if progress_disabled?
-    @progress_display ||= create_progress_display
-  end
-
-  def self.progress_disabled?
-    ENV["TASKI_PROGRESS_DISABLE"] == "1"
-  end
+  NOT_CONFIGURED = Object.new.freeze
+  PROGRESS_MONITOR = Monitor.new
+  @progress_display = NOT_CONFIGURED
 
-  # Get the current progress mode (:tree or :simple)
-  # Environment variable TASKI_PROGRESS_MODE takes precedence over code settings.
-  # @return [Symbol] The current progress mode
-  def self.progress_mode
-    if ENV["TASKI_PROGRESS_MODE"]
-      progress_mode_from_env
-    else
-      @progress_mode || :tree
+  def self.progress_display
+    PROGRESS_MONITOR.synchronize do
+      if @progress_display.equal?(NOT_CONFIGURED)
+        @progress_display = Progress::Layout::Simple.new
+      end
+      @progress_display
     end
   end
 
-  # Set the progress mode (:tree or :simple)
-  # @param mode [Symbol] The mode to use (:tree or :simple)
-  def self.progress_mode=(mode)
-    @progress_mode = mode.to_sym
-    # Reset display so it will be recreated with new mode
-    @progress_display&.stop
-    @progress_display = nil
-  end
-
-  def self.reset_progress_display!
-    @progress_display&.stop
-    @progress_display = nil
-    @progress_mode = nil
-  end
-
-  # @api private
-  def self.create_progress_display
-    case progress_mode
-    when :simple
-      Execution::SimpleProgressDisplay.new
-    when :plain
-      Execution::PlainProgressDisplay.new
-    else
-      Execution::TreeProgressDisplay.new
+  def self.progress_display=(display)
+    PROGRESS_MONITOR.synchronize do
+      unless @progress_display.equal?(NOT_CONFIGURED)
+        @progress_display.stop if @progress_display.respond_to?(:stop)
+      end
+      @progress_display = display
     end
   end
 
-  # @api private
-  def self.progress_mode_from_env
-    case ENV["TASKI_PROGRESS_MODE"]
-    when "simple"
-      :simple
-    when "plain"
-      :plain
-    else
-      :tree
+  def self.reset_progress_display!
+    PROGRESS_MONITOR.synchronize do
+      unless @progress_display.equal?(NOT_CONFIGURED)
+        @progress_display.stop if @progress_display.respond_to?(:stop)
+      end
+      @progress_display = NOT_CONFIGURED
     end
   end
 
@@ -323,6 +323,5 @@ module Taski
   end
 end
 
-# Load Task and Section after Taski module is defined (they depend on TaskError)
+# Load Task after Taski module is defined (it depends on TaskError)
 require_relative "taski/task"
-require_relative "taski/section"