omnizip 0.3.8 → 0.3.10

data/lib/omnizip/error.rb

@@ -3,59 +3,64 @@
 # Copyright (C) 2025 Ribose Inc.
 
 module Omnizip
-  # Base error class for all Omnizip errors
   class Error < StandardError
   end
 
-  # Error raised when compression fails
   class CompressionError < Error
   end
 
-  # Error raised when decompression fails
   class DecompressionError < Error
   end
 
-  # Error raised when an algorithm is not found
   class AlgorithmNotFoundError < Error
   end
 
-  # Error raised when an unknown algorithm is requested
-  class UnknownAlgorithmError < Error
+  # Canonical alias of +AlgorithmNotFoundError+. Older code referenced
+  # +UnknownAlgorithmError+; both names are kept for backward
+  # compatibility.
+  UnknownAlgorithmError = AlgorithmNotFoundError
+
+  class UnknownChecksumError < Error
+  end
+
+  class UnknownFilterError < Error
+  end
+
+  class UnknownEncryptionStrategyError < Error
+  end
+
+  class ConversionNotSupportedError < Error
   end
 
-  # Error raised when a format is not supported
   class UnsupportedFormatError < Error
   end
 
-  # Error raised when format parsing fails
   class FormatError < Error
   end
 
-  # Error raised when archive is invalid
   class InvalidArchiveError < Error
   end
 
-  # Error raised when I/O operations fail
-  class IOError < Error
+  # Renamed from +IOError+ to avoid shadowing Ruby's built-in IOError.
+  # The legacy name is kept as an alias.
+  class IOOperationError < Error
   end
+  IOError = IOOperationError
 
-  # Error raised when checksum validation fails
   class ChecksumError < Error
   end
 
-  # Error raised when optimization strategy is not found
-  class OptimizationNotFound < Error
+  # Canonical name. +OptimizationNotFound+ kept as alias.
+  class OptimizationNotFoundError < Error
   end
+  OptimizationNotFound = OptimizationNotFoundError
 
-  # Error raised when progress tracking fails
   class ProgressError < Error
   end
 
-  # Error raised when ETA calculation fails
   class ETAError < Error
   end
 
-  # Error raised when RAR write is attempted without license
   class NotLicensedError < Error
     def initialize(message = default_message)
       super
@@ -82,7 +87,6 @@ module Omnizip
     end
   end
 
-  # Error raised when RAR executable is not found
   class RarNotAvailableError < Error
     def initialize(message = default_message)
       super

data/lib/omnizip/filter.rb

@@ -57,7 +57,8 @@ module Omnizip
   #     end
   #   end
   class Filter
-    # @return [Symbol] Architecture identifier (:x86, :arm, :arm64, :powerpc, :ia64, :sparc)
+    # @return [Symbol, nil] Architecture identifier (:x86, :arm, :arm64,
+    #   :powerpc, :ia64, :sparc) or nil for architecture-agnostic filters
     attr_reader :architecture
 
     # @return [String] Human-readable filter name
@@ -65,9 +66,10 @@ module Omnizip
 
     # Initialize filter
     #
-    # @param architecture [Symbol] Target architecture
+    # @param architecture [Symbol, nil] Target architecture (optional;
+    #   filters that don't vary by architecture leave this as nil)
     # @param name [String] Human-readable name
-    def initialize(architecture:, name: "Unknown")
+    def initialize(architecture: nil, name: "Unknown")
       @architecture = architecture
       @name = name
     end

data/lib/omnizip/filter_registry.rb

@@ -1,133 +1,109 @@
 # frozen_string_literal: true
 
-#
-# Copyright (C) 2024 Ribose Inc.
-#
-# This file is part of Omnizip.
-#
-# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
-# Based on the 7-Zip LZMA SDK by Igor Pavlov.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# See the COPYING file for the complete text of the license.
-#
-
 module Omnizip
-  # Registry for managing filter classes.
-  #
-  # This class provides a centralized registry for preprocessing filters,
-  # allowing filters to self-register and be retrieved by name.
-  # It implements a plugin-style architecture for extensibility.
-  class FilterRegistry
-    @filters = {}
+  class FilterRegistry < Omnizip::Registry
+    DEFAULT_FORMATS = %i[xz seven_zip].freeze
+
+    BUILTIN_FILTERS = {
+      "bcj-x86": "Omnizip::Filters::BcjX86",
+      "bcj-arm": "Omnizip::Filters::BcjArm",
+      "bcj-arm64": "Omnizip::Filters::BcjArm64",
+      "bcj-ia64": "Omnizip::Filters::BcjIa64",
+      "bcj-ppc": "Omnizip::Filters::BcjPpc",
+      "bcj-sparc": "Omnizip::Filters::BcjSparc",
+      bcj: "Omnizip::Filters::BCJ",
+      bcj2: "Omnizip::Filters::Bcj2",
+      delta: "Omnizip::Filters::Delta",
+    }.freeze
 
     class << self
