cabriolet 0.1.2 → 0.2.0

data/lib/cabriolet/models/winhelp_header.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Windows Help (WinHelp) file header model
+    #
+    # Represents the metadata of a Windows Help file (WinHelp 3.x or 4.x).
+    # WinHelp files contain an internal file system with |SYSTEM, |TOPIC,
+    # and other internal files.
+    class WinHelpHeader
+      attr_accessor :version, :magic, :directory_offset, :free_list_offset, :file_size, :filename # :winhelp3 or :winhelp4         # Magic number (0x35F3 or 0x3F5F0000)
+
+      # Internal files in the help file
+      # Array of hashes: { filename:, file_size:, starting_block: }
+      attr_accessor :internal_files
+
+      # Parsed |SYSTEM file data (if extracted)
+      attr_accessor :system_data
+
+      # Initialize WinHelp header
+      #
+      # @param version [Symbol] :winhelp3 or :winhelp4
+      # @param magic [Integer] Magic number
+      # @param directory_offset [Integer] Offset to internal file directory
+      # @param free_list_offset [Integer] Offset to free list
+      # @param file_size [Integer] Total file size
+      # @param filename [String, nil] Original filename
+      def initialize(
+        version: :winhelp3,
+        magic: 0,
+        directory_offset: 0,
+        free_list_offset: 0,
+        file_size: 0,
+        filename: nil
+      )
+        @version = version
+        @magic = magic
+        @directory_offset = directory_offset
+        @free_list_offset = free_list_offset
+        @file_size = file_size
+        @filename = filename
+
+        @internal_files = []
+        @system_data = nil
+      end
+
+      # Check if header is valid
+      #
+      # @return [Boolean] true if header appears valid
+      def valid?
+        case @version
+        when :winhelp3
+          @magic == 0x35F3
+        when :winhelp4
+          (@magic & 0xFFFF) == 0x3F5F
+        else
+          false
+        end
+      end
+
+      # Check if this is WinHelp 3.x format
+      #
+      # @return [Boolean] true if WinHelp 3.x
+      def winhelp3?
+        @version == :winhelp3
+      end
+
+      # Check if this is WinHelp 4.x format
+      #
+      # @return [Boolean] true if WinHelp 4.x
+      def winhelp4?
+        @version == :winhelp4
+      end
+
+      # Get list of internal filenames
+      #
+      # @return [Array<String>] Internal file names
+      def internal_filenames
+        @internal_files.map { |f| f[:filename] }
+      end
+
+      # Find internal file by name
+      #
+      # @param name [String] Internal filename (e.g., "|SYSTEM")
+      # @return [Hash, nil] File entry or nil if not found
+      def find_file(name)
+        @internal_files.find { |f| f[:filename] == name }
+      end
+
+      # Check if |SYSTEM file exists
+      #
+      # @return [Boolean] true if |SYSTEM file present
+      def has_system_file?
+        !find_file("|SYSTEM").nil?
+      end
+
+      # Check if |TOPIC file exists
+      #
+      # @return [Boolean] true if |TOPIC file present
+      def has_topic_file?
+        !find_file("|TOPIC").nil?
+      end
+
+      # Get version string
+      #
+      # @return [String] Human-readable version
+      def version_string
+        case @version
+        when :winhelp3
+          "Windows Help 3.x (16-bit)"
+        when :winhelp4
+          "Windows Help 4.x (32-bit)"
+        else
+          "Unknown"
+        end
+      end
+
+      # Get magic number as hex string
+      #
+      # @return [String] Hex representation of magic
+      def magic_hex
+        magic_int = @magic.respond_to?(:to_i) ? @magic.to_i : @magic.to_int
+        "0x#{magic_int.to_s(16).upcase}"
+      end
+    end
+  end
+end

