omnizip 0.4.7-x86_64-linux

data/lib/omnizip/models/performance_result.rb

@@ -0,0 +1,85 @@
+# frozen_string: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Represents the performance characteristics of a profiled operation.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The derived-rate keys serialize the calculation methods; attribute
+    # names differ from the keys so generated readers do not shadow them.
+    class PerformanceResult < Lutaml::Model::Serializable
+      attribute :operation_name, :string
+      attribute :total_time, :double
+      attribute :cpu_time, :double
+      attribute :wall_time, :double
+      attribute :memory_allocated, :integer
+      attribute :memory_retained, :integer
+      attribute :object_allocations, :integer
+      attribute :gc_runs, :integer
+      attribute :call_count, :integer
+      attribute :timestamp, :date_time, default: -> { Time.now }
+
+      attribute :throughput, :double, method: :throughput_ops_per_second
+      attribute :average_time, :double, method: :average_time_per_operation
+      attribute :memory_per_op, :double, method: :memory_per_operation
+      attribute :pressure, :double, method: :gc_pressure
+
+      key_value do
+        map "operation_name", to: :operation_name,
+                              render_default: true, render_nil: true
+        map "total_time", to: :total_time,
+                          render_default: true, render_nil: true
+        map "cpu_time", to: :cpu_time,
+                        render_default: true, render_nil: true
+        map "wall_time", to: :wall_time,
+                         render_default: true, render_nil: true
+        map "memory_allocated", to: :memory_allocated,
+                                render_default: true, render_nil: true
+        map "memory_retained", to: :memory_retained,
+                               render_default: true, render_nil: true
+        map "object_allocations", to: :object_allocations,
+                                  render_default: true, render_nil: true
+        map "gc_runs", to: :gc_runs,
+                       render_default: true, render_nil: true
+        map "call_count", to: :call_count,
+                          render_default: true, render_nil: true
+        map "throughput_ops_per_second", to: :throughput,
+                                         render_default: true, render_nil: true
+        map "average_time_per_operation", to: :average_time,
+                                          render_default: true, render_nil: true
+        map "memory_per_operation", to: :memory_per_op,
+                                    render_default: true, render_nil: true
+        map "gc_pressure", to: :pressure,
+                           render_default: true, render_nil: true
+        map "timestamp", to: :timestamp,
+                         render_default: true, render_nil: true
+      end
+
+      def throughput_ops_per_second
+        return nil unless call_count && total_time&.positive?
+
+        call_count.to_f / total_time
+      end
+
+      def average_time_per_operation
+        return nil unless call_count && total_time && call_count.positive?
+
+        total_time / call_count.to_f
+      end
+
+      def memory_per_operation
+        return nil unless call_count && memory_allocated && call_count.positive?
+
+        memory_allocated / call_count.to_f
+      end
+
+      def gc_pressure
+        return nil unless gc_runs && total_time&.positive?
+
+        gc_runs.to_f / total_time
+      end
+    end
+  end
+end

