omnizip 0.4.7-aarch64-linux

data/lib/omnizip/buffer/seven_zip_bridge.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tmpdir"
+
+module Omnizip
+  module Buffer
+    # Bridges the in-memory Buffer API onto the file-based 7z
+    # reader/writer through a temporary file, since the 7z format has
+    # no in-memory stream implementation.
+    module SevenZipBridge
+      class << self
+        # Create a 7z archive in memory
+        #
+        # @param buffer [StringIO] Destination buffer
+        # @param options [Hash] Writer options
+        # @yield [WriteProxy] Block adding entries
+        def create(buffer, options = {}, &block)
+          Dir.mktmpdir("omnizip_buffer_7z") do |tmp|
+            archive_path = File.join(tmp, "buffer.7z")
+            writer = Formats::SevenZip::Writer.new(archive_path, options)
+            block&.call(WriteProxy.new(writer))
+            writer.write
+
+            buffer.write(File.binread(archive_path))
+          end
+        end
+
+        # Read a 7z archive from memory
+        #
+        # @param buffer [StringIO] Archive bytes
+        # @yield [ReadProxy] Block reading entries
+        # @return [ReadProxy, Object] Proxy or block result
+        def open(buffer, &block)
+          Dir.mktmpdir("omnizip_buffer_7z") do |tmp|
+            archive_path = File.join(tmp, "buffer.7z")
+            File.binwrite(archive_path, buffer.string)
+
+            reader = Formats::SevenZip::Reader.new(archive_path)
+            reader.open
+            proxy = ReadProxy.new(reader, tmp)
+
+            block ? yield(proxy) : proxy
+          end
+        end
+      end
+
+      # Mirrors the MemoryArchive write interface onto a 7z writer
+      class WriteProxy
+        # @param writer [Formats::SevenZip::Writer]
+        def initialize(writer)
+          @writer = writer
+        end
+
+        # Add an entry; a trailing slash with empty content adds a
+        # directory entry
+        #
+        # @param name [String] Entry name
+        # @param data [String] Entry content
+        # @return [self]
+        def add(name, data, **_options)
+          if name.end_with?("/") && data.to_s.empty?
+            @writer.add_directory_entry(name)
+          else
+            @writer.add_data(name, data)
+          end
+          self
+        end
+      end
+
+      # Mirrors the MemoryArchive read interface onto a 7z reader
+      class ReadProxy
+        # @param reader [Formats::SevenZip::Reader] opened reader
+        # @param tmp [String] Scratch directory for extraction
+        def initialize(reader, tmp)
+          @reader = reader
+          @tmp = tmp
+        end
+
+        # Yield an Entry wrapper per archive entry
+        def each_entry
+          @reader.list_files.each do |entry|
+            yield Entry.new(entry, @reader, @tmp)
+          end
+        end
+
+        # Filename => content for every file entry
+        #
+        # @return [Hash<String, String>]
+        def extract_all_to_memory
+          result = {}
+          each_entry do |entry|
+            result[entry.name] = entry.read unless entry.directory?
+          end
+          result
+        end
+
+        # Entry names; directories keep a trailing slash like the ZIP
+        # listing convention
+        #
+        # @return [Array<String>]
+        def entry_names
+          @reader.list_files.map do |entry|
+            entry.is_dir ? "#{entry.name}/" : entry.name
+          end
+        end
+
+        # Read-only access to the underlying entries
+        #
+        # @return [Array<Formats::SevenZip::Models::FileEntry>]
+        def raw_entries
+          @reader.list_files
+        end
+
+        # Content of a single named file entry, or nil when absent
+        # (directories carry no content). Extracts just that entry —
+        # not the whole archive.
+        #
+        # @param name [String] Entry name
+        # @return [String, nil]
+        def read_entry(name)
+          entry = raw_entries.find { |e| e.name == name && !e.is_dir }
+          return nil unless entry
+
+          Entry.new(entry, @reader, @tmp).read
+        end
+
+        # Entry wrapper matching MemoryArchive::Entry's surface
+        class Entry
+          attr_reader :name, :size
+
+          # @param entry [Formats::SevenZip::Models::FileEntry]
+          # @param reader [Formats::SevenZip::Reader]
+          # @param tmp [String] Scratch directory
+          def initialize(entry, reader, tmp)
+            @entry = entry
+            @reader = reader
+            @tmp = tmp
+            @name = if entry.is_dir
+                      entry.name.end_with?("/") ? entry.name : "#{entry.name}/"
+                    else
+                      entry.name
+                    end
+            @size = entry.size
+          end
+
+          # @return [Boolean]
+          def directory?
+            @entry.is_dir
+          end
+
+          # @return [Time, nil]
+          def time
+            @entry.mtime
+          end
+
+          # Extract and return this entry's content
+          #
+          # @return [String]
+          def read(_size = nil)
+            return "" if directory? || @entry.has_stream == false
+
+            dest = File.join(@tmp, "entry", @entry.name)
+            @reader.extract_entry(@entry.name, dest)
+            File.binread(dest)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/buffer.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "tmpdir"
+
+module Omnizip
+  # In-memory archive operations without filesystem I/O
+  #
+  # This module provides methods for creating and reading archives
+  # entirely in memory using StringIO, enabling web applications,
+  # testing, and API responses without temporary files.
+  #
+  # @example Create archive in memory
+  #   zip_data = Omnizip::Buffer.create(:zip) do |archive|
+  #     archive.add('readme.txt', 'Hello World')
+  #     archive.add('data.json', '{"key": "value"}')
+  #   end
+  #   # => Returns StringIO with complete ZIP archive
+  #
+  # @example Extract from memory
+  #   contents = Omnizip::Buffer.extract_to_memory(zip_data)
+  #   # => {"readme.txt" => "Hello World", "data.json" => '{"key": "value"}'}
+  #
+  # @example From Hash
+  #   archive_data = {
+  #     'file1.txt' => 'content1',
+  #     'file2.txt' => 'content2'
+  #   }
+  #   zip_buffer = Omnizip::Buffer.create_from_hash(archive_data, :zip)
+  module Buffer
+    # Nested classes - autoloaded
+    autoload :MemoryArchive, "omnizip/buffer/memory_archive"
+    autoload :MemoryExtractor, "omnizip/buffer/memory_extractor"
+    autoload :SevenZipBridge, "omnizip/buffer/seven_zip_bridge"
+
+    class << self
+      # Create archive in memory
+      #
+      # @param format [Symbol] Archive format (:zip, :seven_zip)
+      # @param options [Hash] Format-specific options
+      # @yield [archive] Block to populate archive
+      # @yieldparam archive [MemoryArchive] Archive object to add entries to
+      # @return [StringIO] Complete archive in memory, rewound to start
+      #
+      # @example Create ZIP in memory
+      #   buffer = Omnizip::Buffer.create(:zip) do |archive|
+      #     archive.add('file.txt', 'content')
+      #     archive.add('dir/file2.txt', 'more content')
+      #   end
+      #   File.binwrite('output.zip', buffer.string)
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+      def create(format = :zip, **options, &block)
+        buffer = StringIO.new(String.new(encoding: Encoding::BINARY))
+
+        case format
+        when :zip
+          create_zip(buffer, options, &block)
+        when :seven_zip, :"7z"
+          SevenZipBridge.create(buffer, options, &block)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+
+        buffer.tap(&:rewind)
+      end
+
+      # Open archive from memory
+      #
+      # @param data [String, StringIO] Archive data
+      # @param format [Symbol, nil] Archive format (auto-detected if nil)
+      # @yield [archive] Block to read from archive
+      # @yieldparam archive [MemoryArchive] Archive object to read entries from
+      # @return [MemoryArchive, Object] Archive object or block return value
+      #
+      # @example Read entries
+      #   Omnizip::Buffer.open(zip_data) do |archive|
+      #     archive.each_entry do |entry|
+      #       puts "#{entry.name}: #{entry.size} bytes"
+      #     end
+      #   end
+      def open(data, format: nil, &block)
+        buffer = data.is_a?(StringIO) ? data : StringIO.new(data.b)
+        format ||= detect_format(buffer)
+
+        case format
+        when :zip
+          open_zip(buffer, &block)
+        when :seven_zip, :"7z"
+          SevenZipBridge.open(buffer, &block)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      end
+
+      # Extract all entries to memory
+      #
+      # @param data [String, StringIO] Archive data
+      # @param format [Symbol, nil] Archive format (auto-detected if nil)
+      # @return [Hash<String, String>] Filename => content mapping
+      #
+      # @example Extract to Hash
+      #   files = Omnizip::Buffer.extract_to_memory(zip_data)
+      #   files.each do |name, content|
+      #     puts "#{name}: #{content.bytesize} bytes"
+      #   end
+      def extract_to_memory(data, format: nil)
+        extractor = Buffer::MemoryExtractor.new(data, format: format)
+        extractor.extract_all
+      end
+
+      # Detect archive format from magic bytes. THE buffer-side
+      # sniffer — in-memory data has no extension to route by, so
+      # every consumer delegates here.
+      #
+      # @param buffer [StringIO] Buffer containing archive data
+      # @return [Symbol] Detected format
+      # @raise [Omnizip::FormatError] If format cannot be detected
+      def detect_format(buffer)
+        magic = buffer.read(4).to_s.b
+        buffer.rewind
+
+        case magic
+        when "PK\x03\x04".b, "PK\x05\x06".b, "PK\x07\x08".b
+          # ZIP signatures: local file header, EOCD, data descriptor
+          :zip
+        when "7z\xBC\xAF".b
+          :seven_zip
+        else
+          raise Omnizip::FormatError,
+                "Unknown archive format (magic: #{magic.inspect})"
+        end
+      end
+
+      # Create archive from Hash of filename => content
+      #
+      # @param hash [Hash<String, String>] Filename => content mapping
+      # @param format [Symbol] Archive format
+      # @param options [Hash] Format-specific options
+      # @return [StringIO] Complete archive in memory
+      #
+      # @example Create from Hash
+      #   data = {'file1.txt' => 'content1', 'file2.txt' => 'content2'}
+      #   zip = Omnizip::Buffer.create_from_hash(data, :zip)
+      def create_from_hash(hash, format = :zip, **options)
+        create(format, **options) do |archive|
+          hash.each do |name, content|
+            archive.add(name, content)
+          end
+        end
+      end
+
+      private
+
+      # Create ZIP archive in buffer through the native writer
+      #
+      # @param buffer [StringIO] Buffer to write to
+      # @param options [Hash] ZIP-specific options
+      # @yield [archive] Block to populate archive
+      def create_zip(buffer, _options, &block)
+        writer = Formats::Zip::Writer.new(nil)
+        archive = Buffer::MemoryArchive.new(writer, :zip)
+        block&.call(archive)
+        writer.write_to_io(buffer)
+      end
+
+      # Open ZIP archive from buffer through the native reader.
+      # The reader parses from a path, so the buffer spills to a
+      # temporary file (same pattern as the 7z bridge).
+      #
+      # @param buffer [StringIO] Buffer containing ZIP data
+      # @yield [archive] Block to read from archive
+      # @return [MemoryArchive, Object] Archive or block return value
+      def open_zip(buffer, &block)
+        result = nil
+        Dir.mktmpdir("omnizip_buffer_zip") do |tmp|
+          path = File.join(tmp, "buffer.zip")
+          File.binwrite(path, buffer.string)
+
+          archive = Buffer::MemoryArchive.new(Formats::Zip::Reader.new(path),
+                                              :zip)
+          result = block ? yield(archive) : archive
+        end
+        result
+      end
+    end
+  end
+end

