omnizip 0.3.53 → 0.3.55

data/lib/omnizip/parallel/parallel_extractor.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "fractor"
 require "fileutils"
 
 module Omnizip
@@ -21,101 +20,6 @@ module Omnizip
     #   extractor = Omnizip::Parallel::ParallelExtractor.new(options)
     #   extractor.extract('backup.zip', 'output/')
     class ParallelExtractor
-      # Fractor Work class for extraction jobs
-      class ExtractionWork < Fractor::Work
-        def initialize(entry:, archive_path:, dest_dir:)
-          super({
-            entry: entry,
-            archive_path: archive_path,
-            dest_dir: dest_dir,
-          })
-        end
-
-        def entry
-          input[:entry]
-        end
-
-        def archive_path
-          input[:archive_path]
-        end
-
-        def dest_dir
-          input[:dest_dir]
-        end
-      end
-
-      # Fractor Worker class for extraction
-      class ExtractionWorker < Fractor::Worker
-        def process(work)
-          entry = work.entry
-          archive_path = work.archive_path
-          dest_dir = work.dest_dir
-
-          # Read and decompress entry data
-          data = read_entry_data(archive_path, entry)
-
-          # Determine destination path
-          dest_path = ::File.join(dest_dir, entry.name)
-
-          # Return result
-          Fractor::WorkResult.new(
-            result: {
-              entry_name: entry.name,
-              dest_path: dest_path,
-              data: data,
-              directory: entry.directory?,
-              unix_perms: safe_unix_perms(entry),
-            },
-            work: work,
-          )
-        rescue StandardError => e
-          Fractor::WorkResult.new(
-            error: e,
-            work: work,
-          )
-        end
-
-        private
-
-        def read_entry_data(archive_path, entry)
-          return "" if entry.directory?
-
-          # Open archive and extract entry
-          reader = Omnizip::Formats::Zip::Reader.new(archive_path)
-          reader.read
-
-          ::File.open(archive_path, "rb") do |io|
-            # Find the entry in reader
-            reader_entry = reader.entries.find { |e| e.filename == entry.name }
-            raise Errno::ENOENT, "Entry not found in archive: #{entry.name}" unless reader_entry
-
-            # Seek to entry data
-            io.seek(reader_entry.local_header_offset, ::IO::SEEK_SET)
-
-            # Read and parse local file header
-            fixed_header = io.read(30)
-            return "" unless fixed_header && fixed_header.size == 30
-
-            _signature, _version, _flags, _method, _time, _date, _crc32,
-            _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
-
-            # Skip filename and extra field
-            io.read(filename_length + extra_length)
-
-            # Read compressed data
-            compressed_data = io.read(reader_entry.compressed_size)
-            return "" unless compressed_data
-
-            # Decompress
-            reader.decompress(
-              compressed_data,
-              reader_entry.compression_method,
-              reader_entry.uncompressed_size,
-            )
-          end
-        end
-      end
-
       # @return [Omnizip::Models::ParallelOptions] parallel options
       attr_reader :options
 
@@ -179,41 +83,41 @@ module Omnizip
 
         # Schedule jobs
         entries.each do |entry|
-          file_size = safe_entry_size(entry)
-
           job_queue.push_with_size(
-            file: entry.name,
-            size: file_size,
-            data: { entry: entry },
+            file: entry.filename,
+            size: safe_entry_size(entry),
+            data: { entry_name: entry.filename },
           )
         end
 
-        # Create work items from jobs
+        # Create work items from jobs, largest first
         work_items = []
         until job_queue.empty?
           job = job_queue.pop(timeout: 0.1)
           break unless job
 
-          work_items << ExtractionWork.new(
-            entry: job.data[:entry],
-            archive_path: archive,
-            dest_dir: dest,
-          )
+          work_items << job.data[:entry_name]
+        end
+
+        # Threads, not Ractors: Omnizip's autoloads and Proc-holding
+        # codec constants cannot cross Ractor boundaries on Ruby <= 3.3
+        pool = ThreadPool.new(size: @options.threads)
+        raw_results, raw_errors = pool.map(work_items) do |entry_name|
+          process_entry(archive, dest, entry_name)
         end
 
