taski 0.3.1 → 0.4.0

data/lib/taski/execution/registry.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Taski
+  module Execution
+    class Registry
+      def initialize
+        @tasks = {}
+        @threads = []
+        @monitor = Monitor.new
+        @abort_requested = false
+      end
+
+      # @param task_class [Class] The task class
+      # @yield Block to create the task instance if it doesn't exist
+      # @return [Object] The task instance
+      def get_or_create(task_class)
+        @tasks[task_class] ||= yield
+      end
+
+      # @param task_class [Class] The task class
+      # @return [Object] The task instance
+      # @raise [RuntimeError] If the task is not registered
+      def get_task(task_class)
+        @tasks.fetch(task_class) do
+          raise "Task #{task_class} not registered"
+        end
+      end
+
+      # @param thread [Thread] The thread to register
+      def register_thread(thread)
+        @monitor.synchronize { @threads << thread }
+      end
+
+      def wait_all
+        threads = @monitor.synchronize { @threads.dup }
+        threads.each(&:join)
+      end
+
+      def reset!
+        @monitor.synchronize do
+          @tasks.clear
+          @threads.clear
+          @abort_requested = false
+        end
+      end
+
+      def request_abort!
+        @monitor.synchronize { @abort_requested = true }
+      end
+
+      # @return [Boolean] true if abort has been requested
+      def abort_requested?
+        @monitor.synchronize { @abort_requested }
+      end
+
+      # @param task_class [Class] The task class to run
+      # @param exported_methods [Array<Symbol>] Methods to call to trigger execution
+      # @return [Object] The result of the task execution
+      def run(task_class, exported_methods)
+        exported_methods.each do |method|
+          task_class.public_send(method)
+        end
+
+        wait_all
+
+        get_task(task_class).result
+      end
+    end
+  end
+end

