cabriolet 0.1.2 → 0.2.0

data/lib/cabriolet/cab/compressor.rb

@@ -10,8 +10,10 @@ module Cabriolet
       # 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
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @files = []
         @compression = :mszip
         @set_id = rand(0xFFFF)
@@ -161,54 +163,44 @@ 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
-
-      # Compress data using MSZIP
-      def compress_mszip(data)
-        input = System::MemoryHandle.new(data, Constants::MODE_READ)
-        output = System::MemoryHandle.new("", Constants::MODE_WRITE)
-
-        compressor = Compressors::MSZIP.new(@io_system, input, output,
-                                            Cabriolet.default_buffer_size)
-        compressor.compress
-
-        output.data
-      end
+        return data if @compression == :none
 
-      # Compress data using LZX
-      def compress_lzx(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::LZX.new(@io_system, input, output,
-                                          Cabriolet.default_buffer_size, window_bits: 15)
-        compressor.compress
-
-        output.data
-      end
+        # 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
 
-      # Compress data using Quantum
-      def compress_quantum(data)
-        input = System::MemoryHandle.new(data, Constants::MODE_READ)
-        output = System::MemoryHandle.new("", Constants::MODE_WRITE)
+        # 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

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

data/lib/cabriolet/cab/extractor.rb

@@ -15,6 +15,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 +51,6 @@ module Cabriolet
           end
 
           filelen = Constants::LENGTH_MAX - file.offset
-
         end
 
         # Check for merge requirements
@@ -66,38 +71,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 +233,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 +264,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 +288,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 +344,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 +399,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

data/lib/cabriolet/chm/command_handler.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module CHM
+    # Command handler for CHM (Compiled HTML Help) format
+    #
+    # This handler implements the unified command interface for CHM files,
+    # wrapping the existing CHM::Decompressor and CHM::Compressor classes.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List CHM file contents
+      #
+      # Displays information about the CHM file including version,
+      # language, and lists all contained files with their sizes.
+      #
+      # @param file [String] Path to the CHM file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def list(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        chm = decompressor.open(file)
+
+        display_header(chm)
+        display_files(chm.all_files)
+
+        decompressor.close
+      end
+
+      # Extract files from CHM archive
+      #
+      # Extracts all non-system files from the CHM file to the
+      # specified output directory.
+      #
+      # @param file [String] Path to the CHM file
+      # @param output_dir [String] Output directory path (default: current directory)
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def extract(file, output_dir = nil, _options = {})
+        validate_file_exists(file)
+
+        output_dir ||= "."
+        output_dir = ensure_output_dir(output_dir)
+
+        decompressor = Decompressor.new
+        chm = decompressor.open(file)
+
+        count = 0
+        chm.all_files.each do |f|
+          next if f.system_file?
+
+          output_path = File.join(output_dir, f.filename)
+          output_subdir = File.dirname(output_path)
+          FileUtils.mkdir_p(output_subdir)
+
+          puts "Extracting: #{f.filename}" if verbose?
+          decompressor.extract(f, output_path)
+          count += 1
+        end
+
+        decompressor.close
+        puts "Extracted #{count} file(s) to #{output_dir}"
+      end
+
+      # Create a new CHM archive
+      #
+      # Creates a CHM file from HTML source files.
+      #
+      # @param output [String] Output CHM file path
+      # @param files [Array<String>] List of input HTML files
+      # @param options [Hash] Additional options
+      # @option options [Integer] :window_bits LZX window size (15-21, default: 16)
+      # @return [void]
+      # @raise [ArgumentError] if no files specified
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No files specified" if files.empty?
+
+        files.each do |f|
+          raise ArgumentError, "File does not exist: #{f}" unless File.exist?(f)
+        end
+
+        window_bits = options[:window_bits] || 16
+
+        compressor = Compressor.new
+        files.each do |f|
+          # Default to compressed section for .html, uncompressed for images
+          section = f.end_with?(".html", ".htm") ? :compressed : :uncompressed
+          compressor.add_file(f, "/#{File.basename(f)}", section: section)
+        end
+
+        puts "Creating #{output} with #{files.size} file(s) (window_bits: #{window_bits})" if verbose?
+        bytes = compressor.generate(output, window_bits: window_bits)
+        puts "Created #{output} (#{bytes} bytes, #{files.size} files)"
+      end
+
+      # Display detailed CHM file information
+      #
+      # Shows comprehensive information about the CHM structure,
+      # including directory, sections, and files.
+      #
+      # @param file [String] Path to the CHM file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        chm = decompressor.open(file)
+
+        display_chm_info(chm)
+
+        decompressor.close
+      end
+
+      # Test CHM file integrity
+      #
+      # Verifies the CHM file structure.
+      #
+      # @param file [String] Path to the CHM file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        chm = decompressor.open(file)
+
+        puts "Testing #{chm.filename}..."
+        puts "OK: CHM file structure is valid (#{chm.all_files.size} files)"
+        puts "Note: Full integrity validation not yet implemented"
+
+        decompressor.close
+      end
+
+      private
+
+      # Display CHM header information
+      #
+      # @param chm [CHMFile] The CHM file object
+      # @return [void]
+      def display_header(chm)
+        puts "CHM File: #{chm.filename}"
+        puts "Version: #{chm.version}"
+        puts "Language: #{chm.language}"
+        puts "Chunks: #{chm.num_chunks}, Chunk Size: #{chm.chunk_size}"
+        puts "\nFiles:"
+      end
+
+      # Display list of files in CHM
+      #
+      # @param files [Array<CHMFile>] Array of file objects
+      # @return [void]
+      def display_files(files)
+        files.each do |f|
+          section_name = f.section.id.zero? ? "Uncompressed" : "MSCompressed"
+          puts "  #{f.filename} (#{f.length} bytes, #{section_name})"
+        end
+      end
+
+      # Display comprehensive CHM information
+      #
+      # @param chm [CHMFile] The CHM file object
+      # @return [void]
+      def display_chm_info(chm)
+        puts "CHM File Information"
+        puts "=" * 50
+        puts "Filename: #{chm.filename}"
+        puts "Version: #{chm.version}"
+        puts "Language ID: #{chm.language}"
+        puts "Timestamp: #{chm.timestamp}"
+        puts "Size: #{chm.length} bytes"
+        puts ""
+        puts "Directory:"
+        puts "  Offset: #{chm.dir_offset}"
+        puts "  Chunks: #{chm.num_chunks}"
+        puts "  Chunk Size: #{chm.chunk_size}"
+        puts "  First PMGL: #{chm.first_pmgl}"
+        puts "  Last PMGL: #{chm.last_pmgl}"
+        puts ""
+        puts "Sections:"
+        puts "  Section 0 (Uncompressed): offset #{chm.sec0.offset}"
+        puts "  Section 1 (MSCompressed): LZX compression"
+        puts ""
+
+        regular_files = chm.all_files
+        system_files = chm.all_sysfiles
+
+        puts "Files: #{regular_files.length} regular, #{system_files.length} system"
+        puts ""
+        display_regular_files(regular_files)
+        display_system_files(system_files) if system_files.any?
+      end
+
+      # Display regular files
+      #
+      # @param files [Array<CHMFile>] Array of regular file objects
+      # @return [void]
+      def display_regular_files(files)
+        puts "Regular Files:"
+        files.each do |f|
+          section_name = f.section.id.zero? ? "Sec0" : "Sec1"
+          puts "  #{f.filename}"
+          puts "    Size: #{f.length} bytes (#{section_name})"
+        end
+      end
+
+      # Display system files
+      #
+      # @param files [Array<CHMFile>] Array of system file objects
+      # @return [void]
+      def display_system_files(files)
+        puts ""
+        puts "System Files:"
+        files.each do |f|
+          section_name = f.section.id.zero? ? "Sec0" : "Sec1"
+          puts "  #{f.filename}"
+          puts "    Size: #{f.length} bytes (#{section_name})"
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/chm/compressor.rb

@@ -34,8 +34,10 @@ module Cabriolet
       # Initialize CHM compressor
       #
       # @param io_system [System::IOSystem] I/O system for file operations
-      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
         @files = []
         @timestamp = Time.now.to_i
         @language_id = 0x0409 # English (US)
@@ -156,7 +158,9 @@ module Cabriolet
         input_handle = System::MemoryHandle.new(uncompressed_data, Constants::MODE_READ)
         output_handle = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
-        compressor = Compressors::LZX.new(
+        compressor = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :compressor,
           @io_system,
           input_handle,
           output_handle,
@@ -255,7 +259,7 @@ module Cabriolet
 
       # Build control data for LZX
       def build_control_data
-        control = Binary::LZXControlData.new
+        control = Binary::CHMLZXControlData.new
         control.len = 28
         control.signature = "LZXC"
         control.version = 2