cabriolet 0.2.0 → 0.2.1

data/lib/cabriolet/lit/content_encoder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Encodes LIT content data (NameList, manifest)
+    class ContentEncoder
+      # Build NameList data from sections
+      #
+      # @param sections [Array<Hash>] Sections array
+      # @return [String] Binary NameList data
+      def self.build_namelist_data(sections)
+        data = +""
+        data += [0].pack("v") # Initial field
+
+        # Write number of sections
+        data += [sections.size].pack("v")
+
+        # Write each section name
+        null_terminator = [0].pack("v")
+        sections.each do |section|
+          name = section[:name]
+          # Convert to UTF-16LE
+          name_utf16 = name.encode("UTF-16LE").force_encoding("ASCII-8BIT")
+          name_length = name_utf16.bytesize / 2
+
+          data += [name_length].pack("v")
+          data += name_utf16
+          data += null_terminator
+        end
+
+        data
+      end
+
+      # Build manifest data from manifest structure
+      #
+      # @param manifest [Hash] Manifest structure with mappings
+      # @return [String] Binary manifest data
+      def self.build_manifest_data(manifest)
+        data = +""
+
+        # For simplicity: single directory entry
+        data += [0].pack("C") # Empty directory name = end of directories
+
+        # Write 4 groups
+        terminator = [0].pack("C")
+        4.times do |group|
+          # Get mappings for this group
+          group_mappings = manifest[:mappings].select { |m| m[:group] == group }
+
+          data += [group_mappings.size].pack("V")
+
+          group_mappings.each do |mapping|
+            data += [mapping[:offset]].pack("V")
+
+            # Internal name
+            data += [mapping[:internal_name].bytesize].pack("C")
+            data += mapping[:internal_name]
+
+            # Original name
+            data += [mapping[:original_name].bytesize].pack("C")
+            data += mapping[:original_name]
+
+            # Content type
+            data += [mapping[:content_type].bytesize].pack("C")
+            data += mapping[:content_type]
+
+            # Terminator
+            data += terminator
+          end
+        end
+
+        data
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/content_type_detector.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Detects content type and file group for LIT files
+    class ContentTypeDetector
+      # Guess content type from filename
+      #
+      # @param filename [String] Filename to analyze
+      # @return [String] MIME content type
+      def self.content_type(filename)
+        ext = ::File.extname(filename).downcase
+        case ext
+        when ".html", ".htm"
+          "text/html"
+        when ".css"
+          "text/css"
+        when ".jpg", ".jpeg"
+          "image/jpeg"
+        when ".png"
+          "image/png"
+        when ".gif"
+          "image/gif"
+        when ".txt"
+          "text/plain"
+        else
+          "application/octet-stream"
+        end
+      end
+
+      # Guess file group (0=HTML spine, 1=HTML other, 2=CSS, 3=Images)
+      #
+      # @param filename [String] Filename to analyze
+      # @return [Integer] Group number
+      def self.file_group(filename)
+        ext = ::File.extname(filename).downcase
+        case ext
+        when ".html", ".htm"
+          0 # HTML spine (simplification - could be group 1 for non-spine)
+        when ".css"
+          2 # CSS
+        when ".jpg", ".jpeg", ".png", ".gif"
+          3 # Images
+        else
+          1 # Other
+        end
+      end
+    end
+  end
+end

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

data/lib/cabriolet/lit/piece_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "directory_builder"
+
+module Cabriolet
+  module LIT
+    # Builds piece data for LIT files
+    class PieceBuilder
+      # Build piece 0 data (file size information)
+      #
+      # @param file_data [Array<Hash>] File data array
+      # @return [String] Binary piece 0 data
+      def self.build_piece0(file_data)
+        # Calculate total content size
+        content_size = file_data.sum { |f| f[:uncompressed_size] }
+
+        data = [Binary::LITStructures::Tags::SIZE_PIECE].pack("V")
+        data += [content_size].pack("V")
+        data += [0, 0].pack("VV") # High bits, reserved
+        data
+      end
+
+      # Build piece 1 data (directory IFCM structure)
+      #
+      # @param directory [Hash] Directory structure from DirectoryBuilder
+      # @return [String] Binary piece 1 data
+      def self.build_piece1(directory)
+        builder = DirectoryBuilder.new(chunk_size: directory[:chunk_size])
+
+        # Build IFCM header
+        ifcm = Binary::LITStructures::IFCMHeader.new
+        ifcm.tag = Binary::LITStructures::Tags::IFCM
+        ifcm.version = 1
+        ifcm.chunk_size = directory[:chunk_size]
+        ifcm.param = 0x100000
+        ifcm.reserved1 = 0xFFFFFFFF
+        ifcm.reserved2 = 0xFFFFFFFF
+        ifcm.num_chunks = directory[:num_chunks]
+        ifcm.reserved3 = 0
+
+        data = ifcm.to_binary_s
+
+        # Build AOLL chunk with directory entries
+        directory[:entries].each do |entry|
+          builder.add_entry(
+            name: entry[:name],
+            section: entry[:section],
+            offset: entry[:offset],
+            size: entry[:size],
+          )
+        end
+
+        aoll_chunk = builder.build_aoll_chunk
+        data += aoll_chunk
+
+        # Pad to fill piece (8KB standard)
+        target_size = 8192
+        if data.bytesize < target_size
+          data += "\x00" * (target_size - data.bytesize)
+        end
+
+        data
+      end
+
+      # Build piece 2 data (index information)
+      #
+      # @return [String] Binary piece 2 data
+      def self.build_piece2
+        # Minimal index data for foundation
+        "\x00" * 512
+      end
+    end
+  end
+end