cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/kwaj/decompressor.rb

@@ -21,8 +21,10 @@ module Cabriolet
       #
       # @param io_system [System::IOSystem, nil] Custom I/O system or nil for
       #   default
-      def initialize(io_system = nil)
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @parser = Parser.new(@io_system)
         @buffer_size = DEFAULT_BUFFER_SIZE
       end
@@ -31,7 +33,7 @@ module Cabriolet
       #
       # @param filename [String] Path to the KWAJ file
       # @return [Models::KWAJHeader] Parsed header
-      # @raise [Errors::ParseError] if the file is not a valid KWAJ
+      # @raise [Cabriolet::ErrorParseError] if the file is not a valid KWAJ
       def open(filename)
         @parser.parse(filename)
       end
@@ -52,7 +54,7 @@ module Cabriolet
       # @param filename [String] Input filename
       # @param output_path [String] Where to write the decompressed file
       # @return [Integer] Number of bytes written
-      # @raise [Errors::DecompressionError] if decompression fails
+      # @raise [Cabriolet::ErrorDecompressionError] if decompression fails
       def extract(header, filename, output_path)
         raise ArgumentError, "Header must not be nil" unless header
         raise ArgumentError, "Output path must not be nil" unless output_path
@@ -90,8 +92,8 @@ module Cabriolet
       # @param output_path [String, nil] Path to output file, or nil to
       #   auto-detect
       # @return [Integer] Number of bytes written
-      # @raise [Errors::ParseError] if input is not valid KWAJ
-      # @raise [Errors::DecompressionError] if decompression fails
+      # @raise [Cabriolet::ErrorParseError] if input is not valid KWAJ
+      # @raise [Cabriolet::ErrorDecompressionError] if decompression fails
       def decompress(input_path, output_path = nil)
         # Parse header
         header = open(input_path)
@@ -134,7 +136,7 @@ module Cabriolet
       # @param input_handle [System::FileHandle] Input handle
       # @param output_handle [System::FileHandle] Output handle
       # @return [Integer] Number of bytes written
-      # @raise [Errors::DecompressionError] if decompression fails
+      # @raise [Cabriolet::ErrorDecompressionError] if decompression fails
       def decompress_data(header, input_handle, output_handle)
         case header.comp_type
         when Constants::KWAJ_COMP_NONE
@@ -148,7 +150,7 @@ module Cabriolet
         when Constants::KWAJ_COMP_MSZIP
           decompress_mszip(input_handle, output_handle)
         else
-          raise Errors::DecompressionError,
+          raise Error,
                 "Unsupported compression type: #{header.comp_type}"
         end
       end
@@ -196,12 +198,14 @@ module Cabriolet
       # @param output_handle [System::FileHandle] Output handle
       # @return [Integer] Number of bytes written
       def decompress_szdd(input_handle, output_handle)
