omnizip 0.4.7-aarch64-linux

data/lib/omnizip/algorithm.rb

@@ -0,0 +1,176 @@
+# 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.
+#
+
+require "stringio"
+
+module Omnizip
+  # Abstract base class for compression algorithms.
+  #
+  # All compression algorithms should inherit from this class and implement
+  # the required methods. Algorithms are automatically registered with the
+  # AlgorithmRegistry when defined.
+  class Algorithm
+    attr_reader :options, :filter
+
+    # Initialize algorithm with options.
+    #
+    # @param options [Hash] Algorithm-specific options
+    def initialize(options = {})
+      @options = options
+      @filter = nil
+    end
+
+    class << self
+      # Coerce arbitrary input to a binary readable IO. The trap this
+      # replaces: StringIO has no #to_s (Kernel#to_s returns the
+      # INSPECT string), so StringIO.new(io.to_s) fed "#<StringIO:...>"
+      # text to the codec. Anything readable passes through; Strings
+      # wrap directly.
+      def to_input_io(data)
+        return data if data.respond_to?(:read) # allowed: IO-duck detection — StringIO must pass through (its #to_s is the INSPECT string)
+
+        ::StringIO.new(data.to_s.b)
+      end
+    end
+
+    # Set a preprocessing filter for this algorithm.
+    #
+    # The filter will be applied before compression and reversed after
+    # decompression. Returns self for method chaining.
+    #
+    # @param filter [Omnizip::Filter, FilterPipeline] Filter or
+    #   pipeline to use
+    # @return [self] For method chaining
+    def with_filter(filter)
+      @filter = filter
+      self
+    end
+
+    # Compress data from input to output.
+    #
+    # If a filter is set, data is filtered before compression.
+    #
+    # @param input [IO, String, #read] Input source
+    # @param output [IO, #write] Output destination
+    # @raise [NotImplementedError] Must be implemented by subclass
+    # @return [void]
+    def compress(input, output)
+      raise NotImplementedError,
+            "#{self.class} must implement #compress"
+    end
+
+    # Decompress data from input to output.
+    #
+    # If a filter is set, data is unfiltered after decompression.
+    #
+    # @param input [IO, String, #read] Input source
+    # @param output [IO, #write] Output destination
+    # @raise [NotImplementedError] Must be implemented by subclass
+    # @return [void]
+    def decompress(input, output)
+      raise NotImplementedError,
+            "#{self.class} must implement #decompress"
+    end
+
+    class << self
+      # Get metadata about this algorithm.
+      #
+      # @raise [NotImplementedError] Must be implemented by subclass
+      # @return [Models::AlgorithmMetadata] Algorithm metadata
+      def metadata
+        raise NotImplementedError,
+              "#{self} must implement .metadata"
+      end
+
+      # Class-level convenience: compress `data` and return the
+      # compressed bytes. Carries the algorithm's streaming contract
+      # over a single StringIO so callers with the whole payload in
+      # memory (parallel compressors, small files) don't need to
+      # instantiate and wire streams themselves.
+      #
+      # @param data [String, IO] Input to compress
+      # @param options [Hash] Forwarded to the algorithm
+      # @return [String] Compressed bytes
+      def compress(data, **options)
+        instance = new(options)
+        input = to_input_io(data)
+        output = ::StringIO.new
+        output.set_encoding(Encoding::BINARY)
+        instance.compress(input, output, options)
+        output.string
+      end
+
+      # Class-level convenience: decompress `data` and return the
+      # uncompressed bytes. Mirror of +.compress+.
+      #
+      # @param data [String, IO] Input to decompress
+      # @param options [Hash] Forwarded to the algorithm
+      # @return [String] Decompressed bytes
+      def decompress(data, **options)
+        instance = new(options)
+        input = to_input_io(data)
+        output = ::StringIO.new
+        output.set_encoding(Encoding::BINARY)
+        instance.decompress(input, output, options)
+        output.string
+      end
+
+      # Automatically register algorithm when inherited.
+      #
+      # This hook is called whenever a class inherits from Algorithm,
+      # automatically registering it with the AlgorithmRegistry.
+      #
+      # @param subclass [Class] The inheriting class
+      # @return [void]
+      def inherited(subclass)
+        super
+        # Register algorithm when metadata is defined
+        subclass.define_singleton_method(:register_algorithm) do
+          meta = subclass.metadata
+          AlgorithmRegistry.register(meta.name.to_sym, subclass)
+        rescue NotImplementedError
+          # Metadata not yet defined, will be registered manually
+        end
+      end
+    end
+
+    protected
+
+    # Apply filter to data if filter is set.
+    #
+    # @param data [String] Data to filter
+    # @param position [Integer] Stream position
+    # @return [String] Filtered data
+    def apply_filter(data, position = 0)
+      return data unless @filter
+
+      @filter.encode(data, position)
+    end
+
+    # Reverse filter on data if filter is set.
+    #
+    # @param data [String] Data to unfilter
+    # @param position [Integer] Stream position
+    # @return [String] Unfiltered data
+    def reverse_filter(data, position = 0)
+      return data unless @filter
+
+      @filter.decode(data, position)
+    end
+  end
+end

