omnizip 0.3.1

data/lib/omnizip/profiler.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "models/performance_result"
+require_relative "models/profile_report"
+require_relative "models/optimization_suggestion"
+
+module Omnizip
+  # Main profiler interface using Strategy pattern for different profiling approaches
+  class Profiler
+    attr_reader :report, :enabled
+
+    def initialize(profile_name: "default", enabled: true)
+      @profile_name = profile_name
+      @enabled = enabled
+      @report = Models::ProfileReport.new(profile_name: profile_name)
+      @profilers = {}
+    end
+
+    # Register a profiler strategy
+    def register_profiler(name, profiler)
+      @profilers[name] = profiler
+    end
+
+    # Profile a block of code with the specified profiler strategy
+    def profile(operation_name, profiler_type: :method, &block)
+      return yield unless enabled
+
+      profiler = @profilers[profiler_type]
+      unless profiler
+        raise ArgumentError,
+              "Unknown profiler type: #{profiler_type}"
+      end
+
+      result = profiler.profile(operation_name, &block)
+      @report.add_result(result)
+      result
+    end
+
+    # Profile a method call with automatic naming
+    def profile_method(object, method_name, *args, profiler_type: :method,
+                       **kwargs)
+      operation_name = "#{object.class}##{method_name}"
+      profile(operation_name, profiler_type: profiler_type) do
+        object.public_send(method_name, *args, **kwargs)
+      end
+    end
+
+    # Analyze collected results and identify hot paths
+    def analyze_hot_paths(threshold_percentage: 10.0)
+      total_time = report.total_execution_time
+      return [] if total_time.zero?
+
+      threshold_time = total_time * (threshold_percentage / 100.0)
+
+      hot_operations = report.results.select do |result|
+        result.total_time && result.total_time >= threshold_time
+      end
+
+      hot_operations.each do |op|
+        @report.add_hot_path(
+          operation: op.operation_name,
+          time: op.total_time,
+          percentage: (op.total_time / total_time) * 100,
+        )
+      end
+
+      hot_operations
+    end
+
+    # Identify performance bottlenecks
+    def identify_bottlenecks
+      bottlenecks = []
+
+      # Memory bottlenecks
+      memory_intensive = report.memory_intensive_operations(limit: 3)
+      memory_intensive.each do |op|
+        bottlenecks << {
+          type: :memory,
+          operation: op.operation_name,
+          allocated: op.memory_allocated,
+          severity: calculate_memory_severity(op),
+        }
+        @report.add_bottleneck(bottlenecks.last)
+      end
+
+      # CPU bottlenecks
+      cpu_intensive = report.slowest_operations(limit: 3)
+      cpu_intensive.each do |op|
+        bottlenecks << {
+          type: :cpu,
+          operation: op.operation_name,
+          time: op.total_time,
+          severity: calculate_cpu_severity(op),
+        }
+        @report.add_bottleneck(bottlenecks.last)
+      end
+
+      # GC pressure bottlenecks
+      high_gc = report.results.select do |r|
+        r.gc_pressure && r.gc_pressure > 1.0
+      end
+      high_gc.each do |op|
+        bottlenecks << {
+          type: :gc,
+          operation: op.operation_name,
+          gc_pressure: op.gc_pressure,
+          severity: :high,
+        }
+        @report.add_bottleneck(bottlenecks.last)
+      end
+
+      bottlenecks
+    end
+
+    # Generate optimization suggestions based on profiling data
+    def generate_suggestions
+      # Analyze hot paths for optimization opportunities
+      suggestions = analyze_hot_paths.map do |hot_op|
+        Models::OptimizationSuggestion.new(
+          title: "Optimize hot path: #{hot_op.operation_name}",
+          description: "Operation consuming #{hot_op.total_time}s " \
+                       "(#{((hot_op.total_time / report.total_execution_time) * 100).round(1)}% of total time)",
+          severity: :high,
+          category: :hotpath,
+          impact_estimate: hot_op.total_time / report.total_execution_time,
+          related_operations: [hot_op.operation_name],
+          metrics: { time: hot_op.total_time },
+        )
+      end
+
+      # Analyze memory usage
+      report.memory_intensive_operations(limit: 3).each do |mem_op|
+        next unless mem_op.memory_allocated > 1_000_000 # > 1MB
+
+        suggestions << Models::OptimizationSuggestion.new(
+          title: "Reduce memory allocation: #{mem_op.operation_name}",
+          description: "Operation allocating #{format_bytes(mem_op.memory_allocated)}",
+          severity: calculate_memory_severity(mem_op),
+          category: :memory,
+          impact_estimate: mem_op.memory_allocated / report.total_memory_allocated.to_f,
+          related_operations: [mem_op.operation_name],
+          metrics: { memory_allocated: mem_op.memory_allocated },
+        )
+      end
+
+      suggestions.sort_by(&:priority_score).reverse
+    end
+
+    # Enable profiling
+    def enable!
+      @enabled = true
+    end
+
+    # Disable profiling
+    def disable!
+      @enabled = false
+    end
+
+    # Reset profiler state
+    def reset!
+      @report = Models::ProfileReport.new(profile_name: @profile_name)
+    end
+
+    private
+
+    def calculate_memory_severity(operation)
+      return :low unless operation.memory_allocated
+
+      mb = operation.memory_allocated / (1024.0 * 1024.0)
+      case mb
+      when 0...1 then :low
+      when 1...10 then :medium
+      when 10...50 then :high
+      else :critical
+      end
+    end
+
+    def calculate_cpu_severity(operation)
+      return :low unless operation.total_time
+
+      case operation.total_time
+      when 0...0.1 then :low
+      when 0.1...1.0 then :medium
+      when 1.0...5.0 then :high
+      else :critical
+      end
+    end
+
+    def format_bytes(bytes)
+      return "0 B" if bytes.zero?
+
+      units = %w[B KB MB GB]
+      size = bytes.to_f
+      unit_index = 0
+
+      while size >= 1024.0 && unit_index < units.size - 1
+        size /= 1024.0
+        unit_index += 1
+      end
+
+      format("%.2f %s", size, units[unit_index])
+    end
+  end
+end