-      # Register a filter class with format support.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param filter_class [Class] The filter class to register
-      # @param formats [Array<Symbol>] Supported formats (default: [:xz,
-      #   :seven_zip])
-      # @return [void]
-      def register(name, filter_class, formats: %i[xz seven_zip])
+      def not_found_error_class
+        Omnizip::UnknownFilterError
+      end
+
+      def label
+        "Filter"
+      end
+
+      def register(name, filter_class, formats: DEFAULT_FORMATS)
         raise ArgumentError, "Filter name cannot be nil" if name.nil?
         raise ArgumentError, "Filter class cannot be nil" if filter_class.nil?
 
-        @filters[name.to_sym] = {
-          class: filter_class,
-          formats: formats,
-        }
+        synchronize do
+          storage[normalize_key(name)] = {
+            class: filter_class,
+            formats: formats,
+          }
+        end
+        filter_class
       end
       alias register_with_formats register
 
-      # Retrieve a filter class by name.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @raise [UnknownFilterError] If filter is not registered
-      # @return [Class] The registered filter class
       def get(name)
-        filter = @filters[name.to_sym]
-        unless filter
-          raise UnknownFilterError,
-                "Unknown filter: #{name}. " \
+        entry = entry_for(name)
+        unless entry
+          raise not_found_error_class,
+                "#{label} not registered: #{name.inspect}. " \
                 "Available: #{available.join(', ')}"
         end
 
-        filter[:class]
+        entry[:class]
       end
 
-      # Check if a filter is registered.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @return [Boolean] True if filter is registered, false otherwise
-      def registered?(name)
-        @filters.key?(name.to_sym)
-      end
-
-      # Get list of all registered filter names.
-      #
-      # @return [Array<Symbol>] Array of registered filter names
-      def available
-        @filters.keys
-      end
-
-      # Reset the registry (primarily for testing).
-      #
-      # @return [void]
-      def reset!
-        @filters.clear
-      end
-
-      # Get filter instance for specific format.
-      #
-      # Returns a new filter instance after verifying the filter supports
-      # the specified format.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param format [Symbol] Format identifier (:xz, :seven_zip)
-      # @raise [KeyError] If filter is not registered
-      # @raise [ArgumentError] If filter doesn't support the format
-      # @return [Object] New filter instance
       def get_for_format(name, format)
-        filter_info = @filters[name.to_sym]
-        raise KeyError, "Filter not found: #{name}" unless filter_info
+        entry = entry_for(name)
+        raise KeyError, "Filter not found: #{name}" unless entry
 
-        unless filter_info[:formats].include?(format)
+        unless entry[:formats].include?(format)
           raise ArgumentError,
                 "Filter #{name} not supported for format #{format}"
         end
 
-        filter_info[:class].new
+        entry[:class].new
       end
 
-      # Check if filter supports specific format.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param format [Symbol] Format identifier
-      # @return [Boolean] True if filter supports the format
       def supports_format?(name, format)
-        return false unless @filters[name.to_sym]
+        entry = entry_for(name)
+        return false unless entry
 
-        filter_info = @filters[name.to_sym]
-        filter_info[:formats]&.include?(format)
+        entry[:formats]&.include?(format)
       end
 
-      # Get all filters supporting a specific format.
-      #
-      # @param format [Symbol] Format identifier
-      # @return [Array<Symbol>] Filter names supporting the format
       def filters_for_format(format)
-        @filters.select do |_, info|
-          info[:formats]&.include?(format)
-        end.keys
+        # Ensure all lazy triggers have fired so the format filter list
+        # reflects every registered builtin.
+        lazy_triggers.keys.dup.each { |name| get(name) }
+
+        storage.select { |_, info| info[:formats]&.include?(format) }.keys
+      end
+
+      private
+
+      def entry_for(name)
+        normalized = normalize_key(name)
+        entry = storage[normalized]
+        return entry if entry
+
+        trigger = lazy_triggers[normalized]
+        if trigger
+          synchronize { lazy_triggers.delete(normalized) }
+          trigger.call
+          entry = storage[normalized]
+          return entry if entry
+        end
+
+        nil
       end
     end
   end
+end
 