data/lib/taski/execution/task_wrapper.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Taski
+  module Execution
+    class TaskTiming < Data.define(:start_time, :end_time)
+      # @return [Float, nil] Duration in milliseconds or nil if not available
+      def duration_ms
+        return nil unless start_time && end_time
+        ((end_time - start_time) * 1000).round(1)
+      end
+
+      # @return [TaskTiming] New timing with current time as start
+      def self.start_now
+        new(start_time: Time.now, end_time: nil)
+      end
+
+      # @return [TaskTiming] New timing with current time as end
+      def with_end_now
+        with(end_time: Time.now)
+      end
+    end
+
+    class TaskWrapper
+      attr_reader :task, :result
+
+      STATE_PENDING = :pending
+      STATE_RUNNING = :running
+      STATE_COMPLETED = :completed
+
+      def initialize(task, registry:, coordinator:)
+        @task = task
+        @registry = registry
+        @coordinator = coordinator
+        @result = nil
+        @clean_result = nil
+        @error = nil
+        @monitor = Monitor.new
+        @condition = @monitor.new_cond
+        @clean_condition = @monitor.new_cond
+        @state = STATE_PENDING
+        @clean_state = STATE_PENDING
+        @timing = nil
+
+        register_with_progress_display
+      end
+
+      # @return [Object] The result of task execution
+      def run
+        execute_task_if_needed
+        raise @error if @error # steep:ignore
+        @result
+      end
+
+      # @return [Object] The result of cleanup
+      def clean
+        execute_clean_if_needed
+        @clean_result
+      end
+
+      # @param method_name [Symbol] The name of the exported method
+      # @return [Object] The exported value
+      def get_exported_value(method_name)
+        execute_task_if_needed
+        raise @error if @error # steep:ignore
+        @task.public_send(method_name)
+      end
+
+      private
+
+      def start_thread_with(&block)
+        thread = Thread.new(&block)
+        @registry.register_thread(thread)
+      end
+
+      # Thread-safe state machine that ensures operations are executed exactly once.
+      # Uses pattern matching for exhaustive state handling.
+      def execute_with_state_pattern(state_getter:, starter:, waiter:, pre_start_check: nil)
+        @monitor.synchronize do
+          case state_getter.call
+          in STATE_PENDING
+            pre_start_check&.call
+            starter.call
+            waiter.call
+          in STATE_RUNNING
+            waiter.call
+          in STATE_COMPLETED
+            return
+          end
+        end
+      end
+
+      def execute_task_if_needed
+        execute_with_state_pattern(
+          state_getter: -> { @state },
+          starter: -> { start_async_execution },
+          waiter: -> { wait_for_completion },
+          pre_start_check: -> {
+            if @registry.abort_requested?
+              raise Taski::TaskAbortException, "Execution aborted - no new tasks will start"
+            end
+          }
+        )
+      end
+
+      def start_async_execution
+        @state = STATE_RUNNING
+        @timing = TaskTiming.start_now
+        update_progress(:running)
+        start_thread_with { execute_task }
+      end
+
+      def execute_task
+        if @registry.abort_requested?
+          @error = Taski::TaskAbortException.new("Execution aborted - no new tasks will start")
+          mark_completed
+          return
+        end
+
+        log_start
+        @coordinator.start_dependencies(@task.class)
+        wait_for_dependencies
+        @result = @task.run
+        mark_completed
+        log_completion
+      rescue Taski::TaskAbortException => e
+        @registry.request_abort!
+        @error = e
+        mark_completed
+      rescue => e
+        @error = e
+        mark_completed
+      end
+
+      def wait_for_dependencies
+        dependencies = @task.class.cached_dependencies
+        return if dependencies.empty?
+
+        dependencies.each do |dep_class|
+          dep_class.exported_methods.each do |method|
+            dep_class.public_send(method)
+          end
+        end
+      end
+
+      def execute_clean_if_needed
+        execute_with_state_pattern(
+          state_getter: -> { @clean_state },
+          starter: -> { start_async_clean },
+          waiter: -> { wait_for_clean_completion }
+        )
+      end
+
+      def start_async_clean
+        @clean_state = STATE_RUNNING
+        start_thread_with { execute_clean }
+      end
+
+      def execute_clean
+        log_clean_start
+        @clean_result = @task.clean
+        wait_for_clean_dependencies
+        mark_clean_completed
+        log_clean_completion
+      end
+
+      def wait_for_clean_dependencies
+        dependencies = @task.class.cached_dependencies
+        return if dependencies.empty?
+
+        wait_threads = dependencies.map do |dep_class|
+          Thread.new do
+            dep_class.public_send(:clean)
+          end
+        end
+
+        wait_threads.each(&:join)
+      end
+
+      def mark_completed
+        @timing = @timing&.with_end_now
+        @monitor.synchronize do
+          @state = STATE_COMPLETED
+          @condition.broadcast
+        end
+
+        if @error
+          update_progress(:failed, error: @error)
+        else
+          update_progress(:completed, duration: @timing&.duration_ms)
+        end
+      end
+
+      def mark_clean_completed
+        @monitor.synchronize do
+          @clean_state = STATE_COMPLETED
+          @clean_condition.broadcast
+        end
+      end
+
+      def wait_for_completion
+        @condition.wait_until { @state == STATE_COMPLETED }
+      end
+
+      def wait_for_clean_completion
+        @clean_condition.wait_until { @clean_state == STATE_COMPLETED }
+      end
+
+      def debug_log(message)
+        return unless ENV["TASKI_DEBUG"]
+        puts message
+      end
+
+      def log_start
+        debug_log("Invoking #{@task.class} wrapper in thread #{Thread.current.object_id}...")
+      end
+
+      def log_completion
+        debug_log("Wrapper #{@task.class} completed in thread #{Thread.current.object_id}.")
+      end
+
+      def log_clean_start
+        debug_log("Cleaning #{@task.class} in thread #{Thread.current.object_id}...")
+      end
+
+      def log_clean_completion
+        debug_log("Clean #{@task.class} completed in thread #{Thread.current.object_id}.")
+      end
+
+      def register_with_progress_display
+        Taski.progress_display&.register_task(@task.class)
+      end
+
+      # @param state [Symbol] The new state
+      # @param duration [Float, nil] Duration in milliseconds
+      # @param error [Exception, nil] Error object
+      def update_progress(state, duration: nil, error: nil)
+        Taski.progress_display&.update_task(@task.class, state: state, duration: duration, error: error)
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @task.class.method_defined?(method_name)
+          get_exported_value(method_name)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @task.class.method_defined?(method_name) || super
+      end
+    end
+  end
+end

data/lib/taski/section.rb

@@ -1,272 +1,44 @@
 # frozen_string_literal: true
 
-require_relative "dependency_analyzer"
-require_relative "utils"
-require_relative "utils/tree_display_helper"
-require_relative "utils/dependency_resolver_helper"
+require_relative "task"
 
 module Taski
-  # Section provides an interface abstraction layer for dynamic implementation selection
-  # while maintaining static analysis capabilities
-  class Section
+  class Section < Task
     class << self
