omnizip 0.4.7-aarch64-linux

data/lib/omnizip/models/filter_chain.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Models
+    # Ordered sequence of filters for compression/decompression
+    #
+    # Manages a pipeline of filters that are applied in sequence.
+    # Filters are applied in reverse order during decode.
+    #
+    # @example Create filter chain for XZ executable
+    #   chain = FilterChain.new(format: :xz)
+    #   chain.add_filter(name: :"bcj-x86", architecture: :x86)
+    #   chain.add_filter(name: :lzma2)  # Main compression
+    #   encoded = chain.encode_all(data, position)
+    class FilterChain
+      # @return [Array<FilterConfig>] Ordered filter configurations
+      attr_reader :filters
+
+      # @return [Symbol] Format identifier (:xz, :seven_zip)
+      attr_reader :format
+
+      # Maximum filters in XZ format
+      MAX_FILTERS_XZ = 4
+
+      # Maximum filters in 7z format
+      MAX_FILTERS_SEVEN_ZIP = 4
+
+      # Initialize filter chain
+      #
+      # @param attributes [Hash] Initialization attributes
+      # @option attributes [Symbol] :format Target format
+      def initialize(attributes = {})
+        @format = attributes[:format] || :xz
+        @filters = attributes[:filters] || []
+      end
+
+      # Add a filter to the chain
+      #
+      # @param filter_attributes [Hash] Filter configuration
+      # @option filter_attributes [Symbol] :name Filter name
+      # @option filter_attributes [String] :properties Filter properties
+      # @option filter_attributes [Symbol] :architecture Target architecture
+      # @return [self] For chaining
+      def add_filter(filter_attributes = {})
+        filter = FilterConfig.new(filter_attributes)
+        filter.validate!
+        @filters << filter
+        self
+      end
+
+      # Get maximum filters for current format
+      #
+      # @return [Integer] Maximum number of filters allowed
+      def max_filters
+        case @format
+        when :xz then MAX_FILTERS_XZ
+        when :seven_zip then MAX_FILTERS_SEVEN_ZIP
+        else raise ArgumentError, "Unknown format: #{@format}"
+        end
+      end
+
+      # Validate filter chain
+      #
+      # @return [Boolean] True if valid
+      # @raise [ArgumentError] If validation fails
+      def validate!
+        if @filters.size > max_filters
+          raise ArgumentError,
+                "Too many filters for #{@format}: #{@filters.size} > #{max_filters}"
+        end
+
+        @filters.each(&:validate!)
+        true
+      end
+
+      # Encode data through all filters in order
+      #
+      # @param data [String] Input data
+      # @param position [Integer] Stream position
+      # @return [String] Encoded data
+      def encode_all(data, position = 0)
+        result = data
+        @filters.each do |filter_config|
+          filter = filter_config.filter_instance
+          result = filter.encode(result, position)
+        end
+        result
+      end
+
+      # Decode data through all filters in reverse order
+      #
+      # @param data [String] Input data
+      # @param position [Integer] Stream position
+      # @return [String] Decoded data
+      def decode_all(data, position = 0)
+        result = data
+        @filters.reverse_each do |filter_config|
+          filter = filter_config.filter_instance
+          result = filter.decode(result, position)
+        end
+        result
+      end
+
+      # Get filter IDs for current format
+      #
+      # @return [Array<Integer>] Array of filter IDs in order
+      def filter_ids
+        @filters.map { |f| f.id_for_format(@format) }
+      end
+
+      # Check if chain is empty
+      #
+      # @return [Boolean] True if no filters
+      def empty?
+        @filters.empty?
+      end
+
+      # Get number of filters in chain
+      #
+      # @return [Integer] Filter count
+      def size
+        @filters.size
+      end
+    end
+  end
+end