data/lib/omnizip/checksum_registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Omnizip
+  class ChecksumRegistry < Omnizip::Registry
+    BUILTIN_CHECKSUMS = {
+      crc32: "Omnizip::Checksums::Crc32",
+      crc64: "Omnizip::Checksums::Crc64",
+    }.freeze
+
+    class << self
+      def not_found_error_class
+        Omnizip::UnknownChecksumError
+      end
+
+      def label
+        "Checksum"
+      end
+
+      def register(name, checksum_class)
+        key = normalize_key(name)
+        existing = storage[key]
+        if existing && existing != checksum_class
+          raise ArgumentError, "Checksum '#{key}' is already registered"
+        end
+
+        synchronize { storage[key] = checksum_class }
+        checksum_class
+      end
+
+      def available
+        super.sort
+      end
+    end
+  end
+end
+
+Omnizip::ChecksumRegistry::BUILTIN_CHECKSUMS.each do |name, const_path|
+  Omnizip::ChecksumRegistry.register_lazy(name) do
+    Omnizip::ChecksumRegistry.register(name, Object.const_get(const_path))
+  end
+end

data/lib/omnizip/checksums/crc32.rb

@@ -0,0 +1,101 @@
+# 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
+  module Checksums
+    # CRC32 checksum implementation using IEEE 802.3 polynomial.
+    #
+    # This implementation uses the standard CRC32 polynomial (0xEDB88320)
+    # as used in 7-Zip, ZIP archives, PNG files, and Ethernet frames.
+    #
+    # The algorithm uses a 256-entry pre-computed lookup table for
+    # efficient O(1) per-byte processing, making it suitable for
+    # high-performance checksum calculation.
+    #
+    # Polynomial: 0xEDB88320 (reversed IEEE 802.3)
+    # Initial value: 0xFFFFFFFF
+    # Final XOR: 0xFFFFFFFF
+    # Bit width: 32
+    #
+    # @example One-shot calculation
+    #   checksum = Omnizip::Checksums::Crc32.calculate("abc")
+    #   # => 0x352441C2
+    #
+    # @example Incremental calculation
+    #   crc = Omnizip::Checksums::Crc32.new
+    #   crc.update("Hello, ")
+    #   crc.update("world!")
+    #   result = crc.finalize
+    class Crc32 < CrcBase
+      # IEEE 802.3 polynomial (reversed representation)
+      # This is the standard polynomial used in 7-Zip and ZIP files
+      POLYNOMIAL = 0xEDB88320
+
+      # 32-bit mask for truncating values
+      MASK_32 = 0xFFFFFFFF
+
+      # Pre-computed lookup table for CRC32 calculation
+      # Generated using the IEEE 802.3 polynomial
+      # This table is computed once at class load time for performance
+      TABLE = generate_table(POLYNOMIAL, 32).freeze
+
+      # Process a single byte through the CRC32 algorithm.
+      #
+      # Uses the lookup table for efficient computation:
+      # new_crc = (old_crc >> 8) ^ table[(old_crc ^ byte) & 0xFF]
+      #
+      # @param crc [Integer] current CRC value
+      # @param byte [Integer] byte to process (0-255)
+      # @return [Integer] updated CRC value
+      def process_byte(crc, byte)
+        index = (crc ^ byte) & 0xFF
+        (crc >> 8) ^ TABLE[index]
+      end
+
+      # Get the initial CRC32 value.
+      #
+      # CRC32 starts with all bits set to 1, which helps detect
+      # leading zeros in the data stream.
+      #
+      # @return [Integer] 0xFFFFFFFF
+      def initial_value
+        MASK_32
+      end
+
+      # Get the final XOR value for CRC32.
+      #
+      # The final result is XORed with all 1s to invert the bits,
+      # which is part of the CRC32 standard.
+      #
+      # @return [Integer] 0xFFFFFFFF
+      def final_xor
+        MASK_32
+      end
+
+      # Get the lookup table for CRC32.
+      #
+      # @return [Array<Integer>] 256-entry lookup table
+      def self.lookup_table
+        TABLE
+      end
+    end
+  end
+end
+
+# Self-register with checksum registry
+Omnizip::ChecksumRegistry.register(:crc32, Omnizip::Checksums::Crc32)

