cabriolet 0.2.0 → 0.2.2

data/lib/cabriolet/collections/file_collection.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Collections
+    # FileCollection manages a collection of files for compression
+    # Provides unified interface for adding files and preparing them for compression
+    class FileCollection
+      include Enumerable
+
+      # Initialize a new file collection
+      #
+      # @param format_options [Hash] Options specific to the archive format
+      def initialize(format_options = {})
+        @files = []
+        @format_options = format_options
+      end
+
+      # Add a file to the collection
+      #
+      # @param source_path [String] Path to the source file
+      # @param archive_path [String, nil] Path within the archive (defaults to basename)
+      # @param options [Hash] Additional options for this file
+      # @return [self] Returns self for chaining
+      #
+      # @example
+      #   collection.add("README.md", "docs/README.md")
+      #   collection.add("data.txt") # Uses basename
+      def add(source_path, archive_path = nil, **options)
+        validate_source(source_path)
+
+        @files << {
+          source: source_path,
+          archive: archive_path || ::File.basename(source_path),
+          options: options,
+        }
+
+        self
+      end
+
+      # Add multiple files at once
+      #
+      # @param files [Array<Hash>] Array of file hashes with :source, :archive, :options keys
+      # @return [self] Returns self for chaining
+      def add_all(files)
+        files.each do |file|
+          add(file[:source], file[:archive], **file.fetch(:options, {}))
+        end
+        self
+      end
+
+      # Iterate over files in the collection
+      #
+      # @yield [file_entry] Yields each file entry hash
+      # @return [Enumerator] If no block given
+      def each(&)
+        @files.each(&)
+      end
+
+      # Get the number of files in the collection
+      #
+      # @return [Integer] Number of files
+      def size
+        @files.size
+      end
+
+      # Check if collection is empty
+      #
+      # @return [Boolean] True if no files
+      def empty?
+        @files.empty?
+      end
+
+      # Clear all files from the collection
+      #
+      # @return [self] Returns self for chaining
+      def clear
+        @files.clear
+        self
+      end
+
+      # Prepare files for compression by reading metadata
+      #
+      # @return [Array<Hash>] Array of prepared file info hashes
+      def prepare_for_compression
+        @files.map do |file_entry|
+          prepare_file_info(file_entry)
+        end
+      end
+
+      # Get total uncompressed size of all files
+      #
+      # @return [Integer] Total size in bytes
+      def total_size
+        @files.sum { |f| ::File.size(f[:source]) }
+      end
+
+      # Group files by directory for archive organization
+      #
+      # @return [Hash] Hash with directory paths as keys and file arrays as values
+      def by_directory
+        @files.group_by do |file|
+          ::File.dirname(file[:archive])
+        end
+      end
+
+      # Find files by pattern in archive path
+      #
+      # @param pattern [String, Regexp] Pattern to match
+      # @return [Array<Hash>] Matching file entries
+      def find_by_pattern(pattern)
+        @files.select do |file|
+          if pattern.is_a?(Regexp)
+            file[:archive] =~ pattern
+          else
+            file[:archive].include?(pattern)
+          end
+        end
+      end
+
+      private
+
+      # Validate that source file exists and is accessible
+      #
+      # @param path [String] Path to validate
+      # @raise [ArgumentError] if file doesn't exist or isn't a regular file
+      def validate_source(path)
+        unless ::File.exist?(path)
+          raise ArgumentError, "File does not exist: #{path}"
+        end
+
+        unless ::File.file?(path)
+          raise ArgumentError, "Not a regular file: #{path}"
+        end
+      end
+
+      # Prepare file information for compression
+      #
+      # @param file_entry [Hash] Original file entry
+      # @return [Hash] Prepared file info with metadata
+      def prepare_file_info(file_entry)
+        stat = ::File.stat(file_entry[:source])
+
+        {
+          source_path: file_entry[:source],
+          archive_path: file_entry[:archive],
+          size: stat.size,
+          mtime: stat.mtime,
+          atime: stat.atime,
+          attributes: calculate_attributes(stat),
+          options: file_entry[:options],
+        }
+      end
+
+      # Calculate file attributes for archive format
+      #
+      # @param stat [File::Stat] File stat object
+      # @return [Integer] Attribute flags
+      def calculate_attributes(stat)
+        attribs = Constants::ATTRIB_ARCH
+
+        # Set read-only flag if not writable
+        attribs |= Constants::ATTRIB_READONLY unless stat.writable?
+
+        # Set hidden flag if hidden (Unix dotfiles)
+        basename = ::File.basename(@files.first[:source])
+        attribs |= Constants::ATTRIB_HIDDEN if basename.start_with?(".")
+
+        # Set system flag for system files
+        attribs |= Constants::ATTRIB_SYSTEM if stat.socket? || stat.symlink?
+
+        attribs
+      end
+    end
+  end
+end

