taski 0.7.0 → 0.7.1

data/lib/taski/execution/tree_progress_display.rb

@@ -1,15 +1,27 @@
 # frozen_string_literal: true
 
-require "monitor"
 require "stringio"
+require_relative "base_progress_display"
 
 module Taski
   module Execution
     # Tree-based progress display that shows task execution in a tree structure
     # similar to Task.tree, with real-time status updates and stdout capture.
-    class TreeProgressDisplay
+    class TreeProgressDisplay < BaseProgressDisplay
       SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
 
+      # Output display settings
+      OUTPUT_RESERVED_WIDTH = 30  # Characters reserved for tree structure
+      OUTPUT_MIN_LENGTH = 70      # Minimum visible output length
+      OUTPUT_SEPARATOR = " > "      # Separator before task output
+      GROUP_SEPARATOR = " | "       # Separator between group name and task name
+      TRUNCATION_ELLIPSIS = "..." # Ellipsis for truncated output
+
+      # Display settings
+      RENDER_INTERVAL = 0.1       # Seconds between display updates
+      DEFAULT_TERMINAL_WIDTH = 80   # Default terminal width when unknown
+      DEFAULT_TERMINAL_HEIGHT = 24  # Default terminal height when unknown
+
       # ANSI color codes (matching Task.tree)
       COLORS = {
         reset: "\e[0m",
@@ -169,264 +181,54 @@ module Taski
         end
       end
 
-      # Tracks the progress of a group within a task
-      class GroupProgress
-        attr_accessor :name, :state, :start_time, :end_time, :duration, :error, :last_message
-
-        def initialize(name)
-          @name = name
-          @state = :pending
-          @start_time = nil
-          @end_time = nil
-          @duration = nil
-          @error = nil
-          @last_message = nil
-        end
-      end
-
-      class TaskProgress
-        # Run lifecycle tracking
-        attr_accessor :run_state, :run_start_time, :run_end_time, :run_error, :run_duration
-        # Clean lifecycle tracking
-        attr_accessor :clean_state, :clean_start_time, :clean_end_time, :clean_error, :clean_duration
-        # Display properties
-        attr_accessor :is_impl_candidate
-        # Group tracking
-        attr_accessor :groups, :current_group_index
-
-        def initialize
-          # Run lifecycle
-          @run_state = :pending
-          @run_start_time = nil
-          @run_end_time = nil
-          @run_error = nil
-          @run_duration = nil
-          # Clean lifecycle
-          @clean_state = nil  # nil means clean hasn't started
-          @clean_start_time = nil
-          @clean_end_time = nil
-          @clean_error = nil
-          @clean_duration = nil
-          # Display
-          @is_impl_candidate = false
-          # Groups
-          @groups = []
-          @current_group_index = nil
-        end
-
-        # For backward compatibility - returns the most relevant state for display
-        def state
-          @clean_state || @run_state
-        end
-
-        # Legacy accessors for backward compatibility
-        def start_time
-          @clean_start_time || @run_start_time
-        end
-
-        def end_time
-          @clean_end_time || @run_end_time
-        end
-
-        def error
-          @clean_error || @run_error
-        end
-
-        def duration
-          @clean_duration || @run_duration
-        end
-      end
-
       def initialize(output: $stdout)
-        @output = output
-        @tasks = {}
-        @monitor = Monitor.new
+        super
         @spinner_index = 0
         @renderer_thread = nil
         @running = false
-        @nest_level = 0 # Track nested executor calls
-        @root_task_class = nil
         @tree_structure = nil
         @section_impl_map = {}  # Section -> selected impl class
-        @output_capture = nil  # ThreadOutputCapture for getting task output
+        @last_line_count = 0  # Track number of lines drawn for cursor movement
       end
 
-      # Set the output capture for getting task output
-      # @param capture [ThreadOutputCapture] The output capture instance
-      def set_output_capture(capture)
-        @monitor.synchronize do
-          @output_capture = capture
-        end
-      end
+      protected
 
-      # Set the root task to build tree structure
-      # Only sets root task if not already set (prevents nested executor overwrite)
-      # @param root_task_class [Class] The root task class
-      def set_root_task(root_task_class)
-        @monitor.synchronize do
-          return if @root_task_class # Don't overwrite existing root task
-          @root_task_class = root_task_class
-          build_tree_structure
-        end
-      end
-
-      # Register which impl was selected for a section
-      # @param section_class [Class] The section class
-      # @param impl_class [Class] The selected implementation class
-      def register_section_impl(section_class, impl_class)
-        @monitor.synchronize do
-          @section_impl_map[section_class] = impl_class
-        end
-      end
-
-      # @param task_class [Class] The task class to register
-      def register_task(task_class)
-        @monitor.synchronize do
-          return if @tasks.key?(task_class)
-          @tasks[task_class] = TaskProgress.new
-        end
+      # Template method: Called when root task is set
+      def on_root_task_set
+        build_tree_structure
       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
+      # Template method: Called when a section impl is registered
+      def on_section_impl_registered(section_class, impl_class)
+        @section_impl_map[section_class] = impl_class
       end
 
-      # @param task_class [Class] The task class to update
-      # @param state [Symbol] The new state (:pending, :running, :completed, :failed, :cleaning, :clean_completed, :clean_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
-
-          case state
-          # Run lifecycle states
-          when :pending
-            progress.run_state = :pending
-          when :running
-            progress.run_state = :running
-            progress.run_start_time = Time.now
-          when :completed
-            progress.run_state = :completed
-            progress.run_end_time = Time.now
-            progress.run_duration = duration if duration
-          when :failed
-            progress.run_state = :failed
-            progress.run_end_time = Time.now
-            progress.run_error = error if error
-          # Clean lifecycle states
-          when :cleaning
-            progress.clean_state = :cleaning
-            progress.clean_start_time = Time.now
-          when :clean_completed
-            progress.clean_state = :clean_completed
-            progress.clean_end_time = Time.now
-            progress.clean_duration = duration if duration
-          when :clean_failed
-            progress.clean_state = :clean_failed
-            progress.clean_end_time = Time.now
-            progress.clean_error = error if error
-          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
-
-      # Update group state for a task.
-      # Called by ExecutionContext when group lifecycle events occur.
-      #
-      # @param task_class [Class] The task class containing the group
-      # @param group_name [String] The name of the group
-      # @param state [Symbol] The new state (:running, :completed, :failed)
-      # @param duration [Float, nil] Duration in milliseconds (for completed groups)
-      # @param error [Exception, nil] Error object (for failed groups)
-      def update_group(task_class, group_name, state:, duration: nil, error: nil)
-        @monitor.synchronize do
-          progress = @tasks[task_class]
-          return unless progress
-
-          case state
-          when :running
-            # Create new group and set as current
-            group = GroupProgress.new(group_name)
-            group.state = :running
-            group.start_time = Time.now
-            progress.groups << group
-            progress.current_group_index = progress.groups.size - 1
-          when :completed
-            # Find the group by name and mark completed
-            group = progress.groups.find { |g| g.name == group_name && g.state == :running }
-            if group
-              group.state = :completed
-              group.end_time = Time.now
-              group.duration = duration
-            end
-            progress.current_group_index = nil
-          when :failed
-            # Find the group by name and mark failed
-            group = progress.groups.find { |g| g.name == group_name && g.state == :running }
-            if group
-              group.state = :failed
-              group.end_time = Time.now
-              group.duration = duration
-              group.error = error
-            end
-            progress.current_group_index = nil
-          end
-        end
+      # Template method: Determine if display should activate
+      def should_activate?
+        tty?
       end
 
-      def start
-        should_start = false
-        @monitor.synchronize do
-          @nest_level += 1
-          return if @nest_level > 1 # Already running from outer executor
-          return if @running
-          return unless @output.tty?
-
-          @running = true
-          should_start = true
-        end
-
-        return unless should_start
-
-        @output.print "\e[?25l"  # Hide cursor
-        @output.print "\e7"      # Save cursor position (before any tree output)
+      # Template method: Called when display starts
+      def on_start
+        @running = true
+        @output.print "\e[?1049h" # Switch to alternate screen buffer
+        @output.print "\e[H"      # Move cursor to home (top-left)
+        @output.print "\e[?25l"   # Hide cursor
         @renderer_thread = Thread.new do
           loop do
             break unless @running
             render_live
-            sleep 0.1
+            sleep RENDER_INTERVAL
           end
         end
       end
 
-      def stop
-        should_stop = false
-        @monitor.synchronize do
-          @nest_level -= 1 if @nest_level > 0
-          return unless @nest_level == 0
-          return unless @running
-
-          @running = false
-          should_stop = true
-        end
-
-        return unless should_stop
-
+      # Template method: Called when display stops
+      def on_stop
+        @running = false
         @renderer_thread&.join
-        @output.print "\e[?25h"  # Show cursor
+        @output.print "\e[?25h"   # Show cursor
+        @output.print "\e[?1049l" # Switch back to main screen buffer
         render_final
       end
 
@@ -440,21 +242,6 @@ module Taski
         register_tasks_from_tree(@tree_structure)
       end
 
-      # Register all tasks from tree structure
-      def register_tasks_from_tree(node)
-        return unless node
-
-        task_class = node[:task_class]
-        register_task(task_class)
-
-        # Mark as impl candidate if applicable
-        if node[:is_impl_candidate]
-          @tasks[task_class].is_impl_candidate = true
-        end
-
-        node[:children].each { |child| register_tasks_from_tree(child) }
-      end
-
       def render_live
         # Poll for new output from task pipes
         @output_capture&.poll
@@ -468,32 +255,82 @@ module Taski
 
         return if lines.nil? || lines.empty?
 
-        # Restore cursor to saved position (from start) and clear
-        @output.print "\e8"  # Restore cursor position
-        @output.print "\e[J" # Clear from cursor to end of screen
+        # Build complete frame in buffer for single write (flicker-free)
+        buffer = build_frame_buffer(lines)
+
+        # Write entire frame in single operation
+        @output.print buffer
+        @output.flush
+
+        @last_line_count = lines.size
+      end
 
-        # Redraw all lines
+      ##
+      # Builds a complete frame buffer for flicker-free rendering.
+      # Uses cursor home positioning and line-by-line overwrite instead of clear.
+      # @param lines [Array<String>] The lines to render.
+      # @return [String] The complete frame buffer ready for single write.
+      def build_frame_buffer(lines)
+        buffer = +""
+
+        # Move cursor to home position (top-left) for overwrite
+        buffer << "\e[H"
+
+        # Build each line with clear-to-end-of-line for clean overwrite
         lines.each do |line|
-          @output.print "#{line}\n"
+          buffer << line
+          buffer << "\e[K" # Clear from cursor to end of line (removes old content)
+          buffer << "\n"
         end
 
-        @output.flush
+        # Clear any extra lines from previous render if current has fewer lines
+        if @last_line_count > lines.size
+          (@last_line_count - lines.size).times do
+            buffer << "\e[K\n" # Clear line and move to next
+          end
+        end
+
+        buffer
       end
 
       def render_final
         @monitor.synchronize do
-          lines = build_tree_display
-          return if lines.empty?
+          return unless @root_task_class
 
-          # Restore cursor to saved position (from start) and clear
-          @output.print "\e8"  # Restore cursor position
-          @output.print "\e[J" # Clear from cursor to end of screen
+          root_progress = @tasks[@root_task_class]
+          return unless root_progress
 
-          # Print final state
-          lines.each { |line| @output.puts line }
+          # Print single summary line instead of full tree
+          @output.puts build_summary_line(@root_task_class, root_progress)
         end
       end
 
+      def build_summary_line(task_class, progress)
+        # Determine overall status and icon
+        if progress.run_state == :failed || progress.clean_state == :clean_failed
+          icon = "#{COLORS[:error]}#{ICONS[:failed]}#{COLORS[:reset]}"
+          status = "#{COLORS[:error]}failed#{COLORS[:reset]}"
+        else
+          icon = "#{COLORS[:success]}#{ICONS[:completed]}#{COLORS[:reset]}"
+          status = "#{COLORS[:success]}completed#{COLORS[:reset]}"
+        end
+
+        name = "#{COLORS[:name]}#{task_class.name}#{COLORS[:reset]}"
+
+        # Calculate total duration
+        duration_str = ""
+        if progress.run_duration
+          duration_str = " (#{progress.run_duration}ms)"
+        end
+
+        # Count completed tasks
+        completed_count = @tasks.values.count { |p| p.run_state == :completed }
+        total_count = @tasks.values.count { |p| p.run_state != :pending || p == progress }
+        task_count_str = " [#{completed_count}/#{total_count} tasks]"
+
+        "#{icon} #{name} #{status}#{duration_str}#{task_count_str}"
+      end
+
       # Build display lines from tree structure
       def build_tree_display
         return [] unless @tree_structure
@@ -739,22 +576,22 @@ module Taski
         group_prefix = ""
         if progress&.current_group_index
           current_group = progress.groups[progress.current_group_index]
-          group_prefix = "#{current_group.name}: " if current_group
+          group_prefix = "#{current_group.name}#{GROUP_SEPARATOR}" if current_group
         end
 
         # Truncate if too long (leave space for tree structure)
         terminal_cols = terminal_width
-        max_output_length = terminal_cols - 50
-        max_output_length = 20 if max_output_length < 20
+        max_output_length = terminal_cols - OUTPUT_RESERVED_WIDTH
+        max_output_length = OUTPUT_MIN_LENGTH if max_output_length < OUTPUT_MIN_LENGTH
 
         full_output = "#{group_prefix}#{last_line}"
         truncated = if full_output.length > max_output_length
-          full_output[0, max_output_length - 3] + "..."
+          full_output[0, max_output_length - TRUNCATION_ELLIPSIS.length] + TRUNCATION_ELLIPSIS
         else
           full_output
         end
 
-        " #{COLORS[:dim]}| #{truncated}#{COLORS[:reset]}"
+        "#{COLORS[:dim]}#{OUTPUT_SEPARATOR}#{truncated}#{COLORS[:reset]}"
       end
 
       ##
@@ -764,9 +601,22 @@ module Taski
       def terminal_width
         if @output.respond_to?(:winsize)
           _, cols = @output.winsize
-          cols || 80
+          cols || DEFAULT_TERMINAL_WIDTH
+        else
+          DEFAULT_TERMINAL_WIDTH
+        end
+      end
+
+      ##
+      # Returns the terminal height in rows.
+      # Defaults to 24 if the output IO doesn't support winsize.
+      # @return [Integer] The terminal height in rows.
+      def terminal_height
+        if @output.respond_to?(:winsize)
+          rows, _ = @output.winsize
+          rows || DEFAULT_TERMINAL_HEIGHT
         else
-          80
+          DEFAULT_TERMINAL_HEIGHT
         end
       end
 

data/lib/taski/static_analysis/visitor.rb

@@ -92,6 +92,9 @@ module Taski
         # 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("::")
+
         @class_method_defs.each do |method_name, method_node|
           next unless new_methods.include?(method_name)
 

data/lib/taski/task.rb

@@ -82,12 +82,7 @@ module Taski
       # @raise [ArgumentError] If workers is not a positive integer or nil.
       # @return [Object] The result of task execution.
       def run(args: {}, workers: nil)
-        validate_workers!(workers)
-        Taski.start_args(options: args.merge(_workers: workers), root_task: self)
-        validate_no_circular_dependencies!
-        fresh_wrapper.run
-      ensure
-        Taski.reset_args!
+        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.run }
       end
 
       ##
