omnizip 0.3.9 → 0.3.10

data/lib/omnizip/parallel/job_scheduler.rb

@@ -49,7 +49,7 @@ module Omnizip
       # @return [Float] estimated seconds to completion
       def estimate_completion_time(jobs, worker_count:,
 bytes_per_second: 10_000_000)
-        total_bytes = jobs.sum { |job| job.respond_to?(:size) ? job.size : 0 }
+        total_bytes = jobs.sum { |job| job_size(job) }
         return 0.0 if total_bytes.zero? || worker_count.zero?
 
         # Simple estimate: total bytes / (workers * rate)
@@ -65,7 +65,7 @@ bytes_per_second: 10_000_000)
 
         # Calculate total size per worker
         worker_sizes = assignments.transform_values do |jobs|
-          jobs.sum { |job| job.respond_to?(:size) ? job.size : 1 }
+          jobs.sum { |job| job_size(job) }
         end
 
         sizes = worker_sizes.values
@@ -77,6 +77,24 @@ bytes_per_second: 10_000_000)
 
       private
 
+      # Job size helper. Returns the job's #size if defined, else 1
+      # (counts as one unit of work). Centralized so the rest of the
+      # scheduler doesn't need +respond_to?+ checks.
+      #
+      # @param job [Object]
+      # @return [Integer]
+      def job_size(job)
+        if job.is_a?(::Numeric)
+          job
+        else
+          begin
+            job.size
+          rescue StandardError
+            nil
+          end || 1
+        end
+      end
+
       # Validate scheduling strategy
       #
       # @raise [ArgumentError] if strategy is invalid
@@ -116,7 +134,7 @@ bytes_per_second: 10_000_000)
 
         # Sort jobs by size (largest first) for better balance
         sorted_jobs = jobs.sort_by do |job|
-          -(job.respond_to?(:size) ? job.size : 0)
+          -job_size(job)
         end
 
         # Initialize worker assignments
@@ -125,14 +143,14 @@ bytes_per_second: 10_000_000)
 
         # Assign each job to worker with smallest current load
         sorted_jobs.each do |job|
-          job_size = job.respond_to?(:size) ? job.size : 1
+          job_size_value = job_size(job)
 
           # Find worker with minimum load
           min_worker = worker_loads.each_with_index.min_by { |load, _| load }[1]
 
           # Assign job to this worker
           assignments[min_worker] << job
-          worker_loads[min_worker] += job_size
+          worker_loads[min_worker] += job_size_value
         end
 
         # Add metadata
@@ -175,19 +193,19 @@ bytes_per_second: 10_000_000)
 
         # Sort jobs by size (largest first)
         sorted_jobs = jobs.sort_by do |job|
-          -(job.respond_to?(:size) ? job.size : 0)
+          -job_size(job)
         end
 
         # First-fit decreasing bin packing
         bins = Array.new(worker_count) { { jobs: [], total_size: 0 } }
 
         sorted_jobs.each do |job|
-          job_size = job.respond_to?(:size) ? job.size : 1
+          job_size_value = job_size(job)
 
           # Find bin with minimum total size
           min_bin = bins.min_by { |bin| bin[:total_size] }
           min_bin[:jobs] << job
-          min_bin[:total_size] += job_size
+          min_bin[:total_size] += job_size_value
         end
 
         # Convert to standard format

data/lib/omnizip/parallel/parallel_compressor.rb

@@ -131,11 +131,7 @@ level: 6)
                    when Omnizip::Models::ParallelOptions
                      options.dup
                    when Hash
-                     Omnizip::Models::ParallelOptions.new.tap do |opts|
-                       options.each do |k, v|
-                         opts.send(:"#{k}=", v) if opts.respond_to?(:"#{k}=")
-                       end
-                     end
+                     Omnizip::Models::ParallelOptions.new.apply(options)
                    else
                      Omnizip::Models::ParallelOptions.new
                    end
@@ -302,26 +298,20 @@ level: 6)
           result = work_result.result
           next unless result
 