data/lib/cabriolet/compressors/quantum.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../quantum_shared"
+
 module Cabriolet
   module Compressors
     # Quantum compresses data using arithmetic coding and LZ77-based matching
@@ -13,60 +15,10 @@ module Cabriolet
     # For now, this implementation focuses on correct structure.
     # rubocop:disable Metrics/ClassLength
     class Quantum < Base
-      # Frame size (32KB per frame)
-      FRAME_SIZE = 32_768
-
-      # Match constants
-      MIN_MATCH = 3
-      MAX_MATCH = 259
-
-      # Position slot tables (same as decompressor)
-      POSITION_BASE = [
-        0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384,
-        512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12_288, 16_384,
-        24_576, 32_768, 49_152, 65_536, 98_304, 131_072, 196_608, 262_144,
-        393_216, 524_288, 786_432, 1_048_576, 1_572_864
-      ].freeze
-
-      EXTRA_BITS = [
-        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
-        9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
-        17, 17, 18, 18, 19, 19
-      ].freeze
-
-      LENGTH_BASE = [
-        0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 18, 22, 26,
-        30, 38, 46, 54, 62, 78, 94, 110, 126, 158, 190, 222, 254
-      ].freeze
-
-      LENGTH_EXTRA = [
-        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
-        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
-      ].freeze
+      include QuantumShared
 
       attr_reader :window_bits, :window_size
 
-      # Represents a symbol in an arithmetic coding model
-      class ModelSymbol
-        attr_accessor :sym, :cumfreq
-
-        def initialize(sym, cumfreq)
-          @sym = sym
-          @cumfreq = cumfreq
-        end
-      end
-
-      # Represents an arithmetic coding model
-      class Model
-        attr_accessor :shiftsleft, :entries, :syms
-
-        def initialize(syms, entries)
-          @syms = syms
-          @entries = entries
-          @shiftsleft = 4
-        end
-      end
-
       # Initialize Quantum compressor
       #
       # @param io_system [System::IOSystem] I/O system for reading/writing

data/lib/cabriolet/decompressors/lzx.rb

@@ -105,6 +105,9 @@ module Cabriolet
                      reset_interval: 0, output_length: 0, is_delta: false, salvage: false, **_kwargs)
         super(io_system, input, output, buffer_size)
 
+        # Store salvage flag for error handling
+        @salvage = salvage
+
         # Validate window_bits
         if is_delta
           unless (17..25).cover?(window_bits)
@@ -195,7 +198,17 @@ module Cabriolet
           frame_size = calculate_frame_size
 
           # Decode blocks until frame is complete
-          decode_frame(frame_size)
+          begin
+            decode_frame(frame_size)
+          rescue DecompressionError => e
+            # In salvage mode, if decompression fails, return what we have so far
+            if @salvage
+              warn "Salvage: LZX decompression failed at frame #{@frame}: #{e.message}"
+              return total_written
+            else
+              raise
+            end
+          end
 
           # Apply Intel E8 transformation if needed
           frame_data = if should_apply_e8_transform?(frame_size)
