cabriolet 0.1.0

data/lib/cabriolet/models/cabinet.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Cabinet represents a CAB file or cabinet set
+    class Cabinet
+      attr_accessor :filename, :base_offset, :length, :set_id, :set_index, :flags, :header_resv, :prevname, :nextname,
+                    :previnfo, :nextinfo, :folders, :files, :next_cabinet, :prev_cabinet, :next
+      attr_reader :blocks_offset, :block_resv
+
+      # Initialize a new cabinet
+      #
+      # @param filename [String] Path to the cabinet file
+      def initialize(filename = nil)
+        @filename = filename
+        @base_offset = 0
+        @length = 0
+        @set_id = 0
+        @set_index = 0
+        @flags = 0
+        @header_resv = 0
+        @prevname = nil
+        @nextname = nil
+        @previnfo = nil
+        @nextinfo = nil
+        @folders = []
+        @files = []
+        @next_cabinet = nil
+        @prev_cabinet = nil
+        @next = nil
+        @blocks_offset = 0
+        @block_resv = 0
+      end
+
+      # Check if this cabinet has a predecessor
+      #
+      # @return [Boolean]
+      def has_prev?
+        @flags.anybits?(Constants::FLAG_PREV_CABINET)
+      end
+
+      # Check if this cabinet has a successor
+      #
+      # @return [Boolean]
+      def has_next?
+        @flags.anybits?(Constants::FLAG_NEXT_CABINET)
+      end
+
+      # Check if this cabinet has reserved space
+      #
+      # @return [Boolean]
+      def has_reserve?
+        @flags.anybits?(Constants::FLAG_RESERVE_PRESENT)
+      end
+
+      # Set the blocks offset and reserved space
+      #
+      # @param offset [Integer] Offset to data blocks
+      # @param resv [Integer] Reserved bytes per block
+      # @return [void]
+      def set_blocks_info(offset, resv)
+        @blocks_offset = offset
+        @block_resv = resv
+      end
+
+      # Get total number of files
+      #
+      # @return [Integer]
+      def file_count
+        @files.size
+      end
+
+      # Get total number of folders
+      #
+      # @return [Integer]
+      def folder_count
+        @folders.size
+      end
+    end
+  end
+end

data/lib/cabriolet/models/chm_file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Represents a file within a CHM archive
+    class CHMFile
+      attr_accessor :next_file, :section, :offset, :length, :filename
+
+      def initialize
+        @next_file = nil
+        @section = nil
+        @offset = 0
+        @length = 0
+        @filename = ""
+      end
+
+      # Check if this is a system file (starts with ::)
+      def system_file?
+        filename.start_with?("::")
+      end
+
+      # Check if this is an empty file
+      def empty?
+        length.zero?
+      end
+    end
+  end
+end

data/lib/cabriolet/models/chm_header.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "chm_section"
+
+module Cabriolet
+  module Models
+    # Represents a CHM file header and metadata
+    class CHMHeader
+      attr_accessor :filename, :version, :timestamp, :language, :length, :files, :sysfiles, :sec0, :sec1, :dir_offset,
+                    :num_chunks, :chunk_size, :density, :depth, :index_root, :first_pmgl, :last_pmgl, :chunk_cache
+
+      def initialize
+        @filename = nil
+        @version = 0
+        @timestamp = 0
+        @language = 0
+        @length = 0
+        @files = nil
+        @sysfiles = nil
+        @sec0 = CHMSecUncompressed.new(self)
+        @sec1 = CHMSecMSCompressed.new(self)
+        @dir_offset = 0
+        @num_chunks = 0
+        @chunk_size = 0
+        @density = 0
+        @depth = 0
+        @index_root = 0
+        @first_pmgl = 0
+        @last_pmgl = 0
+        @chunk_cache = nil
+      end
+
+      # Get all files as an array
+      def all_files
+        result = []
+        file = files
+        while file
+          result << file
+          file = file.next_file
+        end
+        result
+      end
+
+      # Get all system files as an array
+      def all_sysfiles
+        result = []
+        file = sysfiles
+        while file
+          result << file
+          file = file.next_file
+        end
+        result
+      end
+
+      # Find a file by name
+      def find_file(filename)
+        file = files
+        while file
+          return file if file.filename == filename
+
+          file = file.next_file
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/cabriolet/models/chm_section.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Base class for CHM sections
+    class CHMSection
+      attr_accessor :chm, :id
+
+      def initialize(chm, id)
+        @chm = chm
+        @id = id
+      end
+    end
+
+    # Section 0: Uncompressed data
+    class CHMSecUncompressed < CHMSection
+      attr_accessor :offset
+
+      def initialize(chm)
+        super(chm, 0)
+        @offset = 0
+      end
+    end
+
+    # Section 1: MSCompressed (LZX) data
+    class CHMSecMSCompressed < CHMSection
+      attr_accessor :content, :control, :spaninfo, :rtable
+
+      def initialize(chm)
+        super(chm, 1)
+        @content = nil
+        @control = nil
+        @spaninfo = nil
+        @rtable = nil
+      end
+    end
+  end
+end

