taski 0.2.3 → 0.3.0

data/lib/taski/logger.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "logging/formatter_factory"
+
 module Taski
   # Enhanced logging functionality for Taski framework
   # Provides structured logging with multiple levels and context information
@@ -13,7 +15,7 @@ module Taski
     def initialize(level: :info, output: $stdout, format: :structured)
       @level = level
       @output = output
-      @format = format
+      @formatter = Logging::FormatterFactory.create(format)
       @start_time = Time.now
     end
 
@@ -103,21 +105,15 @@ module Taski
 
     private
 
-    # Core logging method
+    # Core logging method using Strategy Pattern
     # @param level [Symbol] Log level
     # @param message [String] Log message
     # @param context [Hash] Additional context
     def log(level, message, context)
       return unless should_log?(level)
 
-      case @format
-      when :simple
-        log_simple(level, message, context)
-      when :structured
-        log_structured(level, message, context)
-      when :json
-        log_json(level, message, context)
-      end
+      formatted_line = @formatter.format(level, message, context, @start_time)
+      @output.puts formatted_line
     end
 
     # Check if message should be logged based on current level
@@ -126,57 +122,6 @@ module Taski
     def should_log?(level)
       LEVELS[@level] <= LEVELS[level]
     end
-
-    # Simple log format: [LEVEL] message
-    def log_simple(level, message, context)
-      @output.puts "[#{level.upcase}] #{message}"
-    end
-
-    # Structured log format with timestamp and context
-    def log_structured(level, message, context)
-      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
-      elapsed = ((Time.now - @start_time) * 1000).round(1)
-
-      line = "[#{timestamp}] [#{elapsed}ms] #{level.to_s.upcase.ljust(5)} Taski: #{message}"
-
-      unless context.empty?
-        context_parts = context.map do |key, value|
-          "#{key}=#{format_value(value)}"
-        end
-        line += " (#{context_parts.join(", ")})"
-      end
-
-      @output.puts line
-    end
-
-    # JSON log format for structured logging systems
-    def log_json(level, message, context)
-      require "json"
-
-      log_entry = {
-        timestamp: Time.now.iso8601(3),
-        level: level.to_s,
-        logger: "taski",
-        message: message,
-        elapsed_ms: ((Time.now - @start_time) * 1000).round(1)
-      }.merge(context)
-
-      @output.puts JSON.generate(log_entry)
-    end
-
-    # Format values for structured logging
-    def format_value(value)
-      case value
-      when String
-        (value.length > 50) ? "#{value[0..47]}..." : value
-      when Array
-        (value.size > 5) ? "[#{value[0..4].join(", ")}, ...]" : value.inspect
-      when Hash
-        (value.size > 3) ? "{#{value.keys[0..2].join(", ")}, ...}" : value.inspect
-      else
-        value.inspect
-      end
-    end
   end
 
   class << self
@@ -189,7 +134,7 @@ module Taski
     # Get the current progress display instance (always enabled)
     # @return [ProgressDisplay] Current progress display instance
     def progress_display
-      @progress_display ||= ProgressDisplay.new(force_enable: ENV["TASKI_FORCE_PROGRESS"] == "1")
+      @progress_display ||= ProgressDisplay.new
     end
 
     # Configure the logger with new settings

data/lib/taski/logging/formatter_factory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "simple_formatter"
+require_relative "structured_formatter"
+require_relative "json_formatter"
+
+module Taski
+  module Logging
+    # Factory for creating log formatters
+    class FormatterFactory
+      # Create a formatter instance based on format symbol
+      # @param format [Symbol] Format type (:simple, :structured, :json)
+      # @return [FormatterInterface] Formatter instance
+      def self.create(format)
+        case format
+        when :simple
+          SimpleFormatter.new
+        when :structured
+          StructuredFormatter.new
+        when :json
+          JsonFormatter.new
+        else
+          raise ArgumentError, "Unknown format: #{format}. Valid formats: :simple, :structured, :json"
+        end
+      end
+
+      # Get list of available formats
+      # @return [Array<Symbol>] Available format symbols
+      def self.available_formats
+        [:simple, :structured, :json]
+      end
+    end
+  end
+end

data/lib/taski/logging/formatter_interface.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Taski
+  module Logging
+    # Interface for log formatters
+    # All formatters must implement the format method
+    module FormatterInterface
+      # Format a log entry
+      # @param level [Symbol] Log level (:debug, :info, :warn, :error)
+      # @param message [String] Log message
+      # @param context [Hash] Additional context information
+      # @param start_time [Time] Logger start time for elapsed calculation
+      # @return [String] Formatted log line
+      def format(level, message, context, start_time)
+        raise NotImplementedError, "Subclass must implement format method"
+      end
+    end
+  end
+end