data/lib/omnizip/models/filter_config.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Configuration model for a filter in a compression pipeline.
+    #
+    # This class replaces hash-based filter configuration with a proper
+    # model class. It provides format-aware ID resolution and validation.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    #
+    # @example Create a BCJ filter configuration
+    #   config = FilterConfig.new(name: :bcj_x86, architecture: :x86)
+    #   config.id_for_format(:xz)         # => 0x04
+    #   config.id_for_format(:seven_zip)  # => 0x03030103
+    #
+    # @example Create a Delta filter configuration
+    #   config = FilterConfig.new(name: :delta)
+    #   config.delta?  # => true
+    class FilterConfig < Lutaml::Model::Serializable
+      attribute :name, :symbol
+      attribute :properties, :string, default: ""
+      attribute :architecture, :symbol
+
+      key_value do
+        map "name", to: :name, render_default: true, render_nil: true
+        map "properties", to: :properties,
+                          render_default: true, render_nil: true
+        map "architecture", to: :architecture,
+                            render_default: true, render_nil: true
+      end
+
+      # Initialize filter configuration. The legacy +name_sym+ key is
+      # accepted as an alias for +name+.
+      #
+      # @param attributes [Hash] Initialization attributes
+      # @option attributes [Symbol] :name Filter name
+      # @option attributes [Symbol] :name_sym Filter name (alias)
+      # @option attributes [String] :properties Binary properties data
+      # @option attributes [Symbol] :architecture Target architecture
+      def initialize(attributes = {})
+        attrs = attributes.dup
+        attrs[:name] ||= attrs.delete(:name_sym)
+        attrs[:properties] ||= "" # empty-string defaults do not render
+        super(attrs)
+      end
+
+      # Get filter name as symbol (legacy alias for #name).
+      #
+      # @return [Symbol] Filter name
+      def name_sym
+        name
+      end
+
+      # Get filter instance from registry.
+      #
+      # @return [Object] Filter instance from FilterRegistry
+      # @raise [KeyError] If filter not found in registry
+      def filter_instance
+        filter = Omnizip::FilterRegistry.get(name)
+
+        # Handle architecture parameter if needed
+        if architecture && requires_initialize_kwargs?(filter)
+          filter.new(architecture: architecture)
+        else
+          filter.new
+        end
+      end
+
+      # Get filter ID for specific format.
+      #
+      # Delegates to filter instance's id_for_format method if available.
+      # For older filters without id_for_format, returns a default value.
+      #
+      # @param format [Symbol] Format identifier (:seven_zip, :xz)
+      # @return [Integer] Format-specific filter ID
+      # @raise [NotImplementedError] If filter doesn't support id_for_format
+      def id_for_format(format)
+        filter = filter_instance
+        # FilterRegistry accepts any class, with no inheritance check.
+        # allowed: keeps NotImplementedError for filters without the method
+        if filter.respond_to?(:id_for_format)
+          filter.id_for_format(format)
+        else
+          raise NotImplementedError,
+                "Filter #{name} doesn't support format-aware IDs. " \
+                "Use the newer BCJ filter instead."
+        end
+      end
+
+      # Check if this is a BCJ filter.
+      #
+      # @return [Boolean] True if BCJ filter variant
+      def bcj?
+        name.to_s.start_with?("bcj_")
+      end
+
+      # Check if this is a Delta filter.
+      #
+      # @return [Boolean] True if Delta filter
+      def delta?
+        name == :delta
+      end
+
+      # Validate configuration.
+      #
+      # @return [Boolean] True if valid
+      # @raise [ArgumentError] If filter name is nil or not registered
+      def validate!
+        raise ArgumentError, "Filter name is required" if name.nil?
+
+        unless Omnizip::FilterRegistry.registered?(name)
+          raise ArgumentError, "Filter not registered: #{name}"
+        end
+
+        true
+      end
+
+      private
+
+      # Check if filter class requires keyword arguments for initialize.
+      #
+      # @param klass [Class] Filter class to check
+      # @return [Boolean] True if kwargs are required
+      def requires_initialize_kwargs?(klass)
+        klass.name.include?("BCJ") && !klass.name.include?("BcjX86")
+      end
+    end
+  end
+end