-          # Add compressed entry to writer
-          entry = writer.send(:create_entry,
-                              filename: result[:archive_path],
-                              uncompressed_data: "",
-                              stat: result[:stat])
-
-          # Override with pre-compressed data
-          entry[:compressed_size] = result[:compressed_size]
-          entry[:uncompressed_size] = result[:uncompressed_size]
-          entry[:crc32] = result[:crc32]
-          entry[:compressed_data] = result[:compressed_data]
-
-          writer.instance_variable_get(:@entries) << entry
+          writer.add_precompressed_entry(
+            filename: result[:archive_path],
+            uncompressed_size: result[:uncompressed_size],
+            compressed_size: result[:compressed_size],
+            crc32: result[:crc32],
+            compressed_data: result[:compressed_data],
+            stat: result[:stat],
+          )
 
           @stats[:bytes_processed] += result[:uncompressed_size]
           @stats[:bytes_compressed] += result[:compressed_size]
         end
 
-        # Write with pre-compressed data
-        writer.send(:write_with_precompressed_data, compression)
+        writer.write_precompressed(compression_method: compression)
       end
 
       # Calculate compression ratio

data/lib/omnizip/parallel/parallel_extractor.rb

@@ -64,7 +64,7 @@ module Omnizip
               dest_path: dest_path,
               data: data,
               directory: entry.directory?,
-              unix_perms: entry.respond_to?(:unix_perms) ? entry.unix_perms : 0,
+              unix_perms: safe_unix_perms(entry),
             },
             work: work,
           )
@@ -107,10 +107,11 @@ module Omnizip
             return "" unless compressed_data
 
             # Decompress
-            reader.send(:decompress_data,
-                        compressed_data,
-                        reader_entry.compression_method,
-                        reader_entry.uncompressed_size)
+            reader.decompress(
+              compressed_data,
+              reader_entry.compression_method,
+              reader_entry.uncompressed_size,
+            )
           end
         end
       end
@@ -130,11 +131,7 @@ module Omnizip
                    when Omnizip::Models::ParallelOptions
                      options.dup
                    when Hash
-                     Omnizip::Models::ParallelOptions.new.tap do |opts|
-                       options.each do |k, v|
-                         opts.send(:"#{k}=", v) if opts.respond_to?(:"#{k}=")
-                       end
-                     end
+                     Omnizip::Models::ParallelOptions.new.apply(options)
                    else
                      Omnizip::Models::ParallelOptions.new
                    end
@@ -182,7 +179,7 @@ module Omnizip
 
         # Schedule jobs
         entries.each do |entry|
-          file_size = entry.respond_to?(:size) ? entry.size : 0
+          file_size = safe_entry_size(entry)
 
           job_queue.push_with_size(
             file: entry.name,
@@ -256,6 +253,18 @@ module Omnizip
 
       private
 
+      def safe_unix_perms(entry)
+        entry.unix_perms
+      rescue NoMethodError
+        0
+      end
+
+      def safe_entry_size(entry)
+        entry.size
+      rescue NoMethodError
+        0
+      end
+
       # Read archive entries
       #
       # @param archive_path [String] archive path

data/lib/omnizip/parity/par2_repairer.rb

@@ -162,7 +162,7 @@ module Omnizip
         blocks = []
         block_size = @verifier.metadata[:block_size]
 
-        file_list = @verifier.instance_variable_get(:@file_list)
+        file_list = @verifier.file_list
 
         # Get list of damaged/missing files from verification
         damaged_files = verification.damaged_files
@@ -171,7 +171,7 @@ module Omnizip
         block_index = 0
 
         file_list.each_with_index do |file_info, _file_idx|
-          file_path = @verifier.send(:find_file_path, file_info[:filename])
+          file_path = @verifier.find_file_path(file_info[:filename])
           (file_info[:size].to_f / block_size).ceil
 
           # Treat damaged files same as missing files - don't read corrupted data
@@ -212,7 +212,7 @@ module Omnizip
       #
       # @return [Hash] Map of exponent => recovery_block_data
       def load_parity_blocks_by_exponent
-        recovery_blocks = @verifier.instance_variable_get(:@recovery_blocks)
+        recovery_blocks = @verifier.recovery_blocks
 
         # Group by exponent and take first block for each
         # (PAR2 can have multiple slices with same exponent for large data)
@@ -234,7 +234,7 @@ module Omnizip
 
         # Build file-to-blocks mapping using verifier's file list
         # Note: @verifier was populated by the verify() call in repair()
-        file_list = @verifier.instance_variable_get(:@file_list)
+        file_list = @verifier.file_list
         block_size = @verifier.metadata[:block_size]
 
         # Ensure metadata is loaded
@@ -281,7 +281,7 @@ module Omnizip
         output_dir ||= File.dirname(@par2_file)
         FileUtils.mkdir_p(output_dir)
 
-        @verifier.instance_variable_get(:@file_list).each do |file_info|
+        @verifier.file_list.each do |file_info|
           num_blocks = (file_info[:size].to_f / @verifier.metadata[:block_size]).ceil
           file_blocks_range = (block_idx...(block_idx + num_blocks)).to_a
 

data/lib/omnizip/parity/par2_verifier.rb

@@ -58,6 +58,12 @@ module Omnizip
       # @return [Hash] Parsed PAR2 metadata
       attr_reader :metadata
 
+      # @return [Array<Hash>] Parsed file list (one entry per managed file)
+      attr_reader :file_list
+
+      # @return [Array] Available recovery blocks
+      attr_reader :recovery_blocks
+
       # Initialize verifier
       #
       # @param par2_file [String] Path to .par2 index file
@@ -125,11 +131,11 @@ module Omnizip
         )
       end
 
