cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/cab/compressor.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
+require_relative "../checksum"
+require_relative "../errors"
+
 module Cabriolet
   module CAB
     # Compressor creates CAB files from source files
     # rubocop:disable Metrics/ClassLength
     class Compressor
-      attr_reader :io_system, :files, :compression, :set_id, :cabinet_index
+      attr_reader :io_system, :files, :compression, :set_id, :cabinet_index,
+                  :workers
 
       # Initialize a new compressor
       #
       # @param io_system [System::IOSystem] I/O system for writing
-      def initialize(io_system = nil)
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      # @param workers [Integer] Number of parallel worker threads (default: 1 for sequential)
+      def initialize(io_system = nil, algorithm_factory = nil, workers: 1)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @files = []
         @compression = :mszip
         @set_id = rand(0xFFFF)
         @cabinet_index = 0
+        @workers = workers
       end
 
       # Add a file to the cabinet
@@ -54,6 +62,9 @@ module Cabriolet
         @set_id = options[:set_id] || @set_id
         @cabinet_index = options[:cabinet_index] || @cabinet_index
 
+        # Validate and cache compression method value to avoid repeated hash lookups
+        @compression_method = compression_type_value
+
         # Collect file information
         file_infos = collect_file_infos
 
@@ -127,17 +138,80 @@ module Cabriolet
 
       # Compress all files and return block data
       def compress_files(file_infos)
+        return compress_files_sequential(file_infos) if @workers <= 1
+
+        compress_files_parallel(file_infos)
+      end
+
+      # Compress files using parallel workers via Fractor
+      def compress_files_parallel(file_infos)
+        require_relative "file_compression_work"
+        require_relative "file_compression_worker"
+
+        compression_method = @compression_method || compression_type_value
+
+        # Create work items for each file
+        work_items = file_infos.map do |info|
+          FileCompressionWork.new(
+            source_path: info[:source_path],
+            compression_method: compression_method,
+            block_size: Constants::BLOCK_MAX,
+            io_system: @io_system,
+            algorithm_factory: @algorithm_factory,
+          )
+        end
+
+        # Create worker pool
+        worker_pool = Fractor::WorkerPool.new(
+          FileCompressionWorker,
+          num_workers: @workers,
+        )
+
+        # Submit all work items and wait for completion
+        results = worker_pool.process_work(work_items)
+
+        # Aggregate results in original order
+        file_result_map = {}
+        total_uncompressed = 0
+        all_blocks = []
+
+        results.each do |result|
+          if result.error
+            raise DecompressionError,
+                  "Failed to compress #{result.error[:source_path]}: #{result.error[:message]}"
+          end
+
+          file_result_map[result.result[:source_path]] = result.result
+          total_uncompressed += result.result[:total_uncompressed]
+        end
+
+        # Reorder blocks to match original file order
+        file_infos.each do |info|
+          file_result = file_result_map[info[:source_path]]
+          all_blocks.concat(file_result[:blocks])
+        end
+
+        {
+          blocks: all_blocks,
+          total_uncompressed: total_uncompressed,
+        }
+      end
+
+      # Compress files sequentially (original implementation)
+      def compress_files_sequential(file_infos)
         blocks = []
         total_uncompressed = 0
 
         file_infos.each do |info|
           file_data = ::File.binread(info[:source_path])
-          total_uncompressed += file_data.bytesize
+          file_size = file_data.bytesize
+          total_uncompressed += file_size
 
           # Split into blocks of max 32KB
           offset = 0
-          while offset < file_data.bytesize
-            chunk_size = [Constants::BLOCK_MAX, file_data.bytesize - offset].min
+          while offset < file_size
+            remaining = file_size - offset
+            chunk_size = [Constants::BLOCK_MAX, remaining].min
             chunk = file_data[offset, chunk_size]
 
             # Compress chunk
@@ -161,54 +235,35 @@ module Cabriolet
 
       # Compress a single chunk of data
       def compress_chunk(data)
-        case @compression
-        when :none
-          data
-        when :mszip
-          compress_mszip(data)
-        when :lzx
-          compress_lzx(data)
-        when :quantum
-          compress_quantum(data)
-        else
-          raise ArgumentError, "Unsupported compression type: #{@compression}"
-        end
-      end
+        return data if @compression == :none
 