data/lib/cabriolet/models/file.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Cabriolet
+  module Models
+    # File represents a file within a cabinet
+    class File
+      attr_accessor :filename, :length, :offset, :folder, :folder_index, :attribs, :time_h, :time_m, :time_s, :date_d,
+                    :date_m, :date_y, :next_file
+
+      # Initialize a new file
+      def initialize
+        @filename = nil
+        @length = 0
+        @offset = 0
+        @folder = nil
+        @folder_index = 0
+        @attribs = 0
+        @time_h = 0
+        @time_m = 0
+        @time_s = 0
+        @date_d = 1
+        @date_m = 1
+        @date_y = 1980
+        @next_file = nil
+      end
+
+      # Parse date and time from CAB format
+      #
+      # @param date_bits [Integer] 16-bit date value
+      # @param time_bits [Integer] 16-bit time value
+      # @return [void]
+      def parse_datetime(date_bits, time_bits)
+        @time_h = (time_bits >> 11) & 0x1F
+        @time_m = (time_bits >> 5) & 0x3F
+        @time_s = (time_bits & 0x1F) << 1
+
+        @date_d = date_bits & 0x1F
+        @date_m = (date_bits >> 5) & 0x0F
+        @date_y = ((date_bits >> 9) & 0x7F) + 1980
+      end
+
+      # Get the file's modification time as a Time object
+      #
+      # @return [Time, nil] Modification time or nil if invalid
+      def modification_time
+        Time.new(@date_y, @date_m, @date_d, @time_h, @time_m, @time_s)
+      rescue ::ArgumentError
+        nil
+      end
+
+      # Check if filename is UTF-8 encoded
+      #
+      # @return [Boolean]
+      def utf8_filename?
+        @attribs.anybits?(Constants::ATTRIB_UTF_NAME)
+      end
+
+      # Check if file is read-only
+      #
+      # @return [Boolean]
+      def readonly?
+        @attribs.anybits?(Constants::ATTRIB_READONLY)
+      end
+
+      # Check if file is hidden
+      #
+      # @return [Boolean]
+      def hidden?
+        @attribs.anybits?(Constants::ATTRIB_HIDDEN)
+      end
+
+      # Check if file is a system file
+      #
+      # @return [Boolean]
+      def system?
+        @attribs.anybits?(Constants::ATTRIB_SYSTEM)
+      end
+
+      # Check if file is archived
+      #
+      # @return [Boolean]
+      def archived?
+        @attribs.anybits?(Constants::ATTRIB_ARCH)
+      end
+
+      # Check if file is executable
+      #
+      # @return [Boolean]
+      def executable?
+        @attribs.anybits?(Constants::ATTRIB_EXEC)
+      end
+
+      # Check if this file is continued from a previous cabinet
+      #
+      # @return [Boolean]
+      def continued_from_prev?
+        @folder_index == Constants::FOLDER_CONTINUED_FROM_PREV ||
+          @folder_index == Constants::FOLDER_CONTINUED_PREV_AND_NEXT
+      end
+
+      # Check if this file is continued to a next cabinet
+      #
+      # @return [Boolean]
+      def continued_to_next?
+        @folder_index == Constants::FOLDER_CONTINUED_TO_NEXT ||
+          @folder_index == Constants::FOLDER_CONTINUED_PREV_AND_NEXT
+      end
+
+      # Get a human-readable representation of the file
+      #
+      # @return [String]
+      def to_s
+        "#{@filename} (#{@length} bytes)"
+      end
+    end
+  end
+end

