cabriolet 0.1.2 → 0.2.0

data/lib/cabriolet/models/hlp_file.rb

@@ -2,44 +2,145 @@
 
 module Cabriolet
   module Models
-    # HLP internal file model
+    # QuickHelp topic model
     #
-    # Represents a file within an HLP archive. HLP files contain an internal
-    # file system where each file can be compressed using LZSS MODE_MSHELP.
-    class HLPFile
-      attr_accessor :filename, :offset, :length, :compressed_length,
-                    :compressed, :data
-
-      # Initialize HLP file
-      #
-      # @param filename [String] File name within the HLP archive
-      # @param offset [Integer] Offset in the HLP archive
-      # @param length [Integer] Uncompressed file length
-      # @param compressed_length [Integer] Compressed file length
-      # @param compressed [Boolean] Whether the file is compressed
-      def initialize(filename: nil, offset: 0, length: 0,
-                     compressed_length: 0, compressed: true)
-        @filename = filename
+    # Represents a single topic in a QuickHelp help database.
+    # Each topic contains formatted text lines with styles and hyperlinks.
+    class HLPTopic
+      attr_accessor :index, :offset, :size, :lines, :source_data, :metadata
+
+      # Initialize a QuickHelp topic
+      #
+      # @param index [Integer] Topic index in the database
+      # @param offset [Integer] Offset of topic data in file
+      # @param size [Integer] Size of compressed topic data
+      def initialize(index: 0, offset: 0, size: 0)
+        @index = index
         @offset = offset
-        @length = length
-        @compressed_length = compressed_length
-        @compressed = compressed
-        @data = nil
+        @size = size
+        @lines = []
+        @source_data = nil
+        @metadata = {}
+      end
+
+      # Check if topic has any content
+      #
+      # @return [Boolean] true if topic has lines
+      def empty?
+        @lines.empty?
+      end
+
+      # Get plain text content (without formatting)
+      #
+      # @return [String] plain text of all lines
+      def plain_text
+        @lines.map(&:text).join("\n")
+      end
+
+      # Add a line to the topic
+      #
+      # @param line [HLPLine] line to add
+      # @return [void]
+      def add_line(line)
+        @lines << line
+      end
+    end
+
+    # QuickHelp topic line model
+    #
+    # Represents a single line within a topic, including text, styles, and links.
+    class HLPLine
+      attr_accessor :text, :attributes
+
+      # Initialize a topic line
+      #
+      # @param text [String] plain text content
+      def initialize(text = "")
+        @text = text
+        @attributes = Array.new(text.length) { TextAttribute.new }
+      end
+
+      # Get line length in characters
+      #
+      # @return [Integer] character count
+      def length
+        @text.length
       end
 
-      # Check if file is compressed
+      # Apply style to a range of characters
       #
-      # @return [Boolean] true if file is compressed
-      def compressed?
-        @compressed
+      # @param start_index [Integer] start position (0-based)
+      # @param end_index [Integer] end position (0-based, inclusive)
+      # @param style [Integer] style flags
+      # @return [void]
+      def apply_style(start_index, end_index, style)
+        (start_index..end_index).each do |i|
+          @attributes[i].style = style if i < @attributes.length
+        end
       end
 
-      # Get the size to read from archive
+      # Apply link to a range of characters
       #
-      # @return [Integer] Size to read (compressed or uncompressed)
-      def read_size
-        compressed? ? @compressed_length : @length
+      # @param start_index [Integer] start position (1-based, as per format)
+      # @param end_index [Integer] end position (1-based, inclusive)
+      # @param link [String] link target (context string or topic index)
+      # @return [void]
+      def apply_link(start_index, end_index, link)
+        # Convert from 1-based to 0-based indexing
+        start_idx = start_index - 1
+        end_idx = end_index - 1
+
+        (start_idx..end_idx).each do |i|
+          @attributes[i].link = link if i >= 0 && i < @attributes.length
+        end
+      end
+    end
+
+    # Text attribute model
+    #
+    # Represents style and link information for a single character.
+    class TextAttribute
+      attr_accessor :style, :link
+
+      # Initialize text attribute
+      #
+      # @param style [Integer] style flags (bold, italic, underline)
+      # @param link [String, nil] link target if any
+      def initialize(style = 0, link = nil)
+        @style = style
+        @link = link
+      end
+
+      # Check if character is bold
+      #
+      # @return [Boolean] true if bold
+      def bold?
+        @style.anybits?(Binary::HLPStructures::TextStyle::BOLD)
+      end
+
+      # Check if character is italic
+      #
+      # @return [Boolean] true if italic
+      def italic?
+        @style.anybits?(Binary::HLPStructures::TextStyle::ITALIC)
+      end
+
+      # Check if character is underlined
+      #
+      # @return [Boolean] true if underlined
+      def underline?
+        @style.anybits?(Binary::HLPStructures::TextStyle::UNDERLINE)
+      end
+
+      # Check if character has a link
+      #
+      # @return [Boolean] true if linked
+      def linked?
+        !@link.nil?
       end
     end
