omnizip 0.3.1

data/lib/omnizip/models/algorithm_metadata.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 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 "json"
+
+module Omnizip
+  module Models
+    # Model representing metadata about a compression algorithm.
+    #
+    # This class encapsulates information about a compression algorithm,
+    # including its name, description, version, and capabilities.
+    class AlgorithmMetadata
+      attr_accessor :name, :description, :version, :author,
+                    :max_compression_level, :min_compression_level,
+                    :default_compression_level, :supports_streaming,
+                    :supports_multithreading
+
+      def initialize(**kwargs)
+        @supports_streaming = false
+        @supports_multithreading = false
+
+        kwargs.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          version: @version,
+          author: @author,
+          max_compression_level: @max_compression_level,
+          min_compression_level: @min_compression_level,
+          default_compression_level: @default_compression_level,
+          supports_streaming: @supports_streaming,
+          supports_multithreading: @supports_multithreading,
+        }.compact
+      end
+
+      # Serialize to JSON
+      #
+      # @return [String] JSON representation
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      # Deserialize from JSON
+      #
+      # @param json [String] JSON string
+      # @return [AlgorithmMetadata] Deserialized instance
+      def self.from_json(json)
+        data = JSON.parse(json)
+        new(**data.transform_keys(&:to_sym))
+      end
+    end
+  end
+end

data/lib/omnizip/models/compression_options.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 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 "json"
+
+module Omnizip
+  module Models
+    # Model representing compression operation options.
+    #
+    # This class encapsulates configuration options for compression
+    # operations, including compression level, threading, and buffer sizes.
+    class CompressionOptions
+      attr_accessor :level, :dictionary_size, :num_fast_bytes, :match_finder,
+                    :num_threads, :solid, :buffer_size
+
+      def initialize(**kwargs)
+        @level = 5
+        @num_threads = 1
+        @solid = false
+        @buffer_size = 65_536
+
+        kwargs.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def to_h
+        {
+          level: @level,
+          dictionary_size: @dictionary_size,
+          num_fast_bytes: @num_fast_bytes,
+          match_finder: @match_finder,
+          num_threads: @num_threads,
+          solid: @solid,
+          buffer_size: @buffer_size,
+        }.compact
+      end
+
+      # Serialize to JSON
+      #
+      # @return [String] JSON representation
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      # Deserialize from JSON
+      #
+      # @param json [String] JSON string
+      # @return [CompressionOptions] Deserialized instance
+      def self.from_json(json)
+        data = JSON.parse(json)
+        new(**data.transform_keys(&:to_sym))
+      end
+    end
+  end
+end

data/lib/omnizip/models/conversion_options.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Models
+    # Model for format conversion options
+    class ConversionOptions
+      attr_accessor :source_format, :target_format, :compression,
+                    :compression_level, :filter, :preserve_metadata,
+                    :temp_directory, :solid, :delete_source
+
+      # Initialize conversion options
+      # @param source_format [Symbol, nil] Source format (auto-detect if nil)
+      # @param target_format [Symbol] Target format
+      # @param compression [Symbol, nil] Compression algorithm
+      # @param compression_level [Integer] Compression level (1-9)
+      # @param filter [Symbol, nil] Filter to apply
+      # @param preserve_metadata [Boolean] Preserve metadata
+      # @param temp_directory [String, nil] Temporary directory
+      # @param solid [Boolean] Use solid compression (7z only)
+      # @param delete_source [Boolean] Delete source after conversion
+      def initialize(
+        source_format: nil,
+        target_format: :seven_zip,
+        compression: nil,
+        compression_level: 5,
+        filter: nil,
+        preserve_metadata: true,
+        temp_directory: nil,
+        solid: true,
+        delete_source: false
+      )
+        @source_format = source_format
+        @target_format = target_format
+        @compression = compression
+        @compression_level = compression_level
+        @filter = filter
+        @preserve_metadata = preserve_metadata
+        @temp_directory = temp_directory
+        @solid = solid
+        @delete_source = delete_source
+      end
+
+      # Convert to hash
+      # @return [Hash] Options as hash
+      def to_h
+        {
+          source_format: source_format,
+          target_format: target_format,
+          compression: compression,
+          compression_level: compression_level,
+          filter: filter,
+          preserve_metadata: preserve_metadata,
+          temp_directory: temp_directory,
+          solid: solid,
+          delete_source: delete_source,
+        }
+      end
+
+      # Validate options
+      # @raise [ArgumentError] If options are invalid
+      def validate
+        validate_format(target_format, "target")
+        validate_format(source_format, "source") if source_format
+        validate_compression_level
+
+        true
+      end
+
+      private
+
+      def validate_format(format, type)
+        valid_formats = %i[zip seven_zip 7z]
+        return if valid_formats.include?(format)
+
+        raise ArgumentError, "Invalid #{type} format: #{format}. " \
+                             "Valid formats: #{valid_formats.join(', ')}"
+      end
+
+      def validate_compression_level
+        return if (1..9).cover?(compression_level)
+
+        raise ArgumentError,
+              "Invalid compression level: #{compression_level}. Must be 1-9"
+      end
+    end
+  end
+end