data/lib/cabriolet/models/folder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "folder_data"
+
+module Cabriolet
+  module Models
+    # Folder represents a compressed data stream within a cabinet
+    class Folder
+      attr_accessor :comp_type, :num_blocks, :data, :next_folder, :merge_prev,
+                    :merge_next
+
+      # Initialize a new folder
+      #
+      # @param cabinet [Cabinet, nil] Cabinet containing this folder
+      # @param offset [Integer] Data offset within cabinet
+      def initialize(cabinet = nil, offset = 0)
+        @comp_type = Constants::COMP_TYPE_NONE
+        @num_blocks = 0
+        @data = FolderData.new(cabinet, offset)
+        @next_folder = nil
+        @merge_prev = nil
+        @merge_next = nil
+      end
+
+      # Get the primary data cabinet (for backwards compatibility)
+      #
+      # @return [Cabinet, nil]
+      def data_cab
+        @data.cabinet
+      end
+
+      # Set the primary data cabinet (for backwards compatibility)
+      #
+      # @param cabinet [Cabinet]
+      def data_cab=(cabinet)
+        @data.cabinet = cabinet
+      end
+
+      # Get the primary data offset (for backwards compatibility)
+      #
+      # @return [Integer]
+      def data_offset
+        @data.offset
+      end
+
+      # Set the primary data offset (for backwards compatibility)
+      #
+      # @param offset [Integer]
+      def data_offset=(offset)
+        @data.offset = offset
+      end
+
+      # Get the compression method
+      #
+      # @return [Integer] One of COMP_TYPE_* constants
+      def compression_method
+        @comp_type & Constants::COMP_TYPE_MASK
+      end
+
+      # Get the compression level (for LZX and Quantum)
+      #
+      # @return [Integer] Compression level
+      def compression_level
+        (@comp_type >> 8) & 0x1F
+      end
+
+      # Get human-readable compression name
+      #
+      # @return [String] Name of compression method
+      def compression_name
+        case compression_method
+        when Constants::COMP_TYPE_NONE then "None"
+        when Constants::COMP_TYPE_MSZIP then "MSZIP"
+        when Constants::COMP_TYPE_QUANTUM then "Quantum"
+        when Constants::COMP_TYPE_LZX then "LZX"
+        else "Unknown"
+        end
+      end
+
+      # Check if this folder is uncompressed
+      #
+      # @return [Boolean]
+      def uncompressed?
+        compression_method == Constants::COMP_TYPE_NONE
+      end
+
+      # Check if this folder needs to be merged with a previous folder
+      #
+      # @return [Boolean]
+      def needs_prev_merge?
+        !@merge_prev.nil?
+      end
+
+      # Check if this folder needs to be merged with a next folder
+      #
+      # @return [Boolean]
+      def needs_next_merge?
+        !@merge_next.nil?
+      end
+    end
+  end
+end

data/lib/cabriolet/models/folder_data.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # FolderData represents a data location span for a folder
+    # Folders may span multiple cabinets, so they have a chain of FolderData
+    class FolderData
+      attr_accessor :next_data, :cabinet, :offset
+
+      # Initialize a new FolderData
+      #
+      # @param cabinet [Cabinet] Cabinet containing this data
+      # @param offset [Integer] Offset within cabinet file to data blocks
+      def initialize(cabinet, offset)
+        @cabinet = cabinet
+        @offset = offset
+        @next_data = nil
+      end
+    end
+  end
+end

data/lib/cabriolet/models/hlp_file.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # HLP internal file 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
+        @offset = offset
+        @length = length
+        @compressed_length = compressed_length
+        @compressed = compressed
+        @data = nil
+      end
+
+      # Check if file is compressed
+      #
+      # @return [Boolean] true if file is compressed
+      def compressed?
+        @compressed
+      end
+
+      # Get the size to read from archive
+      #
+      # @return [Integer] Size to read (compressed or uncompressed)
+      def read_size
+        compressed? ? @compressed_length : @length
+      end
+    end
+  end
+end

