omnizip 0.4.7-arm-linux

data/lib/omnizip/rubyzip_compat.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+#
+# Rubyzip Compatibility Layer
+#
+# This file provides a drop-in replacement for the 'zip' gem (rubyzip).
+# Simply require 'omnizip/rubyzip_compat' instead of 'zip' to use Omnizip
+# with existing rubyzip code.
+#
+# Usage:
+#   require 'omnizip/rubyzip_compat'
+#
+#   Zip::File.open('archive.zip') do |zip|
+#     zip.each { |entry| puts entry.name }
+#   end
+#
+
+# Create Zip namespace as alias for Omnizip::Zip
+module Zip
+  # Rubyzip-compatible File class
+  File = Omnizip::Zip::File
+
+  # Rubyzip-compatible Entry class
+  Entry = Omnizip::Zip::Entry
+
+  # Rubyzip-compatible OutputStream class
+  OutputStream = Omnizip::Zip::OutputStream
+
+  # Rubyzip-compatible InputStream class
+  InputStream = Omnizip::Zip::InputStream
+
+  # Error classes for compatibility
+  Error = Omnizip::Error
+  FormatError = Omnizip::FormatError
+  CompressionError = Omnizip::CompressionError
+  DecompressionError = Omnizip::DecompressionError
+  ChecksumError = Omnizip::ChecksumError
+
+  # Version information
+  VERSION = Omnizip::VERSION
+
+  class << self
+    # Legacy compatibility method
+    # @deprecated Use Zip::File.open instead
+    def open(...)
+      File.open(...)
+    end
+
+    # Legacy compatibility method
+    # @deprecated Use Zip::File.create instead
+    def create(...)
+      File.create(...)
+    end
+  end
+end
+
+# Compatibility note
+if $VERBOSE
+  warn "Omnizip: Using Omnizip rubyzip compatibility layer. " \
+       "API is compatible with rubyzip, but implementation differs."
+end

data/lib/omnizip/temp/safe_extract.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module Omnizip
+  module Temp
+    # Safe extraction with atomic move to destination
+    # Provides rollback capability on failure
+    class SafeExtract
+      # Error raised when extraction verification fails
+      class VerificationError < Omnizip::Error; end
+
+      attr_reader :archive_path, :dest_path
+
+      # Create new safe extractor
+      # @param archive_path [String] Path to archive
+      # @param dest_path [String] Destination path
+      def initialize(archive_path, dest_path)
+        @archive_path = archive_path
+        @dest_path = dest_path
+      end
+
+      # Extract safely with verification
+      # @yield [temp_dir] Block for verification (return truthy to proceed)
+      # @return [String] Destination path
+      def extract
+        unless File.exist?(@archive_path)
+          raise Errno::ENOENT, "Archive not found: #{@archive_path}"
+        end
+
+        Dir.mktmpdir("omniz_extract_") do |temp_dir|
+          # Extract to temp directory
+          extract_to_temp(temp_dir)
+
+          # User verification if block given
+          if block_given?
+            result = yield(temp_dir)
+            unless result
+              raise VerificationError, "Extraction verification failed"
+            end
+          end
+
+          # Atomic move to destination
+          move_to_destination(temp_dir)
+        end
+
+        @dest_path
+      end
+
+      # Extract with checksum verification
+      # @param expected_checksums [Hash] Map of filename => CRC32
+      # @return [String] Destination path
+      def extract_verified(expected_checksums)
+        extract do |temp_dir|
+          verify_checksums(temp_dir, expected_checksums)
+        end
+      end
+
+      # Extract with file count verification
+      # @param expected_count [Integer] Expected number of files
+      # @return [String] Destination path
+      def extract_with_count(expected_count)
+        extract do |temp_dir|
+          actual_count = count_files(temp_dir)
+          actual_count == expected_count
+        end
+      end
+
+      # Class method for quick safe extraction
+      # @param archive_path [String] Archive to extract
+      # @param dest_path [String] Destination
+      # @yield [temp_dir] Verification block
+      # @return [String] Destination path
+      def self.extract_safe(archive_path, dest_path, &block)
+        new(archive_path, dest_path).extract(&block)
+      end
+
+      private
+
+      def extract_to_temp(temp_dir)
+        # Every routed format extracts through the handler registry,
+        # same as the convenience API
+        Omnizip.extract_archive(@archive_path, temp_dir)
+      end
+
+      def move_to_destination(temp_dir)
+        # Ensure parent directory exists
+        FileUtils.mkdir_p(File.dirname(@dest_path))
+
+        # Remove destination if it exists
+        FileUtils.rm_rf(@dest_path)
+
+        # Copy contents (can't move since Dir.mktmpdir will try to clean up)
+        FileUtils.cp_r(temp_dir, @dest_path)
+      end
+
+      def verify_checksums(dir, expected)
+        expected.all? do |file, expected_sum|
+          file_path = File.join(dir, file)
+          next false unless File.exist?(file_path)
+
+          # Calculate checksum
+          crc = Omnizip::Checksums::Crc32.new
+          File.open(file_path, "rb") do |f|
+            while (chunk = f.read(64 * 1024))
+              crc.update(chunk)
+            end
+          end
+
+          crc.finalize == expected_sum
+        end
+      end
+
+      def count_files(dir)
+        count = 0
+        Dir.glob(File.join(dir, "**", "*")) do |path|
+          count += 1 unless File.directory?(path)
+        end
+        count
+      end
+    end
+  end
+end

