omnizip 0.3.1

data/examples/rubyzip_compatibility_demo.rb

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# Rubyzip Compatibility Demo
+#
+# This example demonstrates that Omnizip provides a 100% compatible API
+# with rubyzip for common operations.
+#
+
+require_relative "../lib/omnizip/rubyzip_compat"
+require "tempfile"
+require "fileutils"
+
+puts "=" * 80
+puts "Omnizip Rubyzip Compatibility Demo"
+puts "=" * 80
+puts
+
+# Create temp directory for demo
+temp_dir = Dir.mktmpdir("omnizip_demo")
+puts "Working directory: #{temp_dir}"
+puts
+
+begin
+  # Demo 1: Basic File Operations
+  puts "Demo 1: Basic File Operations"
+  puts "-" * 40
+
+  zip_path = File.join(temp_dir, "demo.zip")
+
+  Zip::File.open(zip_path, create: true) do |zip|
+    zip.add("readme.txt") { "Hello from Omnizip!" }
+    zip.add("data.txt") { "Sample data\nLine 2\nLine 3" }
+    zip.add("dir/")
+    zip.add("dir/nested.txt") { "Nested file content" }
+  end
+
+  puts "✓ Created archive with 4 entries"
+
+  # Read back
+  Zip::File.open(zip_path) do |zip|
+    puts "✓ Archive contains #{zip.size} entries:"
+    zip.each do |entry|
+      puts "  - #{entry.name} (#{entry.size} bytes)"
+    end
+  end
+  puts
+
+  # Demo 2: Streaming Write
+  puts "Demo 2: Streaming Write"
+  puts "-" * 40
+
+  stream_path = File.join(temp_dir, "stream.zip")
+
+  Zip::OutputStream.open(stream_path) do |zos|
+    zos.put_next_entry("file1.txt")
+    zos.write("Content 1")
+
+    zos.put_next_entry("file2.txt")
+    zos.write("Content 2")
+
+    zos.put_next_entry("file3.txt")
+    zos.write("Content 3")
+  end
+
+  puts "✓ Created streaming archive with 3 entries"
+  puts
+
+  # Demo 3: Streaming Read
+  puts "Demo 3: Streaming Read"
+  puts "-" * 40
+
+  Zip::InputStream.open(stream_path) do |zis|
+    count = 0
+    while entry = zis.get_next_entry
+      content = zis.read
+      puts "✓ Read #{entry.name}: #{content.inspect}"
+      count += 1
+    end
+    puts "✓ Total entries read: #{count}"
+  end
+  puts
+
+  # Demo 4: Entry Info and Metadata
+  puts "Demo 4: Entry Info and Metadata"
+  puts "-" * 40
+
+  Zip::InputStream.open(stream_path) do |zis|
+    entry = zis.get_next_entry
+    puts "✓ Entry metadata:"
+    puts "  - Name: #{entry.name}"
+    puts "  - Size: #{entry.size} bytes"
+    puts "  - Compressed: #{entry.compressed_size} bytes"
+    puts "  - Time: #{entry.time}"
+    puts "  - Directory: #{entry.directory?}"
+    puts "  - File: #{entry.file?}"
+    puts "  - Compression: #{entry.compression_method}"
+  end
+  puts
+
+  # Demo 5: Batch Operations
+  puts "Demo 5: Batch Operations"
+  puts "-" * 40
+
+  batch_path = File.join(temp_dir, "batch.zip")
+
+  Zip::OutputStream.open(batch_path) do |zos|
+    5.times do |i|
+      zos.put_next_entry("batch_#{i}.txt")
+      zos.write("Batch content #{i}")
+    end
+  end
+
+  count = 0
+  Zip::InputStream.open(batch_path) do |zis|
+    while zis.get_next_entry
+      count += 1
+    end
+  end
+  puts "✓ Created and read #{count} batch entries"
+  puts
+
+  # Demo 6: Directory Entries
+  puts "Demo 6: Directory Entries"
+  puts "-" * 40
+
+  dir_path = File.join(temp_dir, "with_dirs.zip")
+
+  Zip::OutputStream.open(dir_path) do |zos|
+    zos.put_next_entry("folder/")
+    zos.put_next_entry("folder/subfolder/")
+    zos.put_next_entry("folder/file.txt")
+    zos.write("In folder")
+    zos.put_next_entry("folder/subfolder/deep.txt")
+    zos.write("Deep file")
+  end
+
+  Zip::InputStream.open(dir_path) do |zis|
+    while entry = zis.get_next_entry
+      type = entry.directory? ? "[DIR]" : "[FILE]"
+      puts "✓ #{type} #{entry.name}"
+    end
+  end
+  puts
+
+  # Demo 7: Compression Methods
+  puts "Demo 7: Compression Methods"
+  puts "-" * 40
+
+  test_data = "Test data " * 100
+
+  %i[store deflate].each do |method|
+    comp_path = File.join(temp_dir, "#{method}.zip")
+
+    Zip::OutputStream.open(comp_path) do |zos|
+      zos.put_next_entry("test.txt", compression: method)
+      zos.write(test_data)
+    end
+
+    Zip::InputStream.open(comp_path) do |zis|
+      entry = zis.get_next_entry
+      ratio = entry.size.positive? ? (100 - (entry.compressed_size * 100 / entry.size)) : 0
+      puts "✓ #{method.to_s.capitalize}: #{entry.compressed_size}/#{entry.size} bytes (#{ratio}% savings)"
+    end
+  end
+  puts
+
+  # Summary
+  puts "=" * 80
+  puts "All demos completed successfully!"
+  puts "=" * 80
+  puts
+  puts "Key Features Demonstrated:"
+  puts "  ✓ Zip::OutputStream (streaming write with put_next_entry)"
+  puts "  ✓ Zip::InputStream (streaming read with get_next_entry)"
+  puts "  ✓ Zip::Entry metadata (name, size, time, compression, etc.)"
+  puts "  ✓ Directory entries"
+  puts "  ✓ Batch operations"
+  puts "  ✓ Multiple compression methods (Store, Deflate)"
+  puts "  ✓ Content reading from streams"
+  puts
+  puts "Rubyzip API Compatibility: Streaming API ✓"
+  puts "Note: File-based API (Zip::File) works for creation and basic reads."
+  puts "      Full round-trip with Zip::File will be completed in v1.2."
+  puts
+rescue StandardError => e
+  puts "❌ Error: #{e.message}"
+  puts e.backtrace.first(5)
+  exit 1
+ensure
+  # Cleanup
+  FileUtils.rm_rf(temp_dir) if temp_dir
+end

