taski 0.2.3 → 0.3.1

data/lib/taski/progress_display.rb

@@ -1,356 +1,57 @@
 # frozen_string_literal: true
 
-require "stringio"
+require_relative "progress/terminal_controller"
+require_relative "progress/spinner_animation"
+require_relative "progress/output_capture"
+require_relative "progress/display_manager"
 
 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}"
+  # Backward compatibility aliases
+  TerminalController = Progress::TerminalController
+  SpinnerAnimation = Progress::SpinnerAnimation
+  OutputCapture = Progress::OutputCapture
+  TaskStatus = Progress::TaskStatus
 
-    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
+  # Main progress display controller - refactored for better separation of concerns
   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)
+    def initialize(output: $stdout, enable: true, include_captured_output: nil)
       @output = output
-      @terminal = TerminalController.new(output)
-      @spinner = SpinnerAnimation.new
-      @output_capture = OutputCapture.new(output)
+      @terminal = Progress::TerminalController.new(output)
+      @spinner = Progress::SpinnerAnimation.new
+      @output_capture = Progress::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
+      include_captured_output = include_captured_output.nil? ? (output != $stdout) : include_captured_output
+      @display_manager = Progress::DisplayManager.new(@terminal, @spinner, @output_capture, include_captured_output: include_captured_output)
 
-      @completed_tasks = []
-      @current_display_lines = 0
+      @enabled = ENV["TASKI_PROGRESS_DISABLE"] != "1" && enable
     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)
+      @display_manager.start_task_display(task_name)
     end
 
     def complete_task(task_name, duration:)
       return unless @enabled
 
-      status = TaskStatus.new(name: task_name, duration: duration)
-      finish_task(status)
+      @display_manager.complete_task_display(task_name, duration: duration)
     end
 
     def fail_task(task_name, error:, duration:)
       return unless @enabled
 
-      status = TaskStatus.new(name: task_name, duration: duration, error: error)
-      finish_task(status)
+      @display_manager.fail_task_display(task_name, error: error, duration: duration)
     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
+      @display_manager.clear_all_displays
     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/section.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require_relative "dependency_analyzer"