-      private
-
-      # Parse PAR2 index file using packet models
+      # Parse the PAR2 index file and populate +metadata+, +file_list+,
+      # and +recovery_blocks+. Idempotent — safe to call multiple times.
+      #
+      # @return [void]
       def parse_par2_file
-        # Reset state to prevent accumulation if called multiple times
         @metadata = {}
         @file_list = []
         @recovery_blocks = []
@@ -159,24 +165,6 @@ module Omnizip
         load_recovery_volumes
       end
 
-      # Process packet using model-based approach
-      #
-      # @param packet [Models::Packet] Parsed packet model
-      def process_packet_model(packet)
-        case packet
-        when Models::MainPacket
-          process_main_packet_model(packet)
-        when Models::FileDescriptionPacket
-          process_file_description_packet_model(packet)
-        when Models::IfscPacket
-          process_ifsc_packet_model(packet)
-        when Models::RecoverySlicePacket
-          process_recovery_packet_model(packet)
-        when Models::CreatorPacket
-          # Creator packets are informational only
-        end
-      end
-
       # Process main packet model
       #
       # @param packet [Models::MainPacket] Main packet
@@ -358,6 +346,23 @@ module Omnizip
           (file_info[:size].to_f / @metadata[:block_size]).ceil
         end
       end
+
+      private
+
+      def process_packet_model(packet)
+        case packet
+        when Models::MainPacket
+          process_main_packet_model(packet)
+        when Models::FileDescriptionPacket
+          process_file_description_packet_model(packet)
+        when Models::IfscPacket
+          process_ifsc_packet_model(packet)
+        when Models::RecoverySlicePacket
+          process_recovery_packet_model(packet)
+        when Models::CreatorPacket
+          # Creator packets are informational only
+        end
+      end
     end
   end
 end

data/lib/omnizip/parity.rb

@@ -175,16 +175,16 @@ module Omnizip
         return nil unless File.exist?(par2_file)
 
         verifier = Par2Verifier.new(par2_file)
-        verifier.send(:parse_par2_file)
+        verifier.parse_par2_file
 
-        total_blocks = verifier.send(:calculate_total_blocks)
-        recovery_blocks = verifier.instance_variable_get(:@recovery_blocks).size
+        total_blocks = verifier.calculate_total_blocks
+        recovery_blocks = verifier.recovery_blocks.size
 
         {
           par2_file: par2_file,
           block_size: verifier.metadata[:block_size],
           total_blocks: total_blocks,
-          file_count: verifier.metadata[:file_count] || verifier.instance_variable_get(:@file_list).size,
+          file_count: verifier.metadata[:file_count] || verifier.file_list.size,
           recovery_blocks: recovery_blocks,
           redundancy: calculate_redundancy(total_blocks, recovery_blocks),
         }