data/lib/omnizip/checksums/crc64.rb

@@ -0,0 +1,102 @@
+# 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
+  module Checksums
+    # CRC64 checksum implementation using ECMA-182 polynomial.
+    #
+    # This implementation uses the ECMA-182 polynomial for CRC64 calculation
+    # as used in the XZ file format and 7-Zip archives. This is the standard
+    # 64-bit CRC polynomial for data integrity verification in compressed
+    # archives.
+    #
+    # The algorithm uses a 256-entry pre-computed lookup table with 64-bit
+    # values for efficient O(1) per-byte processing.
+    #
+    # Polynomial: 0xC96C5795D7870F42 (ECMA-182)
+    # Initial value: 0xFFFFFFFFFFFFFFFF
+    # Final XOR: 0xFFFFFFFFFFFFFFFF
+    # Bit width: 64
+    #
+    # @example One-shot calculation
+    #   checksum = Omnizip::Checksums::Crc64.calculate("123456789")
+    #   # => 0x995DC9BBDF1939FA
+    #
+    # @example Incremental calculation
+    #   crc = Omnizip::Checksums::Crc64.new
+    #   crc.update("Hello, ")
+    #   crc.update("world!")
+    #   result = crc.finalize
+    class Crc64 < CrcBase
+      # ECMA-182 polynomial (reversed representation)
+      # This is the standard polynomial used in XZ format
+      POLYNOMIAL = 0xC96C5795D7870F42
+
+      # 64-bit mask for truncating values
+      MASK_64 = 0xFFFFFFFFFFFFFFFF
+
+      # Pre-computed lookup table for CRC64 calculation
+      # Generated using the ECMA-182 polynomial
+      # This table is computed once at class load time for performance
+      TABLE = generate_table(POLYNOMIAL, 64).freeze
+
+      # Process a single byte through the CRC64 algorithm.
+      #
+      # Uses the lookup table for efficient computation:
+      # new_crc = (old_crc >> 8) ^ table[(old_crc ^ byte) & 0xFF]
+      #
+      # @param crc [Integer] current CRC value
+      # @param byte [Integer] byte to process (0-255)
+      # @return [Integer] updated CRC value
+      def process_byte(crc, byte)
+        index = (crc ^ byte) & 0xFF
+        (crc >> 8) ^ TABLE[index]
+      end
+
+      # Get the initial CRC64 value.
+      #
+      # CRC64 starts with all bits set to 1, which helps detect
+      # leading zeros in the data stream.
+      #
+      # @return [Integer] 0xFFFFFFFFFFFFFFFF
+      def initial_value
+        MASK_64
+      end
+
+      # Get the final XOR value for CRC64.
+      #
+      # The final result is XORed with all 1s to invert the bits,
+      # which is part of the CRC64 standard.
+      #
+      # @return [Integer] 0xFFFFFFFFFFFFFFFF
+      def final_xor
+        MASK_64
+      end
+
+      # Get the lookup table for CRC64.
+      #
+      # @return [Array<Integer>] 256-entry lookup table
+      def self.lookup_table
+        TABLE
+      end
+    end
+  end
+end
+
+# Self-register with checksum registry
+Omnizip::ChecksumRegistry.register(:crc64, Omnizip::Checksums::Crc64)