omnizip 0.3.1

data/lib/omnizip/formats/rar/compression/dispatcher.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        # Algorithm dispatcher for RAR compression
+        #
+        # Selects appropriate compression algorithm based on RAR method
+        # and dispatches to correct encoder/decoder.
+        #
+        # Responsibilities:
+        # - Algorithm selection based on compression method
+        # - Dispatch to appropriate decoder/encoder
+        # - Error handling for unsupported/unknown methods
+        #
+        # Note: Does NOT perform actual compression/decompression
+        # (delegated to decoder/encoder classes)
+        class Dispatcher
+          # RAR compression methods
+          METHOD_STORE = 0x30      # No compression
+          METHOD_FASTEST = 0x31    # LZ77+Huffman (fast)
+          METHOD_FAST = 0x32       # LZ77+Huffman
+          METHOD_NORMAL = 0x33     # LZ77+Huffman (default)
+          METHOD_GOOD = 0x34       # LZ77+Huffman or PPMd
+          METHOD_BEST = 0x35       # PPMd
+
+          # Custom errors
+          class UnsupportedMethodError < StandardError; end
+          class DecompressionError < StandardError; end
+          class CompressionError < StandardError; end
+
+          class << self
+            # Decompress data using appropriate algorithm
+            #
+            # @param method [Integer] RAR compression method (0x30-0x35)
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            # @raise [UnsupportedMethodError] if method unknown
+            # @raise [DecompressionError] if decompression fails
+            def decompress(method, input, output, options = {})
+              case method
+              when METHOD_STORE
+                decompress_store(input, output)
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL
+                decompress_lz77_huffman(input, output, options)
+              when METHOD_GOOD
+                decompress_good(input, output, options)
+              when METHOD_BEST
+                decompress_ppmd(input, output, options)
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            rescue StandardError => e
+              unless e.is_a?(UnsupportedMethodError)
+                raise DecompressionError,
+                      "Decompression failed: #{e.message}"
+              end
+
+              raise
+            end
+
+            # Compress data using appropriate algorithm
+            #
+            # @param method [Integer] RAR compression method
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            # @raise [UnsupportedMethodError] if method unknown
+            # @raise [CompressionError] if compression fails
+            # @raise [NotImplementedError] for methods not yet implemented
+            def compress(method, input, output, options = {})
+              case method
+              when METHOD_STORE
+                compress_store(input, output)
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL
+                compress_lz77_huffman(input, output, options)
+              when METHOD_GOOD
+                compress_good(input, output, options)
+              when METHOD_BEST
+                compress_ppmd(input, output, options)
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            rescue StandardError => e
+              raise CompressionError, "Compression failed: #{e.message}" unless
+                e.is_a?(UnsupportedMethodError) || e.is_a?(NotImplementedError)
+
+              raise
+            end
+
+            private
+
+            # Decompress METHOD_STORE (no compression)
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            def decompress_store(input, output)
+              # Direct copy, no decompression needed
+              ::IO.copy_stream(input, output)
+            end
+
+            # Decompress using LZ77+Huffman decoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_lz77_huffman(input, output, options)
+              require_relative "lz77_huffman/decoder"
+
+              decoder = LZ77Huffman::Decoder.new(input, options)
+              decoded_data = decoder.decode
+              output.write(decoded_data)
+            end
+
+            # Decompress METHOD_GOOD (adaptive)
+            #
+            # For now, default to LZ77+Huffman
+            # In future, could analyze content to choose algorithm
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_good(input, output, options)
+              # TODO: Implement content-based algorithm selection
+              # For now, use LZ77+Huffman as default
+              decompress_lz77_huffman(input, output, options)
+            end
+
+            # Decompress using PPMd decoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_ppmd(input, output, options)
+              require_relative "ppmd/decoder"
+
+              decoder = PPMd::Decoder.new(input, options)
+              decoded_data = decoder.decode_stream
+              output.write(decoded_data)
+            end
+
+            # Compress METHOD_STORE (no compression)
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            def compress_store(input, output)
+              # Direct copy, no compression
+              ::IO.copy_stream(input, output)
+            end
+
+            # Compress using LZ77+Huffman encoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_lz77_huffman(input, output, options)
+              require_relative "lz77_huffman/encoder"
+
+              encoder = LZ77Huffman::Encoder.new(output, options)
+              encoder.encode(input)
+            end
+
+            # Compress METHOD_GOOD (adaptive)
+            #
+            # For now, default to LZ77+Huffman
+            # In future, could analyze content to choose algorithm
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_good(input, output, options)
+              # TODO: Implement content-based algorithm selection
+              # For now, use LZ77+Huffman as default
+              compress_lz77_huffman(input, output, options)
+            end
+
+            # Compress using PPMd encoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_ppmd(input, output, options)
+              require_relative "ppmd/encoder"
+
+              encoder = PPMd::Encoder.new(output, options)
+              encoder.encode_stream(input)
+            end
+
+            # Select decoder class for method (for testing)
+            #
+            # @param method [Integer] Compression method
+            # @return [Class, nil] Decoder class or nil for METHOD_STORE
+            def select_decoder(method)
+              case method
+              when METHOD_STORE
+                nil
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL, METHOD_GOOD
+                require_relative "lz77_huffman/decoder"
+                LZ77Huffman::Decoder
+              when METHOD_BEST
+                require_relative "ppmd/decoder"
+                PPMd::Decoder
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/lz77_huffman/decoder.rb