data/lib/cabriolet/oab/command_handler.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module OAB
+    # Command handler for OAB (Outlook Offline Address Book) format
+    #
+    # This handler implements the unified command interface for OAB files,
+    # wrapping the existing OAB::Decompressor and OAB::Compressor classes.
+    # OAB files use LZX compression for address book data.
+    #
+    # Unlike other formats, OAB is a compressed data format rather than
+    # an archive - the "list" command displays header information only.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List OAB file information
+      #
+      # Displays information about the OAB file including version,
+      # block size, and target size.
+      #
+      # @param file [String] Path to the OAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def list(file, _options = {})
+        validate_file_exists(file)
+
+        display_oab_info(file)
+      end
+
+      # Extract/decompress OAB file
+      #
+      # Decompresses the OAB file to its original form.
+      # Auto-detects output filename if not specified.
+      #
+      # @param file [String] Path to the OAB file
+      # @param output_dir [String] Output directory (not typically used for OAB)
+      # @param options [Hash] Additional options
+      # @option options [String] :output Output file path
+      # @option options [String] :base_file Base file for incremental patches
+      # @return [void]
+      def extract(file, output_dir = nil, options = {})
+        validate_file_exists(file)
+
+        output = options[:output]
+
+        # Auto-detect output name if not provided
+        if output.nil? && output_dir.nil?
+          output = auto_output_filename(file)
+        end
+
+        # If output_dir is specified, construct output path
+        if output.nil? && output_dir
+          base_name = File.basename(file, ".*")
+          output = File.join(output_dir, base_name)
+        end
+
+        decompressor = Decompressor.new
+
+        # Check if this is an incremental patch
+        if options[:base_file]
+          base_file = options[:base_file]
+          validate_file_exists(base_file)
+
+          puts "Applying incremental patch: #{file} + #{base_file} -> #{output}" if verbose?
+          bytes = decompressor.decompress_incremental(file, base_file, output)
+          puts "Applied patch to #{output} (#{bytes} bytes)"
+        else
+          puts "Decompressing #{file} -> #{output}" if verbose?
+          bytes = decompressor.decompress(file, output)
+          puts "Decompressed #{file} to #{output} (#{bytes} bytes)"
+        end
+      end
+
+      # Create OAB compressed file
+      #
+      # Compresses a file using OAB LZX compression.
+      #
+      # @param output [String] Output OAB file path
+      # @param files [Array<String>] Input file (single file for OAB)
+      # @param options [Hash] Additional options
+      # @option options [Integer] :block_size Block size for compression
+      # @option options [String] :base_file Base file for creating incremental patch
+      # @return [void]
+      # @raise [ArgumentError] if no file specified or multiple files
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No file specified" if files.empty?
+
+        if files.size > 1
+          raise ArgumentError,
+                "OAB format supports only one file at a time"
+        end
+
+        file = files.first
+        unless File.exist?(file)
+          raise ArgumentError,
+                "File does not exist: #{file}"
+        end
+
+        compressor = Compressor.new
+
+        # Auto-generate output name if not provided
+        if output.nil?
+          output = "#{file}.oab"
+        end
+
+        if options[:base_file]
+          base_file = options[:base_file]
+          unless File.exist?(base_file)
+            raise ArgumentError,
+                  "Base file does not exist: #{base_file}"
+          end
+
+          puts "Creating incremental patch: #{file} - #{base_file} -> #{output}" if verbose?
+          bytes = compressor.compress_incremental(file, base_file, output,
+                                                  **options)
+          puts "Created incremental patch #{output} (#{bytes} bytes)"
+        else
+          block_size = options[:block_size]
+          puts "Compressing #{file} -> #{output} (block_size: #{block_size || 'default'})" if verbose?
+          bytes = compressor.compress(file, output, **options)
+          puts "Compressed #{file} to #{output} (#{bytes} bytes)"
+        end
+      end
+
+      # Display detailed OAB file information
+      #
+      # @param file [String] Path to the OAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        display_oab_info(file)
+      end
+
+      # Test OAB file integrity
+      #
+      # Verifies the OAB file structure.
+      #
+      # @param file [String] Path to the OAB file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        puts "Testing #{file}..."
+
+        # Try to read and validate header
+        decompressor = Decompressor.new
+        # We can't easily test without decompressing, so we attempt to read the header
+        io_system = decompressor.io_system
+        handle = io_system.open(file, Constants::MODE_READ)
+
+        begin
+          header_data = io_system.read(handle, 16)
+          if header_data.length < 16
+            puts "ERROR: Failed to read OAB header"
+            return
+          end
+
+          # Check if it's a full file or patch file
+          full_header = Binary::OABStructures::FullHeader.read(header_data)
+          if full_header.valid?
+            puts "OK: OAB full file structure is valid"
+            puts "Version: #{full_header.version_hi}.#{full_header.version_lo}"
+            puts "Target size: #{full_header.target_size} bytes"
+            puts "Block max: #{full_header.block_max} bytes"
+          else
+            # Check for patch header
+            patch_header = Binary::OABStructures::PatchHeader.read(header_data)
+            if patch_header.valid?
+              puts "OK: OAB patch file structure is valid"
+              puts "Version: #{patch_header.version_hi}.#{patch_header.version_lo}"
+              puts "Target size: #{patch_header.target_size} bytes"
+              puts "Source size: #{patch_header.source_size} bytes"
+            else
+              puts "ERROR: Invalid OAB header signature"
+            end
+          end
+        rescue StandardError => e
+          puts "ERROR: OAB file validation failed: #{e.message}"
+        ensure
+          io_system.close(handle)
+        end
+      end
+
+      private
+
+      # Display OAB file information
+      #
+      # @param file [String] Path to the OAB file
+      # @return [void]
+      def display_oab_info(file)
+        puts "OAB File Information"
+        puts "=" * 50
+        puts "Filename: #{file}"
+
+        decompressor = Decompressor.new
+        io_system = decompressor.io_system
+        handle = io_system.open(file, Constants::MODE_READ)
+
+        begin
+          header_data = io_system.read(handle, 28) # Read enough for both header types
+
+          # Try full file header first
+          full_header = Binary::OABStructures::FullHeader.read(header_data[0,
+                                                                           16])
+          if full_header.valid?
+            puts "Type: Full OAB file"
+            puts "Version: #{full_header.version_hi}.#{full_header.version_lo}"
+            puts "Target size: #{full_header.target_size} bytes"
+            puts "Block max: #{full_header.block_max} bytes"
+            return
+          end
+
+          # Try patch file header
+          patch_header = Binary::OABStructures::PatchHeader.read(header_data[0,
+                                                                             28])
+          if patch_header.valid?
+            puts "Type: Incremental OAB patch"
+            puts "Version: #{patch_header.version_hi}.#{patch_header.version_lo}"
+            puts "Target size: #{patch_header.target_size} bytes"
+            puts "Source size: #{patch_header.source_size} bytes"
+            puts "Source CRC: 0x#{patch_header.source_crc.to_s(16).upcase}"
+            puts "Target CRC: 0x#{patch_header.target_crc.to_s(16).upcase}"
+            return
+          end
+
+          puts "Type: Unknown (invalid header)"
+        rescue StandardError => e
+          puts "Error reading OAB header: #{e.message}"
+        ensure
+          io_system.close(handle)
+        end
+      end
+
+      # Auto-detect output filename from OAB file
+      #
+      # @param file [String] Original file path
+      # @return [String] Detected output filename
+      def auto_output_filename(file)
+        # Remove .oab extension if present, otherwise just return the basename
+        base_name = File.basename(file, ".*")
+        # If the file doesn't end with .oab, keep the original name
+        if file.end_with?(".oab")
+          base_name
+        else
+          # Return with .dat extension (common for decompressed OAB)
+          "#{base_name}.dat"
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/oab/compressor.rb

