cabriolet 0.1.0

data/lib/cabriolet/kwaj/parser.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module KWAJ
+    # Parser reads and parses KWAJ file headers
+    #
+    # KWAJ files support multiple compression methods and have variable-length
+    # headers with optional fields determined by flag bits.
+    class Parser
+      attr_reader :io_system
+
+      # Initialize a new parser
+      #
+      # @param io_system [System::IOSystem] I/O system for reading
+      def initialize(io_system)
+        @io_system = io_system
+      end
+
+      # Parse a KWAJ file and return header information
+      #
+      # @param filename [String] Path to the KWAJ file
+      # @return [Models::KWAJHeader] Parsed header
+      # @raise [Errors::ParseError] if the file is not a valid KWAJ
+      def parse(filename)
+        handle = @io_system.open(filename, Constants::MODE_READ)
+        header = parse_handle(handle)
+        @io_system.close(handle)
+        header
+      end
+
+      # Parse KWAJ header from an already-open handle
+      #
+      # @param handle [System::FileHandle, System::MemoryHandle] Open handle
+      # @return [Models::KWAJHeader] Parsed header
+      # @raise [Errors::ParseError] if not a valid KWAJ
+      def parse_handle(handle)
+        # Read base header (14 bytes)
+        base_data = @io_system.read(handle, 14)
+        raise ParseError, "Cannot read KWAJ header" if base_data.bytesize < 14
+
+        # Parse base header
+        base = Binary::KWAJStructures::BaseHeader.read(base_data)
+
+        # Verify signature
+        unless Binary::KWAJStructures.valid_signature?(
+          base.signature1, base.signature2
+        )
+          raise ParseError, "Invalid KWAJ signature"
+        end
+
+        # Create header model
+        header = Models::KWAJHeader.new
+        header.comp_type = base.comp_method
+        header.data_offset = base.data_offset
+        header.headers = base.flags
+
+        # Parse optional headers based on flags
+        parse_optional_headers(handle, header)
+
+        header
+      end
+
+      private
+
+      # Parse optional headers based on flag bits
+      #
+      # @param handle [System::FileHandle, System::MemoryHandle] Open handle
+      # @param header [Models::KWAJHeader] Header to populate
+      # @return [void]
+      # @raise [Errors::ParseError] if header parsing fails
+      def parse_optional_headers(handle, header)
+        # Optional length field (4 bytes)
+        if header.has_length?
+          data = @io_system.read(handle, 4)
+          raise ParseError, "Cannot read length field" if data.bytesize < 4
+
+          header.length = data.unpack1("V") # Little-endian uint32
+        end
+
+        # Optional unknown field 1 (2 bytes)
+        if header.headers.anybits?(Constants::KWAJ_HDR_HASUNKNOWN1)
+          data = @io_system.read(handle, 2)
+          raise ParseError, "Cannot read unknown1 field" if data.bytesize < 2
+          # We read it but don't store it
+        end
+
+        # Optional unknown field 2 (variable length)
+        if header.headers.anybits?(Constants::KWAJ_HDR_HASUNKNOWN2)
+          data = @io_system.read(handle, 2)
+          raise ParseError, "Cannot read unknown2 length" if data.bytesize < 2
+
+          length = data.unpack1("v") # Little-endian uint16
+
+          # Skip the unknown data
+          if length.positive?
+            skip_data = @io_system.read(handle, length)
+            if skip_data.bytesize < length
+              raise ParseError,
+                    "Cannot read unknown2 data"
+            end
+          end
+        end
+
+        # Optional filename and extension
+        if header.has_filename? || header.has_file_extension?
+          parse_filename(handle,
+                         header)
+        end
+
+        # Optional extra text (variable length)
+        return unless header.has_extra_text?
+
+        data = @io_system.read(handle, 2)
+        raise ParseError, "Cannot read extra text length" if
+          data.bytesize < 2
+
+        length = data.unpack1("v") # Little-endian uint16
+
+        return unless length.positive?
+
+        extra_data = @io_system.read(handle, length)
+        if extra_data.bytesize < length
+          raise ParseError,
+                "Cannot read extra text data"
+        end
+
+        header.extra = extra_data
+        header.extra_length = length
+      end
+
+      # Parse filename and extension fields
+      #
+      # @param handle [System::FileHandle, System::MemoryHandle] Open handle
+      # @param header [Models::KWAJHeader] Header to populate
+      # @return [void]
+      # @raise [Errors::ParseError] if filename parsing fails
+      def parse_filename(handle, header)
+        filename_parts = []
+
+        # Read filename (up to 9 bytes, null-terminated)
+        if header.has_filename?
+          name_data = @io_system.read(handle, 9)
+          raise ParseError, "Cannot read filename" if name_data.empty?
+
+          # Find null terminator or end of data
+          null_pos = name_data.index("\x00")
+          raise ParseError, "Filename not null-terminated" unless null_pos
+
+          filename_parts << name_data[0...null_pos]
+          # Seek back to position after null terminator
+          bytes_to_skip = null_pos + 1 - name_data.bytesize
+          @io_system.seek(handle, bytes_to_skip, Constants::SEEK_CUR) if
+            bytes_to_skip != 0
+
+          # No null terminator in 9 bytes is an error
+
+        end
+
+        # Read extension (up to 4 bytes, null-terminated)
+        if header.has_file_extension?
+          ext_data = @io_system.read(handle, 4)
+          raise ParseError, "Cannot read file extension" if ext_data.empty?
+
+          # Find null terminator or end of data
+          null_pos = ext_data.index("\x00")
+          raise ParseError, "File extension not null-terminated" unless null_pos
+
+          extension = ext_data[0...null_pos]
+          filename_parts << ".#{extension}" unless extension.empty?
+          # Seek back to position after null terminator
+          bytes_to_skip = null_pos + 1 - ext_data.bytesize
+          @io_system.seek(handle, bytes_to_skip, Constants::SEEK_CUR) if
+            bytes_to_skip != 0
+
+          # No null terminator in 4 bytes is an error
+
+        end
+
+        header.filename = filename_parts.join unless filename_parts.empty?
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/compressor.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Compressor creates LIT eBook files
+    #
+    # LIT files are Microsoft Reader eBook files that use LZX compression.
+    # The compressor allows adding multiple files to create a LIT archive.
+    #
+    # NOTE: This implementation creates non-encrypted LIT files only.
+    # DES encryption (DRM protection) is not implemented.
+    class Compressor
+      attr_reader :io_system
+      attr_accessor :files
+
+      # Initialize a new LIT compressor
+      #
+      # @param io_system [System::IOSystem, nil] Custom I/O system or nil for
+      #   default
+      def initialize(io_system = nil)
+        @io_system = io_system || System::IOSystem.new
+        @files = []
+      end
+
+      # Add a file to the LIT archive
+      #
+      # @param source_path [String] Path to the source file
+      # @param lit_path [String] Path within the LIT archive
+      # @param options [Hash] Options for the file
+      # @option options [Boolean] :compress Whether to compress the file
+      #   (default: true)
+      # @return [void]
+      def add_file(source_path, lit_path, **options)
+        compress = options.fetch(:compress, true)
+
+        @files << {
+          source: source_path,
+          lit_path: lit_path,
+          compress: compress,
+        }
+      end
+
+      # Generate the LIT archive
+      #
+      # @param output_file [String] Path to output LIT file
+      # @param options [Hash] Generation options
+      # @option options [Integer] :version LIT format version (default: 1)
+      # @option options [Boolean] :encrypt Whether to encrypt (not supported,
+      #   raises error)
+      # @return [Integer] Bytes written to output file
+      # @raise [Errors::CompressionError] if generation fails
+      # @raise [NotImplementedError] if encryption is requested
+      def generate(output_file, **options)
+        version = options.fetch(:version, 1)
+        encrypt = options.fetch(:encrypt, false)
+
+        if encrypt
+          raise NotImplementedError,
+                "DES encryption is not implemented. " \
+                "LIT files will be created without encryption."
+        end
+
+        raise ArgumentError, "No files added to archive" if @files.empty?
+
+        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+
+        begin
+          # Prepare file data
+          file_data = prepare_files
+
+          # Write header
+          header_bytes = write_header(
+            output_handle,
+            version,
+            file_data.size,
+          )
+
+          # Write file entries
+          entries_bytes = write_file_entries(output_handle, file_data)
+
+          # Write file contents
+          content_bytes = write_file_contents(
+            output_handle,
+            file_data,
+          )
+
+          header_bytes + entries_bytes + content_bytes
+        ensure
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      private
+
+      # Prepare file data for archiving
+      #
+      # @return [Array<Hash>] Array of file information hashes
+      def prepare_files
+        @files.map do |file_info|
+          source = file_info[:source]
+          lit_path = file_info[:lit_path]
+          compress = file_info[:compress]
+
+          # Read source file
+          handle = @io_system.open(source, Constants::MODE_READ)
+          begin
+            size = @io_system.seek(handle, 0, Constants::SEEK_END)
+            @io_system.seek(handle, 0, Constants::SEEK_START)
+            data = @io_system.read(handle, size)
+          ensure
+            @io_system.close(handle)
+          end
+
+          {
+            lit_path: lit_path,
+            data: data,
+            uncompressed_size: data.bytesize,
+            compress: compress,
+          }
+        end
+      end
+
+      # Write LIT header
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param version [Integer] LIT format version
+      # @param file_count [Integer] Number of files
+      # @return [Integer] Number of bytes written
+      def write_header(output_handle, version, file_count)
+        header = Binary::LITStructures::LITHeader.new
+        header.signature = Binary::LITStructures::SIGNATURE
+        header.version = version
+        header.flags = 0 # Not encrypted
+        header.file_count = file_count
+        header.header_size = 24 # Size of the header structure
+
+        header_data = header.to_binary_s
+        written = @io_system.write(output_handle, header_data)
+
+        unless written == header_data.bytesize
+          raise Errors::CompressionError,
+                "Failed to write LIT header"
+        end
+
+        written
+      end
+
+      # Write file entries directory
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param file_data [Array<Hash>] Array of file information
+      # @return [Integer] Number of bytes written
+      def write_file_entries(output_handle, file_data)
+        total_bytes = 0
+        current_offset = calculate_header_size(file_data)
+
+        file_data.each do |file_info|
+          # Compress or store data
+          if file_info[:compress]
+            compressed = compress_data(file_info[:data])
+            compressed_size = compressed.bytesize
+            flags = Binary::LITStructures::FileFlags::COMPRESSED
+          else
+            compressed = file_info[:data]
+            compressed_size = compressed.bytesize
+            flags = 0
+          end
+
+          # Store compressed data for later writing
+          file_info[:compressed_data] = compressed
+          file_info[:compressed_size] = compressed_size
+          file_info[:offset] = current_offset
+
+          # Write file entry
+          entry = Binary::LITStructures::LITFileEntry.new
+          entry.filename_length = file_info[:lit_path].bytesize
+          entry.filename = file_info[:lit_path]
+          entry.offset = current_offset
+          entry.compressed_size = compressed_size
+          entry.uncompressed_size = file_info[:uncompressed_size]
+          entry.flags = flags
+
+          entry_data = entry.to_binary_s
+          written = @io_system.write(output_handle, entry_data)
+          total_bytes += written
+
+          current_offset += compressed_size
+        end
+
+        total_bytes
+      end
+
+      # Write file contents
+      #
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param file_data [Array<Hash>] Array of file information with
+      #   compressed data
+      # @return [Integer] Number of bytes written
+      def write_file_contents(output_handle, file_data)
+        total_bytes = 0
+
+        file_data.each do |file_info|
+          written = @io_system.write(
+            output_handle,
+            file_info[:compressed_data],
+          )
+          total_bytes += written
+        end
+
+        total_bytes
+      end
+
+      # Calculate total header size (header + all file entries)
+      #
+      # @param file_data [Array<Hash>] Array of file information
+      # @return [Integer] Total header size in bytes
+      def calculate_header_size(file_data)
+        # Header: 24 bytes
+        header_size = 24
+
+        # File entries: variable size
+        file_data.each do |file_info|
+          # 4 bytes filename length + filename + 28 bytes metadata
+          header_size += 4 + file_info[:lit_path].bytesize + 28
+        end
+
+        header_size
+      end
+
+      # Compress data using LZX
+      #
+      # @param data [String] Data to compress
+      # @return [String] Compressed data
+      def compress_data(data)
+        input_handle = System::MemoryHandle.new(data)
+        output_handle = System::MemoryHandle.new("", Constants::MODE_WRITE)
+
+        begin
+          compressor = Compressors::LZX.new(
+            @io_system,
+            input_handle,
+            output_handle,
+            32_768,
+          )
+
+          compressor.compress
+
+          output_handle.data
+
+          # Memory handles don't need closing but maintain consistency
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/decompressor.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module LIT
+    # Decompressor is the main interface for LIT file operations
+    #
+    # LIT files are Microsoft Reader eBook files that use LZX compression.
+    #
+    # NOTE: This implementation handles non-encrypted LIT files only.
+    # DES-encrypted (DRM-protected) LIT files are not supported.
+    # For encrypted files, use Microsoft Reader or convert to another format
+    # first.
+    class Decompressor
+      attr_reader :io_system
+      attr_accessor :buffer_size
+
+      # Input buffer size for decompression
+      DEFAULT_BUFFER_SIZE = 32_768
+
+      # Initialize a new LIT decompressor
+      #
+      # @param io_system [System::IOSystem, nil] Custom I/O system or nil for
+      #   default
+      def initialize(io_system = nil)
+        @io_system = io_system || System::IOSystem.new
+        @buffer_size = DEFAULT_BUFFER_SIZE
+      end
+
+      # Open and parse a LIT file
+      #
+      # @param filename [String] Path to the LIT file
+      # @return [Models::LITHeader] Parsed header with file list
+      # @raise [Errors::ParseError] if the file is not a valid LIT
+      # @raise [NotImplementedError] if the file is DES-encrypted
+      def open(filename)
+        header = parse_header(filename)
+        header.filename = filename
+
+        # Check for encryption
+        if header.encrypted?
+          raise NotImplementedError,
+                "DES-encrypted LIT files not yet supported. " \
+                "Use Microsoft Reader or another tool to decrypt first."
+        end
+
+        header
+      end
+
+      # Close a LIT file (no-op for compatibility)
+      #
+      # @param _header [Models::LITHeader] Header to close
+      # @return [void]
+      def close(_header)
+        # No resources to free in the header itself
+        # File handles are managed separately during extraction
+        nil
+      end
+
+      # Extract a file from LIT archive
+      #
+      # @param header [Models::LITHeader] LIT header from open()
+      # @param file [Models::LITFile] File entry to extract
+      # @param output_path [String] Where to write the decompressed file
+      # @return [Integer] Number of bytes written
+      # @raise [Errors::DecompressionError] if decompression fails
+      # @raise [NotImplementedError] if the file is encrypted
+      def extract(header, file, output_path)
+        raise ArgumentError, "Header must not be nil" unless header
+        raise ArgumentError, "File must not be nil" unless file
+        raise ArgumentError, "Output path must not be nil" unless output_path
+
+        if file.encrypted?
+          raise NotImplementedError,
+                "DES-encrypted files not yet supported. " \
+                "Use Microsoft Reader or another tool to decrypt first."
+        end
+
+        input_handle = @io_system.open(header.filename, Constants::MODE_READ)
+        output_handle = @io_system.open(output_path, Constants::MODE_WRITE)
+
+        begin
+          # Seek to file data
+          @io_system.seek(input_handle, file.offset, Constants::SEEK_START)
+
+          bytes_written = if file.compressed?
+                            # Decompress using LZX
+                            decompress_lzx(
+                              input_handle, output_handle, file.length
+                            )
+                          else
+                            # Direct copy
+                            copy_data(
+                              input_handle, output_handle, file.length
+                            )
+                          end
+
+          bytes_written
+        ensure
+          @io_system.close(input_handle) if input_handle
+          @io_system.close(output_handle) if output_handle
+        end
+      end
+
+      # Extract all files from LIT archive
+      #
+      # @param header [Models::LITHeader] LIT header from open()
+      # @param output_dir [String] Directory to extract files to
+      # @return [Integer] Number of files extracted
+      # @raise [Errors::DecompressionError] if extraction fails
+      def extract_all(header, output_dir)
+        raise ArgumentError, "Header must not be nil" unless header
+        raise ArgumentError, "Output dir must not be nil" unless output_dir
+
+        # Create output directory if it doesn't exist
+        ::FileUtils.mkdir_p(output_dir)
+
+        extracted = 0
+        header.files.each do |file|
+          output_path = ::File.join(output_dir, file.filename)
+
+          # Create subdirectories if needed
+          file_dir = ::File.dirname(output_path)
+          ::FileUtils.mkdir_p(file_dir) unless ::File.directory?(file_dir)
+
+          extract(header, file, output_path)
+          extracted += 1
+        end
+
+        extracted
+      end
+
+      private
+
+      # Parse LIT file header
+      #
+      # @param filename [String] Path to LIT file
+      # @return [Models::LITHeader] Parsed header
+      # @raise [Errors::ParseError] if file is not valid LIT
+      def parse_header(filename)
+        handle = @io_system.open(filename, Constants::MODE_READ)
+
+        begin
+          # Read and verify signature
+          signature = @io_system.read(handle, 8)
+          unless signature.start_with?(Binary::LITStructures::SIGNATURE[0..3])
+            raise Errors::ParseError,
+                  "Not a valid LIT file: invalid signature"
+          end
+
+          # Seek back to start
+          @io_system.seek(handle, 0, Constants::SEEK_START)
+
+          # Read header structure
+          header_data = @io_system.read(handle, 24)
+          lit_header = Binary::LITStructures::LITHeader.read(header_data)
+
+          # Create header model
+          header = Models::LITHeader.new
+          header.version = lit_header.version
+          header.encrypted = lit_header.flags.anybits?(0x01)
+
+          # Parse file entries
+          header.files = parse_file_entries(
+            handle, lit_header.file_count
+          )
+
+          header
+        ensure
+          @io_system.close(handle) if handle
+        end
+      end
+
+      # Parse file entries from LIT archive
+      #
+      # @param handle [System::FileHandle] File handle positioned at file
+      #   entries
+      # @param file_count [Integer] Number of files to parse
+      # @return [Array<Models::LITFile>] List of file entries
+      def parse_file_entries(handle, file_count)
+        files = []
+
+        file_count.times do
+          # Read filename length
+          len_data = @io_system.read(handle, 4)
+          filename_length = len_data.unpack1("V")
+
+          # Read filename
+          filename = @io_system.read(handle, filename_length)
+
+          # Read file metadata
+          metadata = @io_system.read(handle, 28)
+          offset, _, uncompressed_size, flags =
+            metadata.unpack("QQQV")
+
+          # Create file entry
+          file = Models::LITFile.new
+          file.filename = filename
+          file.offset = offset
+          file.length = uncompressed_size
+          file.compressed = flags.anybits?(Binary::LITStructures::FileFlags::COMPRESSED)
+          file.encrypted = flags.anybits?(Binary::LITStructures::FileFlags::ENCRYPTED)
+
+          files << file
+        end
+
+        files
+      end
+
+      # Decompress data using LZX
+      #
+      # @param input_handle [System::FileHandle] Input handle
+      # @param output_handle [System::FileHandle] Output handle
+      # @param expected_size [Integer] Expected output size
+      # @return [Integer] Number of bytes written
+      def decompress_lzx(input_handle, output_handle, expected_size)
+        decompressor = Decompressors::LZX.new(
+          @io_system,
+          input_handle,
+          output_handle,
+          @buffer_size,
+        )
+
+        decompressor.decompress(expected_size)
+      end
+
+      # Copy data directly without decompression
+      #
+      # @param input_handle [System::FileHandle] Input handle
+      # @param output_handle [System::FileHandle] Output handle
+      # @param size [Integer] Number of bytes to copy
+      # @return [Integer] Number of bytes written
+      def copy_data(input_handle, output_handle, size)
+        bytes_written = 0
+        remaining = size
+
+        while remaining.positive?
+          chunk_size = [remaining, @buffer_size].min
+          data = @io_system.read(input_handle, chunk_size)
+          break if data.empty?
+
+          written = @io_system.write(output_handle, data)
+          bytes_written += written
+          remaining -= written
+        end
+
+        bytes_written
+      end
+    end
+  end
+end