omnizip 0.3.25 → 0.3.26

data/lib/omnizip/algorithms/bzip2.rb

@@ -41,11 +41,8 @@ module Omnizip
     class BZip2 < Algorithm
       # Nested classes - autoloaded
       autoload :Bwt, "omnizip/algorithms/bzip2/bwt"
-      autoload :Mtf, "omnizip/algorithms/bzip2/mtf"
       autoload :Rle, "omnizip/algorithms/bzip2/rle"
-      autoload :Huffman, "omnizip/algorithms/bzip2/huffman"
-      autoload :Encoder, "omnizip/algorithms/bzip2/encoder"
-      autoload :Decoder, "omnizip/algorithms/bzip2/decoder"
+      autoload :Bz2, "omnizip/algorithms/bzip2/bz2"
 
       # Cross-namespace dependencies - autoloaded
       autoload :Crc32, "omnizip/checksums/crc32"
@@ -69,10 +66,8 @@ module Omnizip
       # @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)
+        level = level_from(options)
+        output_stream.write(Bz2.compress(input_stream.read, level))
       end
 
       # Decompress BZip2-compressed data
@@ -83,43 +78,20 @@ module Omnizip
       # @return [void]
       def decompress(input_stream, output_stream, _options = nil)
         output_stream.set_encoding(Encoding::BINARY)
-        decoder = Decoder.new(input_stream)
-        decompressed = decoder.decode_stream
-        output_stream.write(decompressed)
+        output_stream.write(Bz2.decompress(input_stream.read))
       end
 
       private
 
-      # Build encoder options from compression options
-      #
-      # @param options [Models::CompressionOptions, nil] Compression opts
-      # @return [Hash] Encoder options
-      def build_encoder_options(options)
-        return {} if options.nil?
-
-        opts = {}
+      # Compression level (1-9) from options; bzip2's levels map
+      # directly to 100 KB..900 KB block sizes.
+      def level_from(options)
+        return 9 if options.nil?
+        return (options[:level] || 9).clamp(1, 9) if options.is_a?(Hash)
 
         # allowed: options is a public parameter; any object with #level is honored
-        if options.respond_to?(:level)
-          level = options.level || 9
-          opts[:block_size] = block_size_for_level(level)
-        end
-
-        opts
-      end
-
-      # Get block size based on compression level
-      #
-      # BZip2 traditionally uses levels 1-9 corresponding to
-      # 100KB-900KB block sizes
-      #
-      # @param level [Integer] Compression level (1-9)
-      # @return [Integer] Block size in bytes
-      def block_size_for_level(level)
-        # Clamp level to valid range
-        level = [[level, 1].max, 9].min
-        # Each level = 100KB
-        level * 100_000
+        level = options.respond_to?(:level) ? options.level : nil
+        (level || 9).clamp(1, 9)
       end
     end
   end

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.25"
+  VERSION = "0.3.26"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.25
+  version: 0.3.26
 platform: ruby
 authors:
 - Ribose Inc.
@@ -226,10 +226,7 @@ files:
 - lib/omnizip/algorithms/.keep
 - lib/omnizip/algorithms/bzip2.rb
 - lib/omnizip/algorithms/bzip2/bwt.rb
-- lib/omnizip/algorithms/bzip2/decoder.rb
-- lib/omnizip/algorithms/bzip2/encoder.rb
-- lib/omnizip/algorithms/bzip2/huffman.rb
-- lib/omnizip/algorithms/bzip2/mtf.rb
+- lib/omnizip/algorithms/bzip2/bz2.rb
 - lib/omnizip/algorithms/bzip2/rle.rb
 - lib/omnizip/algorithms/deflate.rb
 - lib/omnizip/algorithms/deflate/constants.rb

data/lib/omnizip/algorithms/bzip2/decoder.rb

