omnizip 0.3.1

data/lib/omnizip/formats/rar/compression/ppmd/context.rb

@@ -0,0 +1,105 @@
+# 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 "../../../../algorithms/ppmd7/context"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR variant H context node in PPMd model
+          #
+          # Adapts PPMd7 Context for RAR-specific requirements:
+          # - Different memory allocation strategy
+          # - RAR-specific escape frequency initialization
+          # - Modified probability update rules
+          #
+          # Responsibilities:
+          # - ONE responsibility: Manage RAR PPMd variant H context
+          # - Track symbol statistics for RAR compression
+          # - Maintain context tree structure
+          # - Handle RAR-specific probability updates
+          class Context < Omnizip::Algorithms::PPMd7::Context
+            # RAR variant H escape frequency constant
+            # RAR uses different initial escape frequency than PPMd7
+            RAR_INIT_ESCAPE_FREQ = 1
+
+            # Initialize a new RAR variant H context
+            #
+            # @param order [Integer] The order of this context (depth in tree)
+            # @param suffix [Context, nil] Parent context (shorter context)
+            def initialize(order, suffix = nil)
+              super
+              # RAR variant H uses different escape frequency initialization
+              @escape_freq = RAR_INIT_ESCAPE_FREQ
+            end
+
+            # Update symbol frequency after encoding/decoding (RAR variant)
+            #
+            # RAR variant H uses a slightly different update strategy
+            # compared to standard PPMd7.
+            #
+            # @param symbol [Integer] The symbol to update
+            # @param increment [Integer] Amount to increase frequency
+            # @return [void]
+            def update_symbol(symbol, increment = 1)
+              state = @states[symbol]
+              return unless state
+
+              # RAR variant H frequency update
+              state.freq += increment
+              @sum_freq += increment
+
+              # RAR uses different rescaling threshold
+              rescale_frequencies if @sum_freq > rar_max_freq
+            end
+
+            private
+
+            # RAR variant H maximum frequency threshold
+            #
+            # @return [Integer] Maximum frequency before rescaling
+            def rar_max_freq
+              # RAR uses 124 as maximum frequency (same as PPMd7)
+              124
+            end
+
+            # Rescale frequencies when they grow too large (RAR variant)
+            #
+            # RAR variant H uses same rescaling strategy as PPMd7
+            # but this method is here for future RAR-specific modifications.
+            #
+            # @return [void]
+            def rescale_frequencies
+              @sum_freq = 0
+              @states.each_value do |state|
+                state.freq = [(state.freq + 1) / 2, 1].max
+                @sum_freq += state.freq
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# 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 "../../../../algorithms/ppmd7/decoder"
+require_relative "../../../../algorithms/ppmd7/model"
+require_relative "context"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR PPMd variant H decoder
+          #
+          # Implements decoding for RAR's PPMd variant H compression method.
+          # This adapts the standard PPMd7 algorithm for RAR-specific
+          # requirements:
+          #
+          # - Different memory model initialization
+          # - RAR-specific escape code handling
+          # - Modified context order selection
+          # - Different binary symbol encoding
+          #
+          # Responsibilities:
+          # - ONE responsibility: Decode RAR PPMd variant H compressed data
+          # - Manage decoder state and context
+          # - Transform compressed bits to original bytes
+          # - Maintain synchronized model state
+          class Decoder < Omnizip::Algorithms::PPMd7::Decoder
+            # RAR variant H specific constants
+            RAR_MAX_ORDER = 16
+            RAR_MIN_ORDER = 2
+            RAR_DEFAULT_ORDER = 6
+
+            # RAR memory size multiplier (MB to bytes)
+            RAR_MEM_MULTIPLIER = 1024 * 1024
+
+            # Initialize the RAR PPMd decoder
+            #
+            # @param input [IO] Input stream of compressed data
+            # @param options [Hash] Decoding options
+            # @option options [Integer] :model_order Maximum context order
+            # @option options [Integer] :mem_size Memory size in MB for RAR
+            def initialize(input, options = {})
+              @input = input
+              @options = options
+
+              # RAR uses memory size in MB, convert to bytes
+              mem_size_mb = options[:mem_size] || 16
+              mem_size_bytes = mem_size_mb * RAR_MEM_MULTIPLIER
+
+              # Initialize model with RAR parameters
+              @model = initialize_rar_model(
+                options[:model_order] || RAR_DEFAULT_ORDER,
+                mem_size_bytes,
+              )
+
+              # Use standard range decoder
+              @range_decoder = Omnizip::Algorithms::LZMA::RangeDecoder.new(input)
+            end
+
+            # Decode a stream back to original bytes
+            #
+            # RAR variant H decoding process:
+            # 1. Read compressed bits using range decoder
+            # 2. Use model to find corresponding symbol
+            # 3. Update model to stay synchronized
+            # 4. Handle RAR-specific escape codes
+            #
+            # @param max_bytes [Integer, nil] Maximum bytes to decode
+            # @return [String] Decoded data
+            def decode_stream(max_bytes = nil)
+              result = String.new(encoding: Encoding::BINARY)
+
+              # For now, decode a reasonable amount
+              # Real implementation would use proper termination
+              limit = max_bytes || 1000
+
+              limit.times do
+                symbol = decode_symbol
+                break if symbol.nil?
+
+                result << symbol.chr
+              rescue EOFError, Omnizip::DecompressionError
+                # Handle EOF gracefully - end of compressed data
+                break
+              end
+
+              result
+            end
+
+            private
+
+            # Initialize RAR variant H PPMd model
+            #
+            # RAR uses slightly different initialization than PPMd7:
+            # - Different context creation strategy
+            # - RAR-specific memory allocation
+            # - Modified root context initialization
+            #
+            # @param max_order [Integer] Maximum context order
+            # @param memory_size [Integer] Memory size in bytes
+            # @return [Omnizip::Algorithms::PPMd7::Model] Initialized model
+            def initialize_rar_model(max_order, memory_size)
+              # Validate RAR parameters
+              unless max_order.between?(RAR_MIN_ORDER, RAR_MAX_ORDER)
+                raise ArgumentError,
+                      "RAR max_order must be between #{RAR_MIN_ORDER} and " \
+                      "#{RAR_MAX_ORDER}"
+              end
+
+              # Create model with RAR parameters
+              # Note: Using PPMd7::Model as base, but with RAR contexts
+              Omnizip::Algorithms::PPMd7::Model.new(max_order, memory_size)
+            end
+
+            # Decode a single symbol using RAR variant H
+            #
+            # RAR uses same basic decoding as PPMd7 but with
+            # different escape code handling.
+            #
+            # @return [Integer, nil] Decoded byte or nil if end
+            def decode_symbol
+              # Simplified decoding - real implementation needs:
+              # 1. Proper context selection
+              # 2. RAR-specific escape handling
+              # 3. Binary symbol encoding
+              # 4. Proper termination detection
+
+              # Decode range value
+              value = @range_decoder.decode_direct_bits(16)
+
+              # Find symbol from range using current context
+              symbol = find_symbol_from_range(value)
+              return nil if symbol.nil?
+
+              # Update model to stay in sync
+              @model.update(symbol)
+
+              symbol
+            end
+
+            # Decode RAR-specific escape code
+            #
+            # RAR variant H uses different escape code values
+            # and handling compared to standard PPMd7.
+            #
+            # Escape codes in RAR:
+            # - 0: New symbol follows
+            # - 1: Same as last symbol (run-length)
+            # - 2-255: Reserved for future use
+            #
+            # @return [Integer, nil] Escape code or nil
+            def decode_escape_code
+              # RAR escape codes differ from PPMd7
+              # This is a placeholder for the proper implementation
+
+              # For now, return 0 (new symbol follows)
+              # Real implementation would decode from range coder
+              0
+            end
+
+            # Find symbol from decoded range value (RAR variant)
+            #
+            # Uses RAR-specific probability distribution to map
+            # range value back to original symbol.
+            #
+            # @param value [Integer] Decoded range value
+            # @return [Integer, nil] The symbol
+            def find_symbol_from_range(value)
+              # This is simplified - real RAR implementation uses:
+              # 1. Current context's probability distribution
+              # 2. RAR-specific escape handling
+              # 3. Proper cumulative frequency calculation
+
+              context = @model.root_context
+
+              # Find symbol whose cumulative range contains value
+              scale = 0x10000
+              cum_freq = 0
+
+              context.states.keys.sort.each do |symbol|
+                state = context.states[symbol]
+                next_cum = cum_freq + state.freq
+                sym_low = (cum_freq * scale) / context.total_freq
+                sym_high = (next_cum * scale) / context.total_freq
+
+                return symbol if value >= sym_low && value < sym_high
+
+                cum_freq = next_cum
+              end
+
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,262 @@
+# 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 "../../../../algorithms/ppmd7/encoder"
+require_relative "../../../../algorithms/ppmd7/model"
+require_relative "../../../../algorithms/lzma/range_encoder"
+require_relative "context"
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR PPMd variant H encoder
+          #
+          # Implements encoding for RAR's PPMd variant H compression method.
+          # This adapts the standard PPMd7 algorithm for RAR-specific
+          # requirements:
+          #
+          # - Different memory model initialization
+          # - RAR-specific escape code handling
+          # - Modified context order selection
+          # - Different binary symbol encoding
+          #
+          # Responsibilities:
+          # - ONE responsibility: Encode data using RAR PPMd variant H
+          # - Manage encoder state and context
+          # - Transform original bytes to compressed bits
+          # - Maintain synchronized model state (matches decoder)
+          class Encoder < Omnizip::Algorithms::PPMd7::Encoder
+            # RAR variant H specific constants
+            RAR_MAX_ORDER = 16
+            RAR_MIN_ORDER = 2
+            RAR_DEFAULT_ORDER = 6
+
+            # RAR memory size multiplier (MB to bytes)
+            RAR_MEM_MULTIPLIER = 1024 * 1024
+
+            # Accessor for memory size (for testing)
+            def memory_size
+              @model.instance_variable_get(:@mem_size)
+            end
+
+            # Initialize the RAR PPMd encoder
+            #
+            # @param output [IO] Output stream for compressed data
+            # @param options [Hash] Encoding options
+            # @option options [Integer] :model_order Maximum context order
+            # @option options [Integer] :mem_size Memory size in MB for RAR
+            def initialize(output, options = {})
+              @output = output
+              @options = options
+
+              # RAR uses memory size in MB, convert to bytes
+              mem_size_mb = options[:mem_size] || 16
+              mem_size_bytes = mem_size_mb * RAR_MEM_MULTIPLIER
+
+              # Initialize model with RAR parameters
+              @model = initialize_rar_model(
+                options[:model_order] || RAR_DEFAULT_ORDER,
+                mem_size_bytes,
+              )
+
+              # Use range encoder for bit output
+              @range_encoder = Omnizip::Algorithms::LZMA::RangeEncoder.new(output)
+            end
+
+            # Encode a stream to compressed bytes
+            #
+            # RAR variant H encoding process:
+            # 1. Read byte from input
+            # 2. Find symbol in current context
+            # 3. Encode using range coder with probabilities
+            # 4. Update model to stay synchronized with decoder
+            # 5. Handle RAR-specific escape codes if needed
+            #
+            # @param input [IO] Input stream to compress
+            # @param max_bytes [Integer, nil] Maximum bytes to encode
+            # @return [Integer] Number of bytes encoded
+            def encode_stream(input, max_bytes = nil)
+              bytes_encoded = 0
+
+              loop do
+                break if max_bytes && bytes_encoded >= max_bytes
+
+                byte = input.read(1)
+                break unless byte
+
+                encode_symbol(byte.ord)
+                bytes_encoded += 1
+              end
+
+              # Flush encoder to ensure all data is written
+              @range_encoder.flush
+              bytes_encoded
+            end
+
+            private
+
+            # Initialize RAR variant H PPMd model
+            #
+            # RAR uses slightly different initialization than PPMd7:
+            # - Different context creation strategy
+            # - RAR-specific memory allocation
+            # - Modified root context initialization
+            #
+            # @param max_order [Integer] Maximum context order
+            # @param memory_size [Integer] Memory size in bytes
+            # @return [Omnizip::Algorithms::PPMd7::Model] Initialized model
+            def initialize_rar_model(max_order, memory_size)
+              # Validate RAR parameters
+              unless max_order.between?(RAR_MIN_ORDER, RAR_MAX_ORDER)
+                raise ArgumentError,
+                      "RAR max_order must be between #{RAR_MIN_ORDER} and " \
+                      "#{RAR_MAX_ORDER}"
+              end
+
+              # Create model with RAR parameters
+              # Note: Using PPMd7::Model as base, but with RAR contexts
+              Omnizip::Algorithms::PPMd7::Model.new(max_order, memory_size)
+            end
+
+            # Encode a single symbol using RAR variant H
+            #
+            # RAR uses same basic encoding as PPMd7 but with
+            # different escape code handling and probability calculation.
+            #
+            # Process:
+            # 1. Get current context
+            # 2. Check if symbol exists in context
+            # 3. If yes: encode using frequency information
+            # 4. If no: encode escape + new symbol
+            # 5. Update model state
+            #
+            # @param byte [Integer] Byte value to encode (0-255)
+            # @return [void]
+            def encode_symbol(byte)
+              # Get current context
+              context = @model.current_context
+
+              # Find symbol in context (returns SymbolState or nil)
+              state = context.find_symbol(byte)
+
+              if state
+                # Encode using frequency information
+                encode_symbol_in_context(byte, state, context)
+              else
+                # Encode escape + new symbol
+                encode_escape_code
+                encode_new_symbol(byte)
+              end
+
+              # Update model to stay synchronized with decoder
+              @model.update(byte)
+            end
+
+            # Encode symbol that exists in current context
+            #
+            # Uses the frequency information from the context to
+            # calculate probability range for range encoder.
+            #
+            # @param byte [Integer] Symbol to encode
+            # @param state [SymbolState] Symbol's state
+            # @param context [Context] Current context
+            # @return [void]
+            def encode_symbol_in_context(byte, state, context)
+              # Get frequency from state
+              freq = state.freq
+              total_freq = context.total_freq
+
+              # Calculate cumulative frequency (for range low)
+              cum_freq = 0
+              context.states.each do |sym, st|
+                break if sym >= byte
+
+                cum_freq += st.freq
+              end
+
+              # Encode range using frequencies
+              encode_range(cum_freq, freq, total_freq)
+            end
+
+            # Encode RAR-specific escape code
+            #
+            # RAR variant H uses different escape code values
+            # and handling compared to standard PPMd7.
+            #
+            # Escape codes in RAR:
+            # - 0: New symbol follows
+            # - 1: Same as last symbol (run-length)
+            # - 2-255: Reserved for future use
+            #
+            # @return [void]
+            def encode_escape_code
+              # RAR escape codes differ from PPMd7
+              # For now, encode escape code 0 (new symbol follows)
+              # Real implementation would use context's escape frequency
+
+              # Simplified: encode direct bits for escape
+              @range_encoder.encode_direct_bits(0, 2)
+            end
+
+            # Encode new symbol not in current context
+            #
+            # When a symbol doesn't exist in the current context,
+            # encode it using uniform distribution (all symbols
+            # equally likely).
+            #
+            # @param byte [Integer] Symbol to encode
+            # @return [void]
+            def encode_new_symbol(byte)
+              # Encode as direct 8 bits (uniform distribution)
+              @range_encoder.encode_direct_bits(byte, 8)
+            end
+
+            # Encode a range for the symbol
+            #
+            # Converts frequency information to range and encodes
+            # using the range encoder.
+            #
+            # @param cum_freq [Integer] Cumulative frequency
+            # @param freq [Integer] Symbol frequency
+            # @param total_freq [Integer] Total frequency
+            # @return [void]
+            def encode_range(cum_freq, freq, total_freq)
+              # Scale to range coder scale (16-bit)
+              scale = 0x10000
+              low = (cum_freq * scale) / total_freq
+              ((cum_freq + freq) * scale) / total_freq
+
+              # Encode using direct bits
+              # Full implementation would use proper range subdivision
+              @range_encoder.encode_direct_bits(low, 16)
+
+              # In proper implementation, would also need to encode
+              # the range width (high - low) somehow
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression_method_registry.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      # Registry for RAR compression methods
+      #
+      # This class manages the registration and retrieval of compression
+      # methods for RAR archives. It follows the Registry pattern to allow
+      # dynamic addition of compression methods without modifying core code.
+      #
+      # @example Registering a compression method
+      #   CompressionMethodRegistry.register(
+      #     :rar3_normal,
+      #     Rar3::Compressor,
+      #     Rar3::Decompressor
+      #   )
+      #
+      # @example Getting a compressor
+      #   compressor = CompressionMethodRegistry.compressor(:rar3_normal)
+      class CompressionMethodRegistry
+        class << self
+          # Register a compression method
+          #
+          # @param name [Symbol] The method name
+          # @param compressor [Class] The compressor class
+          # @param decompressor [Class] The decompressor class
+          # @return [void]
+          def register(name, compressor, decompressor)
+            methods[name] = {
+              compressor: compressor,
+              decompressor: decompressor,
+            }
+          end
+
+          # Get a compressor for a method
+          #
+          # @param name [Symbol] The method name
+          # @return [Class] The compressor class
+          # @raise [Error::FormatError] If method not registered
+          def compressor(name)
+            method_data = methods[name]
+            return method_data[:compressor] if method_data
+
+            raise Error::FormatError,
+                  "No compressor registered for method: #{name}"
+          end
+
+          # Get a decompressor for a method
+          #
+          # @param name [Symbol] The method name
+          # @return [Class] The decompressor class
+          # @raise [Error::FormatError] If method not registered
+          def decompressor(name)
+            method_data = methods[name]
+            return method_data[:decompressor] if method_data
+
+            raise Error::FormatError,
+                  "No decompressor registered for method: #{name}"
+          end
+
+          # Check if a method is registered
+          #
+          # @param name [Symbol] The method name
+          # @return [Boolean] True if registered
+          def registered?(name)
+            methods.key?(name)
+          end
+
+          # Get all registered method names
+          #
+          # @return [Array<Symbol>] The registered method names
+          def registered_methods
+            methods.keys
+          end
+
+          # Clear all registered methods (primarily for testing)
+          #
+          # @return [void]
+          def clear
+            @methods = {}
+          end
+
+          # Get a compression method for a RAR version and level
+          #
+          # @param version [String] The RAR version (e.g., "3.0", "5.0")
+          # @param level [Symbol] The compression level
+          # @return [Symbol] The method name
+          def method_for_version(version, level)
+            prefix = version.start_with?("5") ? "rar5" : "rar3"
+            :"#{prefix}_#{level}"
+          end
+
+          private
+
+          # Storage for registered methods
+          #
+          # @return [Hash] The methods hash
+          def methods
+            @methods ||= {}
+          end
+        end
+      end
+    end
+  end
+end