data/lib/omnizip/models/profile_report.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Aggregated profiling report with hot path analysis.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The +summary+ key serializes a nested Summary model built from
+    # the report's aggregates; hot paths and bottlenecks are the
+    # analyzer-supplied hashes.
+    class ProfileReport < Lutaml::Model::Serializable
+      # Aggregate block of {ProfileReport#to_hash}.
+      class Summary < Lutaml::Model::Serializable
+        attribute :total_execution_time, :double, default: 0.0
+        attribute :total_memory_allocated, :integer, default: 0
+        attribute :total_gc_runs, :integer, default: 0
+        attribute :operation_count, :integer, default: 0
+
+        key_value do
+          map "total_execution_time", to: :total_execution_time,
+                                      render_default: true, render_nil: true
+          map "total_memory_allocated", to: :total_memory_allocated,
+                                        render_default: true, render_nil: true
+          map "total_gc_runs", to: :total_gc_runs,
+                               render_default: true, render_nil: true
+          map "operation_count", to: :operation_count,
+                                 render_default: true, render_nil: true
+        end
+      end
+
+      attribute :profile_name, :string
+      attribute :results, PerformanceResult, collection: true, default: []
+      attribute :hot_paths, :hash, collection: true, default: []
+      attribute :bottlenecks, :hash, collection: true, default: []
+      attribute :timestamp, :date_time, default: -> { Time.now }
+      attribute :metadata, :hash, default: {}
+      attribute :summary, Summary, method: :build_summary
+
+      key_value do
+        map "profile_name", to: :profile_name,
+                            render_default: true, render_nil: true
+        map "timestamp", to: :timestamp,
+                         render_default: true, render_nil: true
+        map "summary", to: :summary,
+                       render_default: true, render_nil: true
+        map "results", to: :results,
+                       render_default: true, render_nil: true
+        map "hot_paths", to: :hot_paths,
+                         render_default: true, render_nil: true
+        map "bottlenecks", to: :bottlenecks,
+                           render_default: true, render_nil: true
+        map "metadata", to: :metadata,
+                        render_default: true, render_nil: true
+      end
+
+      # lutaml-model 0.8.x does not render empty-collection defaults,
+      # so they are assigned explicitly to keep every key present.
+      def initialize(attrs = {})
+        super({ results: [], hot_paths: [], bottlenecks: [],
+                metadata: {} }.merge(attrs))
+      end
+
+      def total_execution_time
+        results.filter_map(&:total_time).sum
+      end
+
+      def total_memory_allocated
+        results.filter_map(&:memory_allocated).sum
+      end
+
+      def total_gc_runs
+        results.filter_map(&:gc_runs).sum
+      end
+
+      def slowest_operations(limit: 5)
+        results.select(&:total_time)
+          .sort_by(&:total_time)
+          .reverse
+          .take(limit)
+      end
+
+      def memory_intensive_operations(limit: 5)
+        results.select(&:memory_allocated)
+          .sort_by(&:memory_allocated)
+          .reverse
+          .take(limit)
+      end
+
+      def add_result(result)
+        results << result
+      end
+
+      def add_hot_path(hot_path)
+        hot_paths << hot_path
+      end
+
+      def add_bottleneck(bottleneck)
+        bottlenecks << bottleneck
+      end
+
+      # Serialized aggregate block.
+      #
+      # @return [Summary]
+      def build_summary
+        Summary.new(
+          total_execution_time: total_execution_time,
+          total_memory_allocated: total_memory_allocated,
+          total_gc_runs: total_gc_runs,
+          operation_count: results.size,
+        )
+      end
+    end
+  end
+end

data/lib/omnizip/models/progress_options.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Model representing progress tracking options.
+    #
+    # This class encapsulates configuration for progress tracking,
+    # including reporter type, update interval, and display preferences.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    #
+    # +render_nil+ is deliberately absent: the previous +to_h+ ended in
+    # +.compact+, so an explicitly-nil value was dropped. +render_default+
+    # alone keeps that nil-dropping behaviour.
+    class ProgressOptions < Lutaml::Model::Serializable
+      attribute :reporter, :string, default: "auto"
+      attribute :update_interval, :float, default: 0.5
+      attribute :show_rate, :boolean, default: true
+      attribute :show_eta, :boolean, default: true
+      attribute :show_files, :boolean, default: true
+      attribute :show_bytes, :boolean, default: true
+
+      key_value do
+        map "reporter", to: :reporter, render_default: true
+        map "update_interval", to: :update_interval, render_default: true
+        map "show_rate", to: :show_rate, render_default: true
+        map "show_eta", to: :show_eta, render_default: true
+        map "show_files", to: :show_files, render_default: true
+        map "show_bytes", to: :show_bytes, render_default: true
+      end
+    end
+  end
+end