@@ -1,187 +0,0 @@
-# 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.
-
-module Omnizip
-  module Algorithms
-    class BZip2 < Algorithm
-      # BZip2 Decoder
-      #
-      # Reverses the full BZip2 compression pipeline:
-      # 1. Read block headers
-      # 2. Decode Huffman coding
-      # 3. Reverse Run-Length Encoding (RLE)
-      # 4. Reverse Move-to-Front Transform (MTF)
-      # 5. Reverse Burrows-Wheeler Transform (BWT)
-      # 6. Verify CRC32 checksum
-      #
-      # Processes each block independently and concatenates results.
-      class Decoder
-        attr_reader :input
-
-        # Initialize decoder
-        #
-        # @param input [IO] Input stream
-        # @param options [Hash] Decoding options
-        def initialize(input, _options = {})
-          @input = input
-          @bwt = Bwt.new
-          @mtf = Mtf.new
-          @rle = Rle.new
-          @huffman = Huffman.new
-        end
-
-        # Decode stream using BZip2 algorithm
-        #
-        # @return [String] Decoded data
-        def decode_stream
-          result = []
-
-          # Read and decode all blocks
-          loop do
-            block_data = decode_block
-            break unless block_data
-
-            result << block_data
-          end
-
-          result.join.b
-        end
-
-        private
-
-        # Decode single block
-        #
-        # @return [String, nil] Decoded block or nil if no more blocks
-        def decode_block
-          # Read block header
-          crc_bytes = @input.read(4)
-          return nil unless crc_bytes && crc_bytes.length == 4
-
-          expected_crc = crc_bytes.unpack1("N")
-          primary_index = @input.read(4).unpack1("N")
-          @input.read(4).unpack1("N")
-          rle_length = @input.read(4).unpack1("N")
-
-          # Read Huffman code table
-          codes = read_huffman_codes
-
-          # Read encoded data
-          encoded_length = @input.read(4).unpack1("N")
-          encoded_data = @input.read(encoded_length)
-
-          # Rebuild Huffman tree from codes
-          tree = rebuild_huffman_tree(codes)
-
-          # Decode Huffman
-          rle_data = @huffman.decode(encoded_data, tree, rle_length)
-
-          # Reverse RLE
-          mtf_data = @rle.decode(rle_data)
-
-          # Reverse MTF
-          bwt_data = @mtf.decode(mtf_data)
-
-          # Reverse BWT
-          original_data = @bwt.decode(bwt_data, primary_index)
-
-          # Verify CRC
-          actual_crc = Checksums::Crc32.calculate(original_data)
-          if actual_crc != expected_crc
-            raise "CRC mismatch: expected #{expected_crc}, " \
-                  "got #{actual_crc}"
-          end
-
-          original_data
-        end
-
-        # Read Huffman code table from stream
-        #
-        # @return [Hash<Integer, String>] Symbol => binary code
-        def read_huffman_codes
-          codes = {}
-          code_count = @input.read(2).unpack1("n")
-
-          code_count.times do
-            symbol = @input.read(1).unpack1("C")
-            code_length = @input.read(1).unpack1("C")
-            codes[symbol] = code_length
-          end
-
-          codes
-        end
-
-        # Rebuild Huffman tree from code lengths
-        #
-        # Creates canonical Huffman codes and builds tree
-        #
-        # @param code_lengths [Hash<Integer, Integer>] Symbol => length
-        # @return [Huffman::Node] Root of Huffman tree
-        def rebuild_huffman_tree(code_lengths)
-          # Sort symbols by code length, then by symbol value
-          sorted_symbols = code_lengths.sort_by { |sym, len| [len, sym] }
-
-          # Generate canonical codes
-          codes = {}
-          code_value = 0
-          prev_length = 0
-
-          sorted_symbols.each do |symbol, length|
-            # Shift code value for new length
-            code_value <<= (length - prev_length)
-            codes[symbol] = format("%0#{length}b", code_value)
-            code_value += 1
-            prev_length = length
-          end
-
-          # Build tree from codes
-          build_tree_from_codes(codes)
-        end
-
-        # Build Huffman tree from code strings
-        #
-        # @param codes [Hash<Integer, String>] Symbol => binary code
-        # @return [Huffman::Node] Root node
-        def build_tree_from_codes(codes)
-          root = Huffman::Node.new(nil, 0)
-
-          codes.each do |symbol, code|
-            current = root
-
-            code.each_char do |bit|
-              if bit == "0"
-                current.left ||= Huffman::Node.new(nil, 0)
-                current = current.left
-              else
-                current.right ||= Huffman::Node.new(nil, 0)
-                current = current.right
-              end
-            end
-
-            current.symbol = symbol
-          end
-
-          root
-        end
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-# 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.
-
-module Omnizip
-  module Algorithms
-    class BZip2 < Algorithm
-      # BZip2 Encoder
-      #
-      # Orchestrates the full BZip2 compression pipeline:
-      # 1. Block splitting (configurable block size)
-      # 2. Burrows-Wheeler Transform (BWT)
-      # 3. Move-to-Front Transform (MTF)
-      # 4. Run-Length Encoding (RLE)
-      # 5. Huffman Coding
-      # 6. CRC32 checksum calculation
-      #
-      # Each block is compressed independently for better parallelization
-      # potential and error recovery.
-      class Encoder
-        attr_reader :output, :block_size
-
-        # Block size constants (in bytes)
-        MIN_BLOCK_SIZE = 100_000  # 100KB
-        MAX_BLOCK_SIZE = 900_000  # 900KB
-        DEFAULT_BLOCK_SIZE = 900_000 # 900KB (level 9)
-
-        # Initialize encoder
-        #
-        # @param output [IO] Output stream
-        # @param options [Hash] Encoding options
-        # @option options [Integer] :block_size Block size in bytes
-        def initialize(output, options = {})
-          @output = output
-          @block_size = validate_block_size(
-            options[:block_size] || DEFAULT_BLOCK_SIZE,
-          )
-          @bwt = Bwt.new
-          @mtf = Mtf.new
-          @rle = Rle.new
-          @huffman = Huffman.new
-        end
-
-        # Encode stream using BZip2 algorithm
-        #
-        # @param input [String] Input data to encode
-        # @return [void]
-        def encode_stream(input)
-          return if input.empty?
-
-          # Split into blocks and encode each
-          blocks = split_into_blocks(input)
-          blocks.each { |block| encode_block(block) }
-        end
-
-        private
-
-        # Validate and clamp block size to valid range
-        #
-        # @param size [Integer] Requested block size
-        # @return [Integer] Validated block size
-        def validate_block_size(size)
-          size.clamp(MIN_BLOCK_SIZE, MAX_BLOCK_SIZE)
-        end
-
-        # Split input into blocks
-        #
-        # @param input [String] Input data
-        # @return [Array<String>] Array of blocks
-        def split_into_blocks(input)
-          blocks = []
-          offset = 0
-
-          while offset < input.length
-            block = input[offset, @block_size]
-            blocks << block if block && !block.empty?
-            offset += @block_size
-          end
-
-          blocks
-        end
-
-        # Encode single block through full pipeline
-        #
-        # @param block [String] Block data
-        # @return [void]
-        def encode_block(block)
-          # Calculate CRC of original data
-          crc = Checksums::Crc32.calculate(block)
-
-          # Apply BWT
-          bwt_data, primary_index = @bwt.encode(block)
-
-          # Apply MTF
-          mtf_data = @mtf.encode(bwt_data)
-
-          # Apply RLE
-          rle_data = @rle.encode(mtf_data)
-
-          # Build frequency table for Huffman
-          frequencies = build_frequency_table(rle_data)
-
-          # Build Huffman tree and generate codes
-          tree = @huffman.build_tree(frequencies)
-          codes = generate_canonical_codes(tree)
-
-          # Encode data with Huffman
-          encoded_data = @huffman.encode(rle_data, codes)
-
-          # Write block to output
-          write_block(crc, primary_index, block.length, codes,
-                      encoded_data, rle_data.length)
-        end
-
-        # Build frequency table from data
-        #
-        # @param data [String] Input data
-        # @return [Hash<Integer, Integer>] Byte => frequency
-        def build_frequency_table(data)
-          freq = Hash.new(0)
-          data.each_byte { |byte| freq[byte] += 1 }
-          freq
-        end
-
-        # Generate canonical Huffman codes from tree
-        #
-        # @param tree [Huffman::Node] Huffman tree root
-        # @return [Hash<Integer, String>] Symbol => canonical code
-        def generate_canonical_codes(tree)
-          # Get standard codes first
-          standard_codes = @huffman.generate_codes(tree)
-
-          # Convert to code lengths
-          code_lengths = {}
-          standard_codes.each do |symbol, code|
-            code_lengths[symbol] = code.length
-          end
-
-          # Generate canonical codes from lengths
-          # Sort by (length, symbol) to ensure deterministic ordering
-          sorted_symbols = code_lengths.sort_by { |sym, len| [len, sym] }
-
-          canonical_codes = {}
-          code_value = 0
-          prev_length = 0
-
-          sorted_symbols.each do |symbol, length|
-            # Shift code value for new length
-            code_value <<= (length - prev_length)
-            canonical_codes[symbol] = format("%0#{length}b", code_value)
-            code_value += 1
-            prev_length = length
-          end
-
-          canonical_codes
-        end
-
-        # Write encoded block to output
-        #
-        # @param crc [Integer] CRC32 of original block
-        # @param primary_index [Integer] BWT primary index
-        # @param original_length [Integer] Original block length
-        # @param codes [Hash] Huffman codes
-        # @param encoded_data [String] Huffman-encoded data
-        # @param rle_length [Integer] Length after RLE
-        # @return [void]
-        def write_block(crc, primary_index, original_length, codes,
-                        encoded_data, rle_length)
-          write_block_header(crc, primary_index, original_length, rle_length)
-          write_huffman_codes(codes)
-          write_encoded_data(encoded_data)
-        end
-
-        # Write block header
-        #
-        # @param crc [Integer] CRC32 checksum
-        # @param primary_index [Integer] BWT primary index
-        # @param original_length [Integer] Original block length
-        # @param rle_length [Integer] RLE length
-        # @return [void]
-        def write_block_header(crc, primary_index, original_length,
-                               rle_length)
-          @output.write([crc].pack("N"))
-          @output.write([primary_index].pack("N"))
-          @output.write([original_length].pack("N"))
-          @output.write([rle_length].pack("N"))
-        end
-
-        # Write Huffman codes to output
-        #
-        # @param codes [Hash] Huffman codes
-        # @return [void]
-        def write_huffman_codes(codes)
-          @output.write([codes.size].pack("n"))
-
-          codes.each do |symbol, code|
-            @output.write([symbol].pack("C"))
-            @output.write([code.length].pack("C"))
-          end
-        end
-
-        # Write encoded data to output
-        #
-        # @param encoded_data [String] Huffman-encoded data
-        # @return [void]
-        def write_encoded_data(encoded_data)
-          @output.write([encoded_data.length].pack("N"))
-          @output.write(encoded_data)
-        end
-      end
-    end
-  end
-end