taski 0.4.1 → 0.5.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - ahogappa
@@ -60,16 +60,19 @@ files:
 - examples/README.md
 - examples/context_demo.rb
 - examples/data_pipeline_demo.rb
+- examples/nested_section_demo.rb
 - examples/parallel_progress_demo.rb
 - examples/quick_start.rb
 - examples/reexecution_demo.rb
 - examples/section_demo.rb
+- examples/section_progress_demo.rb
+- examples/tree_progress_demo.rb
 - lib/taski.rb
 - lib/taski/context.rb
-- lib/taski/execution/coordinator.rb
-- lib/taski/execution/parallel_progress_display.rb
+- lib/taski/execution/executor.rb
 - lib/taski/execution/registry.rb
 - lib/taski/execution/task_wrapper.rb
+- lib/taski/execution/tree_progress_display.rb
 - lib/taski/section.rb
 - lib/taski/static_analysis/analyzer.rb
 - lib/taski/static_analysis/dependency_graph.rb

data/lib/taski/execution/coordinator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Taski
-  module Execution
-    class Coordinator
-      def initialize(registry:, analyzer:)
-        @registry = registry
-        @analyzer = analyzer
-      end
-
-      # @param task_class [Class] The task class whose dependencies should be started
-      def start_dependencies(task_class)
-        dependencies = get_dependencies(task_class)
-        return if dependencies.empty?
-
-        dependencies.each do |dep_class|
-          start_dependency_execution(dep_class)
-        end
-      end
-
-      # @param task_class [Class] The task class whose dependencies should be cleaned
-      def start_clean_dependencies(task_class)
-        dependencies = get_dependencies(task_class)
-        return if dependencies.empty?
-
-        dependencies.each do |dep_class|
-          start_dependency_clean(dep_class)
-        end
-      end
-
-      private
-
-      def get_dependencies(task_class)
-        if task_class.respond_to?(:cached_dependencies)
-          task_class.cached_dependencies
-        else
-          @analyzer.analyze(task_class)
-        end
-      end
-
-      def start_thread_with(&block)
-        thread = Thread.new(&block)
-        @registry.register_thread(thread)
-      end
-
-      def start_dependency_execution(dep_class)
-        exported_methods = dep_class.exported_methods
-
-        exported_methods.each do |method|
-          start_thread_with do
-            dep_class.public_send(method)
-          end
-        end
-      end
-
-      def start_dependency_clean(dep_class)
-        start_thread_with do
-          dep_class.public_send(:clean)
-        end
-      end
-    end
-  end
-end

data/lib/taski/execution/parallel_progress_display.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module Taski
-  module Execution
-    class ParallelProgressDisplay
-      SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
-
-      class TaskProgress
-        attr_accessor :state, :start_time, :end_time, :error, :duration
-
-        def initialize
-          @state = :pending
-          @start_time = nil
-          @end_time = nil
-          @error = nil
-          @duration = nil
-        end
-      end
-
-      def initialize(output: $stdout)
-        @output = output
-        @tasks = {}
-        @monitor = Monitor.new
-        @spinner_index = 0
-        @renderer_thread = nil
-        @running = false
-      end
-
-      # @param task_class [Class] The task class to register
-      def register_task(task_class)
-        @monitor.synchronize do
-          @tasks[task_class] = TaskProgress.new
-        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 (:pending, :running, :completed, :failed)
-      # @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]
-          return unless progress
-
-          progress.state = state
-          progress.duration = duration if duration
-          progress.error = error if error
-
-          case state
-          when :running
-            progress.start_time = Time.now
-          when :completed, :failed
-            progress.end_time = Time.now
-          end
-        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
-
-      def render
-        @monitor.synchronize do
-          @tasks.each do |task_class, progress|
-            line = format_task_line(task_class, progress)
-            @output.puts line
-          end
-        end
-      end
-
-      def start
-        return if @running
-
-        @running = true
-        @renderer_thread = Thread.new do
-          loop do
-            break unless @running
-            render_live
-            sleep 0.1
-          end
-        end
-      end
-
-      def stop
-        return unless @running
-
-        @running = false
-        @renderer_thread&.join
-        render_final
-      end
-
-      private
-
-      # @return [Array<String>] Array of formatted task lines
-      def collect_task_lines
-        @tasks.map do |task_class, progress|
-          format_task_line(task_class, progress)
-        end
-      end
-
-      def render_live
-        return unless @output.tty?
-
-        @monitor.synchronize do
-          @spinner_index += 1
-
-          lines = collect_task_lines
-
-          lines.each_with_index do |line, index|
-            @output.print "\r\e[K#{line}"
-            @output.print "\n" unless index == lines.length - 1
-          end
-
-          @output.print "\e[#{lines.length - 1}A" if lines.length > 1
-        end
-      end
-
-      def render_final
-        @monitor.synchronize do
-          lines = collect_task_lines
-
-          if @output.tty? && lines.length > 0
-            lines.each_with_index do |_, index|
-              @output.print "\r\e[K"
-              @output.print "\e[1B" unless index == lines.length - 1
-            end
-            @output.print "\e[#{lines.length - 1}A" if lines.length > 1
-          end
-
-          lines.each do |line|
-            @output.puts line
-          end
-        end
-      end
-
-      # @param task_class [Class] The task class
-      # @param progress [TaskProgress] The task progress
-      # @return [String] Formatted line
-      def format_task_line(task_class, progress)
-        icon = task_icon(progress.state)
-        name = task_class.name || "AnonymousTask"
-        details = task_details(progress)
-
-        "#{icon} #{name}#{details}"
-      end
-
-      # @param state [Symbol] The task state
-      # @return [String] The icon character
-      def task_icon(state)
-        case state
-        when :completed
-          "✅"
-        when :failed
-          "❌"
-        when :running
-          spinner_char
-        when :pending
-          "⏳"
-        else
-          "❓"
-        end
-      end
-
-      # @return [String] Current spinner frame
-      def spinner_char
-        SPINNER_FRAMES[@spinner_index % SPINNER_FRAMES.length]
-      end
-
-      # @param progress [TaskProgress] The task progress
-      # @return [String] Details string
-      def task_details(progress)
-        case progress.state
-        when :completed
-          " (#{progress.duration}ms)"
-        when :failed
-          " (failed)"
-        when :running
-          " (running)"
-        when :pending
-          " (pending)"
-        else
-          ""
-        end
-      end
-    end
-  end
-end