data/lib/omnizip/temp/temp_file.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Omnizip
+  module Temp
+    # RAII-pattern temporary file with automatic cleanup
+    class TempFile
+      attr_reader :path
+
+      # Create new temporary file
+      # @param prefix [String] Filename prefix
+      # @param suffix [String] Filename suffix
+      # @param directory [String, nil] Directory (nil = system default)
+      def initialize(prefix: "omniz_", suffix: "", directory: nil)
+        @prefix = prefix
+        @suffix = suffix
+        @directory = directory
+        @tempfile = nil
+        @path = nil
+        @kept = false
+        @finalized = false
+
+        create
+        setup_finalizer
+      end
+
+      # Get the underlying Tempfile object
+      # @return [Tempfile] The tempfile
+      def file
+        @tempfile
+      end
+
+      # Write data to temp file
+      # @param data [String] Data to write
+      # @return [Integer] Bytes written
+      def write(data)
+        @tempfile.write(data)
+      end
+
+      # Read data from temp file
+      # @param length [Integer, nil] Number of bytes to read
+      # @return [String, nil] Data read
+      def read(length = nil)
+        @tempfile.read(length)
+      end
+
+      # Rewind to beginning of file
+      def rewind
+        @tempfile.rewind
+      end
+
+      # Close the temp file
+      def close
+        @tempfile.close if @tempfile && !@tempfile.closed?
+      end
+
+      # Delete the temp file
+      def unlink
+        return if @finalized || @kept
+
+        if @tempfile
+          @tempfile.close unless @tempfile.closed?
+          @tempfile.unlink
+          @finalized = true
+        end
+      rescue StandardError
+        # Ignore errors during cleanup
+        nil
+      end
+
+      # Prevent automatic deletion
+      def keep!
+        @kept = true
+      end
+
+      # Check if file will be kept
+      # @return [Boolean] True if file won't be auto-deleted
+      def kept?
+        @kept
+      end
+
+      # Check if file has been finalized
+      # @return [Boolean] True if finalized
+      def finalized?
+        @finalized
+      end
+
+      private
+
+      def create
+        @tempfile = if @directory
+                      ::Tempfile.new(
+                        [@prefix, @suffix],
+                        @directory,
+                        binmode: true,
+                      )
+                    else
+                      ::Tempfile.new(
+                        [@prefix, @suffix],
+                        binmode: true,
+                      )
+                    end
+        @path = @tempfile.path
+      end
+
+      def setup_finalizer
+        ObjectSpace.define_finalizer(self, self.class.finalizer(@tempfile))
+      end
+
+      # rubocop:disable-next Lint/IneffectiveAccessModifier
+      def self.finalizer(tempfile)
+        proc do
+          tempfile.close unless tempfile.closed?
+          tempfile.unlink
+        rescue StandardError
+          # Ignore errors in finalizer
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/temp/temp_file_pool.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Temp
+    # Resource pool for managing reusable temp files
+    class TempFilePool
+      DEFAULT_POOL_SIZE = 10
+
+      attr_reader :size
+
+      # Create new temp file pool
+      # @param size [Integer] Maximum pool size
+      def initialize(size: DEFAULT_POOL_SIZE)
+        @size = size
+        @pool = []
+        @mutex = Mutex.new
+        @created_count = 0
+        @reuse_count = 0
+      end
+
+      # Acquire temp file from pool
+      # @yield [temp_file] Block called with temp file
+      # @return [Object] Block return value
+      def acquire(**options)
+        temp_file = get_or_create(**options)
+
+        begin
+          result = yield temp_file
+          release(temp_file)
+          result
+        rescue StandardError => e
+          # Ensure cleanup even on exception
+          temp_file.unlink
+          raise e
+        end
+      end
+
+      # Release temp file back to pool or delete if pool is full
+      # @param temp_file [TempFile] File to release
+      def release(temp_file)
+        @mutex.synchronize do
+          if @pool.size < @size
+            # Return to pool for reuse
+            temp_file.rewind
+            @pool << temp_file
+            @reuse_count += 1
+          else
+            # Pool full, delete it
+            temp_file.unlink
+          end
+        end
+      end
+
+      # Clear all files from pool
+      def clear
+        @mutex.synchronize do
+          @pool.each do |tf|
+            tf.unlink
+          rescue StandardError
+            nil
+          end
+          @pool.clear
+        end
+      end
+
+      # Get available file count in pool
+      # @return [Integer] Number of available files
+      def available_count
+        @mutex.synchronize { @pool.size }
+      end
+
+      # Get statistics
+      # @return [Hash] Pool statistics
+      def stats
+        @mutex.synchronize do
+          {
+            pool_size: @size,
+            available: @pool.size,
+            created: @created_count,
+            reused: @reuse_count,
+            efficiency: efficiency_ratio,
+          }
+        end
+      end
+
+      private
+
+      def get_or_create(**options)
+        @mutex.synchronize do
+          if @pool.empty?
+            # Create new temp file
+            @created_count += 1
+            TempFile.new(**options)
+          else
+            # Reuse from pool (LRU - take from front)
+            @pool.shift
+          end
+        end
+      end
+
+      def efficiency_ratio
+        total = @created_count + @reuse_count
+        return 0.0 if total.zero?
+
+        (@reuse_count.to_f / total * 100).round(2)
+      end
+    end
+  end
+end

