cabriolet 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c71e143078c57e021b1475f9b576e97f63ab7d483451dcb5e48607909cb6ef
-  data.tar.gz: 155a9b0daeffa6ad54a081cd00f21d941d060cb2fd7e5076fd9bafa447833c5c
+  metadata.gz: d301c701aa57d4033c110e9610d76f11e26ae3b8debd3a52d8a3df5ccb725905
+  data.tar.gz: d009c4741e7885ec25ad6766dd79158d1955b80ffc16e9acb0c5a0c1a813b9d0
 SHA512:
-  metadata.gz: 7e64844488da8e4ff630682c2269cab50ba31918d9490d1a6d20a63568a1dd98e05801a21a4877715397f85c2e37d484e571ce07e60a7ad587a88d66ff5d501f
-  data.tar.gz: e48eaabf49eade967b714a8ac471ee5801394674c44355c390363540c88692b991f3c046f3cc0f3af7489c4f05face6b5ab270db73b326a864293132aa6325ef
+  metadata.gz: fd0314bf6196cad4749d2497ee639b7a355eab2a93a4a5e4967878e64cabd6413c08bbfab99aa767e67d1a13a0a3e7e428801819192c6506dba2dbf30f653b3d
+  data.tar.gz: dd1bb57af42a9cc7fa8556bd05632ce79b3b2a994d8276bee8349db7f10428e9d61f254ea8f928583dc8e7f0eca8e2bdd326fd137912fe5afc74c1b0b3f684da

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

data/lib/cabriolet/cab/extractor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../checksum"
 
 module Cabriolet
   module CAB
@@ -424,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

data/lib/cabriolet/cab/file_compression_worker.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module CAB
+    # Worker for compressing files in a CAB archive
+    class FileCompressionWorker < Fractor::Worker
+      # Process a file compression work item
+      #
+      # @param work [FileCompressionWork] Work item to process
+      # @return [Fractor::WorkResult] Result with compressed blocks
+      def process(work)
+        # Read source file
+        file_data = ::File.binread(work.source_path)
+        file_size = file_data.bytesize
+
+        # Split into blocks and compress
+        blocks = []
+        offset = 0
+
+        while offset < file_size
+          remaining = file_size - offset
+          chunk_size = [work.block_size, remaining].min
+          chunk = file_data[offset, chunk_size]
+
+          # Compress chunk
+          compressed_chunk = compress_chunk(chunk, work)
+
+          blocks << {
+            uncompressed_size: chunk.bytesize,
+            compressed_size: compressed_chunk.bytesize,
+            data: compressed_chunk,
+          }
+
+          offset += chunk_size
+        end
+
+        # Return success result
+        Fractor::WorkResult.new(
+          result: {
+            source_path: work.source_path,
+            blocks: blocks,
+            total_uncompressed: file_size,
+            total_compressed: blocks.sum { |b| b[:compressed_size] },
+          },
+          work: work,
+        )
+      rescue StandardError => e
+        # Return error result
+        Fractor::WorkResult.new(
+          error: {
+            message: e.message,
+            class: e.class.name,
+            source_path: work.source_path,
+          },
+          work: work,
+        )
+      end
+
+      private
+
+      # Compress a single chunk of data
+      #
+      # @param chunk [String] Data chunk to compress
+      # @param work [FileCompressionWork] Work item with compression settings
+      # @return [String] Compressed data
+      def compress_chunk(chunk, work)
+        input_handle = System::MemoryHandle.new(chunk)
+        output_handle = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        begin
+          compressor = work.algorithm_factory.create(
+            work.compression_method,
+            :compressor,
+            work.io_system,
+            input_handle,
+            output_handle,
+            chunk.bytesize,
+          )
+
+          compressor.compress
+
+          output_handle.data
+
+          # Memory handles don't need closing
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/checksum.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Utility module for checksum calculations
+  module Checksum
+    # Calculate CAB-style checksum (XOR-based)
+    #
+    # @param data [String] Data to calculate checksum for
+    # @param initial [Integer] Initial checksum value (default: 0)
+    # @return [Integer] Checksum value (32-bit)
+    def self.calculate(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
+    end
+  end
+end