-        # Run the worker pool through the shared engine.
-        engine = Engine.new(worker_class: ExtractionWorker,
-                            threads: @options.threads)
-        results = []
-        errors = engine.run(work_items) { |r| results << r }
-
-        # Handle errors
-        unless errors.empty?
-          error_msgs = errors.map do |e|
-            "#{e.work&.entry&.name}: #{e.error}"
-          end.join("\n")
-          raise Omnizip::ExtractionError, "Extraction errors:\n#{error_msgs}"
+        # Handle errors (raw_errors holds nil for every item that
+        # succeeded — zip+compact would keep those pairs)
+        failure_pairs = raw_errors.each_with_index.filter_map do |error, index|
+          [work_items[index], error] if error
         end
+        unless failure_pairs.empty?
+          error_msgs = failure_pairs.map { |name, e| "#{name}: #{e.message}" }
+            .join("\n")
+          raise Omnizip::DecompressionError, "Extraction errors:\n#{error_msgs}"
+        end
+
+        results = raw_results
 
         # Write files to disk (thread-safe)
         extracted_paths = write_extracted_files(results, overwrite: overwrite)
@@ -242,32 +146,37 @@ module Omnizip
 
       private
 
-      def safe_unix_perms(entry)
-        entry.unix_perms
-      rescue NoMethodError
-        0
+      # Decompress one entry in a worker thread. Each worker opens
+      # the archive independently — its own file handle per thread.
+      def process_entry(archive_path, dest_dir, entry_name)
+        entry = Omnizip::Formats::Zip::Reader.new(archive_path)
+          .entries.find { |e| e.filename == entry_name }
+        raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+
+        {
+          entry_name: entry_name,
+          dest_path: ::File.join(dest_dir, entry_name),
+          data: entry.directory? ? "" : read_entry_data(archive_path, entry_name),
+          directory: entry.directory?,
+          unix_perms: entry.unix_permissions.to_i,
+        }
+      end
+
+      def read_entry_data(archive_path, entry_name)
+        Omnizip::Formats::Zip::Reader.new(archive_path)
+          .read_entry(entry_name)
       end
 
       def safe_entry_size(entry)
-        entry.size
-      rescue NoMethodError
-        0
+        entry.uncompressed_size.to_i
       end
 
-      # Read archive entries
+      # Read archive entries through the native reader
       #
       # @param archive_path [String] archive path
-      # @return [Array<Entry>] array of entries
+      # @return [Array<CentralDirectoryHeader>] array of entries
       def read_archive_entries(archive_path)
-        entries = []
-
-        Omnizip::Zip::File.open(archive_path) do |zip|
-          zip.each do |entry|
-            entries << entry
-          end
-        end
-
-        entries
+        Omnizip::Formats::Zip::Reader.new(archive_path).entries
       end
 
       # Write extracted files to disk
@@ -278,34 +187,36 @@ module Omnizip
       def write_extracted_files(results, overwrite: false)
         extracted_paths = []
 
-        results.each do |work_result|
-          result = work_result.result
+        results.each do |result|
           next unless result
 
           dest_path = result[:dest_path]
 
           # Thread-safe file writing
           @write_mutex.synchronize do
+            if result[:directory]
+              # mkdir_p is idempotent — a file entry may already have
+              # created this directory as its parent
+              FileUtils.mkdir_p(dest_path)
+              extracted_paths << dest_path
+              next
+            end
+
             # Check if file exists
             if ::File.exist?(dest_path) && !overwrite
               raise Errno::EEXIST, "File exists: #{dest_path}"
             end
 
-            # Write file or create directory
-            if result[:directory]
-              FileUtils.mkdir_p(dest_path)
-            else
-              FileUtils.mkdir_p(::File.dirname(dest_path))
-              ::File.binwrite(dest_path, result[:data])
+            FileUtils.mkdir_p(::File.dirname(dest_path))
+            ::File.binwrite(dest_path, result[:data])
 