data/lib/cabriolet/models/hlp_header.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # HLP file 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.
+    class HLPHeader
+      attr_accessor :magic, :version, :filename, :length, :files
+
+      # Initialize HLP 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
+        @version = version
+        @filename = filename
+        @length = length
+        @files = []
+      end
+
+      # Check if header is valid
+      #
+      # @return [Boolean] true if header appears valid
+      def valid?
+        !@magic.nil? && !@version.nil?
+      end
+    end
+  end
+end

data/lib/cabriolet/models/kwaj_header.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Represents a KWAJ file header
+    #
+    # KWAJ files support multiple compression methods and optional headers
+    # determined by flag bits. The header structure is more flexible than SZDD.
+    class KWAJHeader
+      # Compression type
+      # @return [Integer] One of KWAJ_COMP_* constants
+      attr_accessor :comp_type
+
+      # Offset to compressed data
+      # @return [Integer] Byte offset where compressed data starts
+      attr_accessor :data_offset
+
+      # Header flags
+      # @return [Integer] Bitfield indicating which optional headers are present
+      attr_accessor :headers
+
+      # Uncompressed length
+      # @return [Integer, nil] Length of uncompressed data if present
+      attr_accessor :length
+
+      # Original filename
+      # @return [String, nil] Original filename if present
+      attr_accessor :filename
+
+      # Extra text data
+      # @return [String, nil] Extra text data if present
+      attr_accessor :extra
+
+      # Length of extra data
+      # @return [Integer] Number of bytes in extra data
+      attr_accessor :extra_length
+
+      # Initialize a new KWAJ header
+      def initialize
+        @comp_type = Constants::KWAJ_COMP_NONE
+        @data_offset = 0
+        @headers = 0
+        @length = nil
+        @filename = nil
+        @extra = nil
+        @extra_length = 0
+      end
+
+      # Get human-readable compression type name
+      #
+      # @return [String] Compression type name
+      def compression_name
+        case @comp_type
+        when Constants::KWAJ_COMP_NONE
+          "None"
+        when Constants::KWAJ_COMP_XOR
+          "XOR"
+        when Constants::KWAJ_COMP_SZDD
+          "SZDD"
+        when Constants::KWAJ_COMP_LZH
+          "LZH"
+        when Constants::KWAJ_COMP_MSZIP
+          "MSZIP"
+        else
+          "Unknown (#{@comp_type})"
+        end
+      end
+
+      # Check if header has length field
+      #
+      # @return [Boolean] true if length is present
+      def has_length?
+        @headers.anybits?(Constants::KWAJ_HDR_HASLENGTH)
+      end
+
+      # Check if header has filename
+      #
+      # @return [Boolean] true if filename is present
+      def has_filename?
+        @headers.anybits?(Constants::KWAJ_HDR_HASFILENAME)
+      end
+
+      # Check if header has file extension
+      #
+      # @return [Boolean] true if file extension is present
+      def has_file_extension?
+        @headers.anybits?(Constants::KWAJ_HDR_HASFILEEXT)
+      end
+
+      # Check if header has extra text
+      #
+      # @return [Boolean] true if extra text is present
+      def has_extra_text?
+        @headers.anybits?(Constants::KWAJ_HDR_HASEXTRATEXT)
+      end
+    end
+  end
+end

data/lib/cabriolet/models/lit_header.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Models
+    # Represents the header of a Microsoft Reader LIT file
+    #
+    # 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
+
+      def initialize
+        @version = 0
+        @filename = ""
+        @length = 0
+        @encrypted = false
+        @files = []
+      end
+
+      # Check if the LIT file is encrypted
+      #
+      # @return [Boolean] true if the file uses DES encryption
+      def encrypted?
+        @encrypted
+      end
+    end
+
+    # Represents a file entry within a LIT archive
+    class LITFile
+      attr_accessor :filename, :offset, :length, :compressed, :encrypted
+
+      def initialize
+        @filename = ""
+        @offset = 0
+        @length = 0
+        @compressed = true
+        @encrypted = false
+      end
+
+      # Check if the file is compressed
+      #
+      # @return [Boolean] true if the file uses LZX compression
+      def compressed?
+        @compressed
+      end
+
+      # Check if the file is encrypted
+      #
+      # @return [Boolean] true if the file uses DES encryption
+      def encrypted?
+        @encrypted
+      end
+    end
+  end
+end