@@ -391,6 +404,35 @@ module Cabriolet
         @maintree = Huffman::Tree.new(@maintree_lengths, @maintree_maxsymbols,
                                       bit_order: :msb)
         unless @maintree.build_table(LENGTH_TABLEBITS)
+          # In salvage mode, try to build with a default distribution
+          if @salvage
+            # For a valid Huffman tree with @maintree_maxsymbols symbols and LENGTH_TABLEBITS=12,
+            # we need sum(2^(12-len)) = 4096 (for complete tree) or <= 4096 (for partial).
+            # For @maintree_maxsymbols = 784, we need to distribute symbols across lengths 8-10:
+            # Using: 128 at len8 (2048 slots) + 384 at len9 (768 slots) + 272 at len10 (256 slots)
+            # Total: 2048 + 768 + 256 = 3072 slots, leaving 1024 for longer codes
+            # Simpler: use lengths that sum to exactly 4096
+            # 784 symbols: distribute as 192 at len9, 592 at len10 = 384 + 592 = 976 (not enough)
+            # 784 symbols: distribute as 64 at len8, 576 at len9, 144 at len10 = 128 + 1152 + 144 = 1424
+            # Final: 784 symbols across lengths 8-11 to fill 4096 slots
+            # Verify: 64*128 + 384*64 + 256*32 + 80*16 = 8192 + 24576 + 8192 + 1280 = 42240 (wrong)
+
+            # Recalculate: 2^(12-len) slots needed per symbol
+            # len8: 16 slots/symbol, len9: 8 slots/symbol, len10: 4 slots/symbol, len11: 2 slots/symbol
+            # Total slots = sum(2^(12-len) for each symbol) must <= 4096
+            # Simple valid distribution for 784 symbols:
+            # 256 at len10 = 256*4 = 1024
+            # 528 at len12 = 528*1 = 528
+            # Total = 1552 (valid but incomplete tree)
+
+            default_main_lengths = []
+            256.times { default_main_lengths << 10 }
+            528.times { default_main_lengths << 12 }
+            @maintree_lengths = default_main_lengths
+            @maintree = Huffman::Tree.new(default_main_lengths, @maintree_maxsymbols,
+                                          bit_order: :msb)
+            return if @maintree.build_table(LENGTH_TABLEBITS)
+          end
           raise DecompressionError,
                 "Failed to build main tree"
         end
@@ -428,6 +470,22 @@ module Cabriolet
                                      bit_order: :msb)
         return if @pretree.build_table(PRETREE_TABLEBITS)
 
+        # In salvage mode, try to continue with a valid default tree
+        if @salvage
+          # For a valid Huffman tree with table_bits=6, we need exactly 64 slots.
+          # With 8 symbols at length 3: 8 * 2^(6-3) = 8 * 8 = 64 slots (complete)
+          # For simplicity: 8 at length 3 fills direct table (64 slots)
+          default_lengths = [
+            3, 3, 3, 3, 3, 3, 3, 3,  # 8 at length 3: fills 64 slots
+            7, 7, 7, 7, 7, 7, 7, 7,  # 8 at length 7: extended table
+            7, 7, 7, 7               # 4 at length 7: extended table
+          ]
+          @pretree_lengths = default_lengths
+          @pretree = Huffman::Tree.new(default_lengths, PRETREE_MAXSYMBOLS,
+                                       bit_order: :msb)
+          return if @pretree.build_table(PRETREE_TABLEBITS)
+        end
+
         raise DecompressionError, "Failed to build pretree"
       end
 

data/lib/cabriolet/decompressors/quantum.rb

@@ -1,5 +1,33 @@
 # frozen_string_literal: true
 