-        decompressor = Decompressors::LZSS.new(
+        decompressor = @algorithm_factory.create(
+          :lzss,
+          :decompressor,
           @io_system,
           input_handle,
           output_handle,
           @buffer_size,
-          Decompressors::LZSS::MODE_QBASIC,
+          mode: Decompressors::LZSS::MODE_QBASIC,
         )
         decompressor.decompress(0)
       end
@@ -211,9 +215,9 @@ module Cabriolet
       # @param input_handle [System::FileHandle] Input handle
       # @param output_handle [System::FileHandle] Output handle
       # @return [Integer] Number of bytes written
-      # @raise [Errors::DecompressionError] LZH not yet implemented
+      # @raise [Cabriolet::Error] LZH not yet implemented
       def decompress_lzh(_input_handle, _output_handle)
-        raise Errors::DecompressionError,
+        raise Error,
               "LZH compression type is not yet implemented. " \
               "This requires custom Huffman tree implementation."
       end
@@ -224,7 +228,9 @@ module Cabriolet
       # @param output_handle [System::FileHandle] Output handle
       # @return [Integer] Number of bytes written
       def decompress_mszip(input_handle, output_handle)
-        decompressor = Decompressors::MSZIP.new(
+        decompressor = @algorithm_factory.create(
+          Constants::COMP_TYPE_MSZIP,
+          :decompressor,
           @io_system,
           input_handle,
           output_handle,

data/lib/cabriolet/lit/command_handler.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module LIT
+    # Command handler for LIT (Microsoft Reader eBook) format
+    #
+    # This handler implements the unified command interface for LIT files,
+    # wrapping the existing LIT::Decompressor and LIT::Compressor classes.
+    # LIT files use LZX compression and may include DRM protection.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List LIT file contents
+      #
+      # Displays information about the LIT file including version,
+      # language, and lists all contained files with their sizes.
+      #
+      # @param file [String] Path to the LIT file
+      # @param options [Hash] Additional options
+      # @option options [Boolean] :use_manifest Use manifest for original filenames
+      # @return [void]
+      def list(file, options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        lit_file = decompressor.open(file)
+
+        display_header(lit_file)
+        display_files(lit_file, decompressor, options)
+
+        decompressor.close(lit_file)
+      end
+
+      # Extract files from LIT archive
+      #
+      # Extracts all files from the LIT file to the specified output directory.
+      # Uses manifest for filename restoration if available.
+      #
+      # @param file [String] Path to the LIT file
+      # @param output_dir [String] Output directory path (default: current directory)
+      # @param options [Hash] Additional options
+      # @option options [Boolean] :use_manifest Use manifest for filenames (default: true)
+      # @return [void]
+      def extract(file, output_dir = nil, options = {})
+        validate_file_exists(file)
+
+        output_dir ||= "."
+        output_dir = ensure_output_dir(output_dir)
+
+        decompressor = Decompressor.new
+        lit_file = decompressor.open(file)
+
+        use_manifest = options.fetch(:use_manifest, true)
+        count = decompressor.extract_all(lit_file, output_dir,
+                                         use_manifest: use_manifest)
+
+        decompressor.close(lit_file)
+        puts "Extracted #{count} file(s) to #{output_dir}"
+      end
+
+      # Create a new LIT archive
+      #
+      # Creates a LIT file from HTML source files.
+      # Non-encrypted LIT files are created (DRM not supported).
+      #
+      # @param output [String] Output LIT file path
+      # @param files [Array<String>] List of input files to add
+      # @param options [Hash] Additional options
+      # @option options [Integer] :language_id Language ID (default: 0x409 English)
+      # @option options [Integer] :version LIT format version (default: 1)
+      # @return [void]
+      # @raise [ArgumentError] if no files specified
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No files specified" if files.empty?
+
+        files.each do |f|
+          raise ArgumentError, "File does not exist: #{f}" unless File.exist?(f)
+        end
+
+        language_id = options[:language_id] || 0x409
+        version = options[:version] || 1
+
+        compressor = Compressor.new
+        files.each do |f|
+          # Default to adding with compression
+          lit_path = "/#{File.basename(f)}"
+          compressor.add_file(f, lit_path, compress: true)
+        end
+
+        puts "Creating #{output} with #{files.size} file(s) (v#{version}, lang: 0x#{Integer(language_id).to_s(16)})" if verbose?
+        bytes = compressor.generate(output, version: version,
+                                            language_id: language_id)
+        puts "Created #{output} (#{bytes} bytes, #{files.size} files)"
+      end
+
+      # Display detailed LIT file information
+      #
+      # Shows comprehensive information about the LIT structure,
+      # including sections, manifest, and files.
+      #
+      # @param file [String] Path to the LIT file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        lit_file = decompressor.open(file)
+
+        display_lit_info(lit_file)
+
+        decompressor.close(lit_file)
+      end
+
+      # Test LIT file integrity
+      #
+      # Verifies the LIT file structure.
+      #
+      # @param file [String] Path to the LIT file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        lit_file = decompressor.open(file)
+
+        puts "Testing #{file}..."
+        # Check for DRM
+        if lit_file.encrypted?
+          puts "WARNING: LIT file is DRM-encrypted (level: #{lit_file.drm_level})"
+          puts "Encryption is not supported by this implementation"
+        else
+          puts "OK: LIT file structure is valid (#{lit_file.directory.entries.size} files)"
+        end
+
+        decompressor.close(lit_file)
+      end
+
+      private
+
+      # Display LIT header information
+      #
+      # @param lit_file [Models::LITFile] The LIT file object
+      # @return [void]
+      def display_header(lit_file)
+        puts "LIT File: #{File.basename(lit_file.instance_variable_get(:@filename) || 'unknown')}"
+        puts "Version: #{lit_file.version}"
+        puts "Language ID: 0x#{Integer(lit_file.language_id).to_s(16).upcase}"
+        puts "DRM Protected: #{lit_file.encrypted? ? 'Yes' : 'No'}"
+        puts "\nFiles:"
+      end
+
+      # Display list of files in LIT
+      #
+      # @param lit_file [Models::LITFile] The LIT file object
+      # @param decompressor [Decompressor] The decompressor instance
+      # @param options [Hash] Display options
+      # @return [void]
+      def display_files(lit_file, decompressor, options)
+        use_manifest = options.fetch(:use_manifest, true)
+        files = decompressor.list_files(lit_file, use_manifest: use_manifest)
+
+        files.each do |f|
+          name = f[:original_name] || f[:internal_name]
+          size = f[:size]
+          content_type = f[:content_type]
+
+          line = "  #{name} (#{size} bytes)"
+          line += " [#{content_type}]" if content_type && use_manifest
+          puts line
+        end
+      end
+
+      # Display comprehensive LIT information
+      #
+      # @param lit_file [Models::LITFile] The LIT file object
+      # @return [void]
+      def display_lit_info(lit_file)
+        puts "LIT File Information"
+        puts "=" * 50
+
+        filename = lit_file.instance_variable_get(:@filename)
+        puts "Filename: #{filename || 'unknown'}"
+        puts "Version: #{lit_file.version}"
+        puts "Language ID: 0x#{Integer(lit_file.language_id).to_s(16).upcase}"
+        puts "Creator ID: #{lit_file.creator_id}"
+        puts "Timestamp: #{Time.at(lit_file.timestamp)}" if lit_file.respond_to?(:timestamp)
+
+        puts ""
+        if lit_file.encrypted?
+          puts "DRM Protection:"
+          puts "  Status: ENCRYPTED"
+          puts "  Level: #{lit_file.drm_level}"
+          puts "  WARNING: DRM decryption is not supported"
+        else
+          puts "DRM Protection: None"
+        end
+
+        puts ""
+        puts "Sections: #{lit_file.sections.size}"
+        lit_file.sections.compact.each_with_index do |section, idx|
+          puts "  [#{idx}] #{section.name}"
+          puts "      Transforms: #{section.transforms.join(', ')}" if section.transforms.any?
+        end
+
+        puts ""
+        puts "Files: #{lit_file.directory.entries.size - 1}" # Exclude root entry
+
+        # Display manifest if available
+        if lit_file.manifest
+          puts ""
+          puts "Manifest mappings: #{lit_file.manifest.mappings.size}"
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/lit/compressor.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "guid_generator"
+require_relative "content_type_detector"
+require_relative "directory_builder"
+require_relative "structure_builder"
+require_relative "header_writer"
+require_relative "piece_builder"
+require_relative "content_encoder"
+
 module Cabriolet
   module LIT
     # Compressor creates LIT eBook files
@@ -10,15 +18,15 @@ module Cabriolet
     # 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
+      attr_reader :io_system, :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)
+      # @param io_system [System::IOSystem, nil] Custom I/O system or nil for default
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @files = []
       end
 
@@ -27,8 +35,7 @@ module Cabriolet
       # @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)
+      # @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)
@@ -45,209 +52,153 @@ module Cabriolet
       # @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)
+      # @option options [Integer] :language_id Language ID (default: 0x409 English)
+      # @option options [Integer] :creator_id Creator ID (default: 0)
       # @return [Integer] Bytes written to output file
-      # @raise [Errors::CompressionError] if generation fails
-      # @raise [NotImplementedError] if encryption is requested
+      # @raise [Errors::CompressionError] if compression fails
       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
+        language_id = options.fetch(:language_id, 0x409)
+        creator_id = options.fetch(:creator_id, 0)
 
         raise ArgumentError, "No files added to archive" if @files.empty?
+        raise ArgumentError, "Version must be 1" unless version == 1
 
-        output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
+        # Prepare file data
+        file_data = prepare_files
+
+        # Build LIT structure
+        structure_builder = StructureBuilder.new(
+          io_system: @io_system,
+          version: version,
+          language_id: language_id,
+          creator_id: creator_id,
+        )
+        lit_structure = structure_builder.build(file_data)
 
+        # Write to output file
+        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
+          bytes_written = write_lit_file(output_handle, lit_structure)
+          bytes_written
         ensure
-          @io_system.close(output_handle) if output_handle
+          @io_system.close(output_handle)
         end
       end
 
       private
 
-      # Prepare file data for archiving
+      # Write complete LIT file
       #
-      # @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]
+      # @param output_handle [System::FileHandle] Output file handle
+      # @param structure [Hash] LIT structure
+      # @return [Integer] Bytes written
+      def write_lit_file(output_handle, structure)
+        header_writer = HeaderWriter.new(@io_system)
 
-          # 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
+        bytes_written = 0
 
-          {
-            lit_path: lit_path,
-            data: data,
-            uncompressed_size: data.bytesize,
-            compress: compress,
-          }
-        end
-      end
+        # Write primary header (40 bytes)
+        bytes_written += header_writer.write_primary_header(output_handle,
+                                                            structure)
 
-      # 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
+        # Write piece structures (5 * 16 bytes = 80 bytes)
+        bytes_written += header_writer.write_piece_structures(output_handle,
+                                                              structure[:pieces])
+
+        # Write secondary header
+        bytes_written += header_writer.write_secondary_header(
+          output_handle,
+          structure[:secondary_header],
+        )
 
-        written
+        # Write piece data
+        bytes_written += write_piece_data(output_handle, structure)
+
+        bytes_written
       end
 
-      # Write file entries directory
+      # Write piece data
       #
       # @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)
+      # @param structure [Hash] LIT structure
+      # @return [Integer] Bytes written
+      def write_piece_data(output_handle, structure)
         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
+        # Write piece 0: File size information
+        piece0_data = PieceBuilder.build_piece0(structure[:file_data])
+        total_bytes += @io_system.write(output_handle, piece0_data)
+
+        # Write piece 1: Directory (IFCM structure)
+        piece1_data = PieceBuilder.build_piece1(structure[:directory])
+        total_bytes += @io_system.write(output_handle, piece1_data)
+
+        # Write piece 2: Index information
+        piece2_data = PieceBuilder.build_piece2
+        total_bytes += @io_system.write(output_handle, piece2_data)
+
+        # Write piece 3: GUID
+        total_bytes += @io_system.write(output_handle, structure[:piece3_guid])
+
+        # Write piece 4: GUID
+        total_bytes += @io_system.write(output_handle, structure[:piece4_guid])
+
+        # Write actual content data (after pieces, this is where files go)
+        total_bytes += write_content_data(output_handle, structure)
 
         total_bytes
       end
 
-      # Write file contents
+      # Write content data (actual 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)
+      # @param structure [Hash] LIT structure
+      # @return [Integer] Bytes written
+      def write_content_data(output_handle, structure)
         total_bytes = 0
 
-        file_data.each do |file_info|
-          written = @io_system.write(
-            output_handle,
-            file_info[:compressed_data],
-          )
-          total_bytes += written
+        # Write each file's content
+        structure[:file_data].each do |file_info|
+          total_bytes += @io_system.write(output_handle, file_info[:data])
         end
 
-        total_bytes
-      end
+        # Write NameList
+        namelist_data = ContentEncoder.build_namelist_data(structure[:sections])
+        total_bytes += @io_system.write(output_handle, namelist_data)
 
-      # 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
+        # Write manifest
+        manifest_data = ContentEncoder.build_manifest_data(structure[:manifest])
+        total_bytes += @io_system.write(output_handle, manifest_data)
 
-        header_size
+        total_bytes
       end
 
-      # Compress data using LZX
+      # Prepare file data for archiving
       #
-      # @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
+      # @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]
 
-          output_handle.data
+          # 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
 
-          # Memory handles don't need closing but maintain consistency
+          {
+            lit_path: lit_path,
+            data: data,
+            uncompressed_size: data.bytesize,
+            compress: compress,
+          }
         end
       end
     end