omnizip 0.3.1

data/lib/omnizip/algorithms/lzma.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "../algorithm"
+require_relative "../models/algorithm_metadata"
+
+module Omnizip
+  module Algorithms
+    # LZMA (Lempel-Ziv-Markov chain Algorithm) compression
+    #
+    # LZMA is a lossless data compression algorithm that combines
+    # Lempel-Ziv dictionary compression with range coding (a form
+    # of arithmetic coding). It achieves high compression ratios
+    # by using adaptive probability models.
+    #
+    # This implementation uses:
+    # - LZ77 match finder for finding duplicate sequences
+    # - Range coding for probability-based encoding
+    # - Adaptive bit models that adjust based on input data
+    # - State machine for compression context tracking
+    #
+    # The algorithm operates by:
+    # 1. Finding matches using LZ77 dictionary compression
+    # 2. Encoding decisions using range coder with probability models
+    # 3. Maintaining state for optimal compression
+    class LZMA < Algorithm
+      # Initialize the LZMA algorithm with options
+      #
+      # @param options [Hash] Algorithm options
+      # @option options [Integer] :lc Literal context bits (default: 3)
+      # @option options [Integer] :lp Literal position bits (default: 0)
+      # @option options [Integer] :pb Position bits (default: 2)
+      # @option options [Integer] :dict_size Dictionary size (default: 4MB)
+      # @option options [Boolean] :lzma2_mode Raw LZMA mode (no header, for 7-Zip)
+      def initialize(options = {})
+        super()
+        @lc = options[:lc] || 3
+        @lp = options[:lp] || 0
+        @pb = options[:pb] || 2
+        @dict_size = options[:dict_size] || (4 * 1024 * 1024) # 4 MB default
+        @lzma2_mode = options[:lzma2_mode]
+        @uncompressed_size = options[:uncompressed_size] || options[:size]
+      end
+
+      # Get algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "lzma"
+          meta.description = "LZMA compression using range coding " \
+                             "and dictionary compression"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using LZMA algorithm
+      #
+      # @param input_stream [IO] Input stream to compress
+      # @param output_stream [IO] Output stream for compressed data
+      # @param options [Models::CompressionOptions] Compression options
+      # @return [void]
+      def compress(input_stream, output_stream, options = nil)
+        input_data = input_stream.read
+        encoder = Encoder.new(output_stream, build_encoder_options(options))
+        encoder.encode_stream(input_data)
+      end
+
+      # Decompress LZMA-compressed data
+      #
+      # @param input_stream [IO] Input stream of compressed data
+      # @param output_stream [IO] Output stream for decompressed data
+      # @param options [Models::CompressionOptions, Hash] Decompression options
+      # @return [IO] The output_stream (for chaining)
+      def decompress(input_stream, output_stream, options = nil)
+        # Set binary encoding on output stream for proper byte handling
+        output_stream.set_encoding(Encoding::BINARY) if output_stream.respond_to?(:set_encoding)
+
+        # Build decoder options, merging with instance variables as fallbacks
+        decoder_opts = build_decoder_options(options)
+        decoder_opts[:lzma2_mode] = @lzma2_mode if @lzma2_mode && !decoder_opts.key?(:lzma2_mode)
+        decoder_opts[:lc] = @lc if @lc && !decoder_opts.key?(:lc)
+        decoder_opts[:lp] = @lp if @lp && !decoder_opts.key?(:lp)
+        decoder_opts[:pb] = @pb if @pb && !decoder_opts.key?(:pb)
+        decoder_opts[:dict_size] = @dict_size if @dict_size && !decoder_opts.key?(:dict_size)
+        decoder_opts[:uncompressed_size] = @uncompressed_size if @uncompressed_size && !decoder_opts.key?(:uncompressed_size)
+        decoder_opts[:uncompressed_size] ||= options[:size] if options.respond_to?(:key?) && options.key?(:size)
+
+        decoder = Decoder.new(input_stream, decoder_opts)
+        decoder.decode_stream(output_stream)
+        output_stream
+      end
+
+      private
+
+      # Build encoder options from compression options
+      #
+      # @param options [Models::CompressionOptions, Hash, nil] Compression opts
+      # @return [Hash] Encoder options
+      def build_encoder_options(options)
+        return {} if options.nil?
+
+        opts = {}
+
+        # Handle Hash-like options
+        if options.respond_to?(:[])
+          opts[:lc] = options[:lc] if options[:lc]
+          opts[:lp] = options[:lp] if options[:lp]
+          opts[:pb] = options[:pb] if options[:pb]
+          opts[:dict_size] = options[:dict_size] if options[:dict_size]
+          opts[:write_size] = options[:write_size] if options.key?(:write_size)
+          if options.key?(:sdk_compatible)
+            opts[:sdk_compatible] =
+              options[:sdk_compatible]
+          end
+          if options.key?(:xz_compatible)
+            opts[:xz_compatible] =
+              options[:xz_compatible]
+          end
+          opts[:raw_mode] = options[:raw_mode] if options.key?(:raw_mode)
+        end
+
+        # Handle level from both Hash and CompressionOptions
+        level = if options.respond_to?(:level)
+                  options.level || 5
+                elsif options.respond_to?(:[]) && options[:level]
+                  options[:level] || 5
+                else
+                  5
+                end
+
+        opts[:dict_size] ||= dictionary_size_for_level(level)
+
+        opts
+      end
+
+      # Build decoder options from decompression options
+      #
+      # @param options [Models::CompressionOptions, Hash, nil] Decompression opts
+      # @return [Hash] Decoder options
+      def build_decoder_options(options)
+        return {} if options.nil?
+
+        # Handle case where options is an Integer (uncompressed size) instead of Hash
+        return {} if options.is_a?(Integer)
+
+        opts = {}
+
+        # Handle Hash-like options - pass through all decoder-relevant options
+        if options.respond_to?(:key?)
+          opts[:sdk_compatible] = options[:sdk_compatible] if options.key?(:sdk_compatible)
+          opts[:lzma2_mode] = options[:lzma2_mode] if options.key?(:lzma2_mode)
+          opts[:lc] = options[:lc] if options.key?(:lc)
+          opts[:lp] = options[:lp] if options.key?(:lp)
+          opts[:pb] = options[:pb] if options.key?(:pb)
+          opts[:dict_size] = options[:dict_size] if options.key?(:dict_size)
+          opts[:uncompressed_size] = options[:uncompressed_size] if options.key?(:uncompressed_size)
+          opts[:size] = options[:size] if options.key?(:size)
+        end
+
+        opts
+      end
+
+      # Get dictionary size based on compression level
+      #
+      # @param level [Integer] Compression level (0-9)
+      # @return [Integer] Dictionary size in bytes
+      def dictionary_size_for_level(level)
+        1 << case level
+             when 0..1 then 16   # 64KB
+             when 2..3 then 20   # 1MB
+             when 4..5 then 22   # 4MB
+             when 6..7 then 23   # 8MB
+             else 24 # 16MB
+             end
+      end
+    end
+  end
+end
+
+# Load nested classes after LZMA class is defined
+require_relative "lzma/constants"
+require_relative "lzma/bit_model"
+require_relative "lzma/probability_models"
+require_relative "lzma/xz_range_encoder"
+require_relative "lzma/dictionary"
+require_relative "lzma/lzma_state"
+require_relative "lzma/range_coder"
+require_relative "lzma/range_encoder"
+require_relative "lzma/range_decoder"
+require_relative "lzma/match"
+require_relative "lzma/match_finder"
+require_relative "lzma/optimal_encoder"
+require_relative "lzma/state"
+require_relative "lzma/xz_state"
+require_relative "lzma/xz_probability_models"
+require_relative "lzma/xz_price_calculator"
+require_relative "lzma/xz_match_finder_adapter"
+require_relative "../implementations/seven_zip/lzma/state_machine"
+require_relative "lzma/length_coder"
+require_relative "lzma/distance_coder"
+require_relative "lzma/literal_encoder"
+require_relative "lzma/literal_decoder"
+require_relative "lzma/match_finder_config"
+require_relative "../implementations/seven_zip/lzma/match_finder"
+require_relative "lzma/match_finder_factory"
+require_relative "../implementations/seven_zip/lzma/encoder"
+require_relative "lzma/xz_encoder"
+require_relative "lzma/encoder"
+require_relative "lzma/decoder"
+require_relative "lzma/xz_utils_decoder"
+
+# LZMA container format decoders (DIFFERENT from XZ format!)
+# These are standalone formats that use LZMA1 compression
+require_relative "lzma/lzma_alone_decoder"  # .lzma (LZMA_Alone) format
+require_relative "lzma/lzip_decoder"        # .lz (lzip) format
+
+# Register the LZMA algorithm
+Omnizip::AlgorithmRegistry.register(:lzma, Omnizip::Algorithms::LZMA)