+require_relative "../quantum_shared"
+
+# Compatibility shim for String#bytesplice (added in Ruby 3.2)
+unless String.method_defined?(:bytesplice)
+  module StringBytespliceCompat
+    # Compatibility implementation of bytesplice for Ruby < 3.2
+    # Uses clear/append which is slower but works with mutable strings
+    def bytesplice(index, length, other_string, other_index = 0,
+other_length = nil)
+      other_length ||= other_string.bytesize
+
+      # Build new string content
+      prefix = byteslice(0, index)
+      middle = other_string.byteslice(other_index, other_length)
+      suffix = byteslice((index + length)..-1)
+      new_content = prefix + middle + suffix
+
+      # Modify receiver in place
+      clear
+      self << new_content
+
+      self
+    end
+  end
+
+  String.prepend(StringBytespliceCompat)
+end
+
 module Cabriolet
   module Decompressors
     # Quantum handles Quantum-compressed data using arithmetic coding
@@ -8,59 +36,10 @@ module Cabriolet
     # The Quantum method was created by David Stafford, adapted by Microsoft
     # Corporation.
     class Quantum < Base
-      # Frame size (32KB per frame)
-      FRAME_SIZE = 32_768
-
-      # Match constants
-      MAX_MATCH = 259
-
-      # Position slot tables (same as in qtmd.c)
-      POSITION_BASE = [
-        0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384,
-        512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12_288, 16_384,
-        24_576, 32_768, 49_152, 65_536, 98_304, 131_072, 196_608, 262_144,
-        393_216, 524_288, 786_432, 1_048_576, 1_572_864
-      ].freeze
-
-      EXTRA_BITS = [
-        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
-        9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
-        17, 17, 18, 18, 19, 19
-      ].freeze
-
-      LENGTH_BASE = [
-        0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 18, 22, 26,
-        30, 38, 46, 54, 62, 78, 94, 110, 126, 158, 190, 222, 254
-      ].freeze
-
-      LENGTH_EXTRA = [
-        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
-        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
-      ].freeze
+      include QuantumShared
 
       attr_reader :window_bits, :window_size
 
-      # Represents a symbol in an arithmetic coding model
-      class ModelSymbol
-        attr_accessor :sym, :cumfreq
-
-        def initialize(sym, cumfreq)
-          @sym = sym
-          @cumfreq = cumfreq
-        end
-      end
-
-      # Represents an arithmetic coding model
-      class Model
-        attr_accessor :shiftsleft, :entries, :syms
-
-        def initialize(syms, entries)
-          @syms = syms
-          @entries = entries
-          @shiftsleft = 4
-        end
-      end
-
       # Initialize Quantum decompressor
       #
       # @param io_system [System::IOSystem] I/O system for reading/writing
@@ -81,8 +60,13 @@ module Cabriolet
         @window_bits = window_bits
         @window_size = 1 << window_bits
 
-        # Initialize window
-        @window = "\0" * @window_size
+        # Initialize window (mutable for Ruby < 3.2 bytesplice compatibility)
+        @window = if String.method_defined?(:bytesplice)
+                    "\0" * @window_size
+                  else
+                    # In Ruby < 3.2, create mutable window using String.new
+                    String.new("\0" * @window_size)
+                  end
         @window_posn = 0
         @frame_todo = FRAME_SIZE
 
@@ -409,7 +393,52 @@ module Cabriolet
       end
 
       # Copy match from window
+      # Optimized to use bulk byte operations for better performance
       def copy_match(offset, length)