data/lib/omnizip/progress/callback_reporter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "progress_reporter"
+
+module Omnizip
+  module Progress
+    # Progress reporter that calls a user-provided Ruby block.
+    #
+    # This reporter allows users to provide custom callbacks for
+    # progress updates, enabling integration with web frameworks,
+    # GUI applications, or custom logging systems.
+    class CallbackReporter < ProgressReporter
+      attr_reader :callback
+
+      # Initialize a new callback reporter
+      #
+      # @param callback [Proc] Block to call with progress updates
+      # @yield [progress] Yields progress tracker to the block
+      def initialize(&callback)
+        super()
+        @callback = callback || proc { |_| }
+      end
+
+      # Report progress by calling the callback
+      #
+      # @param progress [ProgressTracker] Progress tracker with current state
+      def report(progress)
+        callback.call(progress)
+      end
+    end
+  end
+end

data/lib/omnizip/progress/console_reporter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "progress_reporter"
+require_relative "progress_bar"
+
+module Omnizip
+  module Progress
+    # Progress reporter that displays a progress bar in the console.
+    #
+    # This reporter uses ProgressBar to render a visual progress bar
+    # in the terminal, with automatic TTY detection and color support.
+    class ConsoleReporter < ProgressReporter
+      attr_reader :progress_bar, :output
+
+      # Initialize a new console reporter
+      #
+      # @param output [IO] Output stream (default: $stdout)
+      # @param width [Integer] Bar width (auto-detect if nil)
+      # @param use_color [Boolean] Enable color output
+      def initialize(output: $stdout, width: nil, use_color: true)
+        super()
+        @output = output
+        @progress_bar = ProgressBar.new(width: width, use_color: use_color)
+        @started = false
+      end
+
+      # Report progress to console
+      #
+      # @param progress [ProgressTracker] Progress tracker with current state
+      def report(progress)
+        return unless output.tty?
+
+        @started = true
+        output.print progress_bar.render(progress)
+        output.flush
+      end
+
+      # Called when operation starts
+      #
+      # @param _progress [ProgressTracker] Progress tracker
+      def start(_progress)
+        @started = false
+      end
+
+      # Called when operation completes
+      #
+      # @param _progress [ProgressTracker] Progress tracker
+      def finish(_progress)
+        return unless output.tty? && @started
+
+        # Clear the progress bar and print newline
+        output.print progress_bar.clear
+        output.puts
+        output.flush
+      end
+    end
+  end
+end