-      # Compress data using MSZIP
-      def compress_mszip(data)
-        input = System::MemoryHandle.new(data, Constants::MODE_READ)
+        # Create temporary handles for compression
+        input = System::MemoryHandle.new(data)
         output = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
-        compressor = Compressors::MSZIP.new(@io_system, input, output,
-                                            Cabriolet.default_buffer_size)
-        compressor.compress
-
-        output.data
-      end
-
-      # Compress data using LZX
-      def compress_lzx(data)
-        input = System::MemoryHandle.new(data, Constants::MODE_READ)
-        output = System::MemoryHandle.new("", Constants::MODE_WRITE)
-
-        compressor = Compressors::LZX.new(@io_system, input, output,
-                                          Cabriolet.default_buffer_size, window_bits: 15)
-        compressor.compress
-
-        output.data
-      end
-
-      # Compress data using Quantum
-      def compress_quantum(data)
-        input = System::MemoryHandle.new(data, Constants::MODE_READ)
-        output = System::MemoryHandle.new("", Constants::MODE_WRITE)
+        # Use cached compression method value (calculated in generate)
+        # Fallback to calculation if not yet cached
+        compression_method = @compression_method || compression_type_value
+
+        # Determine window bits based on compression type
+        window_bits = case @compression
+                      when :lzx then 15
+                      when :quantum then 10
+                      end
+
+        compressor = @algorithm_factory.create(
+          compression_method,
+          :compressor,
+          @io_system,
+          input,
+          output,
+          data.bytesize,
+          window_bits: window_bits,
+        )
 
-        compressor = Compressors::Quantum.new(@io_system, input, output,
-                                              Cabriolet.default_buffer_size, window_bits: 10)
         compressor.compress
-
-        output.data
+        output.rewind
+        output.read
       end
 
       # Write the complete cabinet file
@@ -286,7 +341,10 @@ cabinet_size)
           mszip: Constants::COMP_TYPE_MSZIP,
           lzx: Constants::COMP_TYPE_LZX,
           quantum: Constants::COMP_TYPE_QUANTUM,
-        }.fetch(@compression, Constants::COMP_TYPE_MSZIP)
+        }.fetch(@compression) do
+          raise ArgumentError,
+                "Unsupported compression type: #{@compression}"
+        end
       end
 
       # Write CFFILE entry
@@ -339,41 +397,7 @@ cabinet_size)
       # Same algorithm as used in Extractor
       # rubocop:disable Metrics/MethodLength
       def calculate_checksum(data, initial = 0)
-        cksum = initial
-        bytes = data.bytes
-
-        # Process 4-byte chunks
-        (bytes.size / 4).times do |i|
-          offset = i * 4
-          value = bytes[offset] |
-            (bytes[offset + 1] << 8) |
-            (bytes[offset + 2] << 16) |
-            (bytes[offset + 3] << 24)
-          cksum ^= value
-        end
-
-        # Process remaining bytes
-        remainder = bytes.size % 4
-        if remainder.positive?
-          ul = 0
-          offset = bytes.size - remainder
-
-          case remainder
-          when 3
-            ul |= bytes[offset + 2] << 16
-            ul |= bytes[offset + 1] << 8
-            ul |= bytes[offset]
-          when 2
-            ul |= bytes[offset + 1] << 8
-            ul |= bytes[offset]
-          when 1
-            ul |= bytes[offset]
-          end
-
-          cksum ^= ul
-        end
-
-        cksum & 0xFFFFFFFF
+        Checksum.calculate(data, initial)
       end
       # rubocop:enable Metrics/MethodLength
     end

data/lib/cabriolet/cab/decompressor.rb

@@ -10,8 +10,10 @@ module Cabriolet
       # Initialize a new CAB decompressor
       #
       # @param io_system [System::IOSystem, nil] Custom I/O system or nil for default
-      def initialize(io_system = nil)
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @parser = Parser.new(@io_system)
         @buffer_size = Cabriolet.default_buffer_size
         @fix_mszip = false
@@ -57,24 +59,17 @@ module Cabriolet
       # @param output [System::FileHandle, System::MemoryHandle] Output handle
       # @return [Decompressors::Base] Appropriate decompressor instance
       def create_decompressor(folder, input, output)