-  # Error raised when an unknown filter is requested
-  class UnknownFilterError < StandardError; end
+# Lazy triggers — calling the Filters::Registry.register_all re-runs
+# the registration of every builtin filter. Idempotent: register just
+# overwrites the storage entry. Survives reset! because the trigger
+# proc is held by FilterRegistry, not the storage.
+Omnizip::FilterRegistry::BUILTIN_FILTERS.each_key do |name|
+  Omnizip::FilterRegistry.register_lazy(name) do
+    Omnizip::Filters::Registry.register_all
+  end
 end

data/lib/omnizip/filters/bcj2/decoder.rb

@@ -20,11 +20,11 @@ module Omnizip
   module Filters
     # BCJ2 decoder - reconstructs original data from 4 streams.
     #
-    # Combines:
-    # - Main stream (non-convertible bytes)
-    # - Call stream (CALL/E8 addresses)
-    # - Jump stream (JUMP/E9 addresses)
-    # - RC stream (range coder probability data)
+    # Matches the modern 7-Zip SDK Bcj2.c decode loop (v18.06+):
+    # - Pre-allocated output buffer (no dynamic growth)
+    # - Handles E8 (CALL), E9 (JMP), and JCC (0x0F 0x80-0x8F) opcodes
+    # - Probability model: index 0=JCC, 1=E9, 2+prev_byte=E8
+    # - Inline range decoder with cached locals
     class Bcj2Decoder
       include Bcj2Constants
 
@@ -50,147 +50,213 @@ module Omnizip
 
       # Decode 4 streams back to original data.
       #
+      # Matches modern 7-Zip SDK Bcj2Dec_Decode pattern:
+      # - Pre-allocated output buffer sized to expected output
+      # - Single C-optimized regex scan for E8/E9/JCC opcodes
+      # - Direct setbyte writes (no intermediate String allocations)
+      # - Opcode written to output before range-coded decision (matches SDK)
+      #
+      # @param expected_size [Integer, nil] Expected output size for pre-allocation
       # @return [String] Decoded binary data
-      def decode
-        result = String.new(encoding: Encoding::BINARY)
-        init_range_decoder
-
-        loop do
-          break if @main_pos >= @streams.main.bytesize
-
-          byte = @streams.main.getbyte(@main_pos)
-          @main_pos += 1
-
-          # Check for CALL (E8) or JUMP (E9) opcodes
-          if [OPCODE_CALL, OPCODE_JUMP].include?(byte)
-            # Use range decoder to determine if convertible
-            if read_bit(get_prob_index(byte))
-              # Convertible - read address from call/jump stream
-              addr = read_address(byte)
-              result << byte.chr(Encoding::BINARY)
-              result << encode_int32_le(addr)
-              @ip += 5
-            else
-              # Not convertible - just copy byte
-              result << byte.chr(Encoding::BINARY)
-              @ip += 1
-            end
-          else
-            # Regular byte - just copy
-            result << byte.chr(Encoding::BINARY)
-            @ip += 1
-          end
-        end
+      # @raise [Omnizip::DecompressionError] If output exceeds buffer capacity when expected_size is nil
+      def decode(expected_size = nil)
+        main_data = @streams.main
+        main_size = main_data.bytesize
 
-        result
-      end
+        # Pre-allocate output buffer to expected size (C++ SDK: dic is pre-allocated)
+        # When expected_size is unknown, use a conservative upper bound
+        # Each byte can produce at most 5 bytes (opcode + 4-byte address), but
+        # in practice BCJ2 never expands more than 2x due to rarity of convertible opcodes
+        out_capacity = expected_size || (main_size * 2)
+        result = ("\0" * out_capacity).b
+        result_pos = 0
 
-      private
+        # Helper to grow buffer if needed (only when expected_size is nil)
+        grow_buffer = lambda do |required|
+          return if result_pos + required <= result.bytesize
 
-      # Initialize range decoder by reading first 5 bytes from RC stream.
-      #
-      # @return [void]
-      def init_range_decoder
-        @range = 0xFFFFFFFF
-        @code = 0
+          if expected_size
+            raise Omnizip::DecompressionError,
+                  "BCJ2 output size (#{result_pos + required}) exceeds expected size (#{expected_size})"
+          end
+
+          # Dynamic growth when expected_size is unknown
+          new_capacity = [result.bytesize * 2, result_pos + required].max
+          new_buf = ("\0" * new_capacity).b
+          new_buf[0, result_pos] = result.byteslice(0, result_pos)
+          result = new_buf
+        end
+
+        # Cache stream references as locals (avoids repeated ivar lookups in hot loop)
+        call_data = @streams.call
+        jump_data = @streams.jump
+        rc_data = @streams.rc
+        call_size = call_data.bytesize
+        jump_size = jump_data.bytesize
+        rc_size = rc_data.bytesize
+        call_pos = @call_pos
+        jump_pos = @jump_pos
+        rc_pos = @rc_pos
+        probs = @probs
+        ip = @ip
 