data/lib/taski/logging/json_formatter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # JSON log formatter for structured logging systems
+    class JsonFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        require "json"
+
+        log_entry = {
+          timestamp: Time.now.iso8601(3),
+          level: level.to_s,
+          logger: "taski",
+          message: message,
+          elapsed_ms: ((Time.now - start_time) * 1000).round(1)
+        }.merge(context)
+
+        JSON.generate(log_entry)
+      end
+    end
+  end
+end

data/lib/taski/logging/simple_formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # Simple log formatter: [LEVEL] message
+    class SimpleFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        "[#{level.upcase}] #{message}"
+      end
+    end
+  end
+end

data/lib/taski/logging/structured_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "formatter_interface"
+
+module Taski
+  module Logging
+    # Structured log formatter with timestamp and context
+    class StructuredFormatter
+      include FormatterInterface
+
+      def format(level, message, context, start_time)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%3N")
+        elapsed = ((Time.now - start_time) * 1000).round(1)
+
+        line = "[#{timestamp}] [#{elapsed}ms] #{level.to_s.upcase.ljust(5)} Taski: #{message}"
+
+        unless context.empty?
+          context_parts = context.map do |key, value|
+            "#{key}=#{format_value(value)}"
+          end
+          line += " (#{context_parts.join(", ")})"
+        end
+
+        line
+      end
+
+      private
+
+      # Format values for structured logging
+      def format_value(value)
+        case value
+        when String
+          (value.length > 50) ? "#{value[0..47]}..." : value
+        when Array
+          (value.size > 5) ? "[#{value[0..4].join(", ")}, ...]" : value.inspect
+        when Hash
+          (value.size > 3) ? "{#{value.keys[0..2].join(", ")}, ...}" : value.inspect
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/display_colors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # Color constants for progress display
+    module DisplayColors
+      COLORS = {
+        reset: "\033[0m",
+        bold: "\033[1m",
+        dim: "\033[2m",
+        cyan: "\033[36m",
+        green: "\033[32m",
+        red: "\033[31m"
+      }.freeze
+    end
+  end
+end

data/lib/taski/progress/display_manager.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "task_status"
+require_relative "task_formatter"
+
+module Taski
+  module Progress
+    # Manages the display state and coordinates display updates
+    class DisplayManager
+      def initialize(terminal, spinner, output_capture, include_captured_output: false)
+        @terminal = terminal
+        @spinner = spinner
+        @output_capture = output_capture
+        @include_captured_output = include_captured_output
+        @formatter = TaskFormatter.new
+        @completed_tasks = []
+        @current_display_lines = 0
+      end
+
+      def start_task_display(task_name)
+        clear_current_display
+        @output_capture.start
+        start_spinner_display(task_name)
+      end
+
+      def complete_task_display(task_name, duration:)
+        status = TaskStatus.new(name: task_name, duration: duration)
+        finish_task_display(status)
+      end
+
+      def fail_task_display(task_name, error:, duration:)
+        status = TaskStatus.new(name: task_name, duration: duration, error: error)
+        finish_task_display(status)
+      end
+
+      def clear_all_displays
+        @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 @formatter.format_completed_task(status)
+          end
+          @terminal.flush
+        end
+
+        @completed_tasks.clear
+        @current_display_lines = 0
+      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 @formatter.format_current_task(spinner_char, task_name)
+        lines_count += 1
+
+        # Display output lines
+        @output_capture.last_lines.each do |line|
+          @terminal.puts @formatter.format_output_line(line)
+          lines_count += 1
+        end
+
+        @current_display_lines = lines_count
+        @terminal.flush
+      end
+
+      def finish_task_display(status)
+        @spinner.stop
+
+        # Capture output before stopping
+        captured_output = @output_capture.last_lines
+        @output_capture.stop
+        clear_current_display
+
+        # Include captured output if requested (typically for test environments)
+        if @include_captured_output && 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 @formatter.format_completed_task(latest_task)
+        end
+        @terminal.flush
+        @current_display_lines = 1  # Only one line for the latest task
+      end
+
+      def clear_current_display
+        @terminal.clear_lines(@current_display_lines)
+        @current_display_lines = 0
+      end
+    end
+  end
+end

data/lib/taski/progress/output_capture.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # 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
+  end
+end

data/lib/taski/progress/spinner_animation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # 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
+  end
+end

data/lib/taski/progress/task_formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "display_colors"
+
+module Taski
+  module Progress
+    # Handles formatting of task display messages
+    class TaskFormatter
+      include DisplayColors
+
+      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
+    end
+  end
+end

data/lib/taski/progress/task_status.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # 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
+  end
+end

data/lib/taski/progress/terminal_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # 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
+  end
+end