-        case folder.compression_method
-        when Constants::COMP_TYPE_NONE
-          Decompressors::None.new(@io_system, input, output, @buffer_size)
-        when Constants::COMP_TYPE_MSZIP
-          Decompressors::MSZIP.new(@io_system, input, output, @buffer_size,
-                                   fix_mszip: @fix_mszip)
-        when Constants::COMP_TYPE_LZX
-          window_bits = folder.compression_level
-          Decompressors::LZX.new(@io_system, input, output, @buffer_size,
-                                 window_bits: window_bits)
-        when Constants::COMP_TYPE_QUANTUM
-          window_bits = folder.compression_level
-          Decompressors::Quantum.new(@io_system, input, output, @buffer_size,
-                                     window_bits: window_bits)
-        else
-          raise UnsupportedFormatError,
-                "Unsupported compression type: #{folder.compression_method}"
-        end
+        @algorithm_factory.create(
+          folder.compression_method,
+          :decompressor,
+          @io_system,
+          input,
+          output,
+          @buffer_size,
+          fix_mszip: @fix_mszip,
+          salvage: @salvage,
+          window_bits: folder.compression_level,
+        )
       end
 
       # Append a cabinet to another, merging their folders and files
@@ -102,7 +97,8 @@ module Cabriolet
       # @param filename [String] Path to file to search
       # @return [Models::Cabinet, nil] First cabinet found, or nil if none found
       def search(filename)
-        search_buf = Array.new(@search_buffer_size)
+        # Reuse search buffer across searches for better performance
+        search_buf = @search_buffer ||= Array.new(@search_buffer_size)
         first_cabinet = nil
         link_cabinet = nil
         first_len = 0

data/lib/cabriolet/cab/extractor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../checksum"
 
 module Cabriolet
   module CAB
@@ -15,6 +16,12 @@ module Cabriolet
       def initialize(io_system, decompressor)
         @io_system = io_system
         @decompressor = decompressor
+
+        # State reuse for multi-file extraction (like libmspack self->d)
+        @current_folder = nil
+        @current_decomp = nil
+        @current_input = nil
+        @current_offset = 0
       end
 
       # Extract a single file from the cabinet
@@ -45,7 +52,6 @@ module Cabriolet
           end
 
           filelen = Constants::LENGTH_MAX - file.offset
-
         end
 
         # Check for merge requirements
@@ -66,38 +72,74 @@ module Cabriolet
         output_dir = ::File.dirname(output_path)
         FileUtils.mkdir_p(output_dir) unless ::File.directory?(output_dir)
 
-        # Create input wrapper that reads CFDATA blocks across cabinets
-        input_handle = BlockReader.new(@io_system, folder.data,
-                                       folder.num_blocks, salvage)
+        # Check if we need to change folder or reset (libmspack lines 1076-1078)
+        if ENV["DEBUG_BLOCK"]
+          warn "DEBUG extract_file: Checking reset condition for file #{file.filename} (offset=#{file.offset}, length=#{file.length})"
+          warn "  @current_folder == folder: #{@current_folder == folder} (current=#{@current_folder.object_id}, new=#{folder.object_id})"
+          warn "  @current_offset (#{@current_offset}) > file.offset (#{file.offset}): #{@current_offset > file.offset}"
+          warn "  @current_decomp.nil?: #{@current_decomp.nil?}"
+          warn "  Reset needed?: #{@current_folder != folder || @current_offset > file.offset || !@current_decomp}"
+        end
+
+        if @current_folder != folder || @current_offset > file.offset || !@current_decomp
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG extract_file: RESETTING state (creating new BlockReader)"
+          end
+
+          # Reset state
+          @current_input&.close
+          @current_input = nil
+          @current_decomp = nil
+
+          # Create new input (libmspack lines 1092-1095)
+          # This BlockReader will be REUSED across all files in this folder
+          @current_input = BlockReader.new(@io_system, folder.data,
+                                           folder.num_blocks, salvage)
+          @current_folder = folder
+          @current_offset = 0
+
+          # Create decompressor ONCE and reuse it (this is the key fix!)
+          # The decompressor maintains bitstream state across files
+          @current_decomp = @decompressor.create_decompressor(folder,
+                                                              @current_input, nil)
+        elsif ENV["DEBUG_BLOCK"]
+          warn "DEBUG extract_file: NOT resetting (reusing existing BlockReader and decompressor)"
+        end
+
+        # Skip ahead if needed (libmspack lines 1130-1134)
+        if file.offset > @current_offset
+          skip_bytes = file.offset - @current_offset
+
+          # Decompress with NULL output to skip (libmspack line 1130: self->d->outfh = NULL)
+          null_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+          # Reuse existing decompressor, change output to NULL
+          @current_decomp.instance_variable_set(:@output, null_output)
+
+          # Set output length for LZX frame limiting
+          @current_decomp.set_output_length(skip_bytes) if @current_decomp.respond_to?(:set_output_length)
+
+          @current_decomp.decompress(skip_bytes)
+          @current_offset += skip_bytes
+        end
+
+        # Extract actual file (libmspack lines 1137-1141)
+        output_fh = @io_system.open(output_path, Constants::MODE_WRITE)
 
         begin
