cabriolet 0.1.2 → 0.2.1

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

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

data/lib/cabriolet/chm/decompressor.rb

@@ -13,8 +13,9 @@ module Cabriolet
 
       attr_reader :io_system, :chm
 
-      def initialize(io_system = nil)
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @chm = nil
         @input_handle = nil
         @lzx_state = nil
@@ -72,7 +73,7 @@ module Cabriolet
         when 1
           extract_compressed(file, output_path)
         else
-          raise Errors::FormatError, "Invalid section ID: #{file.section.id}"
+          raise Cabriolet::FormatError, "Invalid section ID: #{file.section.id}"
         end
       end
 
@@ -108,13 +109,20 @@ module Cabriolet
         while remaining.positive?
           chunk_size = [buffer_size, remaining].min
           data = @input_handle.read(chunk_size)
-          if data.nil? || data.length < chunk_size
-            raise Errors::ReadError,
+          if data.nil?
+            raise Cabriolet::ReadError,
+                  "Unexpected end of file"
+          end
+
+          # It's OK if we read less than chunk_size (e.g., last chunk or EOF)
+          # Only raise an error if we read nothing when we expected data
+          if data.empty? && remaining.positive?
+            raise Cabriolet::ReadError,
                   "Unexpected end of file"
           end
 
           output_handle.write(data)
-          remaining -= chunk_size
+          remaining -= data.length
         end
 
         output_handle.close
@@ -174,15 +182,18 @@ module Cabriolet
         control = sec.control || find_system_file(Parser::CONTROL_NAME)
 
         unless content
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "MSCompressed Content file not found"
         end
-        raise Errors::FormatError, "ControlData file not found" unless control
+        unless control
+          raise Cabriolet::FormatError,
+                "ControlData file not found"
+        end
 
         # Read control data
         control_data = read_system_file(control)
         unless control_data.length == 28
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "ControlData wrong size"
         end
 
@@ -198,13 +209,14 @@ module Cabriolet
                       when 0x100000 then 20
                       when 0x200000 then 21
                       else
-                        raise Errors::FormatError,
+                        raise Cabriolet::FormatError,
                               "Invalid window size: #{window_size}"
                       end
 
         # Validate reset interval
         if reset_interval.zero? || (reset_interval % LZX_FRAME_SIZE) != 0
-          raise Errors::FormatError, "Invalid reset interval: #{reset_interval}"
+          raise Cabriolet::FormatError,
+                "Invalid reset interval: #{reset_interval}"
         end
 
         # Find reset table entry for this file
@@ -227,7 +239,9 @@ module Cabriolet
         output_handle = System::MemoryHandle.new("")
 
         # Initialize LZX decompressor
-        @lzx_state = Decompressors::LZX.new(
+        @lzx_state = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
           @io_system,
           @input_handle,
           output_handle,
@@ -242,7 +256,7 @@ module Cabriolet
       def parse_control_data(data)
         signature = data[4, 4]
         unless signature == "LZXC"
-          raise Errors::SignatureError,
+          raise Cabriolet::SignatureError,
                 "Invalid LZXC signature"
         end
 
@@ -255,7 +269,8 @@ module Cabriolet
           reset_interval *= LZX_FRAME_SIZE
           window_size *= LZX_FRAME_SIZE
         elsif version != 1
-          raise Errors::FormatError, "Unknown ControlData version: #{version}"
+          raise Cabriolet::FormatError,
+                "Unknown ControlData version: #{version}"
         end
 
         [window_size, reset_interval]
@@ -272,7 +287,7 @@ module Cabriolet
           # Fall back to SpanInfo
           spaninfo = sec.spaninfo || find_system_file(Parser::SPANINFO_NAME)
           unless spaninfo
-            raise Errors::FormatError,
+            raise Cabriolet::FormatError,
                   "Neither ResetTable nor SpanInfo found"
           end
 
@@ -284,12 +299,12 @@ module Cabriolet
       # Read an entry from the reset table
       def read_reset_table_entry(rtable, entry, reset_interval)
         data = read_system_file(rtable)
-        raise Errors::FormatError, "ResetTable too short" if data.length < 40
+        raise Cabriolet::FormatError, "ResetTable too short" if data.length < 40
 
         # Check frame length
         frame_len = data[32, 8].unpack1("Q<")
         unless frame_len == LZX_FRAME_SIZE
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "Invalid frame length"
         end
 
@@ -307,7 +322,7 @@ module Cabriolet
                    when 4 then data[pos, 4].unpack1("V")
                    when 8 then data[pos, 8].unpack1("Q<")
                    else
-                     raise Errors::FormatError,
+                     raise Cabriolet::FormatError,
                            "Invalid entry size: #{entry_size}"
                    end
 
@@ -325,11 +340,14 @@ module Cabriolet
       # Read SpanInfo to get uncompressed length
       def read_spaninfo(spaninfo)
         data = read_system_file(spaninfo)
-        raise Errors::FormatError, "SpanInfo wrong size" unless data.length == 8
+        unless data.length == 8
+          raise Cabriolet::FormatError,
+                "SpanInfo wrong size"
+        end
 
         length = data.unpack1("Q<")
         unless length.positive?
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "Invalid SpanInfo length"
         end
 
@@ -350,7 +368,7 @@ module Cabriolet
       # Read a system file's contents
       def read_system_file(file)
         unless file.section.id.zero?
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "System file must be in section 0"
         end
 
@@ -417,7 +435,7 @@ module Cabriolet
               file.length = length
               return file
             end
-          rescue Errors::FormatError
+          rescue Cabriolet::FormatError
             break
           end
         end

data/lib/cabriolet/chm/parser.rb

@@ -56,9 +56,12 @@ module Cabriolet
         end
 
         # Check GUIDs
-        unless header.guid1 == GUID1 && header.guid2 == GUID2
+        # Note: Some CHM files have both GUIDs set to GUID1 (unusual but valid)
+        # Standard files have GUID1 and GUID2 as expected
+        # We validate that guid2 matches either GUID1 or GUID2
+        unless [GUID1, GUID2].include?(header.guid2)
           raise SignatureError,
-                "Invalid CHM GUIDs"
+                "Invalid CHM GUIDs (guid2 should match CHM format GUID)"
         end
 
         @chm.version = header.version