taski 0.2.0 → 0.2.2

data/lib/taski/progress_display.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Taski
+  # Terminal control operations with ANSI escape sequences
+  class TerminalController
+    # ANSI escape sequences
+    MOVE_UP = "\033[A"
+    CLEAR_LINE = "\033[K"
+    MOVE_UP_AND_CLEAR = "#{MOVE_UP}#{CLEAR_LINE}"
+
+    def initialize(output)
+      @output = output
+    end
+
+    def clear_lines(count)
+      return if count == 0
+
+      count.times { @output.print MOVE_UP_AND_CLEAR }
+    end
+
+    def puts(text)
+      @output.puts text
+    end
+
+    def print(text)
+      @output.print text
+    end
+
+    def flush
+      @output.flush
+    end
+  end
+
+  # Spinner animation with dots-style characters
+  class SpinnerAnimation
+    SPINNER_CHARS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].freeze
+    FRAME_DELAY = 0.1
+
+    def initialize
+      @frame = 0
+      @running = false
+      @thread = nil
+    end
+
+    def start(terminal, task_name, &display_callback)
+      return if @running
+
+      @running = true
+      @frame = 0
+
+      @thread = Thread.new do
+        while @running
+          current_char = SPINNER_CHARS[@frame % SPINNER_CHARS.length]
+          display_callback&.call(current_char, task_name)
+
+          @frame += 1
+          sleep FRAME_DELAY
+        end
+      rescue
+        # Silently handle thread errors
+      end
+    end
+
+    def stop
+      @running = false
+      @thread&.join(0.2)
+      @thread = nil
+    end
+
+    def running?
+      @running
+    end
+  end
+
+  # Captures stdout and maintains last N lines like tail -f
+  class OutputCapture
+    MAX_LINES = 10
+    DISPLAY_LINES = 5
+
+    def initialize(main_output)
+      @main_output = main_output
+      @buffer = []
+      @capturing = false
+      @original_stdout = nil
+      @pipe_reader = nil
+      @pipe_writer = nil
+      @capture_thread = nil
+    end
+
+    def start
+      return if @capturing
+
+      @buffer.clear
+      setup_stdout_redirection
+      @capturing = true
+
+      start_capture_thread
+    end
+
+    def stop
+      return unless @capturing
+
+      @capturing = false
+
+      # Restore stdout
+      restore_stdout
+
+      # Clean up pipes and thread
+      cleanup_capture_thread
+      cleanup_pipes
+    end
+
+    def last_lines
+      @buffer.last(DISPLAY_LINES)
+    end
+
+    def capturing?
+      @capturing
+    end
+
+    private
+
+    def setup_stdout_redirection
+      @original_stdout = $stdout
+      @pipe_reader, @pipe_writer = IO.pipe
+      $stdout = @pipe_writer
+    end
+
+    def restore_stdout
+      return unless @original_stdout
+
+      $stdout = @original_stdout
+      @original_stdout = nil
+    end
+
+    def start_capture_thread
+      @capture_thread = Thread.new do
+        while (line = @pipe_reader.gets)
+          line = line.chomp
+          next if line.empty?
+          next if skip_line?(line)
+
+          add_line_to_buffer(line)
+        end
+      rescue IOError
+        # Pipe closed, normal termination
+      end
+    end
+
+    def skip_line?(line)
+      # Skip logger lines (they appear separately)
+      line.match?(/^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]/)
+    end
+
+    def add_line_to_buffer(line)
+      @buffer << line
+      @buffer.shift while @buffer.length > MAX_LINES
+    end
+
+    def cleanup_capture_thread
+      @capture_thread&.join(0.1)
+      @capture_thread = nil
+    end
+
+    def cleanup_pipes
+      [@pipe_writer, @pipe_reader].each do |pipe|
+        pipe&.close
+      rescue IOError
+        # Already closed, ignore
+      end
+      @pipe_writer = @pipe_reader = nil
+    end
+  end
+
+  # Represents task execution status
+  class TaskStatus
+    attr_reader :name, :duration, :error
+
+    def initialize(name:, duration: nil, error: nil)
+      @name = name
+      @duration = duration
+      @error = error
+    end
+
+    def success?
+      @error.nil?
+    end
+
+    def failure?
+      !success?
+    end
+
+    def duration_ms
+      return nil unless @duration
+      (@duration * 1000).round(1)
+    end
+
+    def icon
+      success? ? "✅" : "❌"
+    end
+
+    def format_duration
+      return "" unless duration_ms
+      "(#{duration_ms}ms)"
+    end
+  end
+
+  # Main progress display controller
+  class ProgressDisplay
+    # ANSI colors
+    COLORS = {
+      reset: "\033[0m",
+      bold: "\033[1m",
+      dim: "\033[2m",
+      cyan: "\033[36m",
+      green: "\033[32m",
+      red: "\033[31m"
+    }.freeze
+
+    def initialize(output: $stdout, force_enable: nil)
+      @output = output
+      @terminal = TerminalController.new(output)
+      @spinner = SpinnerAnimation.new
+      @output_capture = OutputCapture.new(output)
+
+      # Enable if TTY or force enabled or environment variable set
+      @enabled = force_enable.nil? ? (output.tty? || ENV["TASKI_FORCE_PROGRESS"] == "1") : force_enable
+
+      @completed_tasks = []
+      @current_display_lines = 0
+    end
+
+    def start_task(task_name, dependencies: [])
+      puts "DEBUG: start_task called for #{task_name}, enabled: #{@enabled}" if ENV["TASKI_DEBUG"]
+      return unless @enabled
+
+      clear_current_display
+      @output_capture.start
+
+      start_spinner_display(task_name)
+    end
+
+    def complete_task(task_name, duration:)
+      return unless @enabled
+
+      status = TaskStatus.new(name: task_name, duration: duration)
+      finish_task(status)
+    end
+
+    def fail_task(task_name, error:, duration:)
+      return unless @enabled
+
+      status = TaskStatus.new(name: task_name, duration: duration, error: error)
+      finish_task(status)
+    end
+
+    def clear
+      return unless @enabled
+
+      @spinner.stop
+      @output_capture.stop
+      clear_current_display
+
+      # Display final summary of all completed tasks
+      if @completed_tasks.any?
+        @completed_tasks.each do |status|
+          @terminal.puts format_completed_task(status)
+        end
+        @terminal.flush
+      end
+
+      @completed_tasks.clear
+      @current_display_lines = 0
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    private
+
+    def start_spinner_display(task_name)
+      @spinner.start(@terminal, task_name) do |spinner_char, name|
+        display_current_state(spinner_char, name)
+      end
+    end
+
+    def display_current_state(spinner_char, task_name)
+      clear_current_display
+
+      lines_count = 0
+
+      # Only display current task with spinner (no past completed tasks during execution)
+      @terminal.puts format_current_task(spinner_char, task_name)
+      lines_count += 1
+
+      # Display output lines
+      @output_capture.last_lines.each do |line|
+        @terminal.puts format_output_line(line)
+        lines_count += 1
+      end
+
+      @current_display_lines = lines_count
+      @terminal.flush
+    end
+
+    def finish_task(status)
+      @spinner.stop
+
+      # Capture output before stopping
+      captured_output = @output_capture.last_lines
+      @output_capture.stop
+      clear_current_display
+
+      # In test environments (when terminal is StringIO), include captured output
+      if @terminal.is_a?(StringIO) && captured_output.any?
+        captured_output.each do |line|
+          @terminal.puts line.chomp
+        end
+      end
+
+      @completed_tasks << status
+      display_final_state
+    end
+
+    def display_final_state
+      # Only display the newly completed task (last one)
+      if @completed_tasks.any?
+        latest_task = @completed_tasks.last
+        @terminal.puts format_completed_task(latest_task)
+      end
+      @terminal.flush
+      @current_display_lines = 1  # Only one line for the latest task
+    end
+
+    def format_completed_task(status)
+      color = status.success? ? COLORS[:green] : COLORS[:red]
+      "#{color}#{COLORS[:bold]}#{status.icon} #{status.name}#{COLORS[:reset]} #{COLORS[:dim]}#{status.format_duration}#{COLORS[:reset]}"
+    end
+
+    def format_current_task(spinner_char, task_name)
+      "#{COLORS[:cyan]}#{spinner_char}#{COLORS[:reset]} #{COLORS[:bold]}#{task_name}#{COLORS[:reset]}"
+    end
+
+    def format_output_line(line)
+      "  #{COLORS[:dim]}#{line}#{COLORS[:reset]}"
+    end
+
+    def clear_current_display
+      @terminal.clear_lines(@current_display_lines)
+      @current_display_lines = 0
+    end
+  end
+end