-          # Create output file
-          output_fh = @io_system.open(output_path, Constants::MODE_WRITE)
-
-          begin
-            # Create decompressor
-            decomp = @decompressor.create_decompressor(folder, input_handle,
-                                                       output_fh)
-
-            # Skip to file offset if needed
-            if file.offset.positive?
-              # Decompress and discard bytes before file start
-              temp_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
-              temp_decomp = @decompressor.create_decompressor(folder,
-                                                              input_handle, temp_output)
-              temp_decomp.decompress(file.offset)
-            end
+          # Reuse existing decompressor, change output to real file
+          @current_decomp.instance_variable_set(:@output, output_fh)
 
-            # Decompress the file
-            decomp.decompress(filelen)
+          # Set output length for LZX frame limiting
+          @current_decomp.set_output_length(filelen) if @current_decomp.respond_to?(:set_output_length)
 
-            filelen
-          ensure
-            output_fh.close
-          end
+          @current_decomp.decompress(filelen)
+          @current_offset += filelen
         ensure
-          input_handle.close
+          output_fh.close
         end
+
+        filelen
       end
 
       # Extract all files from a cabinet
@@ -192,11 +234,28 @@ module Cabriolet
         end
 
         def read(bytes)
+          # Early return if we've already exhausted all blocks and buffer
+          if @current_block >= @num_blocks && @buffer_pos >= @buffer.bytesize
+            if ENV["DEBUG_BLOCK"]
+              warn "DEBUG BlockReader.read(#{bytes}): Already exhausted, returning empty"
+            end
+            return +""
+          end
+
           result = +""
 
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG BlockReader.read(#{bytes}): buffer_size=#{@buffer.bytesize} buffer_pos=#{@buffer_pos} block=#{@current_block}/#{@num_blocks}"
+          end
+
           while result.bytesize < bytes
             # Read more data if buffer is empty
-            break if (@buffer_pos >= @buffer.bytesize) && !read_next_block
+            if (@buffer_pos >= @buffer.bytesize) && !read_next_block
+              if ENV["DEBUG_BLOCK"]
+                warn "DEBUG BlockReader.read: EXHAUSTED at result.bytesize=#{result.bytesize} (wanted #{bytes})"
+              end
+              break
+            end
 
             # Copy from buffer
             available = @buffer.bytesize - @buffer_pos
@@ -206,6 +265,10 @@ module Cabriolet
             @buffer_pos += to_copy
           end
 
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG BlockReader.read: returning #{result.bytesize} bytes"
+          end
+
           result
         end
 
@@ -226,15 +289,39 @@ module Cabriolet
         private
 
         def read_next_block
-          return false if @current_block >= @num_blocks
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG read_next_block: current_block=#{@current_block} num_blocks=#{@num_blocks}"
+          end
+
+          if @current_block >= @num_blocks
+            if ENV["DEBUG_BLOCK"]
+              warn "DEBUG read_next_block: EXHAUSTED (current_block >= num_blocks)"
+            end
+            return false
+          end
 
           # Read blocks, potentially spanning multiple cabinets
           accumulated_data = +""
 
           loop do
             # Read CFDATA header
+            if ENV["DEBUG_BLOCK"]
+              handle_pos = @cab_handle.tell
+              warn "DEBUG read_next_block: About to read CFDATA header at position #{handle_pos}"
+            end
+
             header_data = @cab_handle.read(Constants::CFDATA_SIZE)
-            return false if header_data.bytesize != Constants::CFDATA_SIZE
+
+            if ENV["DEBUG_BLOCK"]
+              warn "DEBUG read_next_block: Read #{header_data.bytesize} bytes (expected #{Constants::CFDATA_SIZE})"
+            end
+
+            if header_data.bytesize != Constants::CFDATA_SIZE
+              if ENV["DEBUG_BLOCK"]
+                warn "DEBUG read_next_block: FAILED - header read returned #{header_data.bytesize} bytes"
+              end
+              return false
+            end
 
             cfdata = Binary::CFData.read(header_data)
 
@@ -258,8 +345,22 @@ module Cabriolet
             end
 
             # Read compressed data
+            if ENV["DEBUG_BLOCK"]
+              warn "DEBUG read_next_block: About to read #{cfdata.compressed_size} bytes of compressed data"
+            end
+
             compressed_data = @cab_handle.read(cfdata.compressed_size)
-            return false if compressed_data.bytesize != cfdata.compressed_size
+
+            if ENV["DEBUG_BLOCK"]
+              warn "DEBUG read_next_block: Read #{compressed_data.bytesize} bytes of compressed data (expected #{cfdata.compressed_size})"
+            end
+
+            if compressed_data.bytesize != cfdata.compressed_size
+              if ENV["DEBUG_BLOCK"]
+                warn "DEBUG read_next_block: FAILED - compressed data read returned #{compressed_data.bytesize} bytes"
+              end
+              return false
+            end
 
             # Verify checksum if present and not in salvage mode
             if cfdata.checksum.positive? && !@salvage
@@ -299,9 +400,18 @@ module Cabriolet
         end
 
         def open_current_cabinet
+          if ENV["DEBUG_BLOCK"]
+            warn "DEBUG open_current_cabinet: filename=#{@current_data.cabinet.filename} offset=#{@current_data.offset}"
+          end
+
           @cab_handle&.close
           @cab_handle = @io_system.open(@current_data.cabinet.filename, Constants::MODE_READ)
           @cab_handle.seek(@current_data.offset, Constants::SEEK_START)
+
+          if ENV["DEBUG_BLOCK"]
+            actual_pos = @cab_handle.tell
+            warn "DEBUG open_current_cabinet: seeked to position #{actual_pos} (expected #{@current_data.offset})"
+          end
         end
 
         def advance_to_next_cabinet
@@ -315,41 +425,7 @@ module Cabriolet
         end
 
         def calculate_checksum(data, initial = 0)
-          cksum = initial
-          bytes = data.bytes
-
-          # Process 4-byte chunks
-          (bytes.size / 4).times do |i|
-            offset = i * 4
-            value = bytes[offset] |
-              (bytes[offset + 1] << 8) |
-              (bytes[offset + 2] << 16) |
-              (bytes[offset + 3] << 24)
-            cksum ^= value
-          end
-
-          # Process remaining bytes
-          remainder = bytes.size % 4
-          if remainder.positive?
-            ul = 0
-            offset = bytes.size - remainder
-
-            case remainder
-            when 3
-              ul |= bytes[offset + 2] << 16
-              ul |= bytes[offset + 1] << 8
-              ul |= bytes[offset]
-            when 2
-              ul |= bytes[offset + 1] << 8
-              ul |= bytes[offset]
-            when 1
-              ul |= bytes[offset]
-            end
-
-            cksum ^= ul
-          end
-
-          cksum & 0xFFFFFFFF
+          Checksum.calculate(data, initial)
         end
       end
     end

data/lib/cabriolet/cab/file_compression_work.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fractor"
+
+module Cabriolet
+  module CAB
+    # Work item for compressing a single file in a CAB archive
+    class FileCompressionWork < Fractor::Work
+      # Initialize work item for file compression
+      #
+      # @param source_path [String] Path to source file
+      # @param compression_method [Symbol] Compression method to use
+      # @param block_size [Integer] Maximum block size
+      # @param io_system [System::IOSystem] I/O system
+      # @param algorithm_factory [AlgorithmFactory] Algorithm factory
+      def initialize(source_path:, compression_method:, block_size:,
+io_system:, algorithm_factory:)
+        super({
+          source_path: source_path,
+          compression_method: compression_method,
+          block_size: block_size,
+          io_system: io_system,
+          algorithm_factory: algorithm_factory,
+        })
+      end
+
+      def source_path
+        input[:source_path]
+      end
+
+      def compression_method
+        input[:compression_method]
+      end
+
+      def block_size
+        input[:block_size]
+      end
+
+      def io_system
+        input[:io_system]
+      end
+
+      def algorithm_factory
+        input[:algorithm_factory]
+      end
+
+      def id
+        source_path
+      end
+    end
+  end
+end