omnizip 0.4.7-aarch64-linux

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

@@ -0,0 +1,146 @@
+# 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
+      # Run-Length Encoding (RLE) for BZip2
+      #
+      # This is a BZip2-specific RLE variant that encodes runs of
+      # identical bytes. After MTF, the data often contains long runs
+      # of zeros, which RLE compresses efficiently.
+      #
+      # BZip2 RLE encoding scheme:
+      # - Runs of 4-259 identical bytes are encoded as:
+      #   [byte, byte, byte, byte, count-4]
+      # - Where count is 0-255 representing 4-259 repetitions
+      # - Runs < 4 are left unencoded
+      # - This scheme avoids ambiguity in decoding
+      class Rle
+        # Maximum run length (4 + 255)
+        MAX_RUN_LENGTH = 259
+
+        # Minimum run length for encoding
+        MIN_RUN_LENGTH = 4
+
+        # Encode data using BZip2 RLE
+        #
+        # @param data [String] Input data to encode
+        # @return [String] RLE-encoded data
+        def encode(data)
+          return "".b if data.empty?
+
+          result = []
+          i = 0
+
+          while i < data.length
+            byte = data.getbyte(i)
+            run_length = count_run(data, i)
+
+            if run_length >= MIN_RUN_LENGTH
+              # Encode run: emit 4 copies + extra count
+              extra = [run_length - MIN_RUN_LENGTH, 255].min
+              4.times { result << byte }
+              result << extra
+              i += MIN_RUN_LENGTH + extra
+            else
+              # No run, emit single byte
+              result << byte
+              i += 1
+            end
+          end
+
+          result.pack("C*")
+        end
+
+        # Decode RLE-encoded data
+        #
+        # @param data [String] RLE-encoded data
+        # @return [String] Decoded data
+        def decode(data)
+          return "".b if data.empty?
+
+          # Single linear pass over the INPUT: a run marker is four
+          # identical bytes followed by an extra-count byte (the old
+          # decoder rescanned the growing output per byte, which made
+          # decode quadratic).
+          result = []
+          i = 0
+          n = data.bytesize
+
+          while i < n
+            byte = data.getbyte(i)
+            if byte == data.getbyte(i + 1) &&
+                byte == data.getbyte(i + 2) &&
+                byte == data.getbyte(i + 3)
+              count = data.getbyte(i + 4) || 0
+              result << byte
+              result << byte
+              result << byte
+              result << byte
+              count.times { result << byte }
+              i += 5
+            else
+              result << byte
+              i += 1
+            end
+          end
+
+          result.pack("C*")
+        end
+
+        private
+
+        # Count run length starting at given position
+        #
+        # @param data [String] Input data
+        # @param start [Integer] Starting position
+        # @return [Integer] Run length
+        def count_run(data, start)
+          byte = data.getbyte(start)
+          count = 1
+
+          (start + 1).upto([start + MAX_RUN_LENGTH - 1,
+                            data.length - 1].min) do |i|
+            break if data.getbyte(i) != byte
+
+            count += 1
+          end
+
+          count
+        end
+
+        # Check if last n bytes in array match the given byte
+        #
+        # @param array [Array<Integer>] Byte array
+        # @param byte [Integer] Byte to match
+        # @param count [Integer] Number of bytes to check
+        # @return [Boolean] True if last n bytes match
+        def consecutive_match?(array, byte, count)
+          return false if array.length < count
+
+          array[-count..].all?(byte)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/bzip2.rb