-      # === Dependency Resolution ===
-
-      # Resolve method for dependency graph (called by resolve_dependencies)
-      # @param queue [Array] Queue of tasks to process
-      # @param resolved [Array] Array of resolved tasks
-      # @return [self] Returns self for method chaining
-      def resolve(queue, resolved)
-        resolve_common(queue, resolved)
-      end
-
-      # Resolve all dependencies in topological order
-      # @return [Array<Class>] Array of tasks in dependency order
-      def resolve_dependencies
-        resolve_dependencies_common
-      end
-
-      # Analyze dependencies when accessing interface methods
-      def analyze_dependencies_for_interfaces
-        interface_exports.each do |interface_method|
-          dependencies = gather_static_dependencies_for_interface(interface_method)
-          add_unique_dependencies(dependencies)
-        end
-      end
-
-      private
-
-      # Gather dependencies from interface method implementation
-      def gather_static_dependencies_for_interface(interface_method)
-        # For sections, we analyze the impl method
-        # Try instance method first, then class method
-        if impl_defined?
-          # For instance method, we can't analyze dependencies statically
-          # So we return empty array
-          []
-        else
-          DependencyAnalyzer.analyze_method(self, :impl)
-        end
-      end
-
-      # Add dependencies that don't already exist
-      def add_unique_dependencies(dep_classes)
-        dep_classes.each do |dep_class|
-          next if dep_class == self || dependency_exists?(dep_class)
-          add_dependency(dep_class)
-        end
-      end
-
-      # Add a single dependency
-      def add_dependency(dep_class)
-        @dependencies ||= []
-        @dependencies << {klass: dep_class}
-      end
-
-      # Check if dependency already exists
-      def dependency_exists?(dep_class)
-        (@dependencies || []).any? { |d| d[:klass] == dep_class }
-      end
-
-      # Extract class from dependency specification
-      def extract_class(task)
-        case task
-        when Class
-          task
-        when Hash
-          task[:klass]
-        else
-          task
-        end
-      end
-
-      public
-
-      # === Instance Management (minimal for Section) ===
-
-      # Ensure section is available (no actual building needed)
-      # @return [self] Returns self for compatibility with Task interface
-      def ensure_instance_built
-        self
-      end
-
-      # Build method for compatibility (Section doesn't build instances)
-      # @param args [Hash] Optional arguments (ignored for sections)
-      # @return [self] Returns self
-      def build(**args)
-        self
-      end
-
-      # Reset method for compatibility (Section doesn't have state to reset)
-      # @return [self] Returns self
-      def reset!
-        self
-      end
-
-      # Display dependency tree for this section
-      # @param prefix [String] Current indentation prefix
-      # @param visited [Set] Set of visited classes to prevent infinite loops
-      # @param color [Boolean] Whether to use color output
-      # @return [String] Formatted dependency tree
-      def tree(prefix = "", visited = Set.new, color: TreeColors.enabled?)
-        should_return_early, early_result, new_visited = handle_circular_dependency_check(visited, self, prefix)
-        return early_result if should_return_early
-
-        # Get section name with fallback for anonymous classes
-        section_name = name || to_s
-        colored_section_name = color ? TreeColors.section(section_name) : section_name
-        result = "#{prefix}#{colored_section_name}\n"
-
-        # Add possible implementations - detect from nested Task classes
-        possible_implementations = find_possible_implementations
-        if possible_implementations.any?
-          impl_names = possible_implementations.map { |impl| extract_implementation_name(impl) }
-          impl_text = "[One of: #{impl_names.join(", ")}]"
-          colored_impl_text = color ? TreeColors.implementations(impl_text) : impl_text
-          connector = color ? TreeColors.connector("└── ") : "└── "
-          result += "#{prefix}#{connector}#{colored_impl_text}\n"
-        end
-
-        dependencies = @dependencies || []
-        result += render_dependencies_tree(dependencies, prefix, new_visited, color)
-
-        result
-      end
-
-      # Define interface methods for this section
-      def interface(*names)
-        if names.empty?
-          raise ArgumentError, "interface requires at least one method name"
-        end
-
-        @interface_exports = names
-
-        # Create accessor methods for each interface name
-        names.each do |name|
-          define_singleton_method(name) do
-            # Get implementation class
-            implementation_class = get_implementation_class
-
-            # Check if implementation is nil
-            if implementation_class.nil?
-              raise SectionImplementationError,
-                "impl returned nil. " \
-                "Make sure impl returns a Task class."
-            end
-
-            # Validate that it's a Task class
-            unless implementation_class.is_a?(Class) && implementation_class < Taski::Task
-              raise SectionImplementationError,
-                "impl must return a Task class, got #{implementation_class.class}. " \
-                "Make sure impl returns a class that inherits from Taski::Task."
-            end
-
-            # Build the implementation and call the method
-            implementation = implementation_class.build
-
-            begin
-              implementation.send(name)
-            rescue NoMethodError
-              raise SectionImplementationError,
-                "Implementation does not provide required method '#{name}'. " \
-                "Make sure the implementation class has a '#{name}' method or " \
-                "exports :#{name} declaration."
-            end
-          end
-        end
-
-        # Automatically apply exports to existing nested Task classes
-        auto_apply_exports_to_existing_tasks
-      end
-
-      # Get the interface exports for this section
-      def interface_exports
-        @interface_exports || []
-      end
-
-      # Check if impl method is defined (as instance method)
-      def impl_defined?
-        instance_methods(false).include?(:impl)
-      end
-
-      # Get implementation class from instance method
-      def get_implementation_class
-        if impl_defined?
-          # Create a temporary instance to call impl method
-          allocate.impl
-        else
-          # Fall back to class method if exists
-          impl
-        end
-      end
-
-      # Override const_set to auto-add exports to nested Task classes
-      def const_set(name, value)
-        result = super
-
-        # If the constant is a Task class and we have interface exports,
-        # automatically add exports to avoid duplication
-        if value.is_a?(Class) && value < Taski::Task && !interface_exports.empty?
-          # Add exports declaration to the nested task
-          exports_list = interface_exports
-          value.class_eval do
-            exports(*exports_list)
-          end
-        end
-
-        result
-      end
-
-      private
-
-      # Automatically apply exports to existing nested Task classes when interface is defined
-      def auto_apply_exports_to_existing_tasks
-        constants.each do |const_name|
-          const_value = const_get(const_name)
-          if const_value.is_a?(Class) && const_value < Taski::Task && !interface_exports.empty?
-            exports_list = interface_exports
-            const_value.class_eval do
-              exports(*exports_list) unless @exports_defined
-              @exports_defined = true
-            end
-          end
-        end
+      # @param interface_methods [Array<Symbol>] Names of interface methods
+      def interfaces(*interface_methods)
+        exports(*interface_methods)
       end