data/lib/omnizip/models/conversion_result.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Models
+    # Model for format conversion results
+    class ConversionResult
+      attr_reader :source_path, :target_path, :source_format, :target_format,
+                  :source_size, :target_size, :duration, :entry_count,
+                  :compression_ratio, :warnings
+
+      # Initialize conversion result
+      # @param source_path [String] Source file path
+      # @param target_path [String] Target file path
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @param source_size [Integer] Source file size in bytes
+      # @param target_size [Integer] Target file size in bytes
+      # @param duration [Float] Conversion duration in seconds
+      # @param entry_count [Integer] Number of entries converted
+      # @param warnings [Array<String>] Conversion warnings
+      def initialize(
+        source_path:,
+        target_path:,
+        source_format:,
+        target_format:,
+        source_size:,
+        target_size:,
+        duration:,
+        entry_count:,
+        warnings: []
+      )
+        @source_path = source_path
+        @target_path = target_path
+        @source_format = source_format
+        @target_format = target_format
+        @source_size = source_size
+        @target_size = target_size
+        @duration = duration
+        @entry_count = entry_count
+        @warnings = warnings
+        @compression_ratio = calculate_compression_ratio
+      end
+
+      # Get size reduction percentage
+      # @return [Float] Size reduction as percentage
+      def size_reduction
+        return 0.0 if source_size.zero?
+
+        ((source_size - target_size).to_f / source_size * 100).round(2)
+      end
+
+      # Get size ratio
+      # @return [Float] Target size as percentage of source size
+      def size_ratio
+        return 0.0 if source_size.zero?
+
+        (target_size.to_f / source_size * 100).round(2)
+      end
+
+      # Check if conversion resulted in smaller file
+      # @return [Boolean] True if target is smaller
+      def smaller?
+        target_size < source_size
+      end
+
+      # Check if conversion resulted in larger file
+      # @return [Boolean] True if target is larger
+      def larger?
+        target_size > source_size
+      end
+
+      # Check if there were warnings
+      # @return [Boolean] True if warnings exist
+      def warnings?
+        !warnings.empty?
+      end
+
+      # Get average processing speed
+      # @return [Float] MB/s processing speed
+      def processing_speed
+        return 0.0 if duration.zero? || source_size.zero?
+
+        speed = source_size / duration / 1_048_576.0
+        rounded = speed.round(2)
+        # Return actual speed if rounding would give 0 but speed is positive
+        rounded.zero? && speed.positive? ? speed : rounded
+      end
+
+      # Convert to hash
+      # @return [Hash] Result as hash
+      def to_h
+        {
+          source_path: source_path,
+          target_path: target_path,
+          source_format: source_format,
+          target_format: target_format,
+          source_size: source_size,
+          target_size: target_size,
+          size_reduction: size_reduction,
+          size_ratio: size_ratio,
+          duration: duration,
+          entry_count: entry_count,
+          processing_speed: processing_speed,
+          warnings: warnings,
+        }
+      end
+
+      # Format as human-readable string
+      # @return [String] Formatted result
+      def to_s
+        "Converted #{source_path} (#{format_size(source_size)}) to " \
+          "#{target_path} (#{format_size(target_size)}) in #{duration.round(2)}s. " \
+          "#{size_reduction.positive? ? "Saved #{size_reduction.to_i}%" : "Increased #{(-size_reduction).to_i}%"}"
+      end
+
+      private
+
+      def calculate_compression_ratio
+        return 0.0 if source_size.zero?
+
+        (1.0 - (target_size.to_f / source_size)).round(4)
+      end
+
+      def format_size(bytes)
+        return "0 B" if bytes.zero?
+
+        units = %w[B KB MB GB TB]
+        exp = (Math.log(bytes) / Math.log(1024)).to_i
+        exp = [exp, units.size - 1].min
+
+        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+      end
+    end
+  end
+end