data/lib/omnizip/password/encryption_registry.rb

@@ -2,64 +2,25 @@
 
 module Omnizip
   module Password
-    # Registry for encryption strategies
-    class EncryptionRegistry
-      @strategies = {}
-
+    class EncryptionRegistry < Omnizip::Registry
       class << self
-        # Register an encryption strategy
-        # @param name [Symbol] Strategy name
-        # @param strategy_class [Class] Strategy class
-        def register(name, strategy_class)
-          @strategies[name] = strategy_class
-        end
-
-        # Get a strategy by name
-        # @param name [Symbol] Strategy name
-        # @return [Class] Strategy class
-        # @raise [ArgumentError] If strategy not found
-        def get(name)
-          strategy = @strategies[name]
-          return strategy if strategy
-
-          raise ArgumentError, "Unknown encryption strategy: #{name}. " \
-                               "Available: #{@strategies.keys.join(', ')}"
-        end
-
-        # Check if strategy is registered
-        # @param name [Symbol] Strategy name
-        # @return [Boolean] True if registered
-        def registered?(name)
-          @strategies.key?(name)
+        def not_found_error_class
+          Omnizip::UnknownEncryptionStrategyError
         end
 
-        # Get all registered strategy names
-        # @return [Array<Symbol>] Strategy names
-        def strategies
-          @strategies.keys
+        def label
+          "Encryption strategy"
         end
 
-        # Create a strategy instance
-        # @param name [Symbol] Strategy name
-        # @param password [String] Password
-        # @param options [Hash] Strategy options
-        # @return [EncryptionStrategy] Strategy instance
         def create(name, password, **options)
-          strategy_class = get(name)
-          strategy_class.new(password, **options)
-        end
-
-        # Reset registry (for testing)
-        def reset
-          @strategies = {}
+          get(name).new(password, **options)
         end
       end
     end
-
-    # Register built-in strategies
-    EncryptionRegistry.register(:traditional, ZipCryptoStrategy)
-    EncryptionRegistry.register(:zip_crypto, ZipCryptoStrategy)
-    EncryptionRegistry.register(:winzip_aes, WinzipAesStrategy)
-    EncryptionRegistry.register(:aes256, WinzipAesStrategy)
   end
 end
+
+Omnizip::Password::EncryptionRegistry.register(:traditional, Omnizip::Password::ZipCryptoStrategy)
+Omnizip::Password::EncryptionRegistry.register(:zip_crypto, Omnizip::Password::ZipCryptoStrategy)
+Omnizip::Password::EncryptionRegistry.register(:winzip_aes, Omnizip::Password::WinzipAesStrategy)
+Omnizip::Password::EncryptionRegistry.register(:aes256, Omnizip::Password::WinzipAesStrategy)

data/lib/omnizip/password/zip_crypto_strategy.rb

@@ -114,10 +114,7 @@ module Omnizip
       # @param byte [Integer] Byte to add
       # @return [Integer] Updated CRC
       def crc32_update(crc, byte)
-        crc32 = Omnizip::Checksums::Crc32.new
-        crc32.instance_variable_set(:@crc, crc)
-        crc32.update(byte.chr)
-        crc32.value
+        Omnizip::Checksums::Crc32.new.process_byte(crc, byte)
       end
 
       # Generate encryption header

data/lib/omnizip/pipe/stream_decompressor.rb

@@ -163,9 +163,8 @@ module Omnizip
         end
 
         # Preserve timestamp if available
-        if entry.respond_to?(:mtime) && entry.mtime
-          File.utime(entry.mtime, entry.mtime, dest_path)
-        end
+        mtime = entry.mtime if entry.is_a?(Omnizip::Metadata::EntryMetadata)
+        File.utime(mtime, mtime, dest_path) if mtime
 
         bytes
       end

data/lib/omnizip/profile/archive_profile.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/file_type/mime_classifier"
-
 module Omnizip
   module Profile
     # Archive compression profile