data/lib/omnizip/algorithm_registry.rb

@@ -0,0 +1,65 @@
+# 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
+  class AlgorithmRegistry < Omnizip::Registry
+    BUILTIN_ALGORITHMS = {
+      lzma: "Omnizip::Algorithms::LZMA",
+      lzma2: "Omnizip::Algorithms::LZMA2",
+      ppmd7: "Omnizip::Algorithms::PPMd7",
+      ppmd8: "Omnizip::Algorithms::PPMd8",
+      bzip2: "Omnizip::Algorithms::BZip2",
+      deflate: "Omnizip::Algorithms::Deflate",
+      deflate64: "Omnizip::Algorithms::Deflate64",
+      zstandard: "Omnizip::Algorithms::Zstandard",
+    }.freeze
+
+    class << self
+      def not_found_error_class
+        Omnizip::UnknownAlgorithmError
+      end
+
+      def label
+        "Algorithm"
+      end
+
+      # All builtin algorithms register lazily, so the plain storage
+      # keys are empty until each algorithm is first used. Listing
+      # (e.g. the CLI's `omnizip list`) must show the builtins too.
+      def available
+        (super + BUILTIN_ALGORITHMS.keys).uniq
+      end
+
+      def register(name, klass)
+        raise ArgumentError, "Algorithm name cannot be nil" if name.nil?
+        raise ArgumentError, "Algorithm class cannot be nil" if klass.nil?
+
+        super
+      end
+    end
+  end
+end
+
+# Lazy triggers — explicitly re-register on each miss so the entry
+# survives reset!. Object.const_get alone doesn't re-run the file body
+# once the constant is loaded.
+Omnizip::AlgorithmRegistry::BUILTIN_ALGORITHMS.each do |name, const_path|
+  Omnizip::AlgorithmRegistry.register_lazy(name) do
+    Omnizip::AlgorithmRegistry.register(name, Object.const_get(const_path))
+  end
+end

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