@@ -99,12 +94,7 @@ module Taski
       #   Must be a positive integer or nil.
       # @raise [ArgumentError] If workers is not a positive integer or nil.
       def clean(args: {}, workers: nil)
-        validate_workers!(workers)
-        Taski.start_args(options: args.merge(_workers: workers), root_task: self)
-        validate_no_circular_dependencies!
-        fresh_wrapper.clean
-      ensure
-        Taski.reset_args!
+        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.clean }
       end
 
       ##
@@ -118,12 +108,7 @@ module Taski
       # @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)
-        validate_workers!(workers)
-        Taski.start_args(options: args.merge(_workers: workers), root_task: self)
-        validate_no_circular_dependencies!
-        fresh_wrapper.run_and_clean
-      ensure
-        Taski.reset_args!
+        with_execution_setup(args: args, workers: workers) { |wrapper| wrapper.run_and_clean }
       end
 
       ##
@@ -144,6 +129,21 @@ module Taski
 
       private
 
+      ##
+      # Sets up execution environment and yields a fresh wrapper.
+      # Handles workers validation, args lifecycle, and dependency validation.
+      # @param args [Hash] User-defined arguments
+      # @param workers [Integer, nil] Number of worker threads
+      # @yield [wrapper] Block receiving the fresh wrapper to execute
+      # @return [Object] The result of the block
+      def with_execution_setup(args:, workers:)
+        validate_workers!(workers)
+        Taski.with_args(options: args.merge(_workers: workers), root_task: self) do
+          validate_no_circular_dependencies!
+          yield fresh_wrapper
+        end
+      end
+
       ##
       # Creates a fresh TaskWrapper with its own registry.
       # Used for class method execution (Task.run) where each call is independent.
