cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/models/lit_header.rb

@@ -2,53 +2,240 @@
 
 module Cabriolet
   module Models
-    # Represents the header of a Microsoft Reader LIT file
+    # Represents a Microsoft Reader LIT file structure
     #
-    # LIT files are Microsoft Reader eBook files that use LZX compression
-    # and may use DES encryption for DRM-protected content.
-    class LITHeader
-      attr_accessor :version, :filename, :length, :encrypted, :files
+    # LIT files have a complex structure with:
+    # - Primary and secondary headers
+    # - Piece table pointing to various data structures
+    # - Internal directory with IFCM/AOLL/AOLI chunks
+    # - DataSpace sections with transformation layers (compression/encryption)
+    # - Manifest mapping internal to original filenames
+    class LITFile
+      attr_accessor :version, :header_guid, :piece3_guid, :piece4_guid,
+                    :content_offset, :timestamp, :language_id, :creator_id,
+                    :entry_chunklen, :count_chunklen, :entry_unknown,
+                    :count_unknown, :drm_level, :sections, :directory, :manifest
 
       def initialize
         @version = 0
-        @filename = ""
-        @length = 0
-        @encrypted = false
-        @files = []
+        @header_guid = ""
+        @piece3_guid = ""
+        @piece4_guid = ""
+        @content_offset = 0
+        @timestamp = 0
+        @language_id = 0
+        @creator_id = 0
+        @entry_chunklen = 0
+        @count_chunklen = 0
+        @entry_unknown = 0
+        @count_unknown = 0
+        @drm_level = 0
+        @sections = []
+        @directory = nil
+        @manifest = nil
       end
 
-      # Check if the LIT file is encrypted
+      # Check if the LIT file has DRM encryption
       #
-      # @return [Boolean] true if the file uses DES encryption
+      # @return [Boolean] true if DRM is present
       def encrypted?
-        @encrypted
+        drm_level.positive?
+      end
+
+      # Get section by name
+      #
+      # @param name [String] Section name
+      # @return [LITSection, nil] The section or nil if not found
+      def section(name)
+        sections.find { |s| s.name == name }
       end
     end
 
-    # Represents a file entry within a LIT archive
-    class LITFile
-      attr_accessor :filename, :offset, :length, :compressed, :encrypted
+    # Represents a section within the LIT file
+    #
+    # Sections contain compressed/encrypted data with transform layers
+    class LITSection
+      attr_accessor :name, :transforms, :compressed, :encrypted,
+                    :uncompressed_length, :compressed_length,
+                    :window_size, :reset_interval, :reset_table
 
       def initialize
-        @filename = ""
-        @offset = 0
-        @length = 0
-        @compressed = true
+        @name = ""
+        @transforms = []
+        @compressed = false
         @encrypted = false
+        @uncompressed_length = 0
+        @compressed_length = 0
+        @window_size = 0
+        @reset_interval = 0
+        @reset_table = []
       end
 
-      # Check if the file is compressed
+      # Check if section is compressed
       #
-      # @return [Boolean] true if the file uses LZX compression
+      # @return [Boolean] true if compressed
       def compressed?
-        @compressed
+        compressed
       end
 
-      # Check if the file is encrypted
+      # Check if section is encrypted
       #
-      # @return [Boolean] true if the file uses DES encryption
+      # @return [Boolean] true if encrypted
       def encrypted?