+require_relative "utils"
+require_relative "utils/tree_display_helper"
+require_relative "utils/dependency_resolver_helper"
+
+module Taski
+  # Section provides an interface abstraction layer for dynamic implementation selection
+  # while maintaining static analysis capabilities
+  class Section
+    class << self
+      # === Dependency Resolution ===
+
+      # Resolve method for dependency graph (called by resolve_dependencies)
+      # @param queue [Array] Queue of tasks to process
+      # @param resolved [Array] Array of resolved tasks
+      # @return [self] Returns self for method chaining
+      def resolve(queue, resolved)
+        resolve_common(queue, resolved)
+      end
+
+      # Resolve all dependencies in topological order
+      # @return [Array<Class>] Array of tasks in dependency order
+      def resolve_dependencies
+        resolve_dependencies_common
+      end
+
+      # Analyze dependencies when accessing interface methods
+      def analyze_dependencies_for_interfaces
+        interface_exports.each do |interface_method|
+          dependencies = gather_static_dependencies_for_interface(interface_method)
+          add_unique_dependencies(dependencies)
+        end
+      end
+
+      private
+
+      # Gather dependencies from interface method implementation
+      def gather_static_dependencies_for_interface(interface_method)
+        # For sections, we analyze the impl method
+        # Try instance method first, then class method
+        if impl_defined?
+          # For instance method, we can't analyze dependencies statically
+          # So we return empty array
+          []
+        else
+          DependencyAnalyzer.analyze_method(self, :impl)
+        end
+      end
+
+      # Add dependencies that don't already exist
+      def add_unique_dependencies(dep_classes)
+        dep_classes.each do |dep_class|
+          next if dep_class == self || dependency_exists?(dep_class)
+          add_dependency(dep_class)
+        end
+      end
+
+      # Add a single dependency
+      def add_dependency(dep_class)
+        @dependencies ||= []
+        @dependencies << {klass: dep_class}
+      end
+
+      # Check if dependency already exists
+      def dependency_exists?(dep_class)
+        (@dependencies || []).any? { |d| d[:klass] == dep_class }
+      end
+
+      # Extract class from dependency specification
+      def extract_class(task)
+        case task
+        when Class
+          task
+        when Hash
+          task[:klass]
+        else
+          task
+        end
+      end
+
+      public
+
+      # === Instance Management (minimal for Section) ===
+
+      # Ensure section is available (no actual building needed)
+      # @return [self] Returns self for compatibility with Task interface
+      def ensure_instance_built
+        self
+      end
+
+      # Build method for compatibility (Section doesn't build instances)
+      # @param args [Hash] Optional arguments (ignored for sections)
+      # @return [self] Returns self
+      def build(**args)
+        self
+      end
+
+      # Reset method for compatibility (Section doesn't have state to reset)
+      # @return [self] Returns self
+      def reset!
+        self
+      end
+
+      # Display dependency tree for this section
+      # @param prefix [String] Current indentation prefix
+      # @param visited [Set] Set of visited classes to prevent infinite loops
+      # @param color [Boolean] Whether to use color output
+      # @return [String] Formatted dependency tree
+      def tree(prefix = "", visited = Set.new, color: TreeColors.enabled?)
+        should_return_early, early_result, new_visited = handle_circular_dependency_check(visited, self, prefix)
+        return early_result if should_return_early
+
+        # Get section name with fallback for anonymous classes
+        section_name = name || to_s
+        colored_section_name = color ? TreeColors.section(section_name) : section_name
+        result = "#{prefix}#{colored_section_name}\n"
+
+        # Add possible implementations - detect from nested Task classes
+        possible_implementations = find_possible_implementations
+        if possible_implementations.any?
+          impl_names = possible_implementations.map { |impl| extract_implementation_name(impl) }
+          impl_text = "[One of: #{impl_names.join(", ")}]"
+          colored_impl_text = color ? TreeColors.implementations(impl_text) : impl_text
+          connector = color ? TreeColors.connector("└── ") : "└── "
+          result += "#{prefix}#{connector}#{colored_impl_text}\n"
+        end
+
+        dependencies = @dependencies || []
+        result += render_dependencies_tree(dependencies, prefix, new_visited, color)
+
+        result
+      end
+
+      # Define interface methods for this section
+      def interface(*names)
+        if names.empty?
+          raise ArgumentError, "interface requires at least one method name"
+        end
+
+        @interface_exports = names
+
+        # Create accessor methods for each interface name
+        names.each do |name|
+          define_singleton_method(name) do
+            # Get implementation class
+            implementation_class = get_implementation_class
+
+            # Check if implementation is nil
+            if implementation_class.nil?
+              raise SectionImplementationError,
+                "impl returned nil. " \
+                "Make sure impl returns a Task class."
+            end
+
+            # Validate that it's a Task class
+            unless implementation_class.is_a?(Class) && implementation_class < Taski::Task
+              raise SectionImplementationError,
+                "impl must return a Task class, got #{implementation_class.class}. " \
+                "Make sure impl returns a class that inherits from Taski::Task."
+            end
+
+            # Build the implementation and call the method
+            implementation = implementation_class.build
+
+            begin
+              implementation.send(name)
+            rescue NoMethodError
+              raise SectionImplementationError,
+                "Implementation does not provide required method '#{name}'. " \
+                "Make sure the implementation class has a '#{name}' method or " \
+                "exports :#{name} declaration."
+            end
+          end
+        end
+
+        # Automatically apply exports to existing nested Task classes
+        auto_apply_exports_to_existing_tasks
+      end
+
+      # Get the interface exports for this section
+      def interface_exports
+        @interface_exports || []
+      end
+
+      # Check if impl method is defined (as instance method)
+      def impl_defined?
+        instance_methods(false).include?(:impl)
+      end
+
+      # Get implementation class from instance method
+      def get_implementation_class
+        if impl_defined?
+          # Create a temporary instance to call impl method
+          allocate.impl
+        else
+          # Fall back to class method if exists
+          impl
+        end
+      end
+
+      # Override const_set to auto-add exports to nested Task classes
+      def const_set(name, value)
+        result = super
+
+        # If the constant is a Task class and we have interface exports,
+        # automatically add exports to avoid duplication
+        if value.is_a?(Class) && value < Taski::Task && !interface_exports.empty?
+          # Add exports declaration to the nested task
+          exports_list = interface_exports
+          value.class_eval do
+            exports(*exports_list)
+          end
+        end
+
+        result
+      end
+
+      private
+
+      # Automatically apply exports to existing nested Task classes when interface is defined
+      def auto_apply_exports_to_existing_tasks
+        constants.each do |const_name|
+          const_value = const_get(const_name)
+          if const_value.is_a?(Class) && const_value < Taski::Task && !interface_exports.empty?
+            exports_list = interface_exports
+            const_value.class_eval do
+              exports(*exports_list) unless @exports_defined
+              @exports_defined = true
+            end
+          end
+        end
+      end
+
+      # Find possible implementation classes by scanning nested Task classes
+      def find_possible_implementations
+        task_classes = []
+        constants.each do |const_name|
+          const_value = const_get(const_name)
+          if task_class?(const_value)
+            task_classes << const_value
+          end
+        end
+        task_classes
+      end
+
+      # Extract readable name from implementation class
+      def extract_implementation_name(impl_class)
+        class_name = impl_class.name
+        return impl_class.to_s unless class_name&.include?("::")
+
+        class_name.split("::").last
+      end
+
+      # Check if a constant value is a Task class
+      def task_class?(const_value)
+        const_value.is_a?(Class) && const_value < Taski::Task
+      end
+
+      private
+
+      include Utils::TreeDisplayHelper
+      include Utils::DependencyResolverHelper
+
+      # Subclasses should override this method to select appropriate implementation
+      def impl
+        raise NotImplementedError, "Subclass must implement impl"
+      end
+    end
+  end
+end