@@ -0,0 +1,216 @@
+# 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 "../bit_stream"
+require_relative "sliding_window"
+require_relative "huffman_coder"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module LZ77Huffman
+          # RAR LZ77+Huffman decoder
+          #
+          # Orchestrates the decoding of RAR METHOD_NORMAL compressed data.
+          # Combines Huffman coding with LZ77 sliding window compression.
+          #
+          # Responsibilities:
+          # - ONE responsibility: Orchestrate LZ77+Huffman decoding
+          # - Parse Huffman trees from bit stream
+          # - Decode symbols using Huffman coder
+          # - Process LZ77 matches via sliding window
+          # - Manage decoder state and output
+          #
+          # RAR LZ77+Huffman Format:
+          # 1. Block header with Huffman tree definitions
+          # 2. Compressed data stream
+          # 3. Symbols: literals (0-255), matches (length+distance), end marker
+          class Decoder
+            # Symbol ranges
+            LITERAL_SYMBOLS = (0..255)
+            END_OF_BLOCK = 256
+            MATCH_SYMBOLS = (257..511)
+
+            # Match parameters
+            MIN_MATCH_LENGTH = 3
+            MAX_MATCH_LENGTH = 257
+
+            # Window size for RAR4
+            DEFAULT_WINDOW_SIZE = 64 * 1024
+
+            # Initialize LZ77+Huffman decoder
+            #
+            # @param input [IO] Compressed input stream
+            # @param options [Hash] Decoding options
+            # @option options [Integer] :window_size Window size in bytes
+            def initialize(input, options = {})
+              @bit_stream = BitStream.new(input, :read)
+              @window = SlidingWindow.new(options[:window_size] || DEFAULT_WINDOW_SIZE)
+              @huffman = HuffmanCoder.new
+              @output = String.new(encoding: Encoding::BINARY)
+            end
+
+            # Decode compressed data
+            #
+            # Main decoding loop:
+            # 1. Parse Huffman tree (simplified for MVP)
+            # 2. Decode symbols until end-of-block
+            # 3. Process literals and matches
+            #
+            # @param max_output [Integer, nil] Maximum output bytes
+            # @return [String] Decoded data
+            def decode(max_output = nil)
+              @output.clear
+
+              # Parse Huffman tree (simplified - real RAR has complex structure)
+              parse_huffman_trees
+
+              # Decode symbols until end-of-block or max output
+              loop do
+                break if max_output && @output.bytesize >= max_output
+
+                symbol = @huffman.decode_symbol(@bit_stream)
+                break if symbol.nil? || symbol == END_OF_BLOCK
+
+                process_symbol(symbol)
+              end
+
+              @output
+            rescue EOFError
+              @output
+            end
+
+            # Get window size
+            #
+            # @return [Integer] Window size in bytes
+            def window_size
+              @window.size
+            end
+
+            private
+
+            # Parse Huffman trees from bit stream
+            #
+            # RAR uses multiple Huffman tables for different symbol types.
+            # This is a simplified implementation for MVP.
+            #
+            # Simplified format (written by Encoder):
+            # 1. 16-bit number of symbols (always 512 for MVP)
+            # 2. Code lengths (4 bits each, 512 × 4 bits = 2048 bits = 256 bytes)
+            #
+            # Real RAR format:
+            # - MC table: Main code (literals + length codes)
+            # - LD table: Low distance bits
+            # - RC table: Repeat codes
+            # - LDD table: Low distance for distance codes
+            #
+            # @return [void]
+            def parse_huffman_trees
+              # Read number of symbols from encoder (16-bit header)
+              num_symbols = @bit_stream.read_bits(16)
+
+              # Parse tree structure
+              @huffman.parse_tree(@bit_stream, num_symbols)
+            end
+
+            # Process a decoded symbol
+            #
+            # Symbol types:
+            # - 0-255: Literal byte
+            # - 256: End of block
+            # - 257-511: Match (length+distance)
+            #
+            # @param symbol [Integer] Decoded symbol
+            # @return [void]
+            def process_symbol(symbol)
+              if LITERAL_SYMBOLS.cover?(symbol)
+                process_literal(symbol)
+              elsif MATCH_SYMBOLS.cover?(symbol)
+                process_match(symbol)
+              end
+            end
+
+            # Process literal byte
+            #
+            # @param byte [Integer] Literal byte value (0-255)
+            # @return [void]
+            def process_literal(byte)
+              @output << byte.chr
+              @window.add_byte(byte)
+            end
+
+            # Process LZ77 match
+            #
+            # Match symbol encodes both length and distance information.
+            # Additional bits may be read for exact values.
+            #
+            # @param symbol [Integer] Match symbol (257-511)
+            # @return [void]
+            def process_match(symbol)
+              length = decode_match_length(symbol)
+              distance = decode_match_distance
+
+              # Copy match from window
+              match_bytes = @window.copy_match(distance, length)
+              match_bytes.each { |byte| @output << byte.chr }
+            end
+
+            # Decode match length from symbol
+            #
+            # RAR encodes length in the symbol itself plus extra bits.
+            # This is simplified for MVP.
+            #
+            # @param symbol [Integer] Match symbol
+            # @return [Integer] Match length
+            def decode_match_length(symbol)
+              # Simplified length decoding
+              # Real RAR uses complex length encoding with extra bits
+
+              base_length = symbol - 257 + MIN_MATCH_LENGTH
+
+              # Could read extra bits here for longer lengths
+              # For now, use base length
+              [base_length, MAX_MATCH_LENGTH].min
+            end
+
+            # Decode match distance
+            #
+            # Distance is encoded separately, often with additional
+            # Huffman tables and extra bits.
+            #
+            # @return [Integer] Match distance
+            def decode_match_distance
+              # Simplified distance decoding
+              # Real RAR uses separate Huffman table for distance
+
+              # Read distance as direct bits (simplified)
+              # Real implementation would use distance Huffman table
+              distance_bits = 16 # Changed from 8 to 16 bits for 64KB window
+              @bit_stream.read_bits(distance_bits)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/lz77_huffman/encoder.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "../bit_stream"
+require_relative "match_finder"
+require_relative "huffman_builder"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module LZ77Huffman
+          # RAR LZ77+Huffman encoder
+          #
+          # Implements compression using LZ77 string matching combined with
+          # Huffman coding for symbol encoding.
+          #
+          # ## Simplified Huffman Tree Format (MVP)
+          #
+          # This implementation uses a simplified tree format for portability
+          # and ease of implementation. The format differs from official RAR
+          # but maintains full compatibility between encoder and decoder.
+          #
+          # ### Format Structure:
+          # ```
+          # [16-bit num_symbols] [code_lengths...]
+          #       2 bytes         512 × 4 bits = 256 bytes
+          # ```
+          #
+          # ### Details:
+          # - **Header**: 16-bit number of symbols (always 512 for MVP)
+          #   - 0-255: Literal bytes
+          #   - 256: End-of-block marker
+          #   - 257-511: LZ77 match symbols
+          #
+          # - **Code Lengths**: 4 bits per symbol × 512 symbols = 2048 bits
+          #   - Each symbol gets a 4-bit code length (0-15)
+          #   - Length 0 means symbol not used
+          #   - Lengths build canonical Huffman tree
+          #
+          # ### Trade-offs:
+          # - **Fixed Overhead**: 258 bytes (2 + 256) per block
+          # - **Simplicity**: Easy to implement and debug
+          # - **Portability**: Pure Ruby, no external dependencies
+          # - **Compatibility**: Encoder/decoder use identical format
+          #
+          # ### Real RAR Format Differences:
+          # Real RAR uses a more complex format with:
+          # - RLE compression of code lengths
+          # - Multiple Huffman tables (MC, LD, RC, LDD)
+          # - Adaptive tree updates
+          # - More efficient length encoding
+          #
+          # The simplified format is sufficient for MVP and can be upgraded
+          # to full RAR format in future versions without breaking the API.
+          #
+          # @see Decoder for decoding implementation
+          # @see HuffmanCoder for tree building
+          # @see HuffmanBuilder for code generation
+          class Encoder
+            LITERAL_SYMBOLS = (0..255)
+            END_OF_BLOCK = 256
+            MATCH_SYMBOLS = (257..511)
+            MIN_MATCH_LENGTH = 3
+            MAX_MATCH_LENGTH = 257
+
+            attr_reader :compressed_size
+
+            def initialize(output, _options = {})
+              @output = output
+              @bit_stream = BitStream.new(output, :write)
+              @match_finder = MatchFinder.new
+              @huffman_builder = HuffmanBuilder.new
+              @compressed_size = 0
+            end
+
+            def encode(input)
+              data = input.is_a?(String) ? input : input.read
+              return 0 if data.empty?
+
+              start_pos = @output.pos
+              items = collect_items(data)
+              codes = @huffman_builder.generate_codes
+              write_huffman_tree(codes)
+
+              items.each do |item|
+                if item[:type] == :literal
+                  encode_literal(item[:value], codes)
+                else
+                  encode_match(item[:offset], item[:length], codes)
+                end
+              end
+
+              encode_symbol(END_OF_BLOCK, codes)
+              @bit_stream.flush
+              @compressed_size = @output.pos - start_pos
+            end
+
+            private
+
+            def collect_items(data)
+              items = []
+              position = 0
+
+              while position < data.size
+                match = @match_finder.find_match(data.bytes, position)
+
+                if match && match.length >= MIN_MATCH_LENGTH
+                  items << { type: :match, offset: match.offset,
+                             length: match.length }
+                  match_symbol = encode_match_symbol(match.length)
+                  @huffman_builder.add_symbol(match_symbol)
+                  position += match.length
+                else
+                  byte = data.bytes[position]
+                  items << { type: :literal, value: byte }
+                  @huffman_builder.add_symbol(byte)
+                  position += 1
+                end
+              end
+
+              @huffman_builder.add_symbol(END_OF_BLOCK)
+              items
+            end
+
+            def write_huffman_tree(codes)
+              lengths = Array.new(512, 0)
+              codes.each { |symbol, (_code, length)| lengths[symbol] = length }
+              @bit_stream.write_bits(512, 16)
+              lengths.each { |length| @bit_stream.write_bits(length, 4) }
+            end
+
+            def encode_literal(byte, codes)
+              encode_symbol(byte, codes)
+            end
+
+            def encode_match(offset, length, codes)
+              match_symbol = encode_match_symbol(length)
+              encode_symbol(match_symbol, codes)
+              @bit_stream.write_bits(offset, 16) # Changed from 8 to 16 bits for 64KB window
+            end
+
+            def encode_match_symbol(length)
+              base_symbol = length - MIN_MATCH_LENGTH + 257
+              [base_symbol, 511].min
+            end
+
+            def encode_symbol(symbol, codes)
+              code, length = codes[symbol]
+              return unless code && length
+
+              @bit_stream.write_bits(code, length)
+            end
+          end
+        end
+      end
+    end
+  end
+end