data/lib/taski/reference.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'exceptions'
+require_relative "exceptions"
 
 module Taski
   # Reference class for task references
-  # 
+  #
   # Used to create lazy references to task classes by name,
   # which is useful for dependency tracking and metaprogramming.
   class Reference
@@ -37,4 +37,4 @@ module Taski
       "&#{@klass}"
     end
   end
-end
+end

data/lib/taski/task/base.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../exceptions'
+require_relative "../exceptions"
 
 module Taski
   # Base Task class that provides the foundation for task framework
   # This module contains the core constants and basic structure
   class Task
     # Constants for thread-local keys and method tracking
-    THREAD_KEY_SUFFIX = '_building'
+    THREAD_KEY_SUFFIX = "_building"
     TASKI_ANALYZING_DEFINE_KEY = :taski_analyzing_define
     ANALYZED_METHODS = [:build, :clean].freeze
 
@@ -41,6 +41,51 @@ module Taski
       def __resolve__
         @__resolve__ ||= {}
       end
+
+      # Display dependency tree for this task
+      # @param prefix [String] Current indentation prefix
+      # @param visited [Set] Set of visited classes to prevent infinite loops
+      # @return [String] Formatted dependency tree
+      def tree(prefix = "", visited = Set.new)
+        return "#{prefix}#{name} (circular)\n" if visited.include?(self)
+
+        visited = visited.dup
+        visited << self
+
+        result = "#{prefix}#{name}\n"
+
+        dependencies = (@dependencies || []).uniq { |dep| extract_class(dep) }
+        dependencies.each_with_index do |dep, index|
+          dep_class = extract_class(dep)
+          is_last = index == dependencies.length - 1
+
+          connector = is_last ? "└── " : "├── "
+          child_prefix = prefix + (is_last ? "    " : "│   ")
+
+          # For the dependency itself, we want to use the connector
+          # For its children, we want to use the child_prefix
+          dep_tree = dep_class.tree(child_prefix, visited)
+          # Replace the first line (which has child_prefix) with the proper connector
+          dep_lines = dep_tree.lines
+          if dep_lines.any?
+            # Replace the first line prefix with connector
+            first_line = dep_lines[0]
+            fixed_first_line = first_line.sub(/^#{Regexp.escape(child_prefix)}/, prefix + connector)
+            result += fixed_first_line
+            # Add the rest of the lines as-is
+            result += dep_lines[1..].join if dep_lines.length > 1
+          else
+            result += "#{prefix}#{connector}#{dep_class.name}\n"
+          end
+        end
+
+        result
+      end
+
+      private
+
+      include Utils::DependencyUtils
+      private :extract_class
     end
 
     # === Instance Methods ===
@@ -51,10 +96,16 @@ module Taski
       raise NotImplementedError, "You must implement the build method in your task class"
     end
 
+    # Access build arguments passed to parametrized builds
+    # @return [Hash] Build arguments or empty hash if none provided
+    def build_args
+      @build_args || {}
+    end
+
     # Clean method with default empty implementation
     # Subclasses can override this method to implement cleanup logic
     def clean
       # Default implementation does nothing
     end
   end
-end
+end

data/lib/taski/task/define_api.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Taski
   class Task
     class << self
@@ -18,6 +16,9 @@ module Taski
         @dependencies ||= []
         @definitions ||= {}
 
+        # Ensure ref method is defined first time define is called
+        create_ref_method_if_needed
+
         # Create method that tracks dependencies on first call
         create_tracking_method(name)
 
@@ -25,16 +26,37 @@ module Taski
         dependencies = analyze_define_dependencies(block)
 
         @dependencies += dependencies
-        @definitions[name] = { block:, options:, classes: dependencies }
+        @definitions[name] = {block:, options:, classes: dependencies}
       end
 
       private
 
       # === Define API Implementation ===
 
+      # Create ref method if needed to avoid redefinition warnings
+      def create_ref_method_if_needed
+        return if method_defined_for_define?(:ref)
+
+        define_singleton_method(:ref) do |klass_name|
+          # During dependency analysis, track as dependency but defer resolution
+          if Thread.current[TASKI_ANALYZING_DEFINE_KEY]
+            # Create Reference object for deferred resolution
+            reference = Taski::Reference.new(klass_name)
+
+            # Track as dependency by throwing unresolved
+            throw :unresolved, [reference, :deref]
+          else
+            # At runtime, resolve to actual class
+            Object.const_get(klass_name)
+          end
+        end
+        mark_method_as_defined(:ref)
+      end
+
       # Create method that tracks dependencies for define API
       # @param name [Symbol] Method name to create
       def create_tracking_method(name)
+        # Only create tracking method during dependency analysis
         class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def self.#{name}
             __resolve__[__callee__] ||= false
@@ -65,12 +87,16 @@ module Taski
 
           break if klass.nil?
 
-          classes << { klass:, task: }
+          classes << {klass:, task:}
         end
 
         # Reset resolution state
         classes.each do |task_class|
-          task_class[:klass].instance_variable_set(:@__resolve__, {})
+          klass = task_class[:klass]
+          # Only reset Task classes, not Reference objects
+          if klass.respond_to?(:instance_variable_set) && !klass.is_a?(Taski::Reference)
+            klass.instance_variable_set(:@__resolve__, {})
+          end
         end
 
         classes
@@ -90,6 +116,9 @@ module Taski
       # @param name [Symbol] Method name
       # @param definition [Hash] Method definition information
       def create_defined_method(name, definition)
+        # Remove tracking method first to avoid redefinition warnings
+        singleton_class.undef_method(name) if singleton_class.method_defined?(name)
+
         # Class method with lazy evaluation
         define_singleton_method(name) do
           @__defined_values ||= {}
@@ -101,7 +130,7 @@ module Taski
           @__defined_values ||= {}
           @__defined_values[name] ||= self.class.send(name)
         end
-        
+
         # Mark as defined for this resolution
         mark_method_as_defined(name)
       end
@@ -122,4 +151,4 @@ module Taski
       end
     end
   end
-end
+end

data/lib/taski/task/dependency_resolver.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative '../dependency_analyzer'
+require_relative "../dependency_analyzer"
 
 module Taski
   class Task
@@ -23,12 +22,6 @@ module Taski
           queue << task_class
         end
 
-        # Override ref method after resolution for define API compatibility
-        # Note: This may cause "method redefined" warnings, which is expected behavior
-        if (@definitions && !@definitions.empty?) && !method_defined_for_define?(:ref)
-          define_singleton_method(:ref) { |klass| Object.const_get(klass) }
-        end
-
         # Create getter methods for defined values
         create_defined_methods
 
@@ -42,6 +35,7 @@ module Taski
         resolved = []
         visited = Set.new
         resolving = Set.new  # Track currently resolving tasks
+        path_map = {self => []}  # Track paths to each task
 
         while queue.any?
           task_class = queue.shift
@@ -49,12 +43,26 @@ module Taski
 
           # Check for circular dependency
           if resolving.include?(task_class)
-            raise CircularDependencyError, "Circular dependency detected involving #{task_class.name}"
+            # Build error message with path information
+            cycle_path = build_cycle_path(task_class, path_map)
+            raise CircularDependencyError, build_circular_dependency_message(cycle_path)
           end
 
           resolving << task_class
           visited << task_class
+
+          # Store current path for dependencies
+          current_path = path_map[task_class] || []
+
+          # Let task resolve its dependencies
           task_class.resolve(queue, resolved)
+
+          # Track paths for each dependency
+          task_class.instance_variable_get(:@dependencies)&.each do |dep|
+            dep_class = extract_class(dep)
+            path_map[dep_class] = current_path + [task_class] unless path_map.key?(dep_class)
+          end
+
           resolving.delete(task_class)
           resolved << task_class unless resolved.include?(task_class)
         end
@@ -62,6 +70,21 @@ module Taski
         resolved
       end
 
+      private
+
+      # Build the cycle path from path tracking information
+      def build_cycle_path(task_class, path_map)
+        path = path_map[task_class] || []
+        path + [task_class]
+      end
+
+      # Build detailed error message for circular dependencies
+      def build_circular_dependency_message(cycle_path)
+        Utils::CircularDependencyHelpers.build_error_message(cycle_path, "dependency")
+      end
+
+      public
+
       # === Static Analysis ===
 
       # Analyze dependencies when methods are defined
@@ -91,7 +114,7 @@ module Taski
       # @param dep_class [Class] Dependency class to add
       def add_dependency(dep_class)
         @dependencies ||= []
-        @dependencies << { klass: dep_class }
+        @dependencies << {klass: dep_class}
       end
 
       # Check if dependency already exists
@@ -100,6 +123,11 @@ module Taski
       def dependency_exists?(dep_class)
         (@dependencies || []).any? { |d| d[:klass] == dep_class }
       end
+
+      private
+
+      include Utils::DependencyUtils
+      private :extract_class
     end
   end
-end
+end

data/lib/taski/task/exports_api.rb

@@ -28,4 +28,4 @@ module Taski
       end
     end
   end
-end
+end