data/lib/omnizip/models/eta_result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+module Omnizip
+  module Models
+    # Model representing an ETA (Estimated Time to Arrival) calculation result.
+    #
+    # This class encapsulates the result of ETA calculations, including
+    # seconds remaining, formatted time string, and confidence interval.
+    class ETAResult
+      attr_accessor :seconds_remaining, :formatted, :confidence_lower,
+                    :confidence_upper
+
+      # Get confidence interval as array
+      #
+      # @return [Array<Float>] [lower, upper] bounds in seconds
+      def confidence_interval
+        [confidence_lower, confidence_upper]
+      end
+
+      # Check if ETA is reliable (confidence interval is reasonable)
+      #
+      # @return [Boolean] true if confidence interval is within 50% of estimate
+      def reliable?
+        unless seconds_remaining && confidence_lower && confidence_upper
+          return false
+        end
+
+        range = confidence_upper - confidence_lower
+        range < (seconds_remaining * 0.5)
+      end
+
+      def to_h
+        {
+          seconds_remaining: @seconds_remaining,
+          formatted: @formatted,
+          confidence_lower: @confidence_lower,
+          confidence_upper: @confidence_upper,
+        }.compact
+      end
+    end
+  end
+end

data/lib/omnizip/models/extraction_rule.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Models
+    # Represents a rule for extracting files from an archive
+    #
+    # Defines what files to extract and how to extract them using
+    # patterns, predicates, and options.
+    class ExtractionRule
+      attr_reader :patterns, :predicates, :options
+
+      # Initialize a new extraction rule
+      #
+      # @param patterns [Array<String, Regexp>] Patterns to match
+      # @param predicates [Array<Proc>] Custom predicates for matching
+      # @param options [Hash] Extraction options
+      # @option options [Boolean] :preserve_paths Keep directory structure
+      # @option options [Boolean] :flatten Extract all to destination root
+      # @option options [Boolean] :overwrite Overwrite existing files
+      # @option options [String] :dest_prefix Prefix for destination paths
+      def initialize(patterns: [], predicates: [], options: {})
+        @patterns = Array(patterns)
+        @predicates = Array(predicates)
+        @options = default_options.merge(options)
+      end
+
+      # Add a pattern to the rule
+      #
+      # @param pattern [String, Regexp] Pattern to add
+      # @return [self]
+      def add_pattern(pattern)
+        @patterns << pattern
+        self
+      end
+
+      # Add a predicate to the rule
+      #
+      # @param predicate [Proc] Predicate block to add
+      # @return [self]
+      def add_predicate(&predicate)
+        @predicates << predicate if predicate
+        self
+      end
+
+      # Check if any patterns are defined
+      #
+      # @return [Boolean]
+      def patterns?
+        !@patterns.empty?
+      end
+
+      # Check if any predicates are defined
+      #
+      # @return [Boolean]
+      def predicates?
+        !@predicates.empty?
+      end
+
+      # Check if the rule has any conditions
+      #
+      # @return [Boolean]
+      def conditions?
+        patterns? || predicates?
+      end
+
+      # Get option value
+      #
+      # @param key [Symbol] Option key
+      # @return [Object] Option value
+      def [](key)
+        @options[key]
+      end
+
+      # Set option value
+      #
+      # @param key [Symbol] Option key
+      # @param value [Object] Option value
+      def []=(key, value)
+        @options[key] = value
+      end
+
+      # Check if paths should be preserved
+      #
+      # @return [Boolean]
+      def preserve_paths?
+        @options[:preserve_paths]
+      end
+
+      # Check if paths should be flattened
+      #
+      # @return [Boolean]
+      def flatten?
+        @options[:flatten]
+      end
+
+      # Check if existing files should be overwritten
+      #
+      # @return [Boolean]
+      def overwrite?
+        @options[:overwrite]
+      end
+
+      private
+
+      def default_options
+        {
+          preserve_paths: true,
+          flatten: false,
+          overwrite: false,
+          dest_prefix: nil,
+        }
+      end
+    end
+  end
+end

data/lib/omnizip/models/filter_chain.rb

@@ -0,0 +1,144 @@
+# 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_relative "filter_config"
+
+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