+        # Initialize range decoder (read first 5 bytes from RC stream)
+        range = 0xFFFFFFFF
+        code = 0
         5.times do
-          break if @rc_pos >= @streams.rc.bytesize
+          break if rc_pos >= rc_size
 
-          @code = (@code << 8) | @streams.rc.getbyte(@rc_pos)
-          @rc_pos += 1
+          code = ((code << 8) | rc_data.getbyte(rc_pos)) & 0xFFFFFFFF
+          rc_pos += 1
         end
-      end
 
-      # Read a single bit from range coder.
-      #
-      # @param prob_index [Integer] Probability model index
-      # @return [Boolean] Decoded bit (true = 1, false = 0)
-      def read_bit(prob_index) # rubocop:disable Naming/PredicateMethod
-        normalize_range
-
-        prob = @probs[prob_index]
-        bound = (@range >> BIT_MODEL_TOTAL_BITS) * prob
-
-        if @code < bound
-          # Bit is 0
-          @range = bound
-          @probs[prob_index] += (BIT_MODEL_TOTAL - prob) >> MOVE_BITS
-          false
-        else
-          # Bit is 1
-          @range -= bound
-          @code -= bound
-          @probs[prob_index] -= prob >> MOVE_BITS
-          true
-        end
-      end
+        # Regex to find E8, E9, or JCC (0x0F followed by 0x80-0x8F)
+        opcode_re = /[\xe8\xe9]|\x0f[\x80-\x8f]/n
+        main_pos = @main_pos
+        prev_byte = 0
 
-      # Normalize range decoder if needed.
-      #
-      # @return [void]
-      def normalize_range
-        while @range < TOP_VALUE
-          @range <<= 8
-          next_byte = if @rc_pos < @streams.rc.bytesize
-                        @streams.rc.getbyte(@rc_pos)
-                      else
-                        0
-                      end
-          @code = (@code << 8) | next_byte
-          @rc_pos += 1 if @rc_pos < @streams.rc.bytesize
-        end
-      end
+        while main_pos < main_size
+          # C-optimized scan for E8, E9, and JCC opcodes
+          next_pos = main_data.index(opcode_re, main_pos)
 
-      # Get probability model index for a byte.
-      #
-      # @param byte [Integer] Byte value
-      # @return [Integer] Probability model index
-      def get_prob_index(byte)
-        # Use byte-specific model for E8, general model for E9
-        byte == OPCODE_CALL ? (2 + (@ip & 0xFF)) : 0
-      end
+          unless next_pos
+            # No more opcodes — bulk copy remaining bytes
+            chunk_len = main_size - main_pos
+            grow_buffer.call(chunk_len)
+            result[result_pos, chunk_len] =
+              main_data.byteslice(main_pos, chunk_len)
+            result_pos += chunk_len
+            ip += chunk_len
+            main_pos = main_size
+            break
+          end
 
-      # Read 32-bit address from call or jump stream.
-      #
-      # @param opcode [Integer] Opcode (E8 or E9)
-      # @return [Integer] Converted address
-      def read_address(opcode)
-        stream_pos = opcode == OPCODE_CALL ? @call_pos : @jump_pos
-        stream = opcode == OPCODE_CALL ? @streams.call : @streams.jump
-
-        # Read 4 bytes (big-endian in stream, stored as absolute)
-        addr = 0
-        4.times do |i|
-          break if stream_pos >= stream.bytesize
-
-          addr |= stream.getbyte(stream_pos) << (24 - (i * 8))
-          stream_pos += 1
-        end
+          # Bulk copy bytes before opcode
+          if next_pos > main_pos
+            chunk_len = next_pos - main_pos
+            grow_buffer.call(chunk_len)
+            result[result_pos, chunk_len] =
+              main_data.byteslice(main_pos, chunk_len)
+            result_pos += chunk_len
+            ip += chunk_len
+            main_pos = next_pos
+            # Track prev_byte from bulk copy (last byte before opcode in output)
+            prev_byte = main_data.getbyte(next_pos - 1)
+          end
+
+          byte = main_data.getbyte(main_pos)
+
+          if byte == 0x0F
+            # JCC: 0x0F followed by 0x80-0x8F conditional jump
+            # Ensure buffer has room for 2 opcode bytes + potential 4 address bytes
+            grow_buffer.call(6)
+            # Write 0x0F to output (SDK writes opcode bytes before range decision)
+            result.setbyte(result_pos, 0x0F)
+            result_pos += 1
+            ip += 1
+            main_pos += 1
+
+            # Read and write the 0x8x second opcode byte
+            byte = main_data.getbyte(main_pos)
+            result.setbyte(result_pos, byte)
+            result_pos += 1
+            ip += 1
+            main_pos += 1
+
+            prob_idx = 0 # JCC uses probability index 0
+            is_call = false
+          else
+            # E8 (CALL) or E9 (JMP) — write opcode before range decision
+            # Ensure buffer has room for 1 opcode byte + potential 4 address bytes
+            grow_buffer.call(5)
+            result.setbyte(result_pos, byte)
+            result_pos += 1
+            ip += 1
+            main_pos += 1
+
+            if byte == 0xE8
+              prob_idx = 2 + prev_byte  # E8 uses prev_byte context (256 models)
+              is_call = true
+            else
+              prob_idx = 1              # E9 uses fixed index 1
+              is_call = false
+            end
+          end
+
+          # Inline range decoder normalization
+          if range < TOP_VALUE
+            range = (range << 8) & 0xFFFFFFFF
+            rc_byte = rc_pos < rc_size ? rc_data.getbyte(rc_pos) : 0
+            code = ((code << 8) | rc_byte) & 0xFFFFFFFF
+            rc_pos += 1 if rc_pos < rc_size
+          end
 
