cabriolet 0.2.0 → 0.2.1

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/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

data/lib/cabriolet/extraction/extractor.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "fractor"
+require_relative "file_extraction_work"
+require_relative "file_extraction_worker"
+
+module Cabriolet
+  module Extraction
+    # Unified extractor using Fractor for parallel file extraction
+    # Single workers: 1 = sequential, N = parallel
+    class Extractor
+      DEFAULT_WORKERS = 4
+
+      attr_reader :archive, :output_dir, :workers, :stats
+
+      def initialize(archive, output_dir, workers: DEFAULT_WORKERS, **options)
+        @archive = archive
+        @output_dir = output_dir
+        @workers = [workers, 1].max # At least 1 worker
+        @preserve_paths = options.fetch(:preserve_paths, true)
+        @overwrite = options.fetch(:overwrite, false)
+        @stats = { extracted: 0, skipped: 0, failed: 0, bytes: 0 }
+      end
+
+      # Extract all files from archive
+      #
+      # @return [Hash] Extraction statistics
+      def extract_all
+        FileUtils.mkdir_p(@output_dir)
+
+        # Create work items for all files
+        work_items = @archive.files.map do |file|
+          FileExtractionWork.new(
+            file,
+            output_dir: @output_dir,
+            preserve_paths: @preserve_paths,
+            overwrite: @overwrite,
+          )
+        end
+
+        # Create supervisor with workers
+        supervisor = Fractor::Supervisor.new(
+          worker_pools: [
+            {
+              worker_class: FileExtractionWorker,
+              num_workers: @workers,
+            },
+          ],
+        )
+
+        # Add all work items
+        supervisor.add_work_items(work_items)
+
+        # Run extraction
+        supervisor.run
+
+        # Collect results
+        collect_stats(supervisor.results)
+
+        @stats
+      end
+
+      # Extract files with progress callback
+      #
+      # @yield [current, total, file] Progress callback
+      # @return [Hash] Extraction statistics
+      def extract_with_progress(&block)
+        return extract_all unless block
+
+        FileUtils.mkdir_p(@output_dir)
+
+        # For progress tracking, we need to process in batches
+        # or use a custom approach since Fractor doesn't have built-in callbacks
+        total = @archive.files.count
+        current = 0
+
+        # Sequential mode uses simple iteration with progress
+        if @workers == 1
+          @archive.files.each do |file|
+            extract_single_file(file)
+            current += 1
+            yield(current, total, file)
+          end
+          return @stats
+        end
+
+        # Parallel mode: batch files for progress updates
+        batch_size = [@archive.files.count / @workers, 1].max
+        batches = @archive.files.each_slice(batch_size).to_a
+
+        batches.each do |batch|
+          work_items = batch.map do |file|
+            FileExtractionWork.new(
+              file,
+              output_dir: @output_dir,
+              preserve_paths: @preserve_paths,
+              overwrite: @overwrite,
+            )
+          end
+
+          supervisor = Fractor::Supervisor.new(
+            worker_pools: [
+              {
+                worker_class: FileExtractionWorker,
+                num_workers: @workers,
+              },
+            ],
+          )
+
+          supervisor.add_work_items(work_items)
+          supervisor.run
+
+          batch.each do |file|
+            current += 1
+            yield(current, total, file)
+          end
+        end
+
+        @stats
+      end
+
+      private
+
+      # Extract a single file (for sequential mode with progress)
+      #
+      # @param file [Object] File to extract
+      # @return [Object] Result from worker
+      def extract_single_file(file)
+        work = FileExtractionWork.new(
+          file,
+          output_dir: @output_dir,
+          preserve_paths: @preserve_paths,
+          overwrite: @overwrite,
+        )
+
+        worker = FileExtractionWorker.new
+        result = worker.process(work)
+
+        update_stats_from_result(result)
+
+        result
+      end
+
+      # Collect statistics from Fractor results
+      #
+      # @param results [Fractor::Results] Results from supervisor
+      def collect_stats(results)
+        results.results.each do |result|
+          update_stats_from_result(result)
+        end
+      end
+
+      # Update stats from a single work result
+      #
+      # @param result [Fractor::WorkResult] Result from worker
+      def update_stats_from_result(result)
+        if result.success?
+          data = result.result
+          if data.is_a?(Hash) && data[:status] == :skipped
+            @stats[:skipped] += 1
+          else
+            @stats[:extracted] += 1
+            @stats[:bytes] += data[:size] if data.is_a?(Hash) && data[:size]
+          end
+        else
+          @stats[:failed] += 1
+        end
+      end
+    end
+  end
+end