cabriolet 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c71e143078c57e021b1475f9b576e97f63ab7d483451dcb5e48607909cb6ef
-  data.tar.gz: 155a9b0daeffa6ad54a081cd00f21d941d060cb2fd7e5076fd9bafa447833c5c
+  metadata.gz: 9d2875b9afed58332c6e9823f3f383a60d802bac8514cb2015fdbd6a7f1559dc
+  data.tar.gz: 6979ce57ad3d47867bed19330d70b5db483bc33ac8920ee2986faa35828d6cbc
 SHA512:
-  metadata.gz: 7e64844488da8e4ff630682c2269cab50ba31918d9490d1a6d20a63568a1dd98e05801a21a4877715397f85c2e37d484e571ce07e60a7ad587a88d66ff5d501f
-  data.tar.gz: e48eaabf49eade967b714a8ac471ee5801394674c44355c390363540c88692b991f3c046f3cc0f3af7489c4f05face6b5ab270db73b326a864293132aa6325ef
+  metadata.gz: edd7b1345bee36e75fb5796a3840f087a9dfa51e41c599fa767938e8d64ab0abc985e563b9fb246fc86fc4798eb3f98539f774023eaf613f50a1c9e4a2a6d518
+  data.tar.gz: c5cfc76ae8dc5239efa9e90d0956d2518eab56c669d4b7e4087debc4955f509cc97440296c53084152cb30059b25044b6231cd9a84ee94e85f446a20f3306e08

data/README.adoc

@@ -3,6 +3,9 @@
 image:https://img.shields.io/gem/v/cabriolet.svg[RubyGems Version, link=https://rubygems.org/gems/cabriolet]
 image:https://img.shields.io/github/license/omnizip/cabriolet.svg[License]
 
+image:https://img.shields.io/badge/Website-Cabriolet_documentation-blue.svg["Documentation site", link="https://omnizip.github.io/cabriolet"]
+
+
 Pure Ruby implementation for extracting and creating Microsoft compression
 format files.
 

data/lib/cabriolet/binary/bitstream.rb

@@ -51,6 +51,24 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
 
       private
 
+      # Read 2 bytes as a little-endian 16-bit word for MSB mode
+      # This is a shared helper for read_bits_msb and peek_bits
+      #
+      # @return [Integer] 16-bit word, or nil if at EOF and not in salvage mode
+      def read_msb_word
+        byte0 = read_byte
+        if byte0.nil? && (@salvage || @input_end)
+          byte0 = 0
+        end
+
+        byte1 = read_byte
+        if byte1.nil?
+          byte1 = 0
+        end
+
+        byte0 | (byte1 << 8)
+      end
+
       # Read bits in LSB-first order
       #
       # Per libmspack: EOF handling allows padding to avoid bitstream overrun.
@@ -95,34 +113,17 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
       def read_bits_msb(num_bits)
         # Ensure we have enough bits in the buffer
         while @bits_left < num_bits
-          # Read 2 bytes at a time (little-endian), like libmspack
-          byte0 = read_byte
-          if byte0.nil? && (@salvage || @input_end)
-            # First EOF: pad with zeros
-            # Second EOF: read_byte will raise DecompressionError
-            byte0 = 0
-          end
-
-          byte1 = read_byte
-          if byte1.nil?
-            # Pad with 0 if only 1 byte left (or EOF)
-            byte1 = 0
-          end
-
-          # Combine as little-endian 16-bit value
-          word = byte0 | (byte1 << 8)
+          word = read_msb_word
 
           # DEBUG
-          warn "DEBUG MSB read_bytes: byte0=0x#{byte0.to_s(16)} byte1=0x#{byte1.to_s(16)} word=0x#{word.to_s(16)} bits_left=#{@bits_left}" if ENV["DEBUG_BITSTREAM"]
+          warn "DEBUG MSB read_bytes: word=0x#{word.to_s(16)} bits_left=#{@bits_left}" if ENV["DEBUG_BITSTREAM"]
 
           # INJECT_BITS (MSB): inject at the left side