data/lib/omnizip/algorithms/lzma2/chunk_manager.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+require_relative "constants"
+
+module Omnizip
+  module Algorithms
+    class LZMA2
+      # LZMA2 Chunk Manager - handles chunk boundaries and decisions
+      #
+      # This class is responsible for:
+      # - Splitting data into chunks of appropriate size
+      # - Deciding whether to compress or store each chunk uncompressed
+      # - Managing chunk buffering
+      # - Providing thread safety infrastructure (for future use)
+      #
+      # The chunk manager implements intelligent compression decisions
+      # based on compression ratio thresholds.
+      #
+      # IMPORTANT: LZMA2 format limits uncompressed chunk size to 65536 bytes
+      # due to 2-byte size encoding. This manager enforces that limit.
+      class ChunkManager
+        include Constants
+
+        attr_reader :chunk_size
+
+        # Maximum bytes per chunk (LZMA2 spec limit)
+        MAX_CHUNK_BYTES = UNCOMPRESSED_SIZE_MAX + 1 # 65536 bytes
+
+        # Chunk data model
+        #
+        # Represents a single chunk of data with its metadata
+        class Chunk
+          attr_reader :data, :compressed_data, :is_compressed
+
+          # Initialize a chunk
+          #
+          # @param data [String] Uncompressed chunk data
+          def initialize(data)
+            @data = data
+            @compressed_data = nil
+            @is_compressed = false
+          end
+
+          # Set compressed data
+          #
+          # @param compressed [String] Compressed data
+          # @return [void]
+          def compressed_data=(compressed)
+            @compressed_data = compressed
+            @is_compressed = true
+          end
+
+          # Get the data to write (compressed or uncompressed)
+          #
+          # @return [String] Data to write
+          def output_data
+            @is_compressed ? @compressed_data : @data
+          end
+
+          # Get size of output data
+          #
+          # @return [Integer] Size in bytes
+          def output_size
+            output_data.bytesize
+          end
+
+          # Get uncompressed size
+          #
+          # @return [Integer] Size in bytes
+          def uncompressed_size
+            @data.bytesize
+          end
+        end
+
+        # Initialize chunk manager
+        #
+        # @param chunk_size [Integer] Desired chunk size
+        def initialize(chunk_size = CHUNK_SIZE_DEFAULT)
+          @chunk_size = validate_chunk_size(chunk_size)
+          # Enforce LZMA2 format limit
+          @effective_chunk_size = [@chunk_size, MAX_CHUNK_BYTES].min
+        end
+
+        # Split data into chunks
+        #
+        # @param data [String] Data to split
+        # @return [Array<Chunk>] Array of chunks
+        def create_chunks(data)
+          chunks = []
+          pos = 0
+
+          while pos < data.bytesize
+            chunk_data = data.byteslice(pos, @effective_chunk_size)
+            chunks << Chunk.new(chunk_data)
+            pos += @effective_chunk_size
+          end
+
+          chunks
+        end
+
+        # Decide if chunk should be compressed
+        #
+        # Makes decision based on compression ratio threshold.
+        # If compressed size is not significantly smaller than
+        # uncompressed size, store uncompressed.
+        #
+        # @param chunk [Chunk] Chunk with compressed data set
+        # @return [Boolean] True if should use compression
+        def should_compress?(chunk)
+          return false unless chunk.compressed_data
+
+          # Calculate compression ratio
+          ratio = chunk.output_size.to_f / chunk.uncompressed_size
+
+          # Only use compression if ratio is below threshold
+          ratio < COMPRESSION_THRESHOLD
+        end
+
+        # Decide if chunk is last chunk
+        #
+        # @param chunk_index [Integer] Current chunk index
+        # @param total_chunks [Integer] Total number of chunks
+        # @return [Boolean] True if last chunk
+        def last_chunk?(chunk_index, total_chunks)
+          chunk_index == total_chunks - 1
+        end
+
+        # Calculate optimal chunk size for data
+        #
+        # This method can be used to dynamically adjust chunk size
+        # based on data characteristics (future enhancement).
+        #
+        # @param data_size [Integer] Total data size
+        # @return [Integer] Optimal chunk size
+        def optimal_chunk_size(data_size)
+          # For now, use effective chunk size
+          # Future: could adjust based on data size
+          return @effective_chunk_size if data_size <= @effective_chunk_size * 2
+
+          # For larger data, might want larger chunks (up to max)
+          [@effective_chunk_size * 2, MAX_CHUNK_BYTES].min
+        end
+
+        private
+
+        # Validate chunk size
+        #
+        # @param size [Integer] Chunk size to validate
+        # @return [Integer] Validated size
+        # @raise [ArgumentError] If size is invalid
+        def validate_chunk_size(size)
+          unless size.between?(CHUNK_SIZE_MIN, CHUNK_SIZE_MAX)
+            raise ArgumentError,
+                  "Chunk size must be between #{CHUNK_SIZE_MIN} " \
+                  "and #{CHUNK_SIZE_MAX}"
+          end
+          size
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma2/constants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    # LZMA2 Format Constants (from XZ Utils specification)
+    module LZMA2Const
+      # Maximum size of compressed data per chunk (excluding headers)
+      CHUNK_MAX = 65536 # 64 KB
+
+      # Maximum size of uncompressed data per chunk
+      # Limited by 16-bit size field in LZMA2 header (stores size-1)
+      # Max value is 0xFFFF + 1 = 65536 bytes
+      UNCOMPRESSED_MAX = 65536 # 64 KB
+
+      # Maximum size of LZMA2 chunk header
+      HEADER_MAX = 6
+
+      # Size of uncompressed chunk header
+      HEADER_UNCOMPRESSED = 3
+
+      # Control byte values
+      CONTROL_END = 0x00                    # End of stream marker
+      CONTROL_UNCOMPRESSED_RESET = 0x01     # Uncompressed with dict reset
+      CONTROL_UNCOMPRESSED = 0x02           # Uncompressed without reset
+      CONTROL_LZMA_MIN = 0x80               # Minimum LZMA control byte
+
+      # Control byte flags (for LZMA chunks)
+      FLAG_UNCOMPRESSED_SIZE = 0x80         # Base flag for LZMA chunks
+      FLAG_RESET_STATE = 0x20               # Reset LZMA state
+      FLAG_RESET_PROPERTIES = 0x40          # Reset properties + state
+      FLAG_RESET_DICT = 0x60                # Reset dict + properties + state
+
+      # Dictionary size encoding constants
+      DICT_SIZE_MIN = 4096 # 4 KB minimum
+      DICT_SIZE_MAX = 0xFFFFFFFF # 4 GB maximum
+    end
+
+    # Alias for backward compatibility
+    LZMA2Constants = LZMA2Const
+  end
+end