data/lib/omnizip/models/split_options.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Models
+    # Configuration for split archive (multi-volume) creation
+    # Defines how archives should be split into volumes
+    class SplitOptions
+      attr_accessor :volume_size, :naming_pattern, :span_strategy
+
+      # Naming pattern types
+      NAMING_NUMERIC = :numeric  # .001, .002, .003
+      NAMING_ALPHA = :alpha      # .aa, .ab, .ac
+
+      # Span strategies
+      STRATEGY_FIRST_FIT = :first_fit  # Fill volumes sequentially
+      STRATEGY_BALANCED = :balanced    # Balance files across volumes
+
+      # Default volume size (100 MB)
+      DEFAULT_VOLUME_SIZE = 100 * 1024 * 1024
+
+      # Initialize with default options
+      def initialize
+        @volume_size = DEFAULT_VOLUME_SIZE
+        @naming_pattern = NAMING_NUMERIC
+        @span_strategy = STRATEGY_FIRST_FIT
+      end
+
+      # Parse volume size from string (e.g., "100M", "4.7G")
+      #
+      # @param size_str [String] Size string with unit
+      # @return [Integer] Size in bytes
+      def self.parse_volume_size(size_str)
+        return size_str if size_str.is_a?(Integer)
+
+        size_str = size_str.to_s.strip.upcase
+        multiplier = case size_str
+                     when /(\d+(?:\.\d+)?)\s*K(?:B)?$/
+                       1024
+                     when /(\d+(?:\.\d+)?)\s*M(?:B)?$/
+                       1024 * 1024
+                     when /(\d+(?:\.\d+)?)\s*G(?:B)?$/
+                       1024 * 1024 * 1024
+                     when /(\d+(?:\.\d+)?)\s*T(?:B)?$/
+                       1024 * 1024 * 1024 * 1024
+                     else
+                       return size_str.to_i
+                     end
+
+        (Regexp.last_match(1).to_f * multiplier).to_i
+      end
+
+      # Generate volume filename
+      #
+      # @param base_path [String] Base archive path (e.g., "backup.7z.001")
+      # @param volume_number [Integer] Volume number (1-based)
+      # @return [String] Volume filename
+      def volume_filename(base_path, volume_number)
+        # Extract base and extension
+        base = base_path.sub(/\.\d{3}$/, "")
+        base = base.sub(/\.[a-z]{2,}$/, "") if @naming_pattern == NAMING_ALPHA
+
+        case @naming_pattern
+        when NAMING_NUMERIC
+          format("%s.%03d", base, volume_number)
+        when NAMING_ALPHA
+          format("%s.%s", base, alpha_suffix(volume_number))
+        else
+          format("%s.%03d", base, volume_number)
+        end
+      end
+
+      # Validate options
+      #
+      # @raise [ArgumentError] if options are invalid
+      def validate!
+        raise ArgumentError, "volume_size must be positive" unless
+          @volume_size.positive?
+
+        valid_patterns = [NAMING_NUMERIC, NAMING_ALPHA]
+        unless valid_patterns.include?(@naming_pattern)
+          raise ArgumentError,
+                "naming_pattern must be one of #{valid_patterns.inspect}"
+        end
+
+        valid_strategies = [STRATEGY_FIRST_FIT, STRATEGY_BALANCED]
+        unless valid_strategies.include?(@span_strategy)
+          raise ArgumentError,
+                "span_strategy must be one of #{valid_strategies.inspect}"
+        end
+
+        true
+      end
+
+      private
+
+      # Generate alpha suffix for volume number
+      #
+      # @param volume_number [Integer] Volume number (1-based)
+      # @return [String] Alpha suffix (aa, ab, ..., az, ba, ..., zz, aaa, ...)
+      def alpha_suffix(volume_number)
+        # Convert 1 -> aa, 2 -> ab, ..., 26 -> az, 27 -> ba, etc.
+        num = volume_number - 1 # Convert to 0-based
+
+        # For two-character format (minimum):
+        # Second character cycles through a-z (rightmost, least significant)
+        second = ("a".ord + (num % 26)).chr
+
+        # First character represents which group of 26 we're in
+        first_index = num / 26
+        first = ("a".ord + first_index).chr
+
+        first + second
+      end
+    end
+  end
+end

