omnizip 0.4.7-arm-linux

data/lib/omnizip/profiler/report_generator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Omnizip
+  class Profiler
+    # Generates formatted profiling reports with optimization recommendations
+    class ReportGenerator
+      attr_reader :report
+
+      def initialize(report)
+        @report = report
+      end
+
+      # Generate a human-readable text report
+      def generate_text_report
+        lines = []
+        lines << ("=" * 80)
+        lines << "PERFORMANCE PROFILING REPORT"
+        lines << ("=" * 80)
+        lines << "Profile: #{report.profile_name}"
+        lines << "Timestamp: #{report.timestamp}"
+        lines << ""
+
+        lines += generate_summary_section
+        lines += generate_results_section
+        lines += generate_hot_paths_section
+        lines += generate_bottlenecks_section
+
+        lines.join("\n")
+      end
+
+      # Generate a JSON report
+      def generate_json_report
+        JSON.pretty_generate(report.to_hash)
+      end
+
+      # Save report to file
+      def save_to_file(filename, format: :text)
+        content = case format
+                  when :text then generate_text_report
+                  when :json then generate_json_report
+                  else raise ArgumentError, "Unknown format: #{format}"
+                  end
+
+        # Create parent directories if they don't exist
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir)
+
+        File.write(filename, content)
+        puts "Report saved to #{filename}"
+      end
+
+      # Print report to console
+      def print_report
+        puts generate_text_report
+      end
+
+      private
+
+      def generate_summary_section
+        lines = []
+        lines << ("-" * 80)
+        lines << "SUMMARY"
+        lines << ("-" * 80)
+        lines << format("Total Execution Time: %.3fs",
+                        report.total_execution_time)
+        lines << format("Total Memory Allocated: %s",
+                        format_bytes(report.total_memory_allocated))
+        lines << format("Total GC Runs: %d", report.total_gc_runs)
+        lines << format("Operations Profiled: %d", report.results.size)
+        lines << ""
+        lines
+      end
+
+      def generate_results_section
+        return [] if report.results.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "DETAILED RESULTS"
+        lines << ("-" * 80)
+        lines << "Operation                                    Time (s)          Memory      Calls"
+        lines << ("-" * 80)
+
+        report.results.sort_by(&:total_time).reverse.each do |result|
+          lines << format("%-40s %12.3f %15s %10d",
+                          truncate(result.operation_name, 40),
+                          result.total_time || 0.0,
+                          format_bytes(result.memory_allocated || 0),
+                          result.call_count || 0)
+        end
+        lines << ""
+        lines
+      end
+
+      def generate_hot_paths_section
+        return [] if report.hot_paths.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "HOT PATHS (>10% execution time)"
+        lines << ("-" * 80)
+
+        report.hot_paths.each do |hot_path|
+          lines << format("  %s: %.3fs (%.1f%%)",
+                          hot_path[:operation],
+                          hot_path[:time],
+                          hot_path[:percentage])
+        end
+        lines << ""
+        lines
+      end
+
+      def generate_bottlenecks_section
+        return [] if report.bottlenecks.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "PERFORMANCE BOTTLENECKS"
+        lines << ("-" * 80)
+
+        report.bottlenecks.group_by { |b| b[:type] }.each do |type, bottlenecks|
+          lines << "\n#{type.to_s.upcase} Bottlenecks:"
+          bottlenecks.each do |bottleneck|
+            lines << format("  [%s] %s",
+                            bottleneck[:severity].to_s.upcase,
+                            bottleneck[:operation])
+
+            case type
+            when :memory
+              lines << format("    Memory: %s",
+                              format_bytes(bottleneck[:allocated]))
+            when :cpu
+              lines << format("    Time: %.3fs", bottleneck[:time])
+            when :gc
+              lines << format("    GC Pressure: %.2f runs/s",
+                              bottleneck[:gc_pressure])
+            end
+          end
+        end
+        lines << ""
+        lines
+      end
+
+      def format_bytes(bytes)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+
+      def truncate(string, max_length)
+        return string if string.length <= max_length
+
+        "#{string[0...(max_length - 3)]}..."
+      end
+    end
+  end
+end

data/lib/omnizip/profiler.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Main profiler interface using Strategy pattern for different profiling approaches
+  class Profiler
+    autoload :PerformanceResult, "omnizip/models/performance_result"
+    autoload :ProfileReport, "omnizip/models/profile_report"
+    autoload :OptimizationSuggestion, "omnizip/models/optimization_suggestion"
+    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)
+      Omnizip::CliOutputFormatter.format_size(bytes)
+    end
+  end
+end

data/lib/omnizip/progress/callback_reporter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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,59 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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,89 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+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