taski 0.3.0 → 0.4.0

data/lib/taski/logger.rb

@@ -1,158 +0,0 @@
-# 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
-  class Logger
-    # Log levels in order of severity
-    LEVELS = {debug: 0, info: 1, warn: 2, error: 3}.freeze
-
-    # @param level [Symbol] Minimum log level to output (:debug, :info, :warn, :error)
-    # @param output [IO] Output destination (default: $stdout)
-    # @param format [Symbol] Log format (:simple, :structured, :json)
-    def initialize(level: :info, output: $stdout, format: :structured)
-      @level = level
-      @output = output
-      @formatter = Logging::FormatterFactory.create(format)
-      @start_time = Time.now
-    end
-
-    # Log debug message with optional context
-    # @param message [String] Log message
-    # @param context [Hash] Additional context information
-    def debug(message, **context)
-      log(:debug, message, context)
-    end
-
-    # Log info message with optional context
-    # @param message [String] Log message
-    # @param context [Hash] Additional context information
-    def info(message, **context)
-      log(:info, message, context)
-    end
-
-    # Log warning message with optional context
-    # @param message [String] Log message
-    # @param context [Hash] Additional context information
-    def warn(message, **context)
-      log(:warn, message, context)
-    end
-
-    # Log error message with optional context
-    # @param message [String] Log message
-    # @param context [Hash] Additional context information
-    def error(message, **context)
-      log(:error, message, context)
-    end
-
-    # Log task build start event
-    # @param task_name [String] Name of the task being built
-    # @param dependencies [Array] List of task dependencies
-    # @param args [Hash] Build arguments for parametrized builds
-    def task_build_start(task_name, dependencies: [], args: nil)
-      context = {
-        task: task_name,
-        dependencies: dependencies.size,
-        dependency_names: dependencies.map { |dep| dep.is_a?(Hash) ? dep[:klass].inspect : dep.inspect }
-      }
-      context[:args] = args if args && !args.empty?
-
-      info("Task build started", **context)
-    end
-
-    # Log task build completion event
-    # @param task_name [String] Name of the task that was built
-    # @param duration [Float] Build duration in seconds
-    def task_build_complete(task_name, duration: nil)
-      context = {task: task_name}
-      context[:duration_ms] = (duration * 1000).round(2) if duration
-      info("Task build completed", **context)
-    end
-
-    # Log task build failure event
-    # @param task_name [String] Name of the task that failed
-    # @param error [Exception] The error that occurred
-    # @param duration [Float] Duration before failure in seconds
-    def task_build_failed(task_name, error:, duration: nil)
-      context = {
-        task: task_name,
-        error_class: error.class.name,
-        error_message: error.message
-      }
-      context[:duration_ms] = (duration * 1000).round(2) if duration
-      context[:backtrace] = error.backtrace&.first(3) if error.backtrace
-      error("Task build failed", **context)
-    end
-
-    # Log dependency resolution event
-    # @param task_name [String] Name of the task resolving dependencies
-    # @param resolved_count [Integer] Number of dependencies resolved
-    def dependency_resolved(task_name, resolved_count:)
-      debug("Dependencies resolved",
-        task: task_name,
-        resolved_dependencies: resolved_count)
-    end
-
-    # Log circular dependency detection
-    # @param cycle_path [Array] The circular dependency path
-    def circular_dependency_detected(cycle_path)
-      error("Circular dependency detected",
-        cycle: cycle_path.map { |klass| klass.name || klass.inspect },
-        cycle_length: cycle_path.size)
-    end
-
-    private
-
-    # 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)
-
-      formatted_line = @formatter.format(level, message, context, @start_time)
-      @output.puts formatted_line
-    end
-
-    # Check if message should be logged based on current level
-    # @param level [Symbol] Message level to check
-    # @return [Boolean] True if message should be logged
-    def should_log?(level)
-      LEVELS[@level] <= LEVELS[level]
-    end
-  end
-
-  class << self
-    # Get the current logger instance
-    # @return [Logger] Current logger instance
-    def logger
-      @logger ||= Logger.new
-    end
-
-    # Get the current progress display instance (always enabled)
-    # @return [ProgressDisplay] Current progress display instance
-    def progress_display
-      @progress_display ||= ProgressDisplay.new
-    end
-
-    # Configure the logger with new settings
-    # @param level [Symbol] Log level (:debug, :info, :warn, :error)
-    # @param output [IO] Output destination
-    # @param format [Symbol] Log format (:simple, :structured, :json)
-    def configure_logger(level: :info, output: $stdout, format: :structured)
-      @logger = Logger.new(level: level, output: output, format: format)
-    end
-
-    # Set logger to quiet mode (only errors)
-    def quiet!
-      @logger = Logger.new(level: :error, output: @logger&.instance_variable_get(:@output) || $stdout)
-    end
-
-    # Set logger to verbose mode (all messages)
-    def verbose!
-      @logger = Logger.new(level: :debug, output: @logger&.instance_variable_get(:@output) || $stdout)
-    end
-  end
-end

data/lib/taski/logging/formatter_factory.rb

@@ -1,34 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,115 +0,0 @@
-# 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

@@ -1,105 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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