+        # Use bulk copy for matches longer than 32 bytes
+        if length > 32
+          copy_match_bulk(offset, length)
+        else
+          copy_match_byte_by_byte(offset, length)
+        end
+      end
+
+      # Bulk copy using bytesplice for better performance on longer matches
+      def copy_match_bulk(offset, length)
+        if offset > @window_posn
+          # Match wraps around window
+          if offset > @window_size
+            raise DecompressionError,
+                  "Match offset beyond window"
+          end
+
+          # Copy from end of window
+          src_pos = @window_size - (offset - @window_posn)
+          copy_len = offset - @window_posn
+
+          if copy_len < length
+            # Copy from end, then from beginning
+            @window.bytesplice(@window_posn, copy_len, @window, src_pos,
+                               copy_len)
+            @window_posn += copy_len
+            remaining = length - copy_len
+            @window.bytesplice(@window_posn, remaining, @window, 0, remaining)
+            @window_posn += remaining
+          else
+            # Copy entirely from end
+            @window.bytesplice(@window_posn, length, @window, src_pos, length)
+            @window_posn += length
+          end
+        else
+          # Normal copy - use bytesplice for bulk operation
+          src_pos = @window_posn - offset
+          @window.bytesplice(@window_posn, length, @window, src_pos, length)
+          @window_posn += length
+        end
+      end
+
+      # Byte-by-byte copy for short matches (fallback)
+      def copy_match_byte_by_byte(offset, length)
         if offset > @window_posn
           # Match wraps around window
           if offset > @window_size

data/lib/cabriolet/extraction/base_extractor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Cabriolet
+  module Extraction
+    # BaseExtractor provides common extraction functionality for all extractors
+    # Reduces code duplication between SimpleExtractor and Parallel::Extractor
+    class BaseExtractor
+      # Initialize the base extractor
+      #
+      # @param output_dir [String] Directory to extract files to
+      # @param preserve_paths [Boolean] Whether to preserve directory structure
+      # @param overwrite [Boolean] Whether to overwrite existing files
+      def initialize(output_dir, preserve_paths: true, overwrite: false)
+        @output_dir = output_dir
+        @preserve_paths = preserve_paths
+        @overwrite = overwrite
+      end
+
+      protected
+
+      # Build the output path for a file, handling path preservation and cleaning
+      #
+      # @param filename [String] Original filename from archive (may have backslashes)
+      # @return [String] Full output path for the file
+      def build_output_path(filename)
+        # Normalize path separators (Windows archives use backslashes)
+        clean_name = filename.gsub("\\", "/")
+
+        if @preserve_paths
+          # Keep directory structure
+          ::File.join(@output_dir, clean_name)
+        else
+          # Flatten to output directory (just basename)
+          ::File.join(@output_dir, ::File.basename(clean_name))
+        end
+      end
+
+      # Extract a single file to disk
+      #
+      # @param file [Object] File object from archive (must respond to :name and :data)
+      # @yield [path, data] Optional block for custom handling instead of default write
+      # @return [String, nil] Output path if successful, nil if skipped or failed
+      def extract_file(file)
+        output_path = build_output_path(file.name)
+
+        # Check if file exists and skip if not overwriting
+        if ::File.exist?(output_path) && !@overwrite
+          return nil
+        end
+
+        # Create parent directory
+        dir = ::File.dirname(output_path)
+        FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+
+        # Get file data
+        data = file.data
+        return nil unless data
+
+        # Write file data
+        ::File.binwrite(output_path, data)
+
+        # Preserve file attributes if available
+        preserve_file_attributes(output_path, file)
+
+        output_path
+      rescue StandardError => e
+        warn "Failed to extract #{file.name}: #{e.message}"
+        nil
+      end
+
+      # Preserve file attributes (timestamps, etc.) if available on the file object
+      #
+      # @param path [String] Path to extracted file
+      # @param file [Object] File object from archive
+      def preserve_file_attributes(path, file)
+        # Try various timestamp attributes that different formats use
+        if file.respond_to?(:datetime) && file.datetime
+          ::File.utime(::File.atime(path), file.datetime, path)
+        elsif file.respond_to?(:mtime) && file.mtime
+          atime = file.respond_to?(:atime) ? file.atime : ::File.atime(path)
+          ::File.utime(atime, file.mtime, path)
+        end
+      end
+    end
+  end
+end