-              # Set permissions if Unix
-              if result[:unix_perms].positive?
-                ::File.chmod(result[:unix_perms] & 0o777, dest_path)
-              end
-
-              @stats[:bytes_extracted] += result[:data].bytesize
+            # Set permissions if Unix
+            if result[:unix_perms].positive?
+              ::File.chmod(result[:unix_perms] & 0o777, dest_path)
             end
 
+            @stats[:bytes_extracted] += result[:data].bytesize
+
             extracted_paths << dest_path
           end
         end

data/lib/omnizip/parallel/thread_pool.rb

@@ -0,0 +1,60 @@
+# frozen_string: true
+
+module Omnizip
+  module Parallel
+    # Bounded thread pool for library work.
+    #
+    # Unlike the Fractor pool, threads share the VM state — Ractor
+    # workers cannot trigger Omnizip's autoloads or touch Proc-holding
+    # codec constants on Ruby <= 3.3 ("require by autoload on
+    # non-main Ractor is not supported"). Decompression itself still
+    # parallelizes: the zlib/bzip2 C extensions release the GVL.
+    class ThreadPool
+      # @return [Integer] number of worker threads
+      attr_reader :size
+
+      # Initialize the pool
+      #
+      # @param size [Integer] worker thread count (at least 1)
+      def initialize(size:)
+        @size = [size.to_i, 1].max
+      end
+
+      # Run +block+ for every item, at most +size+ at a time, and
+      # return a pair of parallel arrays: results (nil where an item
+      # raised) and errors (nil where it succeeded). Item order is
+      # preserved in both arrays.
+      #
+      # @param items [Array] work items
+      # @yieldparam item [Object] one work item
+      # @return [Array<Array, Array>]
+      def map(items)
+        results = Array.new(items.size)
+        errors = Array.new(items.size)
+        queue = Queue.new
+        items.each_with_index { |item, index| queue << [item, index] }
+
+        threads = Array.new(@size) do
+          Thread.new do
+            loop do
+              begin
+                item, index = queue.pop(true)
+              rescue ThreadError
+                break
+              end
+
+              begin
+                results[index] = yield(item)
+              rescue StandardError => e
+                errors[index] = e
+              end
+            end
+          end
+        end
+        threads.each(&:join)
+
+        [results, errors]
+      end
+    end
+  end
+end

data/lib/omnizip/parallel/worker_pool.rb

@@ -132,8 +132,12 @@ module Omnizip
       def shutdown(timeout: 30)
         return unless @running
 
+        # Stop in BOTH modes: batch worker Ractors otherwise linger
+        # in Ractor.receive for the life of the process, burning CPU
+        # after the batch completes
+        @supervisor&.stop
+
         if @continuous
-          @supervisor.stop
           @supervisor_thread&.join(timeout)
         end
 

data/lib/omnizip/parallel.rb

@@ -29,6 +29,7 @@ module Omnizip
     autoload :Engine, "omnizip/parallel/engine"
     autoload :ParallelCompressor, "omnizip/parallel/parallel_compressor"
     autoload :ParallelExtractor, "omnizip/parallel/parallel_extractor"
+    autoload :ThreadPool, "omnizip/parallel/thread_pool"
 
     class << self
       # Global configuration

data/lib/omnizip/version.rb

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

data/lib/omnizip.rb

@@ -85,6 +85,9 @@ module Omnizip
   autoload :ArchiveHandlers, "omnizip/archive_handlers"
   autoload :Archive, "omnizip/archive"
   autoload :Password, "omnizip/password"
+  # The class lives at the top level of omnizip/password.rb; without
+  # this entry, referencing it does not trigger the Password autoload
+  autoload :PasswordError, "omnizip/password"
   autoload :Convenience, "omnizip/convenience"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.53
+  version: 0.3.55
 platform: ruby
 authors:
 - Ribose Inc.
@@ -650,6 +650,7 @@ files:
 - lib/omnizip/parallel/job_scheduler.rb
 - lib/omnizip/parallel/parallel_compressor.rb
 - lib/omnizip/parallel/parallel_extractor.rb
+- lib/omnizip/parallel/thread_pool.rb
 - lib/omnizip/parallel/worker_pool.rb
 - lib/omnizip/parity.rb
 - lib/omnizip/parity/chunked_block_processor.rb