+
+    # Backward compatibility alias
+    HLPFile = HLPTopic
   end
 end

data/lib/cabriolet/models/hlp_header.rb

@@ -2,35 +2,123 @@
 
 module Cabriolet
   module Models
-    # HLP file header model
+    # QuickHelp database header model
     #
-    # NOTE: This implementation is based on the knowledge that HLP files use
-    # LZSS compression with MODE_MSHELP, but cannot be fully validated due to
-    # lack of test fixtures. Testing relies on round-trip
-    # compression/decompression and comparison with libmspack tools if
-    # available.
+    # Represents the metadata of a QuickHelp help database (.HLP file).
+    # HLP files contain topics, context strings, and optional compression
+    # (keyword dictionary and Huffman coding).
     class HLPHeader
-      attr_accessor :magic, :version, :filename, :length, :files
+      attr_accessor :magic, :version, :attributes, :control_character,
+                    :topic_count, :context_count, :display_width, :predefined_ctx_count, :database_name, :topic_index_offset, :context_strings_offset, :context_map_offset, :keywords_offset, :huffman_tree_offset, :topic_text_offset, :database_size, :filename, :keywords, :huffman_tree
 
-      # Initialize HLP header
+      # Topics and context data
+      attr_accessor :topics, :contexts, :context_map
+
+      # Initialize QuickHelp database header
       #
-      # @param magic [String] Magic number (should be specific to HLP)
-      # @param version [Integer] Format version
-      # @param filename [String] Original filename
-      # @param length [Integer] Uncompressed file length
-      def initialize(magic: nil, version: nil, filename: nil, length: 0)
-        @magic = magic
+      # @param magic [String] Magic number (should be 0x4C 0x4E)
+      # @param version [Integer] Format version (should be 2)
+      # @param attributes [Integer] Attribute flags
+      # @param control_character [Integer] Control character (usually ':' or 0xFF)
+      # @param topic_count [Integer] Number of topics
+      # @param context_count [Integer] Number of context strings
+      # @param display_width [Integer] Display width in characters
+      # @param database_name [String] Database name for external links
+      def initialize(
+        magic: nil,
+        version: 2,
+        attributes: 0,
+        control_character: 0x3A,
+        topic_count: 0,
+        context_count: 0,
+        display_width: 80,
+        predefined_ctx_count: 0,
+        database_name: "",
+        topic_index_offset: 0,
+        context_strings_offset: 0,
+        context_map_offset: 0,
+        keywords_offset: 0,
+        huffman_tree_offset: 0,
+        topic_text_offset: 0,
+        database_size: 0,
+        filename: nil
+      )
+        @magic = magic || Binary::HLPStructures::SIGNATURE
         @version = version
+        @attributes = attributes
+        @control_character = control_character
+        @topic_count = topic_count
+        @context_count = context_count
+        @display_width = display_width
+        @predefined_ctx_count = predefined_ctx_count
+        @database_name = database_name
+        @topic_index_offset = topic_index_offset
+        @context_strings_offset = context_strings_offset
+        @context_map_offset = context_map_offset
+        @keywords_offset = keywords_offset
+        @huffman_tree_offset = huffman_tree_offset
+        @topic_text_offset = topic_text_offset
+        @database_size = database_size
         @filename = filename
-        @length = length
-        @files = []
+
+        # Collections
+        @topics = []
+        @contexts = []
+        @context_map = []
+        @keywords = []
+        @huffman_tree = nil
       end
 
       # Check if header is valid
       #
       # @return [Boolean] true if header appears valid
       def valid?
-        !@magic.nil? && !@version.nil?
+        @magic == Binary::HLPStructures::SIGNATURE &&
+          @version == 2 &&
+          @topic_count >= 0 &&
+          @context_count >= 0
+      end
+
+      # Check if case-sensitive context strings
+      #
+      # @return [Boolean] true if case-sensitive
+      def case_sensitive?
+        @attributes.anybits?(Binary::HLPStructures::Attributes::CASE_SENSITIVE)
+      end
+
+      # Check if database is locked (cannot be decoded by HELPMAKE)
+      #
+      # @return [Boolean] true if locked
+      def locked?
+        @attributes.anybits?(Binary::HLPStructures::Attributes::LOCKED)
+      end
+
+      # Check if keyword compression is used
+      #
+      # @return [Boolean] true if keywords present
+      def has_keywords?
+        @keywords_offset.positive? && !@keywords.empty?
+      end
+
+      # Check if Huffman compression is used
+      #
+      # @return [Boolean] true if Huffman tree present
+      def has_huffman?
+        @huffman_tree_offset.positive? && !@huffman_tree.nil?
+      end
+
+      # Get control character as string
+      #
+      # @return [String] control character
+      def control_char
+        @control_character.chr(Encoding::ASCII)
+      end
+
+      # Get database name without null padding
+      #
+      # @return [String] trimmed database name
+      def db_name
+        @database_name.split("\x00").first || ""
       end
     end
   end

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