omnizip 0.3.1

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,181 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Temporary file management with automatic cleanup
+  # Provides safe, atomic operations with RAII pattern
+  module Temp
+    # 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
+          require_relative "zip/file"
+          Omnizip::Zip::File.create(path) do |zip|
+            zip.add(name) { data }
+          end
+        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
+
+require_relative "temp/temp_file"
+require_relative "temp/temp_file_pool"
+require_relative "temp/safe_extract"

data/lib/omnizip/version.rb

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

data/lib/omnizip/zip/entry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "../formats/zip/central_directory_header"
+require_relative "../metadata/entry_metadata"
+
+module Omnizip
+  module Zip
+    # Rubyzip-compatible Entry class
+    # Wraps CentralDirectoryHeader with rubyzip API
+    class Entry
+      attr_reader :header, :ftype, :filepath
+
+      # Create entry from CentralDirectoryHeader
+      def initialize(header, filepath: nil)
+        @header = header
+        @filepath = filepath
+        @ftype = header.directory? ? :directory : :file
+      end
+
+      # Entry name (path within archive)
+      def name
+        header.filename
+      end
+
+      # Uncompressed size
+      def size
+        header.uncompressed_size
+      end
+
+      # Compressed size
+      def compressed_size
+        header.compressed_size
+      end
+
+      # CRC32 checksum
+      def crc
+        header.crc32
+      end
+
+      # Compression method ID
+      def compression_method
+        header.compression_method
+      end
+
+      # Modification time
+      def time
+        dos_time_to_time(header.last_mod_date, header.last_mod_time)
+      end
+
+      # Is this a directory?
+      def directory?
+        @ftype == :directory
+      end
+      alias_method :is_directory, :directory?
+
+      # Is this a file?
+      def file?
+        @ftype == :file
+      end
+
+      # Is this a symbolic link?
+      def symlink?
+        false # Not supported yet
+      end
+
+      # Get comment
+      def comment
+        header.comment || ""
+      end
+
+      # Set comment
+      def comment=(value)
+        header.comment = value
+      end
+
+      # Get extra field
+      def extra
+        header.extra_field || ""
+      end
+
+      # Set extra field
+      def extra=(value)
+        header.extra_field = value
+      end
+
+      # Unix permissions
+      def unix_perms
+        header.unix_permissions
+      end
+
+      # Set Unix permissions
+      def unix_perms=(perms)
+        header.unix_permissions = perms
+      end
+
+      # Get metadata for this entry
+      # @return [Omnizip::Metadata::EntryMetadata] Entry metadata
+      def metadata
+        @metadata ||= Omnizip::Metadata::EntryMetadata.new(self)
+      end
+
+      # Save metadata changes
+      # Marks the entry as modified so changes are written on archive close
+      def save_metadata
+        # Changes are already applied to the header
+        # This is a convenience method for the API
+        metadata.reset_modified
+      end
+
+      # Extract this entry to a destination path
+      # Note: This requires access to the archive file
+      def extract(dest_path)
+        raise NotImplementedError,
+              "Entry#extract requires File context. Use Omnizip::Zip::File#extract instead"
+      end
+
+      # Get input stream for this entry
+      # Note: This requires access to the archive file
+      def get_input_stream
+        raise NotImplementedError,
+              "Entry#get_input_stream requires File context"
+      end
+
+      # String representation
+      def to_s
+        name
+      end
+
+      # Equality comparison
+      def ==(other)
+        return false unless other.is_a?(Entry)
+
+        name == other.name
+      end
+
+      private
+
+      # Convert DOS date/time to Ruby Time
+      def dos_time_to_time(dos_date, dos_time)
+        return Time.now if dos_date.zero? && dos_time.zero?
+
+        year = ((dos_date >> 9) & 0x7F) + 1980
+        month = (dos_date >> 5) & 0x0F
+        day = dos_date & 0x1F
+
+        hour = (dos_time >> 11) & 0x1F
+        min = (dos_time >> 5) & 0x3F
+        sec = (dos_time & 0x1F) * 2
+
+        Time.new(year, month, day, hour, min, sec)
+      rescue ArgumentError
+        Time.now
+      end
+    end
+  end
+end