data/lib/omnizip/profile/binary_profile.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/file_type/mime_classifier"
-
 module Omnizip
   module Profile
     # Binary compression profile

data/lib/omnizip/profile/compression_profile.rb

@@ -148,7 +148,6 @@ module Omnizip
 
         # Auto-select BCJ filter based on MIME type
         # For executables, default to x86 architecture
-        require "omnizip/file_type/mime_classifier"
         if FileType::MimeClassifier.executable?(mime_type)
           :bcj_x86
         end

data/lib/omnizip/profile/profile_detector.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/file_type/mime_classifier"
-
 module Omnizip
   module Profile
     # Automatic profile detection based on file analysis

data/lib/omnizip/profile/text_profile.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/file_type/mime_classifier"
-
 module Omnizip
   module Profile
     # Text compression profile

data/lib/omnizip/profile.rb

@@ -161,8 +161,6 @@ module Omnizip
       # @param mime_type [String] MIME type string
       # @return [CompressionProfile] Best profile
       def select_best_profile_for_mime(profiles, mime_type)
-        require "omnizip/file_type/mime_classifier"
-
         # Determine category from MIME type
         category = FileType::MimeClassifier.profile_category(mime_type)
 

data/lib/omnizip/registry.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Generic, thread-safe registry base class.
+  #
+  # Subclasses override the hooks +#not_found_error_class+,
+  # +#normalize_key+, and +#label+ to specialize behavior. They may also
+  # override +#register+ / +#get+ to add domain-specific arguments
+  # (e.g., +#register_with_formats+ on FilterRegistry).
+  #
+  # The base class is intentionally minimal: it owns a Hash store and a
+  # Mutex, and exposes the canonical CRUD quintet (+register+, +get+,
+  # +registered?+, +available+, +reset!+). Backward-compat aliases are
+  # provided so existing call sites keep working.
+  class Registry
+    class << self
+      def not_found_error_class
+        Omnizip::Error
+      end
+
+      def normalize_key(key)
+        key.to_sym
+      end
+
+      def label
+        return "Item" unless name
+
+        name.gsub(/^Omnizip::/, "")
+      end
+
+      def register(key, value)
+        synchronize { storage[normalize_key(key)] = value }
+        value
+      end
+
+      # Register a lazy trigger for +key+. When +get(key)+ is called and
+      # the key isn't yet in storage, the block is invoked. The block is
+      # expected to trigger autoload of the implementation file (e.g., by
+      # referencing a constant), which then self-registers.
+      def register_lazy(key, &trigger)
+        lazy_triggers[normalize_key(key)] = trigger
+      end
+
+      def get(key)
+        normalized = normalize_key(key)
+        value = storage[normalized]
+        return value if value
+
+        trigger = lazy_triggers[normalized]
+        if trigger
+          synchronize { lazy_triggers.delete(normalized) }
+          trigger.call
+          value = storage[normalized]
+          return value if value
+        end
+
+        raise not_found_error_class,
+              "#{label} not registered: #{key.inspect}. " \
+              "Available: #{available.join(', ')}"
+      end
+
+      def registered?(key)
+        normalized = normalize_key(key)
+        storage.key?(normalized) || lazy_triggers.key?(normalized)
+      end
+
+      def available
+        storage.keys
+      end
+      alias all available
+      alias strategies available
+
+      def reset!
+        # Clear stored entries but keep lazy triggers — the builtin
+        # autoload list should survive a reset so subsequent +get+ calls
+        # for builtins still trigger the autoload (which re-registers).
+        synchronize { storage.clear }
+      end
+      alias clear reset!
+      alias clear! reset!
+      alias reset reset!
+
+      def entries
+        synchronize { storage.dup }
+      end
+
+      def each(&block)
+        return to_enum(:each) unless block
+
+        entries.each(&block)
+      end
+
+      private
+
+      def storage
+        @storage ||= {}
+      end
+
+      def lazy_triggers
+        @lazy_triggers ||= {}
+      end
+
+      def synchronize(&block)
+        mutex.synchronize(&block)
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+    end
+  end
+end

data/lib/omnizip/version.rb

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