@@ -0,0 +1,108 @@
+# 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
+    # BZip2 block-sorting compression algorithm
+    #
+    # BZip2 combines several compression techniques in a pipeline:
+    # 1. Burrows-Wheeler Transform (BWT) - block-sorting transformation
+    # 2. Move-to-Front Transform (MTF) - exploits locality
+    # 3. Run-Length Encoding (RLE) - compresses repeated bytes
+    # 4. Huffman Coding - variable-length entropy encoding
+    #
+    # This algorithm is particularly effective for:
+    # - Text files with repetitive patterns
+    # - Data with high local similarity
+    # - Files where block-sorting improves compressibility
+    #
+    # Block size affects both compression ratio and memory usage.
+    # Larger blocks (up to 900KB) generally provide better compression
+    # but require more memory.
+    class BZip2 < Algorithm
+      # Nested classes - autoloaded
+      autoload :Bwt, "omnizip/algorithms/bzip2/bwt"
+      autoload :Rle, "omnizip/algorithms/bzip2/rle"
+      autoload :Bz2, "omnizip/algorithms/bzip2/bz2"
+
+      # Cross-namespace dependencies - autoloaded
+      autoload :Crc32, "omnizip/checksums/crc32"
+
+      # Get algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "bzip2"
+          meta.description = "BZip2 block-sorting compression using " \
+                             "BWT, MTF, RLE, and Huffman coding"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using BZip2 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)
+        level = level_from(options)
+        data = input_stream.read
+        output_stream.write(
+          Backends.compress("bzip2", data, level) { Bz2.compress(data, level) },
+        )
+      end
+
+      # Decompress BZip2-compressed data
+      #
+      # @param input_stream [IO] Input stream of compressed data
+      # @param output_stream [IO] Output stream for decompressed data
+      # @param options [Models::CompressionOptions] Decompression options
+      # @return [void]
+      def decompress(input_stream, output_stream, _options = nil)
+        output_stream.set_encoding(Encoding::BINARY)
+        compressed = input_stream.read
+        plain = Backends.decompress("bzip2", compressed, Backends::UNKNOWN_LENGTH) do
+          Bz2.decompress(compressed)
+        end
+        output_stream.write(plain)
+      end
+
+      private
+
+      # 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
+        level = options.respond_to?(:level) ? options.level : nil
+        (level || 9).clamp(1, 9)
+      end
+    end
+  end
+end
+
+# Register the BZip2 algorithm
+Omnizip::AlgorithmRegistry.register(:bzip2, Omnizip::Algorithms::BZip2)

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Algorithms
+    class Deflate
+      # Constants for Deflate algorithm
+      module Constants
+        # Compression levels
+        NO_COMPRESSION = Zlib::NO_COMPRESSION
+        BEST_SPEED = Zlib::BEST_SPEED
+        BEST_COMPRESSION = Zlib::BEST_COMPRESSION
+        DEFAULT_COMPRESSION = Zlib::DEFAULT_COMPRESSION
+
+        # Compression strategies
+        FILTERED = Zlib::FILTERED
+        HUFFMAN_ONLY = Zlib::HUFFMAN_ONLY
+        RLE = Zlib::RLE
+        FIXED = Zlib::FIXED
+        DEFAULT_STRATEGY = Zlib::DEFAULT_STRATEGY
+
+        # Buffer size for streaming operations
+        BUFFER_SIZE = 32 * 1024 # 32KB
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Algorithms
+    class Deflate
+      # Deflate decoder using Zlib
+      #
+      # This class wraps Ruby's Zlib::Inflate to provide Deflate
+      # decompression following the established Omnizip architecture.
+      class Decoder
+        include Constants
+
+        attr_reader :input_stream
+
+        # Initialize decoder
+        #
+        # @param input_stream [IO] Input stream of compressed data
+        def initialize(input_stream)
+          @input_stream = input_stream
+        end
+
+        # Decode compressed data stream
+        #
+        # @return [String] Decompressed data
+        def decode_stream
+          compressed = @input_stream.read
+          inflater = Zlib::Inflate.new
+          decompressed = inflater.inflate(compressed)
+          inflater.close
+          decompressed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Omnizip
+  module Algorithms
+    class Deflate
+      # Deflate encoder using Zlib
+      #
+      # This class wraps Ruby's Zlib::Deflate to provide Deflate
+      # compression following the established Omnizip architecture.
+      class Encoder
+        include Constants
+
+        attr_reader :output_stream, :options
+
+        # Initialize encoder
+        #
+        # @param output_stream [IO] Output stream for compressed data
+        # @param options [Hash] Encoder options
+        # @option options [Integer] :level Compression level (0-9)
+        # @option options [Integer] :strategy Compression strategy
+        # @option options [Integer] :window_bits Window size (8-15)
+        def initialize(output_stream, options = {})
+          @output_stream = output_stream
+          @options = options
+          @level = options[:level] || DEFAULT_COMPRESSION
+          @strategy = options[:strategy] || DEFAULT_STRATEGY
+          @window_bits = options[:window_bits] || 15
+        end
+
+        # Encode data stream
+        #
+        # @param data [String] Data to compress
+        # @return [void]
+        def encode_stream(data)
+          deflater = Zlib::Deflate.new(@level, @window_bits, 9, @strategy)
+          compressed = deflater.deflate(data, Zlib::FINISH)
+          deflater.close
+          @output_stream.write(compressed)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/deflate.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+# 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
+    # Deflate compression algorithm (RFC 1951)
+    #
+    # Deflate is a widely-used lossless data compression algorithm that
+    # combines LZ77 compression with Huffman coding. It is the foundation
+    # of many popular formats including ZIP, gzip, and PNG.
+    #
+    # The algorithm works in two phases:
+    # 1. LZ77 compression - Identifies repeated byte sequences
+    # 2. Huffman coding - Encodes the result using variable-length codes
+    #
+    # This implementation uses Ruby's Zlib library which provides a
+    # well-tested, efficient implementation of the Deflate algorithm.
+    #
+    # Deflate is particularly effective for:
+    # - Text files and source code
+    # - HTML, XML, and JSON documents
+    # - Files with repeated patterns
+    # - General-purpose compression needs
+    class Deflate < Algorithm
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/algorithms/deflate/constants"
+      autoload :Encoder, "omnizip/algorithms/deflate/encoder"
+      autoload :Decoder, "omnizip/algorithms/deflate/decoder"
+
+      # Get algorithm metadata
+      #
+      # @return [AlgorithmMetadata] Algorithm information
+      def self.metadata
+        Models::AlgorithmMetadata.new.tap do |meta|
+          meta.name = "deflate"
+          meta.description = "Deflate compression using LZ77 and " \
+                             "Huffman coding (RFC 1951)"
+          meta.version = "1.0.0"
+        end
+      end
+
+      # Compress data using Deflate 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
+        level = build_encoder_options(options)[:level] || 6
+        output_stream.write(
+          Backends.compress("zlib", input_data, level) do
+            encoder = Encoder.new(output_stream, build_encoder_options(options))
+            encoder.encode_stream(input_data)
+          end,
+        )
+      end
+
+      # Decompress Deflate-compressed data
+      #
+      # @param input_stream [IO] Input stream of compressed data
+      # @param output_stream [IO] Output stream for decompressed data
+      # @param options [Models::CompressionOptions] Decompression options
+      # @return [void]
+      def decompress(input_stream, output_stream, _options = nil)
+        output_stream.set_encoding(Encoding::BINARY)
+        compressed = input_stream.read
+        # The encoder's streams carry the zlib wrapper (RFC 1950) —
+        # the Rust "zlib" name speaks exactly that framing.
+        decompressed = Backends.decompress("zlib", compressed, Backends::UNKNOWN_LENGTH) do
+          Decoder.new(StringIO.new(compressed)).decode_stream
+        end
+        output_stream.write(decompressed)
+      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 = {}
+
+        # allowed: options is a public parameter; any object with #level is honored
+        if options.respond_to?(:level)
+          opts[:level] = map_compression_level(options.level)
+        end
+
+        opts
+      end
+
+      # Map generic compression level (0-9) to Zlib level
+      #
+      # @param level [Integer] Compression level (0-9)
+      # @return [Integer] Zlib compression level
+      def map_compression_level(level)
+        return Zlib::DEFAULT_COMPRESSION if level.nil?
+
+        case level
+        when 0 then Zlib::NO_COMPRESSION
+        when 1 then Zlib::BEST_SPEED
+        when 9 then Zlib::BEST_COMPRESSION
+        else level
+        end
+      end
+    end
+  end
+end
+
+# Register the Deflate algorithm
+Omnizip::AlgorithmRegistry.register(:deflate, Omnizip::Algorithms::Deflate)

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class Deflate64
+      # Constants for Deflate64 (Enhanced Deflate) algorithm
+      module Constants
+        # Dictionary/window size - 64KB vs 32KB in standard Deflate
+        DICTIONARY_SIZE = 65_536
+
+        # Match length constraints
+        MAX_MATCH_LENGTH = 258
+        MIN_MATCH_LENGTH = 3
+        MAX_DISTANCE = DICTIONARY_SIZE - 1
+
+        # Huffman coding constants
+        LITERAL_CODES = 286
+        DISTANCE_CODES = 30
+        LENGTH_CODES = 19
+
+        # Block types
+        BLOCK_TYPE_STORED = 0
+        BLOCK_TYPE_FIXED = 1
+        BLOCK_TYPE_DYNAMIC = 2
+
+        # End of block marker
+        END_OF_BLOCK = 256
+
+        # Maximum code lengths
+        MAX_LITERAL_CODE_LENGTH = 15
+        MAX_DISTANCE_CODE_LENGTH = 15
+
+        # Hash table size for LZ77
+        HASH_SIZE = 65_536
+        HASH_SHIFT = 5
+
+        # Search limits
+        MAX_CHAIN_LENGTH = 4096
+        GOOD_MATCH = 32
+        NICE_MATCH = 258
+        MAX_LAZY_MATCH = 258
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Omnizip
+  module Algorithms
+    class Deflate64
+      # Deflate64 decoder
+      class Decoder
+        include Constants
+
+        attr_reader :window_size
+
+        def initialize(input_stream)
+          @input_stream = input_stream
+          @window_size = DICTIONARY_SIZE
+          @window = []
+          @huffman = HuffmanCoder.new
+        end
+
+        # Decompress input stream to output stream
+        #
+        # @param output_stream [IO] Output data stream
+        def decompress(output_stream)
+          compressed_data = @input_stream.read
+
+          # Deserialize trees and compressed data
+          literal_tree, distance_tree, data = deserialize_with_trees(compressed_data)
+
+          # Decode Huffman-encoded data
+          tokens = @huffman.decode(data, literal_tree, distance_tree)
+
+          # Reconstruct data from LZ77 tokens
+          decompressed = reconstruct_from_tokens(tokens)
+
+          output_stream.write(decompressed)
+        end
+
+        # Deserialize compressed data with Huffman trees
+        #
+        # @param data [String] Serialized compressed data
+        # @return [Array] Literal tree, distance tree, compressed data
+        def deserialize_with_trees(data)
+          # Extract sizes (4 bytes each)
+          literal_size, distance_size = data.unpack("NN")
+          offset = 8
+
+          # Extract literal tree JSON
+          literal_json = data[offset, literal_size]
+          offset += literal_size
+
+          # Extract distance tree JSON
+          distance_json = data[offset, distance_size]
+          offset += distance_size
+
+          # Extract compressed data
+          compressed = data[offset..]
+
+          # Parse trees from JSON with symbol keys as integers
+          literal_tree = parse_tree_from_json(literal_json)
+          distance_tree = parse_tree_from_json(distance_json)
+
+          [literal_tree, distance_tree, compressed]
+        end
+
+        # Parse Huffman tree from JSON with integer keys
+        #
+        # @param json [String] JSON string
+        # @return [Hash] Huffman tree with integer keys
+        def parse_tree_from_json(json)
+          parsed = JSON.parse(json)
+          # Convert string keys back to integers
+          parsed.transform_keys(&:to_i)
+        end
+
+        # Reconstruct data from LZ77 tokens
+        #
+        # @param tokens [Array<Hash>] LZ77 tokens
+        # @return [String] Decompressed data
+        def reconstruct_from_tokens(tokens)
+          output = []
+
+          tokens.each do |token|
+            if token[:type] == :literal
+              byte_char = token[:value].chr(Encoding::BINARY)
+              output << byte_char
+              @window << token[:value]
+            elsif token[:type] == :match
+              copy_from_window(
+                output,
+                token[:distance],
+                token[:length],
+              )
+            end
+
+            # Maintain 64KB window
+            while @window.size > @window_size
+              @window.shift
+            end
+          end
+
+          output.join.force_encoding(Encoding::BINARY)
+        end
+
+        # Decode single block
+        #
+        # @param data [String] Compressed block
+        # @return [String] Decompressed data
+        def decode_block(data)
+          tokens = @huffman.decode(data, {}, {})
+          reconstruct_from_tokens(tokens)
+        end
+
+        private
+
+        # Copy data from sliding window
+        #
+        # @param output [Array] Output buffer
+        # @param distance [Integer] Distance back in window
+        # @param length [Integer] Number of bytes to copy
+        def copy_from_window(output, distance, length)
+          start_pos = @window.size - distance
+
+          # Check if we're trying to copy from beyond the window
+          if start_pos.negative?
+            raise Omnizip::DecompressionError,
+                  "Invalid distance: #{distance} exceeds window size #{@window.size}"
+          end
+
+          length.times do |i|
+            # Handle RLE case where we copy bytes we just wrote
+            idx = (start_pos + i) % @window.size
+            byte = @window[idx]
+
+            if byte.nil?
+              raise Omnizip::DecompressionError,
+                    "Window access failed at index #{idx} (start: #{start_pos}, i: #{i})"
+            end
+
+            byte_char = byte.chr(Encoding::BINARY)
+            output << byte_char
+            @window << byte
+
+            # Maintain window size during copy
+            @window.shift if @window.size > @window_size
+          end
+        end
+      end
+    end
+  end
+end