@@ -199,14 +199,9 @@ module Taski
             wrapper.get_exported_value(method)
           else
             # Outside execution - fresh execution (top-level call)
-            args_was_nil = Taski.args.nil?
-            begin
-              Taski.start_args(options: {}, root_task: self) if args_was_nil
+            Taski.with_args(options: {}, root_task: self) do
               validate_no_circular_dependencies!
               fresh_wrapper.get_exported_value(method)
-            ensure
-              # Only reset if we set args
-              Taski.reset_args! if args_was_nil
             end
           end
         end

data/lib/taski/test_helper/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Taski
+  module TestHelper
+    # Raised when attempting to mock a class that is not a Taski::Task or Taski::Section subclass.
+    class InvalidTaskError < ArgumentError
+    end
+
+    # Raised when attempting to mock a method that is not an exported method of the task.
+    class InvalidMethodError < ArgumentError
+    end
+  end
+end

data/lib/taski/test_helper/minitest.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module Taski
+  module TestHelper
+    # Minitest integration module.
+    # Include this in your test class for automatic mock cleanup.
+    #
+    # @example
+    #   class MyTaskTest < Minitest::Test
+    #     include Taski::TestHelper::Minitest
+    #
+    #     def test_something
+    #       mock_task(FetchData, result: "mocked")
+    #       # ... test code ...
+    #     end
+    #     # Mocks are automatically cleaned up after each test
+    #   end
+    module Minitest
+      def self.included(base)
+        base.include(Taski::TestHelper)
+      end
+
+      # Reset mocks before each test to ensure clean state.
+      def setup
+        super
+        Taski::TestHelper.reset_mocks!
+      end
+
+      # Reset mocks after each test to prevent pollution.
+      def teardown
+        Taski::TestHelper.reset_mocks!
+        super
+      end
+    end
+  end
+end