data/lib/omnizip/temp.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Temporary file management with automatic cleanup
+  # Provides safe, atomic operations with RAII pattern
+  module Temp
+    # Nested classes - autoloaded
+    autoload :TempFile, "omnizip/temp/temp_file"
+    autoload :TempFilePool, "omnizip/temp/temp_file_pool"
+    autoload :SafeExtract, "omnizip/temp/safe_extract"
+
+    # Configuration for temp file operations
+    class Configuration
+      attr_accessor :directory, :prefix, :cleanup_on_exit
+
+      def initialize
+        @directory = nil # Use system default (Dir.tmpdir)
+        @prefix = "omniz_"
+        @cleanup_on_exit = true
+      end
+    end
+
+    class << self
+      # Global configuration
+      # @return [Configuration] Current configuration
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      # Configure temp file operations
+      # @yield [config] Configuration block
+      def configure
+        yield configuration
+        setup_cleanup_hooks if configuration.cleanup_on_exit
+      end
+
+      # Create temporary file with automatic cleanup
+      # @param prefix [String] Filename prefix
+      # @param suffix [String] Filename suffix
+      # @yield [path] Block called with temp file path
+      # @return [Object] Block return value
+      def file(prefix: nil, suffix: "")
+        prefix ||= configuration.prefix
+        temp_file = TempFile.new(
+          prefix: prefix,
+          suffix: suffix,
+          directory: configuration.directory,
+        )
+
+        registry.track(temp_file)
+
+        begin
+          yield(temp_file.path)
+        ensure
+          registry.untrack(temp_file)
+          temp_file.unlink unless temp_file.kept?
+        end
+      end
+
+      # Create temporary directory with automatic cleanup
+      # @param prefix [String] Directory prefix
+      # @yield [path] Block called with temp directory path
+      # @return [Object] Block return value
+      def directory(prefix: nil, &block)
+        require "tmpdir"
+        prefix ||= configuration.prefix
+
+        Dir.mktmpdir(prefix, configuration.directory, &block)
+      end
+
+      # Create temporary archive with automatic cleanup
+      # @param format [Symbol] Archive format (:zip, :seven_zip)
+      # @yield [archive] Block called with archive helper
+      # @return [Object] Block return value
+      def with_archive(format: :zip)
+        suffix = format == :zip ? ".zip" : ".7z"
+
+        file(suffix: suffix) do |path|
+          archive = ArchiveHelper.new(path, format)
+          yield(archive)
+        end
+      end
+
+      # Get temp file registry
+      # @return [TempFileRegistry] Registry instance
+      def registry
+        @registry ||= TempFileRegistry.new
+      end
+
+      # Cleanup all tracked temp files
+      def cleanup_all
+        registry.cleanup_all
+      end
+
+      private
+
+      def setup_cleanup_hooks
+        return if @hooks_installed
+
+        # AtExit handler for normal termination
+        at_exit { cleanup_all }
+
+        # Signal handlers for interruption
+        %w[INT TERM].each do |signal|
+          Signal.trap(signal) do
+            cleanup_all
+            exit(1)
+          end
+        end
+
+        @hooks_installed = true
+      end
+    end
+
+    # Helper class for temp archive operations
+    class ArchiveHelper
+      attr_reader :path, :format
+
+      def initialize(path, format)
+        @path = path
+        @format = format
+      end
+
+      # Add file to archive
+      # @param name [String] Entry name
+      # @param data [String] Entry data
+      def add_file(name, data = nil, &block)
+        data = yield if block
+
+        case format
+        when :zip
+          # Native writer — the rubyzip-compat Omnizip::Zip seam is
+          # for library consumers migrating from rubyzip, not for
+          # internal use
+          writer = Omnizip::Formats::Zip::Writer.new(path)
+          writer.add_data(name, data.to_s)
+          writer.write
+        end
+      end
+    end
+
+    # Registry to track all temp files
+    class TempFileRegistry
+      def initialize
+        @temp_files = []
+        @mutex = Mutex.new
+      end
+
+      # Track a temp file
+      # @param temp_file [TempFile] File to track
+      def track(temp_file)
+        @mutex.synchronize do
+          @temp_files << temp_file
+        end
+      end
+
+      # Untrack a temp file
+      # @param temp_file [TempFile] File to untrack
+      def untrack(temp_file)
+        @mutex.synchronize do
+          @temp_files.delete(temp_file)
+        end
+      end
+
+      # Cleanup all tracked files
+      def cleanup_all
+        @mutex.synchronize do
+          @temp_files.each do |temp_file|
+            temp_file.unlink
+          rescue StandardError
+            nil
+          end
+          @temp_files.clear
+        end
+      end
+
+      # Get count of tracked files
+      # @return [Integer] Number of tracked files
+      def count
+        @mutex.synchronize { @temp_files.size }
+      end
+    end
+  end
+end

data/lib/omnizip/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Omnizip
+  VERSION = "0.4.7"
+end