taski 0.2.1 → 0.2.3

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/task/base.rb

@@ -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,6 +96,12 @@ 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

data/lib/taski/task/define_api.rb

@@ -37,7 +37,19 @@ module Taski
       def create_ref_method_if_needed
         return if method_defined_for_define?(:ref)
 
-        define_singleton_method(:ref) { |klass| Object.const_get(klass) }
+        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
 
@@ -80,7 +92,11 @@ module Taski
 
         # 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

data/lib/taski/task/dependency_resolver.rb

@@ -80,17 +80,7 @@ module Taski
 
       # Build detailed error message for circular dependencies
       def build_circular_dependency_message(cycle_path)
-        path_names = cycle_path.map { |klass| klass.name || klass.to_s }
-
-        message = "Circular dependency detected!\n"
-        message += "Cycle: #{path_names.join(" → ")}\n\n"
-        message += "Detailed dependency chain:\n"
-
-        cycle_path.each_cons(2).with_index do |(from, to), index|
-          message += "  #{index + 1}. #{from.name} depends on → #{to.name}\n"
-        end
-
-        message
+        Utils::CircularDependencyHelpers.build_error_message(cycle_path, "dependency")
       end
 
       public
@@ -133,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

data/lib/taski/task/instance_management.rb

@@ -8,9 +8,19 @@ module Taski
       # === Lifecycle Management ===
 
       # Build this task and all its dependencies
-      def build
-        resolve_dependencies.reverse_each do |task_class|
-          task_class.ensure_instance_built
+      # @param args [Hash] Optional arguments for parametrized builds
+      # @return [Task] Returns task instance (singleton or temporary)
+      def build(**args)
+        if args.empty?
+          # Traditional build: singleton instance with caching
+          resolve_dependencies.reverse_each do |task_class|
+            task_class.ensure_instance_built
+          end
+          # Return the singleton instance for consistency
+          instance_variable_get(:@__task_instance)
+        else
+          # Parametrized build: temporary instance without caching
+          build_with_args(args)
         end
       end
 
@@ -41,6 +51,32 @@ module Taski
         reset!
       end
 
+      # === Parametrized Build Support ===
+
+      # Build temporary instance with arguments
+      # @param args [Hash] Build arguments
+      # @return [Task] Temporary task instance
+      def build_with_args(args)
+        # Resolve dependencies first (same as normal build)
+        resolve_dependencies.reverse_each do |task_class|
+          task_class.ensure_instance_built
+        end
+
+        # Create temporary instance with arguments
+        temp_instance = new
+        temp_instance.instance_variable_set(:@build_args, args)
+
+        # Build with logging using common utility
+        Utils::TaskBuildHelpers.with_build_logging(name.to_s,
+          dependencies: @dependencies || [],
+          args: args) do
+          temp_instance.build
+          temp_instance
+        end
+      end
+
+      private :build_with_args
+
       # === Instance Management ===
 
       # Ensure task instance is built (public because called from build)
@@ -93,18 +129,10 @@ module Taski
       # @return [Task] Built task instance
       def build_instance
         instance = new
-        build_start_time = Time.now
-        begin
-          Taski.logger.task_build_start(name.to_s, dependencies: @dependencies || [])
+        Utils::TaskBuildHelpers.with_build_logging(name.to_s,
+          dependencies: @dependencies || []) do
           instance.build
-          duration = Time.now - build_start_time
-          Taski.logger.task_build_complete(name.to_s, duration: duration)
           instance
-        rescue => e
-          duration = Time.now - build_start_time
-          # Log the error with full context
-          Taski.logger.task_build_failed(name.to_s, error: e, duration: duration)
-          raise TaskBuildError, "Failed to build task #{name}: #{e.message}"
         end
       end
 
@@ -129,6 +157,8 @@ module Taski
         end
       end
 
+      private
+
       # Build current dependency path from thread-local storage
       # @return [Array<Class>] Array of classes in the current build path
       def build_current_dependency_path
@@ -150,27 +180,11 @@ module Taski
       # @param cycle_path [Array<Class>] The circular dependency path
       # @return [String] Formatted error message
       def build_runtime_circular_dependency_message(cycle_path)
-        path_names = cycle_path.map { |klass| klass.name || klass.to_s }
-
-        message = "Circular dependency detected!\n"
-        message += "Cycle: #{path_names.join(" → ")}\n\n"
-        message += "The dependency chain is:\n"
-
-        cycle_path.each_cons(2).with_index do |(from, to), index|
-          message += "  #{index + 1}. #{from.name} is trying to build → #{to.name}\n"
-        end
-
-        message += "\nThis creates an infinite loop that cannot be resolved."
-        message
+        Utils::CircularDependencyHelpers.build_error_message(cycle_path, "runtime")
       end
 