-        # Update stream position
-        if opcode == OPCODE_CALL
-          @call_pos = stream_pos
-        else
-          @jump_pos = stream_pos
+          prob = probs[prob_idx]
+          bound = (range >> BIT_MODEL_TOTAL_BITS) * prob
+
+          if code < bound
+            # Bit = 0: not convertible (opcode already written to output)
+            range = bound
+            probs[prob_idx] = prob + ((BIT_MODEL_TOTAL - prob) >> MOVE_BITS)
+            prev_byte = byte
+          else
+            # Bit = 1: convertible — read 4-byte address from call/jump stream
+            range -= bound
+            code -= bound
+            probs[prob_idx] = prob - (prob >> MOVE_BITS)
+
+            # Read 4 bytes big-endian from call stream (E8) or jump stream (E9/JCC)
+            if is_call
+              if call_pos + 4 <= call_size
+                addr = call_data.byteslice(call_pos, 4).unpack1("N")
+                call_pos += 4
+              else
+                addr = 0
+                4.times do |i|
+                  break if call_pos >= call_size
+
+                  addr |= call_data.getbyte(call_pos) << (24 - (i * 8))
+                  call_pos += 1
+                end
+              end
+            elsif jump_pos + 4 <= jump_size
+              addr = jump_data.byteslice(jump_pos, 4).unpack1("N")
+              jump_pos += 4
+            else
+              addr = 0
+              4.times do |i|
+                break if jump_pos >= jump_size
+
+                addr |= jump_data.getbyte(jump_pos) << (24 - (i * 8))
+                jump_pos += 1
+              end
+            end
+
+            # Convert absolute address to relative (ip already past opcode bytes)
+            addr = (addr - (ip + 4)) & 0xFFFFFFFF
+
+            # Write 4-byte little-endian address directly (no pack/Array alloc)
+            result.setbyte(result_pos, addr & 0xFF)
+            result.setbyte(result_pos + 1, (addr >> 8) & 0xFF)
+            result.setbyte(result_pos + 2, (addr >> 16) & 0xFF)
+            result.setbyte(result_pos + 3, (addr >> 24) & 0xFF)
+            result_pos += 4
+            ip += 4
+            prev_byte = (addr >> 24) & 0xFF
+          end
         end
 
-        # Convert back to relative
-        addr - (@ip + 5)
-      end
+        # Store final positions back
+        @main_pos = main_pos
+        @call_pos = call_pos
+        @jump_pos = jump_pos
+        @rc_pos = rc_pos
+        @range = range
+        @code = code
+        @ip = ip
 
-      # Encode 32-bit integer as little-endian bytes.
-      #
-      # @param value [Integer] Value to encode
-      # @return [String] 4-byte string
-      def encode_int32_le(value)
-        unsigned = value & 0xFFFFFFFF
-        [
-          unsigned & 0xFF,
-          (unsigned >> 8) & 0xFF,
-          (unsigned >> 16) & 0xFF,
-          (unsigned >> 24) & 0xFF,
-        ].pack("C*")
+        # Return exact output (trim if pre-allocated too large)
+        result_pos < result.bytesize ? result.byteslice(0, result_pos) : result
       end
     end
   end