data/lib/omnizip/progress/log_reporter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require_relative "progress_reporter"
+
+module Omnizip
+  module Progress
+    # Progress reporter that writes to a log file.
+    #
+    # This reporter writes timestamped progress updates to a log file,
+    # useful for debugging, auditing, or monitoring long-running operations.
+    class LogReporter < ProgressReporter
+      attr_reader :log_file, :verbose
+
+      # Initialize a new log reporter
+      #
+      # @param log_file [String, IO] Log file path or IO object
+      # @param verbose [Boolean] Include detailed information
+      def initialize(log_file:, verbose: false)
+        super()
+        @log_file = log_file.is_a?(String) ? File.open(log_file, "a") : log_file
+        @verbose = verbose
+        @owns_file = log_file.is_a?(String)
+      end
+
+      # Report progress to log file
+      #
+      # @param progress [ProgressTracker] Progress tracker with current state
+      def report(progress)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+
+        if verbose
+          log_file.puts format(
+            "[%s] Progress: %.1f%% (%d/%d files, %d/%d bytes) - %s - %s - ETA: %s",
+            timestamp,
+            progress.percentage,
+            progress.files_processed,
+            progress.operation_progress.total_files,
+            progress.bytes_processed,
+            progress.operation_progress.total_bytes,
+            progress.current_file || "unknown",
+            progress.rate_formatted,
+            progress.eta_formatted,
+          )
+        else
+          log_file.puts format(
+            "[%s] Progress: %.1f%% - %s",
+            timestamp,
+            progress.percentage,
+            progress.current_file || "processing",
+          )
+        end
+
+        log_file.flush
+      end
+
+      # Called when operation starts
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def start(progress)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        log_file.puts format(
+          "[%s] Started: %d files, %d bytes",
+          timestamp,
+          progress.operation_progress.total_files,
+          progress.operation_progress.total_bytes,
+        )
+        log_file.flush
+      end
+
+      # Called when operation completes
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def finish(progress)
+        timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        log_file.puts format(
+          "[%s] Completed in %.2fs",
+          timestamp,
+          progress.elapsed_seconds,
+        )
+        log_file.flush
+
+        # Close file if we opened it
+        log_file.close if @owns_file
+      end
+    end
+  end
+end

data/lib/omnizip/progress/operation_progress.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Progress
+    # Represents the current state of an operation's progress.
+    #
+    # This class stores all data about the current progress of an operation,
+    # including file counts, byte counts, current file being processed,
+    # and calculated percentages.
+    class OperationProgress
+      attr_reader :total_files, :total_bytes, :files_done, :bytes_done,
+                  :current_file, :start_time
+
+      # Initialize a new operation progress tracker
+      #
+      # @param total_files [Integer] Total number of files to process
+      # @param total_bytes [Integer] Total bytes to process
+      def initialize(total_files:, total_bytes:)
+        @total_files = total_files
+        @total_bytes = total_bytes
+        @files_done = 0
+        @bytes_done = 0
+        @current_file = nil
+        @start_time = Time.now
+      end
+
+      # Update progress with new values
+      #
+      # @param files [Integer] Number of files completed
+      # @param bytes [Integer] Number of bytes processed
+      # @param current_file [String] Name of file currently processing
+      def update(files:, bytes:, current_file: nil)
+        @files_done = files
+        @bytes_done = bytes
+        @current_file = current_file
+      end
+
+      # Calculate overall percentage complete
+      #
+      # @return [Float] Percentage complete (0.0-100.0)
+      def percentage
+        return 0.0 if total_bytes.zero?
+
+        (bytes_done.to_f / total_bytes * 100.0).round(1)
+      end
+
+      # Calculate percentage of files complete
+      #
+      # @return [Float] Percentage of files complete (0.0-100.0)
+      def files_percent
+        return 0.0 if total_files.zero?
+
+        (files_done.to_f / total_files * 100.0).round(1)
+      end
+
+      # Calculate percentage of bytes complete
+      #
+      # @return [Float] Percentage of bytes complete (0.0-100.0)
+      def bytes_percent
+        return 0.0 if total_bytes.zero?
+
+        (bytes_done.to_f / total_bytes * 100.0).round(1)
+      end
+
+      # Get elapsed time in seconds
+      #
+      # @return [Float] Seconds elapsed since start
+      def elapsed_seconds
+        Time.now - start_time
+      end
+
+      # Get remaining bytes to process
+      #
+      # @return [Integer] Bytes remaining
+      def remaining_bytes
+        total_bytes - bytes_done
+      end
+
+      # Get remaining files to process
+      #
+      # @return [Integer] Files remaining
+      def remaining_files
+        total_files - files_done
+      end
+
+      # Check if operation is complete
+      #
+      # @return [Boolean] true if all files and bytes processed
+      def complete?
+        files_done >= total_files && bytes_done >= total_bytes
+      end
+
+      # Get progress as hash for serialization
+      #
+      # @return [Hash] Progress data
+      def to_h
+        {
+          total_files: total_files,
+          total_bytes: total_bytes,
+          files_done: files_done,
+          bytes_done: bytes_done,
+          current_file: current_file,
+          percentage: percentage,
+          files_percent: files_percent,
+          bytes_percent: bytes_percent,
+          elapsed_seconds: elapsed_seconds,
+          remaining_bytes: remaining_bytes,
+          remaining_files: remaining_files,
+          complete: complete?,
+        }
+      end
+    end
+  end
+end