@@ -0,0 +1,236 @@
+# 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
+      # Burrows-Wheeler Transform (BWT)
+      #
+      # The BWT is a block-sorting compression algorithm that
+      # rearranges a character string into runs of similar characters.
+      # This transformation is reversible and forms the foundation of
+      # the BZip2 compression algorithm.
+      #
+      # The transformation works by:
+      # 1. Creating all rotations of the input string
+      # 2. Sorting these rotations lexicographically
+      # 3. Taking the last column of the sorted rotations
+      # 4. Recording the row index of the original string
+      #
+      # This groups similar characters together, making the data
+      # more compressible for subsequent stages (MTF, RLE, Huffman).
+      class Bwt
+        # Encode data using Burrows-Wheeler Transform (optimized)
+        #
+        # @param data [String] Input data to transform
+        # @return [Array<String, Integer>] Transformed data and primary idx
+        def encode(data)
+          return ["".b, 0] if data.empty?
+
+          n = data.length
+          bytes = data.bytes
+
+          # Doubled bytes: rotation a's byte at offset o is
+          # dbl[a + o] — indexing needs no modulo, and comparisons
+          # can run 8 bytes at a time (modulo arithmetic in the
+          # comparator dominated the encoder's profile).
+          dbl = bytes * 2
+
+          # Build suffix array without creating rotation strings
+          suffix_array = (0...n).to_a
+          suffix_array.sort! do |a, b|
+            compare_rotations(dbl, a, b, n)
+          end
+
+          # Find primary index (position where suffix starts at 0)
+          primary_index = suffix_array.index(0)
+
+          # Extract last column (character before each suffix)
+          transformed = suffix_array.map do |idx|
+            dbl[n + idx - 1]
+          end.pack("C*").b
+
+          [transformed, primary_index]
+        end
+
+        # Decode data using reverse Burrows-Wheeler Transform
+        #
+        # @param data [String] Transformed data (last column)
+        # @param primary_index [Integer] Index of original string
+        # @return [String] Original data
+        def decode(data, primary_index)
+          return "".b if data.empty?
+
+          # Build LF (Last-to-First) mapping
+          # This maps each position in L to corresponding position in F
+          lf = build_lf_mapping(data)
+
+          # Reconstruct by following the LF chain. The first column
+          # is the sorted last column — sort ONCE (the previous code
+          # re-sorted inside the loop, making decode O(n^2 log n)).
+          first_column = data.bytes.sort
+          result = []
+          idx = primary_index
+
+          data.length.times do
+            result << first_column[idx]
+            idx = lf[idx]
+          end
+
+          result.pack("C*").b
+        end
+
+        # Build LF (Last-to-First) mapping for BWT decode
+        #
+        # For each position i in the sorted order (first column),
+        # LF[i] tells us which position in the sorted order corresponds
+        # to the same character in the last column
+        #
+        # @param last_column [String] Last column (transformed data)
+        # @return [Array<Integer>] LF mapping array
+        def build_lf_mapping(last_column)
+          n = last_column.length
+
+          # Count occurrences of each byte value
+          counts = Array.new(256, 0)
+          last_column.each_byte { |b| counts[b] += 1 }
+
+          # Build cumulative counts (start position of each byte in sorted array)
+          cumulative = Array.new(256, 0)
+          sum = 0
+          256.times do |i|
+            cumulative[i] = sum
+            sum += counts[i]
+          end
+
+          # Build the LF mapping
+          # For each position in last column, find its position in first column
+          lf = Array.new(n)
+          occurrence = Array.new(256, 0) # Track which occurrence of each byte
+
+          last_column.each_byte.with_index do |byte, i|
+            # This byte's position in first column is:
+            # cumulative[byte] + occurrence[byte]
+            pos_in_first = cumulative[byte] + occurrence[byte]
+            occurrence[byte] += 1
+
+            # Now find which last column position corresponds to this first column position
+            # We need the inverse: which last column index has this sorted position
+            lf[pos_in_first] = i
+          end
+
+          lf
+        end
+
+        private
+
+        # Compare two rotations without creating strings
+        # This is the key optimization - avoids O(n²) memory allocation
+        #
+        # @param bytes [Array<Integer>] Byte array
+        # @param a [Integer] First rotation start index
+        # @param b [Integer] Second rotation start index
+        # @param n [Integer] Length
+        # @return [Integer] -1, 0, or 1 for comparison result
+        # Compare rotations a and b over the doubled byte array.
+        # Four big-endian bytes per step: the chunk fits a Fixnum (no
+        # Bignum allocation), the low-offset byte dominates so the
+        # order is lexicographic, and the doubled array removes the
+        # per-byte modulo.
+        def compare_rotations(dbl, a, b, n)
+          len = 0
+          while len + 4 <= n
+            wa = (dbl[a + len] << 24) |
+              (dbl[a + len + 1] << 16) |
+              (dbl[a + len + 2] << 8) |
+              dbl[a + len + 3]
+            wb = (dbl[b + len] << 24) |
+              (dbl[b + len + 1] << 16) |
+              (dbl[b + len + 2] << 8) |
+              dbl[b + len + 3]
+            return wa <=> wb if wa != wb
+
+            len += 4
+          end
+          while len < n
+            cmp = dbl[a + len] <=> dbl[b + len]
+            return cmp if cmp != 0
+
+            len += 1
+          end
+          0
+        end
+
+        # Build next array for BWT decode
+        #
+        # The next array tells us where each character in the last
+        # column appears in the first column, taking duplicates into
+        # account using stable counting.
+        #
+        # @param last_column [String] Last column (transformed data)
+        # @return [Array<Integer>] Next array
+        def build_next_array(last_column)
+          n = last_column.length
+
+          # Count character frequencies
+          counts = Array.new(256, 0)
+          last_column.each_byte { |b| counts[b] += 1 }
+
+          # Calculate cumulative sums (positions in first column)
+          cumulative = Array.new(256, 0)
+          sum = 0
+          256.times do |i|
+            cumulative[i] = sum
+            sum += counts[i]
+          end
+
+          # Build next array
+          next_array = Array.new(n)
+          last_column.each_byte.with_index do |byte, i|
+            next_array[i] = cumulative[byte]
+            cumulative[byte] += 1
+          end
+
+          next_array
+        end
+
+        # Reconstruct original string using next array
+        #
+        # @param first_column [String] First column (sorted)
+        # @param next_array [Array<Integer>] Next positions
+        # @param primary_index [Integer] Starting position
+        # @return [String] Original string
+        def reconstruct_from_next(first_column, next_array, primary_index)
+          result = []
+          idx = primary_index
+
+          first_column.length.times do
+            result << first_column.getbyte(idx)
+            idx = next_array[idx]
+          end
+
+          result.pack("C*").b
+        end
+      end
+    end
+  end
+end