taski 0.4.2 → 0.5.0

data/lib/taski/task.rb

@@ -2,7 +2,6 @@
 
 require_relative "static_analysis/analyzer"
 require_relative "execution/registry"
-require_relative "execution/coordinator"
 require_relative "execution/task_wrapper"
 
 module Taski
@@ -24,11 +23,16 @@ module Taski
       # Each call creates a fresh TaskWrapper instance for re-execution support.
       # Use class methods (e.g., MyTask.result) for cached single execution.
       def new
-        Execution::TaskWrapper.new(
-          super,
-          registry: registry,
-          coordinator: coordinator
+        fresh_registry = Execution::Registry.new
+        task_instance = allocate
+        task_instance.send(:initialize)
+        wrapper = Execution::TaskWrapper.new(
+          task_instance,
+          registry: fresh_registry
         )
+        # Pre-register to prevent Executor from creating a duplicate wrapper
+        fresh_registry.register(self, wrapper)
+        wrapper
       end
 
       def cached_dependencies
@@ -55,105 +59,19 @@ module Taski
         Taski.global_registry
       end
 
-      def coordinator
-        @coordinator ||= Execution::Coordinator.new(
-          registry: registry,
-          analyzer: StaticAnalysis::Analyzer
-        )
-      end
-
       def reset!
         registry.reset!
         Taski.reset_global_registry!
         Taski.reset_context!
-        @coordinator = nil
         @circular_dependency_checked = false
       end
 
       def tree
-        build_tree(self, "", {}, false)
+        Execution::TreeProgressDisplay.render_static_tree(self)
       end
 
       private
 
-      # ANSI color codes
-      COLORS = {
-        reset: "\e[0m",
-        task: "\e[32m",      # green
-        section: "\e[34m",   # blue
-        impl: "\e[33m",      # yellow
-        tree: "\e[90m",      # gray
-        name: "\e[1m"        # bold
-      }.freeze
-
-      def build_tree(task_class, prefix, task_index_map, is_impl, ancestors = Set.new)
-        type_label = colored_type_label(task_class)
-        impl_prefix = is_impl ? "#{COLORS[:impl]}[impl]#{COLORS[:reset]} " : ""
-        task_number = get_task_number(task_class, task_index_map)
-        name = "#{COLORS[:name]}#{task_class.name}#{COLORS[:reset]}"
-
-        # Detect circular reference
-        if ancestors.include?(task_class)
-          circular_marker = "#{COLORS[:impl]}(circular)#{COLORS[:reset]}"
-          return "#{impl_prefix}#{task_number} #{name} #{type_label} #{circular_marker}\n"
-        end
-
-        result = "#{impl_prefix}#{task_number} #{name} #{type_label}\n"
-
-        # Register task number if not already registered
-        task_index_map[task_class] = task_index_map.size + 1 unless task_index_map.key?(task_class)
-
-        # Add to ancestors for circular detection
-        new_ancestors = ancestors + [task_class]
-
-        # Use static analysis to include Section.impl candidates for visualization
-        dependencies = StaticAnalysis::Analyzer.analyze(task_class).to_a
-        is_section = section_class?(task_class)
-
-        dependencies.each_with_index do |dep, index|
-          is_last = (index == dependencies.size - 1)
-          result += format_dependency_branch(dep, prefix, is_last, task_index_map, is_section, new_ancestors)
-        end
-
-        result
-      end
-
-      def format_dependency_branch(dep, prefix, is_last, task_index_map, is_impl, ancestors)
-        connector, extension = tree_connector_chars(is_last)
-        dep_tree = build_tree(dep, "#{prefix}#{extension}", task_index_map, is_impl, ancestors)
-
-        result = "#{prefix}#{COLORS[:tree]}#{connector}#{COLORS[:reset]}"
-        lines = dep_tree.lines
-        result += lines.first
-        lines.drop(1).each { |line| result += line }
-        result
-      end
-
-      def tree_connector_chars(is_last)
-        if is_last
-          ["└── ", "    "]
-        else
-          ["├── ", "│   "]
-        end
-      end
-
-      def get_task_number(task_class, task_index_map)
-        number = task_index_map[task_class] || (task_index_map.size + 1)
-        "#{COLORS[:tree]}[#{number}]#{COLORS[:reset]}"
-      end
-
-      def colored_type_label(klass)
-        if section_class?(klass)
-          "#{COLORS[:section]}(Section)#{COLORS[:reset]}"
-        else
-          "#{COLORS[:task]}(Task)#{COLORS[:reset]}"
-        end
-      end
-
-      def section_class?(klass)
-        defined?(Taski::Section) && klass < Taski::Section
-      end
-
       # Use allocate + initialize instead of new to avoid infinite loop
       # since new is overridden to return TaskWrapper
       def cached_wrapper
@@ -162,8 +80,7 @@ module Taski
           task_instance.send(:initialize)
           Execution::TaskWrapper.new(
             task_instance,
-            registry: registry,
-            coordinator: coordinator
+            registry: registry
           )
         end
       end

data/lib/taski/version.rb

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

data/lib/taski.rb

@@ -5,9 +5,9 @@ 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/coordinator"
 require_relative "taski/execution/task_wrapper"
-require_relative "taski/execution/parallel_progress_display"
+require_relative "taski/execution/executor"
+require_relative "taski/execution/tree_progress_display"
 require_relative "taski/context"
 require_relative "taski/task"
 require_relative "taski/section"
@@ -59,13 +59,17 @@ module Taski
     @global_registry = nil
   end
 
+  # Progress display is enabled by default (tree-style).
+  # Environment variables:
+  # - TASKI_PROGRESS_DISABLE=1: Disable progress display entirely
+  # - TASKI_FORCE_PROGRESS=1: Force enable even without TTY (for testing)
   def self.progress_display
-    return nil unless progress_enabled?
-    @progress_display ||= Execution::ParallelProgressDisplay.new
+    return nil if progress_disabled?
+    @progress_display ||= Execution::TreeProgressDisplay.new
   end
 
-  def self.progress_enabled?
-    ENV["TASKI_PROGRESS"] == "1" || ENV["TASKI_FORCE_PROGRESS"] == "1"
+  def self.progress_disabled?
+    ENV["TASKI_PROGRESS_DISABLE"] == "1"
   end
 
   def self.reset_progress_display!

data/sig/taski.rbs

@@ -2,7 +2,8 @@ module Taski
   VERSION: String
 
   self.@global_registry: Execution::Registry?
-  self.@progress_display: Execution::ParallelProgressDisplay?
+  self.@progress_display: Execution::TreeProgressDisplay?
+  self.@context: Context?
 
   # Type alias for Task class (singleton type with class methods)
   # This represents a Class that inherits from Taski::Task
@@ -11,9 +12,12 @@ module Taski
   # Module-level methods
   def self.global_registry: () -> Execution::Registry
   def self.reset_global_registry!: () -> void
-  def self.progress_display: () -> Execution::ParallelProgressDisplay?
-  def self.progress_enabled?: () -> bool
+  def self.progress_display: () -> Execution::TreeProgressDisplay?
+  def self.progress_disabled?: () -> bool
   def self.reset_progress_display!: () -> void
+  def self.context: () -> Hash[Symbol, untyped]
+  def self.start_context: (options: Hash[Symbol, untyped], root_task: Class) -> void
+  def self.reset_context!: () -> void
 
   # Custom exceptions
   class TaskAbortException < StandardError
@@ -29,23 +33,25 @@ module Taski
 
   # Context class for execution context management
   class Context
-    self.@monitor: Monitor
-    self.@working_directory: String?
-    self.@started_at: Time?
-    self.@root_task: Class?
-
-    def self.working_directory: () -> String
-    def self.started_at: () -> Time
-    def self.root_task: () -> Class?
-    def self.set_root_task: (Class task) -> void
-    def self.reset!: () -> void
+    @options: Hash[Symbol | String, untyped]
+    @root_task: Class
+    @started_at: Time
+    @working_directory: String
+
+    attr_reader started_at: Time
+    attr_reader working_directory: String
+    attr_reader root_task: Class
+
+    def initialize: (options: Hash[Symbol | String, untyped], root_task: Class) -> void
+    def []: (Symbol | String key) -> untyped
+    def fetch: (Symbol | String key, ?untyped default) ?{ () -> untyped } -> untyped
+    def key?: (Symbol | String key) -> bool
   end
 
   # Main Task class
   class Task
     self.@exported_methods: Array[Symbol]
     self.@dependencies_cache: Set[task_class]?
-    self.@coordinator: Execution::Coordinator?
     self.@circular_dependency_checked: bool
 
     # Class methods
@@ -54,10 +60,9 @@ module Taski
     def self.new: () -> Execution::TaskWrapper
     def self.cached_dependencies: () -> Set[task_class]
     def self.clear_dependency_cache: () -> void
-    def self.run: () -> untyped
-    def self.clean: () -> void
+    def self.run: (?context: Hash[Symbol, untyped]) -> untyped
+    def self.clean: (?context: Hash[Symbol, untyped]) -> void
     def self.registry: () -> Execution::Registry
-    def self.coordinator: () -> Execution::Coordinator
     def self.reset!: () -> void
     def self.tree: () -> String
 
@@ -69,9 +74,6 @@ module Taski
     private
 
     # Private class methods
-    def self.build_tree: (task_class task_class, String prefix, Set[task_class] visited) -> String
-    def self.format_dependency_branch: (task_class dep, String prefix, bool is_last, Set[task_class] visited) -> String
-    def self.tree_connector_chars: (bool is_last) -> [String, String]
     def self.cached_wrapper: () -> Execution::TaskWrapper
     def self.define_instance_reader: (Symbol method_name) -> void
     def self.define_class_accessor: (Symbol method_name) -> void
@@ -119,7 +121,8 @@ module Taski
 
       def initialize: () -> void
       def get_or_create: (Class task_class) { () -> TaskWrapper } -> TaskWrapper
-      def get_task: (Class task_class) -> TaskWrapper
+      def get_task: (Class task_class) -> TaskWrapper?
+      def register: (Class task_class, TaskWrapper wrapper) -> void
       def register_thread: (Thread thread) -> void
       def wait_all: () -> void
       def reset!: () -> void
@@ -128,31 +131,52 @@ module Taski
       def run: (Class task_class, Array[Symbol] exported_methods) -> untyped
     end
 
-    # Coordinator class for dependency management
-    class Coordinator
-      @registry: Registry
-      @analyzer: singleton(StaticAnalysis::Analyzer)
+    # Executor class for parallel task execution (Producer-Consumer pattern)
+    class Executor
+      STATE_PENDING: Symbol
+      STATE_ENQUEUED: Symbol
+      STATE_COMPLETED: Symbol
 
-      def initialize: (registry: Registry, analyzer: singleton(StaticAnalysis::Analyzer)) -> void
-      def start_dependencies: (task_class task_class) -> void
-      def start_clean_dependencies: (task_class task_class) -> void
-      def get_dependencies: (task_class task_class) -> Set[task_class]
+      @registry: Registry
+      @worker_count: Integer
+      @execution_queue: Thread::Queue
+      @completion_queue: Thread::Queue
+      @workers: Array[Thread]
+      @dependencies: Hash[Class, Set[Class]]
+      @task_states: Hash[Class, Symbol]
+      @completed_tasks: Set[Class]
+
+      def self.execute: (Class root_task_class, registry: Registry) -> void
+      def initialize: (registry: Registry, ?worker_count: Integer?) -> void
+      def execute: (Class root_task_class) -> void
 
       private
 
-      def start_thread_with: () { () -> void } -> void
-      def start_dependency_execution: (task_class dep_class) -> void
-      def start_dependency_clean: (task_class dep_class) -> void
+      def default_worker_count: () -> Integer
+      def build_dependency_graph: (Class root_task_class) -> void
+      def enqueue_ready_tasks: () -> void
+      def ready_to_execute?: (Class task_class) -> bool
+      def enqueue_task: (Class task_class) -> void
+      def get_or_create_wrapper: (Class task_class) -> TaskWrapper
+      def start_workers: () -> void
+      def worker_loop: () -> void
+      def execute_task: (Class task_class, TaskWrapper wrapper) -> void
+      def run_main_loop: (Class root_task_class) -> void
+      def no_running_tasks?: () -> bool
+      def handle_completion: (Hash[Symbol, untyped] event) -> void
+      def shutdown_workers: () -> void
+      def debug_log: (String message) -> void
     end
 
     # TaskWrapper class for task execution
     class TaskWrapper
       attr_reader task: Task
       attr_reader result: untyped
+      attr_reader error: StandardError?
+      attr_reader timing: TaskTiming?
 
       @task: Task
       @registry: Registry
-      @coordinator: Coordinator
       @result: untyped
       @clean_result: untyped
       @error: StandardError?
@@ -167,38 +191,38 @@ module Taski
       STATE_RUNNING: Symbol
       STATE_COMPLETED: Symbol
 
-      def initialize: (Task task, registry: Registry, coordinator: Coordinator) -> void
+      def initialize: (Task task, registry: Registry) -> void
+      def state: () -> Symbol
+      def pending?: () -> bool
+      def completed?: () -> bool
       def run: () -> untyped
-      def clean: () -> void
+      def clean: () -> untyped
       def get_exported_value: (Symbol method_name) -> untyped
-      def start_thread_with: () { () -> void } -> void
-      def execute_with_state_pattern: (state_getter: ^() -> Symbol, starter: ^() -> void, waiter: ^() -> void, ?pre_start_check: (^() -> void)?) -> void
-      def execute_task_if_needed: () -> void
-      def start_async_execution: () -> void
-      def execute_task: () -> void
-      def wait_for_dependencies: () -> void
-      def execute_clean_if_needed: () -> void
-      def start_async_clean: () -> void
-      def execute_clean: () -> void
-      def wait_for_clean_dependencies: () -> void
-      def mark_completed: () -> void
-      def mark_clean_completed: () -> void
-      def wait_for_completion: () -> untyped
+      def mark_running: () -> bool
+      def mark_completed: (untyped result) -> void
+      def mark_failed: (StandardError error) -> void
+      def mark_clean_completed: (untyped result) -> void
+      def wait_for_completion: () -> void
       def wait_for_clean_completion: () -> void
-      def debug_log: (String message) -> void
-      def log_start: () -> void
-      def log_completion: () -> void
-      def log_clean_start: () -> void
-      def log_clean_completion: () -> void
-      def register_with_progress_display: () -> void
-      def update_progress: (Symbol state, ?duration: Numeric?, ?error: Exception?) -> void
       def method_missing: (Symbol name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
       def respond_to_missing?: (Symbol name, ?bool include_private) -> bool
+
+      private
+
+      def trigger_execution_and_wait: () -> void
+      def trigger_clean_and_wait: () -> void
+      def execute_clean: () -> void
+      def wait_for_clean_dependencies: () -> void
+      def check_abort!: () -> void
+      def update_progress: (Symbol state, ?duration: Numeric?, ?error: Exception?) -> void
+      def debug_log: (String message) -> void
     end
 
-    # ParallelProgressDisplay class for progress visualization
-    class ParallelProgressDisplay
+    # TreeProgressDisplay class for tree-based progress visualization
+    class TreeProgressDisplay
       SPINNER_FRAMES: Array[String]
+      COLORS: Hash[Symbol, String]
+      ICONS: Hash[Symbol, String]
 
       @output: IO
       @tasks: Hash[Class, TaskProgress]
@@ -206,6 +230,30 @@ module Taski
       @spinner_index: Integer
       @renderer_thread: Thread?
       @running: bool
+      @nest_level: Integer
+      @root_task_class: Class?
+      @tree_structure: Hash[Symbol, untyped]?
+      @section_impl_map: Hash[Class, Class]
+      @last_line_count: Integer
+
+      # Shared class methods
+      def self.section_class?: (Class klass) -> bool
+      def self.nested_class?: (Class child_class, Class parent_class) -> bool
+      def self.render_static_tree: (Class root_task_class) -> String
+
+      # Static tree renderer (internal class)
+      class StaticTreeRenderer
+        @task_index_map: Hash[Class, Integer]
+
+        def render: (Class root_task_class) -> String
+
+        private
+
+        def build_tree: (Class task_class, String prefix, bool is_impl, Set[Class] ancestors) -> String
+        def render_dependency_branch: (Class dep, String prefix, bool is_last, bool is_impl, Set[Class] ancestors) -> String
+        def get_task_number: (Class task_class) -> String
+        def colored_type_label: (Class klass) -> String
+      end
 
       class TaskProgress
         attr_accessor state: Symbol
@@ -213,28 +261,39 @@ module Taski
         attr_accessor end_time: Time?
         attr_accessor error: Exception?
         attr_accessor duration: Numeric?
+        attr_accessor is_impl_candidate: bool
 
         def initialize: () -> void
       end
 
       def initialize: (?output: IO) -> void
+      def set_root_task: (Class root_task_class) -> void
+      def register_section_impl: (Class section_class, Class impl_class) -> void
       def register_task: (Class task_class) -> void
       def task_registered?: (Class task_class) -> bool
       def update_task: (Class task_class, state: Symbol, ?duration: Numeric?, ?error: Exception?) -> void
       def task_state: (Class task_class) -> Symbol?
-      def render: () -> void
       def start: () -> void
       def stop: () -> void
 
       private
 
-      def collect_task_lines: () -> Array[String]
+      def build_tree_structure: () -> void
+      def build_tree_node: (Class task_class, Set[Class] ancestors) -> Hash[Symbol, untyped]?
+      def register_tasks_from_tree: (Hash[Symbol, untyped] node) -> void
       def render_live: () -> void
       def render_final: () -> void
-      def format_task_line: (Class task_class, TaskProgress progress) -> String
-      def task_icon: (Symbol state) -> String
+      def build_tree_display: () -> Array[String]
+      def build_root_tree_lines: (Hash[Symbol, untyped] node, String prefix, Array[String] lines) -> void
+      def render_children: (Hash[Symbol, untyped] node, String prefix, Array[String] lines, Class parent_task_class, bool ancestor_selected) -> void
+      def format_tree_line: (Class task_class, TaskProgress? progress, bool is_impl, bool is_selected) -> String
+      def format_unknown_task: (Class task_class, ?bool is_selected) -> String
+      def task_status_icon: (Symbol state, bool is_selected) -> String
       def spinner_char: () -> String
+      def type_label_for: (Class task_class, ?bool is_selected) -> String
       def task_details: (TaskProgress progress) -> String
+      def section_class?: (Class klass) -> bool
+      def nested_class?: (Class child_class, Class parent_class) -> bool
     end
   end
 
@@ -246,19 +305,21 @@ module Taski
 
       private
 
-      def self.extract_run_method_location: (Class task_class) -> [String, Integer]?
+      def self.target_method_for: (Class task_class) -> Symbol
+      def self.extract_method_location: (Class task_class, Symbol method_name) -> [String, Integer]?
     end
 
     # Visitor class for AST traversal
     class Visitor < Prism::Visitor
       @target_task_class: Class
+      @target_method: Symbol
       @dependencies: Set[task_class]
-      @in_target_run_method: bool
+      @in_target_method: bool
       @current_namespace_path: Array[String?]
 
       attr_reader dependencies: Set[task_class]
 
-      def initialize: (Class task_class) -> void
+      def initialize: (Class task_class, Symbol target_method) -> void
       def visit_class_node: (Prism::ClassNode node) -> untyped
       def visit_module_node: (Prism::ModuleNode node) -> untyped
       def visit_def_node: (Prism::DefNode node) -> untyped
@@ -268,8 +329,10 @@ module Taski
 
       def within_namespace: (String? name) { () -> void } -> void
       def in_target_class?: () -> bool
+      def in_impl_method?: () -> bool
       def extract_constant_name: (untyped node) -> String?
       def detect_task_dependency: (Prism::CallNode node) -> void
+      def detect_impl_candidate: (untyped node) -> void
       def extract_receiver_constant: (untyped receiver) -> String?
       def resolve_and_add_dependency: (String constant_name) -> void
       def resolve_constant: (String name) -> task_class?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  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