data/lib/omnizip/progress/progress_bar.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Progress
+    # Visual progress bar for terminal output.
+    #
+    # This class renders a progress bar with percentage, file counts,
+    # rate, and ETA information. It supports color output and automatic
+    # width detection.
+    class ProgressBar
+      attr_reader :width, :use_color
+
+      # Initialize a new progress bar
+      #
+      # @param width [Integer] Bar width in characters (auto-detect if nil)
+      # @param use_color [Boolean] Enable color output
+      def initialize(width: nil, use_color: true)
+        @width = width || detect_terminal_width
+        @use_color = use_color && color_supported?
+      end
+
+      # Render progress bar string
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      # @return [String] Formatted progress bar
+      def render(progress)
+        bar = build_bar(progress.percentage)
+        info = build_info(progress)
+
+        "\r#{bar} #{info}"
+      end
+
+      # Clear the progress bar line
+      #
+      # @return [String] Clear string
+      def clear
+        "\r#{' ' * width}\r"
+      end
+
+      private
+
+      # Build the progress bar component
+      #
+      # @param percentage [Float] Completion percentage (0.0-100.0)
+      # @return [String] Progress bar string
+      def build_bar(percentage)
+        bar_width = 20
+        filled = ((percentage / 100.0) * bar_width).round
+        empty = bar_width - filled
+
+        bar = "[#{'=' * filled}#{'>' if filled.positive?}#{' ' * [empty - 1,
+                                                                  0].max}]"
+
+        if use_color
+          colorize(bar, :green)
+        else
+          bar
+        end
+      end
+
+      # Build the info component (percentage, files, rate, ETA)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      # @return [String] Info string
+      def build_info(progress)
+        parts = []
+
+        # Percentage
+        parts << format("%3.0f%%", progress.percentage)
+
+        # File count
+        parts << format(
+          "(%d/%d files)",
+          progress.files_processed,
+          progress.operation_progress.total_files,
+        )
+
+        # Current file (truncate if too long)
+        if progress.current_file
+          filename = truncate_filename(progress.current_file, 30)
+          parts << filename
+        end
+
+        # Rate
+        parts << progress.rate_formatted if progress.rate_bps.positive?
+
+        # ETA
+        eta = progress.eta_formatted
+        parts << "ETA: #{eta}" unless eta == "calculating..."
+
+        parts.join(" - ")
+      end
+
+      # Truncate filename to fit width
+      #
+      # @param filename [String] Filename to truncate
+      # @param max_length [Integer] Maximum length
+      # @return [String] Truncated filename
+      def truncate_filename(filename, max_length)
+        return filename if filename.length <= max_length
+
+        "...#{filename[(-max_length + 3)..]}"
+      end
+
+      # Detect terminal width
+      #
+      # @return [Integer] Terminal width in characters
+      def detect_terminal_width
+        if ENV["COLUMNS"]
+          ENV["COLUMNS"].to_i
+        elsif $stdout.tty?
+          begin
+            require "io/console"
+            $stdout.winsize[1]
+          rescue LoadError, NoMethodError
+            80 # Default fallback
+          end
+        else
+          80
+        end
+      end
+
+      # Check if terminal supports color
+      #
+      # @return [Boolean] true if color is supported
+      def color_supported?
+        return false unless $stdout.tty?
+        return false if ENV["TERM"] == "dumb"
+
+        true
+      end
+
+      # Colorize string with ANSI color codes
+      #
+      # @param text [String] Text to colorize
+      # @param color [Symbol] Color name (:green, :yellow, :red, etc.)
+      # @return [String] Colorized string
+      def colorize(text, color)
+        color_codes = {
+          green: 32,
+          yellow: 33,
+          red: 31,
+          blue: 34,
+          cyan: 36,
+        }
+
+        code = color_codes[color] || 0
+        "\e[#{code}m#{text}\e[0m"
+      end
+    end
+  end
+end

data/lib/omnizip/progress/progress_reporter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Progress
+    # Abstract base class for progress reporters.
+    #
+    # This class defines the interface for progress reporting strategies.
+    # Subclasses implement specific reporting mechanisms (console, callback,
+    # log file, etc.).
+    #
+    # @abstract Subclass and override {#report} to implement a reporter
+    class ProgressReporter
+      # Report progress to the output mechanism
+      #
+      # @param progress [ProgressTracker] Progress tracker with current state
+      # @raise [NotImplementedError] if not implemented by subclass
+      def report(progress)
+        raise NotImplementedError, "#{self.class} must implement #report"
+      end
+
+      # Called when operation starts (optional hook)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def start(progress)
+        # Optional hook for subclasses
+      end
+
+      # Called when operation completes (optional hook)
+      #
+      # @param progress [ProgressTracker] Progress tracker
+      def finish(progress)
+        # Optional hook for subclasses
+      end
+    end
+  end
+end