data/lib/taski/test_helper/mock_registry.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Taski
+  module TestHelper
+    # Global registry that stores mock definitions for tests.
+    # Uses a Mutex for thread-safety when accessed from worker threads.
+    # Mocks should be reset in test setup/teardown to ensure test isolation.
+    module MockRegistry
+      @mutex = Mutex.new
+      @mocks = {}
+
+      class << self
+        # Registers a mock for a task class.
+        # If a mock already exists for this class, it is replaced.
+        # @param task_class [Class] The task class to mock
+        # @param mock_wrapper [MockWrapper] The mock wrapper instance
+        def register(task_class, mock_wrapper)
+          @mutex.synchronize do
+            @mocks[task_class] = mock_wrapper
+          end
+        end
+
+        # Retrieves the mock wrapper for a task class, if one exists.
+        # @param task_class [Class] The task class to look up
+        # @return [MockWrapper, nil] The mock wrapper or nil if not mocked
+        def mock_for(task_class)
+          @mutex.synchronize do
+            @mocks[task_class]
+          end
+        end
+
+        # Checks if any mocks are registered.
+        # Used for optimization to skip mock lookup in hot paths.
+        # @return [Boolean] true if mocks exist
+        def mocks_active?
+          @mutex.synchronize do
+            !@mocks.empty?
+          end
+        end
+
+        # Clears all registered mocks.
+        # Should be called in test setup/teardown.
+        def reset!
+          @mutex.synchronize do
+            @mocks = {}
+          end
+        end
+      end
+    end
+  end
+end