+    end
 
-      # Find possible implementation classes by scanning nested Task classes
-      def find_possible_implementations
-        task_classes = []
-        constants.each do |const_name|
-          const_value = const_get(const_name)
-          if task_class?(const_value)
-            task_classes << const_value
-          end
-        end
-        task_classes
+    def run
+      implementation_class = impl
+      unless implementation_class
+        raise "Section #{self.class} does not have an implementation. Override 'impl' method."
       end
 
-      # Extract readable name from implementation class
-      def extract_implementation_name(impl_class)
-        class_name = impl_class.name
-        return impl_class.to_s unless class_name&.include?("::")
+      apply_interface_to_implementation(implementation_class)
 
-        class_name.split("::").last
+      self.class.exported_methods.each do |method|
+        value = implementation_class.public_send(method)
+        instance_variable_set("@#{method}", value)
       end
+    end
 
-      # Check if a constant value is a Task class
-      def task_class?(const_value)
-        const_value.is_a?(Class) && const_value < Taski::Task
-      end
+    # @return [Class] The implementation task class
+    # @raise [NotImplementedError] If not implemented by subclass
+    def impl
+      raise NotImplementedError, "Subclasses must implement the impl method to return implementation class"
+    end
 
-      private
+    private
 
-      include Utils::TreeDisplayHelper
-      include Utils::DependencyResolverHelper
+    # @param implementation_class [Class] The implementation task class
+    def apply_interface_to_implementation(implementation_class)
+      interface_methods = self.class.exported_methods
+      return if interface_methods.empty?
 
-      # Subclasses should override this method to select appropriate implementation
-      def impl
-        raise NotImplementedError, "Subclass must implement impl"
-      end
+      implementation_class.exports(*interface_methods)
     end
   end
 end

data/lib/taski/static_analysis/analyzer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "visitor"
+
+module Taski
+  module StaticAnalysis
+    class Analyzer
+      # @param task_class [Class] The task class to analyze
+      # @return [Set<Class>] Set of task classes that are dependencies
+      def self.analyze(task_class)
+        source_location = extract_run_method_location(task_class)
+        return Set.new unless source_location
+
+        file_path, _line_number = source_location
+        parse_result = Prism.parse_file(file_path)
+
+        visitor = Visitor.new(task_class)
+        visitor.visit(parse_result.value)
+        visitor.dependencies
+      end
+
+      # @param task_class [Class] The task class
+      # @return [Array<String, Integer>, nil] File path and line number, or nil
+      def self.extract_run_method_location(task_class)
+        task_class.instance_method(:run).source_location
+      rescue NameError
+        nil
+      end
+
+      private_class_method :extract_run_method_location
+    end
+  end
+end