@@ -32,8 +32,10 @@ module Cabriolet
       # Initialize OAB compressor
       #
       # @param io_system [System::IOSystem, nil] 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
         @buffer_size = DEFAULT_BUFFER_SIZE
         @block_size = DEFAULT_BLOCK_SIZE
       end
@@ -47,7 +49,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress(input_file, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         input_handle = @io_system.open(input_file, Constants::MODE_READ)
         output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
@@ -93,7 +95,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress_data(data, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         input_handle = System::MemoryHandle.new(data, Constants::MODE_READ)
         output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
@@ -138,7 +140,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress_incremental(input_file, base_file, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         # For now, just compress the new file with patch header
         # A full implementation would generate binary diffs
@@ -249,7 +251,8 @@ module Cabriolet
         compressed_data = compress_with_lzx(block_data)
 
         # Use compressed data (or original if compression fails)
-        patch_data = compressed_data && compressed_data.bytesize < block_data.bytesize ? compressed_data : block_data
+        is_compressed = compressed_data && compressed_data.bytesize < block_data.bytesize
+        patch_data = is_compressed ? compressed_data : block_data
         patch_size = patch_data.bytesize
 
         # Calculate CRC
@@ -257,6 +260,7 @@ module Cabriolet
 
         # Write patch block header
         block_header = Binary::OABStructures::PatchBlockHeader.new
+        block_header.flags = is_compressed ? 1 : 0
         block_header.patch_size = patch_size
         block_header.target_size = block_size
         block_header.source_size = source_size
@@ -287,9 +291,14 @@ module Cabriolet
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Compress with LZX
-        compressor = Compressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
-          window_bits: window_bits
+        compressor = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :compressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
+          window_bits: window_bits,
         )
 
         compressor.compress

data/lib/cabriolet/oab/decompressor.rb

@@ -25,8 +25,10 @@ module Cabriolet
       # Initialize OAB decompressor
       #
       # @param io_system [System::IOSystem, nil] 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
         @buffer_size = DEFAULT_BUFFER_SIZE
       end
 
@@ -161,9 +163,9 @@ target_remaining)
       # @return [Integer] Bytes written
       def decompress_patch_block(patch_handle, base_handle, output_handle,
                                  block_max, target_remaining)
-        # Read patch block header
-        block_data = @io_system.read(patch_handle, 16)
-        if block_data.length < 16
+        # Read patch block header (20 bytes with flags field)
+        block_data = @io_system.read(patch_handle, 20)
+        if block_data.length < 20
           raise Error,
                 "Failed to read patch block header"
         end
@@ -177,6 +179,25 @@ target_remaining)
           raise Error, "Invalid patch block header"
         end
 
