cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/lit/directory_builder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Builds LIT directory structure with AOLL chunks
+    class DirectoryBuilder
+      # Chunk size for directory entries (8KB)
+      DEFAULT_CHUNK_SIZE = 0x2000
+
+      attr_reader :chunk_size, :entries
+
+      # Initialize directory builder
+      #
+      # @param chunk_size [Integer] Chunk size for directory entries
+      def initialize(chunk_size: DEFAULT_CHUNK_SIZE)
+        @chunk_size = chunk_size
+        @entries = []
+      end
+
+      # Add an entry to the directory
+      #
+      # @param name [String] Entry name
+      # @param section [Integer] Section number
+      # @param offset [Integer] Offset within section
+      # @param size [Integer] Size in bytes
+      def add_entry(name:, section:, offset:, size:)
+        @entries << {
+          name: name,
+          section: section,
+          offset: offset,
+          size: size,
+        }
+      end
+
+      # Build the directory structure
+      #
+      # @return [Hash] Directory structure with entries and metadata
+      def build
+        {
+          entries: @entries,
+          chunk_size: @chunk_size,
+          num_chunks: calculate_num_chunks,
+        }
+      end
+
+      # Build AOLL (Archive Object List List) chunk
+      #
+      # @return [String] Binary AOLL chunk data
+      def build_aoll_chunk
+        # Build all entry data first
+        entries_data = @entries.map { |entry| encode_entry(entry) }.join
+
+        # Calculate quickref offset (starts after entries data)
+        quickref_offset = entries_data.bytesize
+
+        # Build AOLL header
+        header = Binary::LITStructures::AOLLHeader.new
+        header.tag = Binary::LITStructures::Tags::AOLL
+        header.quickref_offset = quickref_offset
+        header.current_chunk_low = 0
+        header.current_chunk_high = 0
+        header.prev_chunk_low = 0xFFFFFFFF
+        header.prev_chunk_high = 0xFFFFFFFF
+        header.next_chunk_low = 0xFFFFFFFF
+        header.next_chunk_high = 0xFFFFFFFF
+        header.entries_so_far = @entries.size
+        header.reserved = 0
+        header.chunk_distance = 0
+        header.reserved2 = 0
+
+        header.to_binary_s + entries_data
+      end
+
+      # Calculate total size needed for directory
+      #
+      # @return [Integer] Size in bytes
+      def calculate_size
+        # IFCM header + AOLL chunk + padding
+        ifcm_size = Binary::LITStructures::IFCMHeader.new.to_binary_s.bytesize
+        aoll_size = build_aoll_chunk.bytesize
+        target_size = @chunk_size
+
+        [ifcm_size + aoll_size, target_size].max
+      end
+
+      private
+
+      # Calculate number of chunks needed
+      #
+      # @return [Integer] Number of chunks
+      def calculate_num_chunks
+        return 1 if @entries.empty?
+
+        total_size = @entries.sum { |e| estimate_entry_size(e) }
+        [1, (total_size / @chunk_size.to_f).ceil].max
+      end
+
+      # Estimate size of a directory entry
+      #
+      # @param entry [Hash] Directory entry
+      # @return [Integer] Estimated size
+      def estimate_entry_size(entry)
+        name_size = entry[:name].bytesize
+        # Name length (1-5 bytes) + name + section (1-5 bytes) + offset (1-5 bytes) + size (1-5 bytes)
+        5 + name_size + 15
+      end
+
+      # Encode a directory entry with variable-length integers
+      #
+      # @param entry [Hash] Directory entry
+      # @return [String] Encoded entry data
+      def encode_entry(entry)
+        data = +""
+
+        # Encode name length and name
+        name = entry[:name].dup.force_encoding("UTF-8")
+        data += encode_vint(name.bytesize)
+        data += name
+
+        # Encode section, offset, size
+        data += encode_vint(entry[:section])
+        data += encode_vint(entry[:offset])
+        data += encode_vint(entry[:size])
+
+        data
+      end
+
+      # Write a variable-length integer (MSB = continuation bit)
+      #
+      # @param value [Integer] Value to encode
+      # @return [String] Encoded integer
+      def encode_vint(value)
+        return [0x00].pack("C") if value.zero?
+
+        bytes = []
+
+        # Extract 7-bit chunks from value
+        loop do
+          bytes.unshift(value & 0x7F)
+          value >>= 7
+          break if value.zero?
+        end
+
+        # Set MSB on all bytes except the last
+        (0...(bytes.size - 1)).each do |i|
+          bytes[i] |= 0x80
+        end
+
+        bytes.pack("C*")
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/guid_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Generates GUIDs for LIT files
+    class GuidGenerator
+      # Generate a random GUID
+      #
+      # @return [String] 16-byte random GUID
+      def self.generate
+        require "securerandom"
+        SecureRandom.random_bytes(16)
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/header_writer.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Writes LIT headers to output
+    class HeaderWriter
+      # Initialize header writer
+      #
+      # @param io_system [System::IOSystem] I/O system for writing
+      def initialize(io_system)
+        @io_system = io_system
+      end
+
+      # Write primary header
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param structure [Hash] LIT structure
+      # @return [Integer] Bytes written
+      def write_primary_header(output_handle, structure)
+        header = Binary::LITStructures::PrimaryHeader.new
+        header.signature = Binary::LITStructures::SIGNATURE
+        header.version = structure[:version]
+        header.header_length = 40
+        header.num_pieces = 5
+        header.secondary_header_length = structure[:secondary_header][:length]
+        header.header_guid = structure[:header_guid]
+
+        header_data = header.to_binary_s
+        @io_system.write(output_handle, header_data)
+      end
+
+      # Write piece structures
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param pieces [Array<Hash>] Pieces array
+      # @return [Integer] Bytes written
+      def write_piece_structures(output_handle, pieces)
+        total_bytes = 0
+
+        pieces.each do |piece|
+          piece_struct = Binary::LITStructures::PieceStructure.new
+          piece_struct.offset_low = piece[:offset]
+          piece_struct.offset_high = 0
+          piece_struct.size_low = piece[:size]
+          piece_struct.size_high = 0
+
+          piece_data = piece_struct.to_binary_s
+          total_bytes += @io_system.write(output_handle, piece_data)
+        end
+
+        total_bytes
+      end
+
+      # Write secondary header block
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param sec_hdr [Hash] Secondary header metadata
+      # @return [Integer] Bytes written
+      def write_secondary_header(output_handle, sec_hdr)
+        header = Binary::LITStructures::SecondaryHeader.new
+
+        # SECHDR block
+        header.sechdr_version = 2
+        header.sechdr_length = 152
+
+        # Entry directory info
+        header.entry_aoli_idx = 0
+        header.entry_aoli_idx_high = 0
+        header.entry_reserved1 = 0
+        header.entry_last_aoll = 0
+        header.entry_reserved2 = 0
+        header.entry_chunklen = sec_hdr[:entry_chunklen]
+        header.entry_two = 2
+        header.entry_reserved3 = 0
+        header.entry_depth = sec_hdr[:entry_depth]
+        header.entry_reserved4 = 0
+        header.entry_entries = sec_hdr[:entry_entries]
+        header.entry_reserved5 = 0
+
+        # Count directory info
+        header.count_aoli_idx = 0xFFFFFFFF
+        header.count_aoli_idx_high = 0xFFFFFFFF
+        header.count_reserved1 = 0
+        header.count_last_aoll = 0
+        header.count_reserved2 = 0
+        header.count_chunklen = sec_hdr[:count_chunklen]
+        header.count_two = 2
+        header.count_reserved3 = 0
+        header.count_depth = 1
+        header.count_reserved4 = 0
+        header.count_entries = sec_hdr[:count_entries]
+        header.count_reserved5 = 0
+
+        header.entry_unknown = sec_hdr[:entry_unknown]
+        header.count_unknown = sec_hdr[:count_unknown]
+
+        # CAOL block
+        header.caol_tag = Binary::LITStructures::Tags::CAOL
+        header.caol_version = 2
+        header.caol_length = 80 # 48 + 32
+        header.creator_id = sec_hdr[:creator_id]
+        header.caol_reserved1 = 0
+        header.caol_entry_chunklen = sec_hdr[:entry_chunklen]
+        header.caol_count_chunklen = sec_hdr[:count_chunklen]
+        header.caol_entry_unknown = sec_hdr[:entry_unknown]
+        header.caol_count_unknown = sec_hdr[:count_unknown]
+        header.caol_reserved2 = 0
+
+        # ITSF block
+        header.itsf_tag = Binary::LITStructures::Tags::ITSF
+        header.itsf_version = 4
+        header.itsf_length = 32
+        header.itsf_unknown = 1
+        header.content_offset_low = sec_hdr[:content_offset]
+        header.content_offset_high = 0
+        header.timestamp = sec_hdr[:timestamp]
+        header.language_id = sec_hdr[:language_id]
+
+        header_data = header.to_binary_s
+        @io_system.write(output_handle, header_data)
+      end
+    end
+  end
+end