data/lib/omnizip/algorithms/lzma2/encoder.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "properties"
+require_relative "simple_lzma2_encoder"
+
+module Omnizip
+  module Algorithms
+    # LZMA2 encoder - delegates to XzLZMA2Encoder
+    #
+    # This class provides a backward-compatible API that delegates to the
+    # complete XzLZMA2Encoder implementation ported from XZ Utils.
+    #
+    # Based on XZ Utils lzma2_encoder.c
+    class LZMA2Encoder
+      attr_reader :dict_size, :lc, :lp, :pb
+
+      # Initialize the encoder
+      #
+      # @param dict_size [Integer] Dictionary size (default: 8MB)
+      # @param lc [Integer] Literal context bits (default: 3)
+      # @param lp [Integer] Literal position bits (default: 0)
+      # @param pb [Integer] Position bits (default: 2)
+      # @param standalone [Boolean] If true, write property byte for
+      #   standalone LZMA2 files (default: false)
+      def initialize(
+        dict_size: 8 * 1024 * 1024,
+        lc: 3,
+        lp: 0,
+        pb: 2,
+        standalone: false,
+        **
+      )
+        @dict_size = dict_size
+        @lc = lc
+        @lp = lp
+        @pb = pb
+        @standalone = standalone
+
+        # Create the SimpleLZMA2Encoder (uses working XzEncoder internally)
+        @encoder = LZMA2::SimpleLZMA2Encoder.new(
+          dict_size: dict_size,
+          lc: lc,
+          lp: lp,
+          pb: pb,
+          standalone: standalone,
+        )
+      end
+
+      # Encode data into LZMA2 format
+      #
+      # @param input [String] Input data to compress
+      # @return [String] LZMA2 compressed data
+      def encode(input)
+        @encoder.encode(input)
+      end
+
+      # Compress data from input stream to output stream
+      # This method provides compatibility with the AlgorithmRegistry interface
+      #
+      # @param input_io [IO] Input stream to read from
+      # @param output_io [IO] Output stream to write to
+      # @param level [Integer] Compression level (not used, kept for compatibility)
+      # @return [Integer] Number of bytes written
+      def compress(input_io, output_io, _level = nil)
+        input_data = input_io.read
+        compressed = encode(input_data)
+        output_io.write(compressed)
+        compressed.bytesize
+      end
+
+      # Decompress data from input stream to output stream
+      # This method provides compatibility with the AlgorithmRegistry interface
+      #
+      # @param input_io [IO] Input stream to read from
+      # @param output_io [IO] Output stream to write to
+      # @param size [Integer] Expected uncompressed size (optional)
+      # @return [Integer] Number of bytes written
+      def decompress(input_io, output_io, _size = nil)
+        # Check if this is being called for 7-Zip format (raw LZMA2 stream)
+        # 7-Zip stores LZMA2 without a property byte
+        # We can detect this by checking if input_io is a StringIO (which is used
+        # by StreamDecompressor for 7-Zip format)
+        raw_mode = input_io.is_a?(StringIO)
+
+        # Create a decoder instance
+        decoder = LZMA2::Decoder.new(input_io, raw_mode: raw_mode)
+
+        # For raw_mode (7-Zip format), we need to provide dict_size
+        # Use default 8MB if not specified
+        if raw_mode
+          # Re-create decoder with dict_size option
+          decoder = LZMA2::Decoder.new(input_io,
+                                       raw_mode: true,
+                                       dict_size: @dict_size)
+        end
+
+        # Decode the stream
+        result = decoder.decode_stream
+
+        # Write to output
+        output_io.write(result)
+
+        result.bytesize
+      end
+
+      # Encode dictionary size for LZMA2 properties
+      # Returns a single byte encoding the dictionary size
+      #
+      # @param dict_size [Integer] Dictionary size to encode
+      # @return [Integer] Encoded dictionary size byte
+      def self.encode_dict_size(dict_size)
+        # LZMA2 dictionary size encoding (XZ Utils format)
+        # Byte value d encodes dictionary size as:
+        #   If d < 40: size = 2^((d/2) + 12)  (for even d)
+        #           or size = 3 * 2^((d-1)/2 + 11)  (for odd d)
+        #   If d == 40: size = 0xFFFFFFFF (4GB - 1)
+
+        # Clamp to valid range
+        d = [dict_size, LZMA2Constants::DICT_SIZE_MIN].max
+
+        # For 8MB (8 * 1024 * 1024 = 8388608 = 2^23):
+        # We want: 2^((d/2) + 12) = 2^23
+        # So: (d/2) + 12 = 23
+        # Therefore: d/2 = 11, d = 22
+
+        # Calculate log2 of dict_size
+        log2_size = 0
+        temp = d
+        while temp > 1
+          log2_size += 1
+          temp >>= 1
+        end
+
+        # Encoding formula for power-of-2 sizes:
+        # d = 2 * (log2_size - 12)
+        if d == (1 << log2_size)
+          # Exact power of 2
+          [(log2_size - 12) * 2, 40].min
+        else
+          # Between 2^n and 2^n + 2^(n-1), use odd encoding
+          [((log2_size - 12) * 2) + 1, 40].min
+        end
+      end
+    end
+  end
+end