+        # Check if data is compressed or uncompressed
+        if block_header.uncompressed?
+          # Uncompressed data - read and write directly
+          data = @io_system.read(patch_handle, block_header.patch_size)
+          if data.length < block_header.patch_size
+            raise Error, "Failed to read uncompressed patch data"
+          end
+
+          # Verify CRC
+          actual_crc = Zlib.crc32(data)
+          if actual_crc != block_header.crc
+            raise Error, "CRC mismatch in patch block"
+          end
+
+          @io_system.write(output_handle, data)
+          return block_header.target_size
+        end
+
+        # Compressed data - use LZX decompression
         # Calculate window size for LZX
         window_size = ((block_header.source_size + 32_767) & ~32_767) +
           block_header.target_size
@@ -245,12 +266,17 @@ target_remaining)
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Decompress with LZX
-        lzx = Decompressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
+        lzx = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
           window_bits: window_bits,
           reset_interval: 0,
           output_length: block_size,
-          is_delta: false
+          is_delta: false,
         )
 
         bytes_decompressed = lzx.decompress(block_size)
@@ -286,12 +312,17 @@ target_remaining)
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Decompress with LZX DELTA (includes reference data)
-        lzx = Decompressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
+        lzx = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
           window_bits: window_bits,
           reset_interval: 0,
           output_length: block_header.target_size,
-          is_delta: true
+          is_delta: true,
         )
 
         # For patches, we'd need to set reference data in the LZX window

data/lib/cabriolet/offset_calculator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Abstract base class for offset calculators
+  #
+  # Single responsibility: Calculate file positions within archive.
+  # Strategy pattern: Different formats implement different calculation strategies.
+  #
+  # Subclasses must implement:
+  # - calculate(structure) - Returns hash of offsets
+  #
+  # @example Creating a calculator
+  #   class MyFormatCalculator < OffsetCalculator
+  #     def calculate(structure)
+  #       { header: 0, data: 100 }
+  #     end
+  #   end
+  class OffsetCalculator
+    # Calculate all offsets in archive structure
+    #
+    # @param structure [Hash] Archive structure with files, folders, etc.
+    # @return [Hash] Offset information
+    # @raise [NotImplementedError] if not implemented by subclass
+    def calculate(structure)
+      raise NotImplementedError,
+            "#{self.class.name} must implement calculate(structure)"
+    end
+
+    protected
+
+    # Helper: Calculate cumulative offsets for items
+    #
+    # @param items [Array] Items to calculate offsets for
+    # @param initial_offset [Integer] Starting offset
+    # @yield [item] Block that returns size for each item
+    # @return [Array<Hash>] Items with their offsets
+    def cumulative_offsets(items, initial_offset = 0)
+      offset = initial_offset
+      items.map do |item|
+        current_offset = offset
+        item_size = yield(item)
+        offset += item_size
+        { item: item, offset: current_offset, size: item_size }
+      end
+    end
+  end
+
+  # CAB-specific offset calculator
+  #
+  # Calculates offsets for CFHEADER, CFFOLDER entries, CFFILE entries,
+  # and CFDATA blocks in Microsoft Cabinet files.
+  class CABOffsetCalculator < OffsetCalculator
+    # Calculate CAB file offsets
+    #
+    # @param structure [Hash] Must contain :folders and :files
+    # @return [Hash] Offset information
+    def calculate(structure)
+      offset = Constants::CFHEADER_SIZE
+
+      # Folders section
+      folders_offset = offset
+      offset += Constants::CFFOLDER_SIZE * structure[:folders].size
+
+      # Files section
+      files_offset = offset
+      structure[:files].each do |file_info|
+        offset += Constants::CFFILE_SIZE
+        offset += file_info[:name].bytesize + 1 # null-terminated
+      end
+
+      # Data blocks section
+      data_offset = offset
+
+      {
+        folders: folders_offset,
+        files: files_offset,
+        data: data_offset,
+      }
+    end
+  end
+end