-      # Extract class from dependency hash
-      # @param dep [Hash] Dependency information
-      # @return [Class] The dependency class
-      def extract_class(dep)
-        klass = dep[:klass]
-        klass.is_a?(Reference) ? klass.deref : klass
-      end
+      include Utils::DependencyUtils
+      private :extract_class
     end
   end
 end

data/lib/taski/utils.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Taski
+  # Common utility functions for the Taski framework
+  module Utils
+    # Handle circular dependency error message generation
+    module CircularDependencyHelpers
+      # Build detailed error message for circular dependencies
+      # @param cycle_path [Array<Class>] The circular dependency path
+      # @param context [String] Context of the error (dependency, runtime)
+      # @return [String] Formatted error message
+      def self.build_error_message(cycle_path, context = "dependency")
+        path_names = cycle_path.map { |klass| klass.name || klass.to_s }
+
+        message = "Circular dependency detected!\n"
+        message += "Cycle: #{path_names.join(" → ")}\n\n"
+        message += "The #{context} chain is:\n"
+
+        cycle_path.each_cons(2).with_index do |(from, to), index|
+          action = (context == "dependency") ? "depends on" : "is trying to build"
+          message += "  #{index + 1}. #{from.name} #{action} → #{to.name}\n"
+        end
+
+        message += "\nThis creates an infinite loop that cannot be resolved." if context == "dependency"
+        message
+      end
+    end
+
+    # Common dependency utility functions
+    module DependencyUtils
+      # Extract class from dependency hash
+      # @param dep [Hash] Dependency information
+      # @return [Class] The dependency class
+      def extract_class(dep)
+        klass = dep[:klass]
+        klass.is_a?(Reference) ? klass.deref : klass
+      end
+    end
+
+    # Common task build utility functions
+    module TaskBuildHelpers
+      # Format arguments hash for display in error messages
+      # @param args [Hash] Arguments hash
+      # @return [String] Formatted arguments string
+      def self.format_args(args)
+        return "" if args.nil? || args.empty?
+
+        formatted_pairs = args.map do |key, value|
+          "#{key}: #{value.inspect}"
+        end
+        "{#{formatted_pairs.join(", ")}}"
+      end
+
+      # Execute block with comprehensive build logging and progress display
+      # @param task_name [String] Name of the task being built
+      # @param dependencies [Array] List of dependencies
+      # @param args [Hash] Build arguments for parametrized builds
+      # @yield Block to execute with logging
+      # @return [Object] Result of the block execution
+      def self.with_build_logging(task_name, dependencies: [], args: nil)
+        build_start_time = Time.now
+
+        begin
+          # Traditional logging first (before any stdout redirection)
+          Taski.logger.task_build_start(task_name, dependencies: dependencies, args: args)
+
+          # Show progress display if enabled (this may redirect stdout)
+          Taski.progress_display&.start_task(task_name, dependencies: dependencies)
+
+          result = yield
+          duration = Time.now - build_start_time
+
+          # Complete progress display first (this restores stdout)
+          Taski.progress_display&.complete_task(task_name, duration: duration)
+
+          # Then do logging (on restored stdout)
+          begin
+            Taski.logger.task_build_complete(task_name, duration: duration)
+          rescue IOError
+            # If logger fails due to closed stream, write to STDERR instead
+            warn "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")}] INFO  Taski: Task build completed (task=#{task_name}, duration_ms=#{(duration * 1000).round(2)})"
+          end
+
+          result
+        rescue => e
+          duration = Time.now - build_start_time
+
+          # Complete progress display first (with error)
+          Taski.progress_display&.fail_task(task_name, error: e, duration: duration)
+
+          # Then do error logging (on restored stdout)
+          begin
+            Taski.logger.task_build_failed(task_name, error: e, duration: duration)
+          rescue IOError
+            # If logger fails due to closed stream, write to STDERR instead
+            warn "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")}] ERROR Taski: Task build failed (task=#{task_name}, error=#{e.message}, duration_ms=#{(duration * 1000).round(2)})"
+          end
+
+          error_message = "Failed to build task #{task_name}"
+          error_message += " with args #{format_args(args)}" if args && !args.empty?
+          error_message += ": #{e.message}"
+          raise TaskBuildError, error_message
+        end
+      end
+    end
+  end
+end