data/lib/omnizip/optimization_registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Omnizip
+  class OptimizationRegistry < Omnizip::Registry
+    class << self
+      def not_found_error_class
+        Omnizip::OptimizationNotFoundError
+      end
+
+      def label
+        "Optimization strategy"
+      end
+
+      def apply(name, target, **options)
+        get(name).new(**options).optimize(target)
+      end
+
+      def metadata(name)
+        get(name).metadata
+      end
+    end
+
+    class Strategy
+      attr_reader :options
+
+      def initialize(**options)
+        @options = options
+      end
+
+      def optimize(_target)
+        raise NotImplementedError,
+              "#{self.class} must implement #optimize"
+      end
+
+      def self.metadata
+        {
+          name: name,
+          description: "No description provided",
+          category: :general,
+          impact: :unknown,
+        }
+      end
+    end
+  end
+end

data/lib/omnizip/parallel/engine.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fractor"
+
+module Omnizip
+  module Parallel
+    # Engine owns the Fractor worker-pool dance: build the pool, submit
+    # a batch of work, run it to completion, return successful and
+    # failed results. Callers (ParallelCompressor, ParallelExtractor,
+    # future operations) supply the worker class and the work items;
+    # Engine handles the threading.
+    #
+    # This is the deep module behind the parallel API: the threading
+    # shape is identical across every consumer, so it lives here once.
+    # Domain-specific concerns (which file to read, which archive to
+    # open, what stats to track) stay with the caller.
+    class Engine
+      # @param worker_class [Class] a +Fractor::Worker+ subclass whose
+      #   +#process(work)+ turns one work item into a result.
+      # @param threads [Integer] worker count.
+      def initialize(worker_class:, threads:)
+        @worker_class = worker_class
+        @threads = threads
+      end
+
+      # Run +work_items+ through the pool and yield each successful
+      # +Fractor::WorkResult+ to the caller-supplied block.
+      #
+      # @param work_items [Array<Fractor::Work>] batch to submit.
+      # @yieldparam result [Fractor::WorkResult] a successful result.
+      # @return [Array<Fractor::WorkResult>] the failed results, for
+      #   the caller to decide how to surface.
+      def run(work_items)
+        pool = WorkerPool.new(
+          worker_class: @worker_class,
+          num_workers: @threads,
+          continuous: false,
+        )
+        pool.start
+        begin
+          pool.submit_batch(work_items)
+          pool.run
+
+          pool.successful_results.each { |r| yield r if block_given? }
+          pool.failed_results
+        ensure
+          pool.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/parallel/job_queue.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Parallel
+    # Thread-safe job queue for parallel compression/extraction
+    #
+    # Manages a queue of compression or extraction jobs with priority support.
+    # Jobs are ordered by priority (large files first for better load balancing).
+    #
+    # @example Create and use job queue
+    #   queue = Omnizip::Parallel::JobQueue.new(max_size: 100)
+    #   queue.push(file: 'large.dat', size: 1_000_000, priority: :high)
+    #   job = queue.pop
+    #
+    # @example Size-based priority
+    #   queue.push_with_size(file: 'file.txt', size: 1024)
+    class JobQueue
+      # Job structure for queue items
+      Job = Struct.new(:file, :data, :size, :priority, :metadata,
+                       keyword_init: true) do
+        def <=>(other)
+          # Higher priority first, then larger files first
+          priority_order = { high: 0, normal: 1, low: 2 }
+          priority_cmp = (priority_order[priority] || 1) <=> (priority_order[other.priority] || 1)
+          return priority_cmp unless priority_cmp.zero?
+
+          # If same priority, larger files first
+          -(size <=> other.size)
+        end
+      end
+
+      # @return [Integer] maximum queue size
+      attr_reader :max_size
+
+      # @return [Integer] current queue size
+      attr_reader :size
+
+      # Initialize job queue
+      #
+      # @param max_size [Integer] maximum number of jobs in queue
+      def initialize(max_size: 1000)
+        @max_size = max_size
+        @queue = []
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @closed = false
+        @size = 0
+      end
+
+      # Push a job onto the queue
+      #
+      # @param file [String] file path
+      # @param data [Object] job data
+      # @param size [Integer] file size in bytes
+      # @param priority [Symbol] job priority (:high, :normal, :low)
+      # @param metadata [Hash] additional metadata
+      # @raise [ClosedQueueError] if queue is closed
+      # @return [Job] the created job
+      def push(file:, data: nil, size: 0, priority: :normal, metadata: {})
+        @mutex.synchronize do
+          raise ClosedQueueError, "Queue is closed" if @closed
+
+          # Wait if queue is full
+          @cond.wait(@mutex) while @size >= @max_size && !@closed
+
+          raise ClosedQueueError, "Queue is closed" if @closed
+
+          job = Job.new(
+            file: file,
+            data: data,
+            size: size,
+            priority: priority,
+            metadata: metadata,
+          )
+
+          @queue << job
+          @size += 1
+
+          # Keep queue sorted by priority
+          @queue.sort!
+
+          @cond.signal
+          job
+        end
+      end
+
+      # Push a job with automatic priority based on file size
+      #
+      # @param file [String] file path
+      # @param size [Integer] file size in bytes
+      # @param data [Object] job data
+      # @param metadata [Hash] additional metadata
+      # @return [Job] the created job
+      def push_with_size(file:, size:, data: nil, metadata: {})
+        # Determine priority based on size
+        # Large files (>10MB) get high priority for better load balancing
+        priority = if size > 10 * 1024 * 1024
+                     :high
+                   elsif size > 1024 * 1024
+                     :normal
+                   else
+                     :low
+                   end
+
+        push(file: file, data: data, size: size, priority: priority,
+             metadata: metadata)
+      end
+
+      # Pop a job from the queue
+      #
+      # @param timeout [Numeric, nil] timeout in seconds, nil for no timeout
+      # @return [Job, nil] job or nil if timeout or closed
+      def pop(timeout: nil)
+        @mutex.synchronize do
+          if timeout
+            deadline = Time.now + timeout
+            while @queue.empty? && !@closed
+              remaining = deadline - Time.now
+              return nil if remaining <= 0
+
+              @cond.wait(@mutex, remaining)
+            end
+          else
+            @cond.wait(@mutex) while @queue.empty? && !@closed
+          end
+
+          return nil if @queue.empty?
+
+          job = @queue.shift
+          @size -= 1
+          @cond.signal # Signal waiting pushers
+          job
+        end
+      end
+
+      # Pop multiple jobs in batch
+      #
+      # @param count [Integer] maximum number of jobs to pop
+      # @param timeout [Numeric, nil] timeout in seconds
+      # @return [Array<Job>] array of jobs (may be empty)
+      def pop_batch(count, timeout: nil)
+        jobs = []
+        count.times do
+          job = pop(timeout: timeout)
+          break unless job
+
+          jobs << job
+        end
+        jobs
+      end
+
+      # Check if queue is empty
+      #
+      # @return [Boolean] true if empty
+      def empty?
+        @mutex.synchronize { @queue.empty? }
+      end
+
+      # Check if queue is closed
+      #
+      # @return [Boolean] true if closed
+      def closed?
+        @mutex.synchronize { @closed }
+      end
+
+      # Close the queue
+      #
+      # No more jobs can be pushed after closing.
+      # Pending pops will return nil.
+      def close
+        @mutex.synchronize do
+          @closed = true
+          @cond.broadcast # Wake up all waiting threads
+        end
+      end
+
+      # Clear all jobs from queue
+      #
+      # @return [Integer] number of jobs cleared
+      def clear
+        @mutex.synchronize do
+          count = @queue.size
+          @queue.clear
+          @size = 0
+          @cond.broadcast
+          count
+        end
+      end
+
+      # Get queue statistics
+      #
+      # @return [Hash] statistics hash
+      def stats
+        @mutex.synchronize do
+          {
+            size: @size,
+            max_size: @max_size,
+            closed: @closed,
+            utilization: @max_size.zero? ? 0.0 : @size.to_f / @max_size,
+            priority_counts: @queue.group_by(&:priority).transform_values(&:count),
+          }
+        end
+      end
+    end
+
+    # Exception raised when trying to push to a closed queue
+    class ClosedQueueError < StandardError; end
+  end
+end