-        @encrypted
+        encrypted
+      end
+    end
+
+    # Represents the internal directory structure
+    #
+    # Directory contains file entries with encoded integers for efficiency
+    class LITDirectory
+      attr_accessor :entries, :num_chunks, :entry_chunklen, :count_chunklen
+
+      def initialize
+        @entries = []
+        @num_chunks = 0
+        @entry_chunklen = 0
+        @count_chunklen = 0
+      end
+
+      # Find entry by name
+      #
+      # @param name [String] Entry name
+      # @return [LITDirectoryEntry, nil] The entry or nil if not found
+      def find(name)
+        entries.find { |e| e.name == name }
+      end
+
+      # Get all entries in a section
+      #
+      # @param section_id [Integer] Section ID
+      # @return [Array<LITDirectoryEntry>] Entries in the section
+      def entries_in_section(section_id)
+        entries.select { |e| e.section == section_id }
+      end
+    end
+
+    # Represents a single directory entry
+    #
+    # Entries use variable-length encoded integers to save space
+    class LITDirectoryEntry
+      attr_accessor :name, :section, :offset, :size
+
+      def initialize
+        @name = ""
+        @section = 0
+        @offset = 0
+        @size = 0
+      end
+
+      # Check if this is a root entry
+      #
+      # @return [Boolean] true if root entry
+      def root?
+        ["/", ""].include?(name)
+      end
+
+      # Get the directory portion of the name
+      #
+      # @return [String] Directory path
+      def directory
+        return "/" if root?
+
+        parts = name.split("/")
+        parts[0..-2].join("/")
+      end
+
+      # Get the filename portion
+      #
+      # @return [String] Filename
+      def filename
+        return "" if root?
+
+        name.split("/").last
+      end
+    end
+
+    # Represents the manifest file
+    #
+    # Maps internal filenames to original filenames and content types
+    class LITManifest
+      attr_accessor :mappings
+
+      def initialize
+        @mappings = []
+      end
+
+      # Find mapping by internal name
+      #
+      # @param internal_name [String] Internal filename
+      # @return [LITManifestMapping, nil] The mapping or nil
+      def find_by_internal(internal_name)
+        mappings.find { |m| m.internal_name == internal_name }
+      end
+
+      # Find mapping by original name
+      #
+      # @param original_name [String] Original filename
+      # @return [LITManifestMapping, nil] The mapping or nil
+      def find_by_original(original_name)
+        mappings.find { |m| m.original_name == original_name }
+      end
+
+      # Get all HTML files
+      #
+      # @return [Array<LITManifestMapping>] HTML file mappings
+      def html_files
+        mappings.select { |m| m.content_type =~ /html/i }
+      end
+
+      # Get all CSS files
+      #
+      # @return [Array<LITManifestMapping>] CSS file mappings
+      def css_files
+        mappings.select { |m| m.content_type =~ /css/i }
+      end
+
+      # Get all image files
+      #
+      # @return [Array<LITManifestMapping>] Image file mappings
+      def image_files
+        mappings.select { |m| m.content_type =~ /image/i }
+      end
+    end
+
+    # Represents a single manifest mapping
+    class LITManifestMapping
+      attr_accessor :offset, :internal_name, :original_name, :content_type,
+                    :group
+
+      def initialize
+        @offset = 0
+        @internal_name = ""
+        @original_name = ""
+        @content_type = ""
+        @group = 0
+      end
+
+      # Check if this is an HTML file
+      #
+      # @return [Boolean] true if HTML
+      def html?
+        content_type =~ /html/i
+      end
+
+      # Check if this is a CSS file
+      #
+      # @return [Boolean] true if CSS
+      def css?
+        content_type =~ /css/i
+      end
+
+      # Check if this is an image
+      #
+      # @return [Boolean] true if image
+      def image?
+        content_type =~ /image/i
       end
     end
   end

data/lib/cabriolet/models/szdd_header.rb

@@ -64,8 +64,16 @@ module Cabriolet
         return compressed_filename unless normal_format? && @missing_char
 
         # Replace trailing underscore with missing character
-        # Pattern: ends with .XX_ where XX is any 2+ characters
-        compressed_filename.sub(/\.(\w+)_$/, ".\\1#{@missing_char}")
+        # Uppercase unless all extension characters are lowercase
+        extension_match = compressed_filename.match(/\.(\w+)_$/)
+        if extension_match
+          extension = extension_match[1]
+          # Uppercase unless extension is entirely lowercase
+          missing_char = extension == extension.downcase ? @missing_char.downcase : @missing_char.upcase
+          compressed_filename.sub(/\.(\w+)_$/, ".\\1#{missing_char}")
+        else
+          compressed_filename
+        end
       end
     end
   end

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