data/exe/omnizip

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# 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_relative "../lib/omnizip"
+
+begin
+  Omnizip::Cli.start(ARGV)
+rescue StandardError => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/lib/omnizip/algorithm.rb

@@ -0,0 +1,130 @@
+# 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_relative "algorithm_registry"
+
+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
+
+    # 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 [Filters::FilterBase, 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
+
+      # 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,86 @@
+# 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 compression algorithm classes.
+  #
+  # This class provides a centralized registry for compression algorithms,
+  # allowing algorithms to self-register and be retrieved by name.
+  # It implements a plugin-style architecture for extensibility.
+  class AlgorithmRegistry
+    class << self
+      # Register an algorithm class with the registry.
+      #
+      # @param name [Symbol, String] The name identifier for the algorithm
+      # @param klass [Class] The algorithm class to register
+      # @raise [ArgumentError] If name or klass is nil
+      # @return [void]
+      def register(name, klass)
+        raise ArgumentError, "Algorithm name cannot be nil" if name.nil?
+        raise ArgumentError, "Algorithm class cannot be nil" if klass.nil?
+
+        algorithms[name.to_sym] = klass
+      end
+
+      # Retrieve an algorithm class by name.
+      #
+      # @param name [Symbol, String] The name identifier for the algorithm
+      # @raise [UnknownAlgorithmError] If algorithm is not registered
+      # @return [Class] The registered algorithm class
+      def get(name)
+        algorithm = algorithms[name.to_sym]
+        return algorithm if algorithm
+
+        raise UnknownAlgorithmError,
+              "Unknown algorithm: #{name}. " \
+              "Available: #{available.join(', ')}"
+      end
+
+      # Check if an algorithm is registered.
+      #
+      # @param name [Symbol, String] The name identifier for the algorithm
+      # @return [Boolean] True if algorithm is registered, false otherwise
+      def registered?(name)
+        algorithms.key?(name.to_sym)
+      end
+
+      # Get list of all registered algorithm names.
+      #
+      # @return [Array<Symbol>] Array of registered algorithm names
+      def available
+        algorithms.keys
+      end
+
+      # Reset the registry (primarily for testing).
+      #
+      # @return [void]
+      def reset!
+        algorithms.clear
+      end
+
+      private
+
+      # Get or initialize the algorithms hash.
+      #
+      # @return [Hash] The algorithms registry
+      def algorithms
+        @algorithms ||= {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# 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
+
+          # Build suffix array without creating rotation strings
+          # Use direct byte comparison for efficiency
+          suffix_array = (0...n).to_a
+
+          # Sort using optimized comparison that avoids string allocation
+          suffix_array.sort! do |a, b|
+            compare_rotations(bytes, 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|
+            bytes[(idx - 1) % n]
+          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
+          result = []
+          idx = primary_index
+
+          data.length.times do
+            # The first column is the sorted last column
+            # Get the character at this position
+            byte_val = data.bytes.sort[idx]
+            result << byte_val
+            # Follow LF mapping to next position
+            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
+        def compare_rotations(bytes, a, b, n)
+          # Fast path: compare first few bytes directly
+          8.times do |offset|
+            byte_a = bytes[(a + offset) % n]
+            byte_b = bytes[(b + offset) % n]
+            cmp = byte_a <=> byte_b
+            return cmp if cmp != 0
+          end
+
+          # Continue comparing remaining bytes
+          (8...n).each do |offset|
+            byte_a = bytes[(a + offset) % n]
+            byte_b = bytes[(b + offset) % n]
+            cmp = byte_a <=> byte_b
+            return cmp if cmp != 0
+          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