data/lib/omnizip/models/match_result.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Represents the result of pattern matching against archive entries.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The serialized "matches" is the match COUNT (not the entry
+    # objects, which are arbitrary caller types); the live entry
+    # collection stays a plain reader.
+    class MatchResult < Lutaml::Model::Serializable
+      include Enumerable
+
+      attribute :total_scanned, :integer, default: 0
+
+      attribute :pattern_repr, :string, method: :pattern_to_s
+      attribute :match_count, :integer, method: :count
+      attribute :rate, :double, method: :match_rate
+
+      key_value do
+        map "pattern", to: :pattern_repr,
+                       render_default: true, render_nil: true
+        map "matches", to: :match_count,
+                       render_default: true, render_nil: true
+        map "scanned", to: :total_scanned,
+                       render_default: true, render_nil: true
+        map "match_rate", to: :rate,
+                          render_default: true, render_nil: true
+      end
+
+      attr_reader :matches, :pattern
+
+      # Initialize a new match result
+      #
+      # @param pattern [Object] The pattern that was matched
+      # @param matches [Array] Array of matched entries
+      # @param total_scanned [Integer] Total entries scanned
+      def initialize(pattern = nil, matches: [], total_scanned: 0)
+        super(total_scanned: total_scanned)
+        @pattern = pattern
+        @matches = Array(matches)
+      end
+
+      # Add a matched entry
+      #
+      # @param entry [Object] Entry that matched
+      # @return [self]
+      def add_match(entry)
+        @matches << entry
+        self
+      end
+
+      # Increment the scan counter
+      #
+      # @param count [Integer] Number to increment by
+      # @return [self]
+      def increment_scanned(count = 1)
+        self.total_scanned = total_scanned + count
+        self
+      end
+
+      # Get the number of matches
+      #
+      # @return [Integer]
+      def count
+        @matches.size
+      end
+
+      # Check if any matches were found
+      #
+      # @return [Boolean]
+      def any?
+        !@matches.empty?
+      end
+
+      # Check if no matches were found
+      #
+      # @return [Boolean]
+      def none?
+        @matches.empty?
+      end
+
+      # Get match rate (matches/scanned)
+      #
+      # @return [Float] Match rate between 0.0 and 1.0
+      def match_rate
+        return 0.0 if total_scanned.zero?
+
+        count.to_f / total_scanned
+      end
+
+      # Get match percentage
+      #
+      # @return [Float] Match percentage between 0.0 and 100.0
+      def match_percentage
+        match_rate * 100.0
+      end
+
+      # Iterate over matches
+      #
+      # @yield [entry] Each matched entry
+      # @return [Enumerator, self]
+      def each(&block)
+        return matches.to_enum unless block
+
+        matches.each(&block)
+        self
+      end
+
+      # Get first match
+      #
+      # @return [Object, nil]
+      def first
+        @matches.first
+      end
+
+      # Get last match
+      #
+      # @return [Object, nil]
+      def last
+        @matches.last
+      end
+
+      # Convert to array
+      #
+      # @return [Array]
+      def to_a
+        @matches.dup
+      end
+
+      # Serialized pattern representation.
+      #
+      # @return [String] The pattern as a string
+      def pattern_to_s
+        @pattern.to_s
+      end
+    end
+  end
+end

data/lib/omnizip/models/optimization_suggestion.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Represents a performance optimization suggestion based on
+    # profiling data.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The priority_score key serializes the derived #priority_score
+    # method under a distinct attribute name.
+    class OptimizationSuggestion < Lutaml::Model::Serializable
+      SEVERITY_LEVELS = %i[low medium high critical].freeze
+      CATEGORIES = %i[
+        memory cpu hotpath algorithm io gc allocation concurrency
+      ].freeze
+
+      attribute :title, :string
+      attribute :description, :string
+      attribute :severity, :symbol
+      attribute :category, :symbol
+      attribute :impact_estimate, :double
+      attribute :implementation_effort, :double
+      attribute :related_operations, :string, collection: true, default: []
+      attribute :code_locations, :string, collection: true, default: []
+      attribute :metrics, :hash, default: {}
+
+      attribute :priority, :double, method: :priority_score
+
+      key_value do
+        map "title", to: :title, render_default: true, render_nil: true
+        map "description", to: :description,
+                           render_default: true, render_nil: true
+        map "severity", to: :severity, render_default: true, render_nil: true
+        map "category", to: :category, render_default: true, render_nil: true
+        map "impact_estimate", to: :impact_estimate,
+                               render_default: true, render_nil: true
+        map "implementation_effort", to: :implementation_effort,
+                                     render_default: true, render_nil: true
+        map "priority_score", to: :priority,
+                              render_default: true, render_nil: true
+        map "related_operations", to: :related_operations,
+                                  render_default: true, render_nil: true
+        map "code_locations", to: :code_locations,
+                              render_default: true, render_nil: true
+        map "metrics", to: :metrics, render_default: true, render_nil: true
+      end
+
+      # Severity and category are validated after the framework
+      # constructor assigns the attributes. Empty-collection defaults
+      # are assigned explicitly (lutaml-model 0.8.x drops them).
+      def initialize(attrs = {})
+        super({ related_operations: [], code_locations: [],
+                metrics: {} }.merge(attrs))
+        validate_severity!(severity)
+        validate_category!(category)
+      end
+
+      def critical?
+        severity == :critical
+      end
+
+      def high_priority?
+        severity == :high || critical?
+      end
+
+      def priority_score
+        severity_weight = SEVERITY_LEVELS.index(severity) + 1
+        impact_weight = impact_estimate || 1.0
+        effort_weight = implementation_effort ? (1.0 / implementation_effort) : 1.0
+
+        severity_weight * impact_weight * effort_weight
+      end
+
+      private
+
+      def validate_severity!(severity)
+        return if SEVERITY_LEVELS.include?(severity)
+
+        raise ArgumentError,
+              "Invalid severity: #{severity}. " \
+              "Must be one of: #{SEVERITY_LEVELS.join(', ')}"
+      end
+
+      def validate_category!(category)
+        return if CATEGORIES.include?(category)
+
+        raise ArgumentError,
+              "Invalid category: #{category}. " \
+              "Must be one of: #{CATEGORIES.join(', ')}"
+      end
+    end
+  end
+end

data/lib/omnizip/models/parallel_options.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Model for parallel processing configuration
+    #
+    # Stores settings for parallel compression and extraction operations
+    # including thread count, queue size, and load balancing strategy.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    #
+    # @example Create parallel options
+    #   options = Omnizip::Models::ParallelOptions.new
+    #   options.threads = 8
+    #   options.queue_size = 100
+    #   options.strategy = :dynamic
+    #
+    # @example Use with parallel compression
+    #   Omnizip::Parallel.compress_directory('files/', 'backup.zip', options)
+    class ParallelOptions < Lutaml::Model::Serializable
+      include AttributeApply
+
+      # @return [Integer] Number of worker threads (default: auto-detect)
+      attribute :threads, :integer, default: -> { detect_cpu_count }
+
+      # @return [Integer] Maximum size of job queue (default: 1000)
+      attribute :queue_size, :integer, default: 1000
+
+      # @return [Integer] Chunk size for chunked operations in bytes
+      attribute :chunk_size, :integer, default: 64 * 1024 * 1024 # 64MB default
+
+      # @return [Symbol] Load balancing strategy (:dynamic or :static)
+      attribute :strategy, :symbol, default: :dynamic
+
+      # @return [Boolean] Enable verbose progress output
+      attribute :verbose, :boolean, default: false
+
+      # @return [Integer] Batch size for work queue polling
+      attribute :batch_size, :integer, default: 10
+
+      key_value do
+        map "threads", to: :threads, render_default: true, render_nil: true
+        map "queue_size", to: :queue_size,
+                          render_default: true, render_nil: true
+        map "chunk_size", to: :chunk_size,
+                          render_default: true, render_nil: true
+        map "strategy", to: :strategy, render_default: true, render_nil: true
+        map "verbose", to: :verbose, render_default: true, render_nil: true
+        map "batch_size", to: :batch_size,
+                          render_default: true, render_nil: true
+      end
+
+      # Validate options
+      #
+      # Named +validate_options!+ rather than +validate!+ so it does not
+      # shadow Lutaml::Model::Validation#validate!(register:).
+      #
+      # @raise [ArgumentError] if options are invalid
+      # @return [Boolean] true if valid
+      def validate_options!
+        validate_positive(:threads)
+        validate_positive(:queue_size)
+        validate_positive(:chunk_size)
+        validate_strategy
+        validate_positive(:batch_size)
+
+        true
+      end
+
+      # Apply a hash of attributes. Only keys declared as +attribute+s
+      # above are applied; unknown keys are silently ignored.
+      #
+      # Keys must be Symbols. String keys are ignored, so +#to_hash+ output
+      # cannot be fed back in directly — use +.from_hash+ for that.
+      #
+      # @param values [Hash{Symbol=>Object}] attributes to set
+      # @return [self]
+
+      private
+
+      # Raise unless +name+ holds a positive Integer. A nil or non-Integer
+      # value fails with the same message as a zero or negative one, so
+      # callers get +ArgumentError+ rather than +NoMethodError+.
+      #
+      # @param name [Symbol] attribute to check
+      # @raise [ArgumentError] if the value is not a positive Integer
+      # @return [void]
+      def validate_positive(name)
+        value = public_send(name)
+        return if value.is_a?(Integer) && value.positive?
+
+        raise ArgumentError, "#{name} must be > 0"
+      end
+
+      # @raise [ArgumentError] unless +strategy+ is one of the known values
+      # @return [void]
+      def validate_strategy
+        return if %i[dynamic static].include?(strategy)
+
+        raise ArgumentError, "strategy must be :dynamic or :static"
+      end
+
+      # Detect number of available CPU cores
+      #
+      # @return [Integer] number of CPUs
+      def detect_cpu_count
+        require "etc"
+        Etc.nprocessors
+      rescue StandardError
+        4 # fallback to 4 threads
+      end
+    end
+  end
+end