omnizip 0.3.1

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

@@ -0,0 +1,101 @@
+# 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
+      # Move-to-Front (MTF) Transform
+      #
+      # MTF is a data transformation that exploits locality of reference.
+      # It maintains a list of symbols and moves accessed symbols to the
+      # front of the list. This tends to concentrate frequently accessed
+      # symbols at low indices, making the data more compressible.
+      #
+      # After BWT, the data often has runs of the same character. MTF
+      # converts these to runs of low numbers (often 0), which are then
+      # efficiently compressed by RLE.
+      #
+      # The algorithm:
+      # 1. Initialize symbol list [0, 1, 2, ..., 255]
+      # 2. For each byte in input:
+      #    - Find its position in the symbol list
+      #    - Output that position
+      #    - Move the byte to the front of the list
+      class Mtf
+        # Encode data using Move-to-Front transform
+        #
+        # @param data [String] Input data to transform
+        # @return [String] MTF-encoded data (byte indices)
+        def encode(data)
+          return "".b if data.empty?
+
+          symbols = init_symbol_list
+          result = []
+
+          data.each_byte do |byte|
+            # Find position of byte in symbol list
+            index = symbols.index(byte)
+            result << index
+
+            # Move byte to front
+            symbols.delete_at(index)
+            symbols.unshift(byte)
+          end
+
+          result.pack("C*")
+        end
+
+        # Decode MTF-encoded data
+        #
+        # @param data [String] MTF-encoded indices
+        # @return [String] Original data
+        def decode(data)
+          return "".b if data.empty?
+
+          symbols = init_symbol_list
+          result = []
+
+          data.each_byte do |index|
+            # Get byte at this index
+            byte = symbols[index]
+            result << byte
+
+            # Move byte to front
+            symbols.delete_at(index)
+            symbols.unshift(byte)
+          end
+
+          result.pack("C*")
+        end
+
+        private
+
+        # Initialize symbol list with all possible byte values
+        #
+        # @return [Array<Integer>] Symbol list [0, 1, 2, ..., 255]
+        def init_symbol_list
+          (0..255).to_a
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# 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?
+
+          result = []
+          i = 0
+          skip_count = 0
+
+          while i < data.length
+            byte = data.getbyte(i)
+            result << byte
+            i += 1
+
+            # Decrement skip counter if active
+            if skip_count.positive?
+              skip_count -= 1
+              next
+            end
+
+            # Check for run encoding (4 consecutive identical bytes)
+            next unless i >= 4 && consecutive_match?(result, byte, 4)
+
+            # Read run count
+            break if i >= data.length
+
+            count = data.getbyte(i)
+            i += 1
+
+            # Emit additional copies
+            count.times { result << byte }
+
+            # Skip checking for next 3 bytes (need 4 to form a run)
+            skip_count = 3
+          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,130 @@
+# 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
+    # 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
+      # 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)
+        input_data = input_stream.read
+        encoder = Encoder.new(output_stream,
+                              build_encoder_options(options))
+        encoder.encode_stream(input_data)
+      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)
+        if output_stream.respond_to?(:set_encoding)
+          output_stream.set_encoding(Encoding::BINARY)
+        end
+        decoder = Decoder.new(input_stream)
+        decompressed = decoder.decode_stream
+        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 = {}
+
+        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
+      end
+    end
+  end
+end
+
+# Load nested classes after BZip2 class is defined
+require_relative "bzip2/bwt"
+require_relative "bzip2/mtf"
+require_relative "bzip2/rle"
+require_relative "bzip2/huffman"
+require_relative "bzip2/encoder"
+require_relative "bzip2/decoder"
+
+# 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,38 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "constants"
+
+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,46 @@
+# frozen_string_literal: true
+
+require "zlib"
+require_relative "constants"
+
+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,128 @@
+# 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
+    # 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
+      # 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
+        encoder = Encoder.new(output_stream, build_encoder_options(options))
+        encoder.encode_stream(input_data)
+      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)
+        if output_stream.respond_to?(:set_encoding)
+          output_stream.set_encoding(Encoding::BINARY)
+        end
+        decoder = Decoder.new(input_stream)
+        decompressed = decoder.decode_stream
+        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 = {}
+
+        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
+
+# Load nested classes after Deflate class is defined
+require_relative "deflate/constants"
+require_relative "deflate/encoder"
+require_relative "deflate/decoder"
+
+# 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