-          # bit_buffer |= word << (BITBUF_WIDTH -16 - bits_left)
           @bit_buffer |= (word << (@bitbuf_width - 16 - @bits_left))
           @bits_left += 16
         end
 
         # PEEK_BITS (MSB): extract from the left
-        # result = bit_buffer >> (BITBUF_WIDTH - num_bits)
         result = @bit_buffer >> (@bitbuf_width - num_bits)
 
         # REMOVE_BITS (MSB): shift left
@@ -251,9 +252,19 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
       # @return [Integer] Bits as an integer
       def read_bits_be(num_bits)
         result = 0
-        num_bits.times do
-          result = (result << 1) | read_bits(1)
+        full_bytes = num_bits / 8
+        remaining_bits = num_bits % 8
+
+        # Read full bytes first (more efficient than bit-by-bit)
+        full_bytes.times do
+          result = (result << 8) | read_bits(8)
         end
+
+        # Read remaining bits
+        if remaining_bits.positive?
+          result = (result << remaining_bits) | read_bits(remaining_bits)
+        end
+
         result
       end
 

data/lib/cabriolet/binary/bitstream_writer.rb

@@ -4,6 +4,10 @@ module Cabriolet
   module Binary
     # BitstreamWriter provides bit-level I/O operations for writing compressed data
     class BitstreamWriter
+      # Pre-computed byte constants for fast single-byte writes
+      # Avoids repeated array packing for each byte written
+      BYTE_CONSTANTS = Array.new(256) { |i| [i].pack("C") }.freeze
+
       attr_reader :io_system, :handle, :buffer_size
 
       # Initialize a new bitstream writer
@@ -129,7 +133,8 @@ module Cabriolet
       # @param byte [Integer] Byte value to write
       # @return [void]
       def write_byte(byte)
-        data = [byte].pack("C")
+        # Use pre-encoded byte constant for better performance
+        data = BYTE_CONSTANTS[byte]
         # DEBUG
         if ENV["DEBUG_BITSTREAM"]
           warn "DEBUG write_byte: pos=#{@bits_in_buffer} byte=#{byte} (#{byte.to_s(2).rjust(
@@ -217,9 +222,21 @@ module Cabriolet
       # @param num_bits [Integer] Number of bits to write
       # @return [void]
       def write_bits_be(value, num_bits)
-        num_bits.times do |i|
-          bit = (value >> (num_bits - 1 - i)) & 1
-          write_bits(bit, 1)
+        # Write full bytes first for better performance
+        full_bytes = num_bits / 8
+        remaining_bits = num_bits % 8
+
+        # Write complete bytes MSB first
+        full_bytes.times do |i|
+          byte_shift = num_bits - 8 - (i * 8)
+          byte = (value >> byte_shift) & 0xFF
+          write_bits(byte, 8)
+        end
+
+        # Write remaining bits
+        if remaining_bits.positive?
+          remaining_value = value & ((1 << remaining_bits) - 1)
+          write_bits(remaining_value, remaining_bits)
         end
       end
 

data/lib/cabriolet/cab/compressor.rb

@@ -1,23 +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
       # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
-      def initialize(io_system = nil, algorithm_factory = nil)
+      # @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
@@ -56,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
 
@@ -129,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
@@ -169,18 +241,9 @@ module Cabriolet
         input = System::MemoryHandle.new(data)
         output = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
-        # Get compression method value
-        compression_method = begin
-          {
-            none: Constants::COMP_TYPE_NONE,
-            mszip: Constants::COMP_TYPE_MSZIP,
-            lzx: Constants::COMP_TYPE_LZX,
-            quantum: Constants::COMP_TYPE_QUANTUM,
-          }.fetch(@compression)
-        rescue KeyError
-          raise ArgumentError,
-                "Unsupported compression type: #{@compression}"
-        end
+        # 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
@@ -278,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
@@ -331,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

@@ -97,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