cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/szdd/command_handler.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module SZDD
+    # Command handler for SZDD (LZSS-compressed) format
+    #
+    # This handler implements the unified command interface for SZDD files,
+    # wrapping the existing SZDD::Decompressor and SZDD::Compressor classes.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List SZDD file information
+      #
+      # For SZDD files, list displays detailed file information
+      # rather than a file listing (single file archive).
+      #
+      # @param file [String] Path to the SZDD file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def list(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        display_szdd_info(header, file)
+
+        decompressor.close(header)
+      end
+
+      # Extract SZDD compressed file
+      #
+      # Expands the SZDD file to its original form.
+      # Auto-detects output filename if not specified.
+      #
+      # @param file [String] Path to the SZDD file
+      # @param output [String, nil] Output file path (or directory, for single-file extraction)
+      # @param options [Hash] Additional options
+      # @option options [String] :output Output file path
+      # @return [void]
+      def extract(file, output = nil, options = {})
+        validate_file_exists(file)
+
+        # Use output file from options if specified, otherwise use positional argument
+        output ||= options[:output]
+
+        # Auto-detect output name if not provided
+        output ||= auto_output_filename(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        puts "Expanding #{file} -> #{output}" if verbose?
+        bytes = decompressor.extract(header, output)
+        decompressor.close(header)
+
+        puts "Expanded #{file} to #{output} (#{bytes} bytes)"
+      end
+
+      # Create SZDD compressed file
+      #
+      # Compresses a file using SZDD (LZSS) compression.
+      #
+      # @param output [String] Output SZDD file path
+      # @param files [Array<String>] Input file (single file for SZDD)
+      # @param options [Hash] Additional options
+      # @option options [String] :missing_char Missing character for filename
+      # @option options [String] :szdd_format SZDD format (:normal, :qbasic)
+      # @return [void]
+      # @raise [ArgumentError] if no file specified or multiple files
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No file specified" if files.empty?
+
+        if files.size > 1
+          raise ArgumentError,
+                "SZDD format supports only one file at a time"
+        end
+
+        file = files.first
+        unless File.exist?(file)
+          raise ArgumentError,
+                "File does not exist: #{file}"
+        end
+
+        format = parse_format_option(options[:szdd_format])
+        compress_options = { format: format }
+        if options[:missing_char]
+          compress_options[:missing_char] =
+            options[:missing_char]
+        end
+
+        # Auto-generate output name if not provided
+        if output.nil?
+          output = auto_generate_output(file)
+        end
+
+        compressor = Compressor.new
+
+        puts "Compressing #{file} -> #{output}" if verbose?
+        bytes = compressor.compress(file, output, **compress_options)
+
+        puts "Compressed #{file} to #{output} (#{bytes} bytes)"
+      end
+
+      # Display detailed SZDD file information
+      #
+      # @param file [String] Path to the SZDD file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        display_szdd_info(header, file)
+
+        decompressor.close(header)
+      end
+
+      # Test SZDD file integrity
+      #
+      # Verifies the SZDD file structure.
+      #
+      # @param file [String] Path to the SZDD file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        puts "Testing #{file}..."
+        # TODO: Implement full integrity testing
+        puts "OK: SZDD file structure is valid"
+        puts "Format: #{header.format.to_s.upcase}"
+        puts "Uncompressed size: #{header.length} bytes"
+
+        decompressor.close(header)
+      end
+
+      private
+
+      # Display SZDD file information
+      #
+      # @param header [Header] The SZDD header object
+      # @param file [String] Original file path
+      # @return [void]
+      def display_szdd_info(header, file)
+        puts "SZDD File Information"
+        puts "=" * 50
+        puts "Filename: #{file}"
+        puts "Format: #{header.format.to_s.upcase}"
+        puts "Uncompressed size: #{header.length} bytes"
+        if header.missing_char
+          puts "Missing character: '#{header.missing_char}'"
+          puts "Suggested filename: #{header.suggested_filename(File.basename(file))}"
+        end
+      end
+
+      # Auto-detect output filename from SZDD header
+      #
+      # @param file [String] Original file path
+      # @return [String] Detected output filename
+      def auto_output_filename(file)
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+        output = decompressor.auto_output_filename(file, header)
+        decompressor.close(header)
+        output
+      end
+
+      # Auto-generate output filename for SZDD
+      #
+      # SZDD convention: file.txt -> file.tx_
+      #
+      # @param file [String] Original file path
+      # @return [String] Generated output filename
+      def auto_generate_output(file)
+        # Replace extension last character with underscore
+        # file.txt -> file.tx_
+        ext = File.extname(file)
+        if ext.length == 2 # Single char extension like .c
+          base = File.basename(file, ext)
+          output = "#{base}#{ext[0]}_"
+        else
+          # For no extension or multi-char extension, just append _
+          output = "#{file}_"
+        end
+        output
+      end
+
+      # Parse format option to symbol
+      #
+      # @param format_value [String, Symbol] The format type
+      # @return [Symbol] The format symbol
+      def parse_format_option(format_value)
+        return :normal if format_value.nil?
+
+        format = format_value.to_sym
+        valid_formats = %i[normal qbasic]
+
+        unless valid_formats.include?(format)
+          raise ArgumentError,
+                "Invalid SZDD format: #{format_value}. " \
+                "Valid options: #{valid_formats.join(', ')}"
+        end
+
+        format
+      end
+    end
+  end
+end

data/lib/cabriolet/szdd/compressor.rb

@@ -14,8 +14,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
       end
 
       # Compress a file to SZDD format
@@ -59,12 +61,14 @@ module Cabriolet
                         Compressors::LZSS::MODE_QBASIC
                       end
 
-          compressor = Compressors::LZSS.new(
+          compressor = @algorithm_factory.create(
+            :lzss,
+            :compressor,
             @io_system,
             input_handle,
             output_handle,
             2048,
-            lzss_mode,
+            mode: lzss_mode,
           )
 
           compressed_bytes = compressor.compress
@@ -107,18 +111,18 @@ module Cabriolet
           )
 
           # Compress data using LZSS
-          lzss_mode = if format == :normal
-                        Compressors::LZSS::MODE_EXPAND
-                      else
-                        Compressors::LZSS::MODE_QBASIC
-                      end
-
-          compressor = Compressors::LZSS.new(
+          compressor = @algorithm_factory.create(
+            :lzss,
+            :compressor,
             @io_system,
             input_handle,
             output_handle,
             2048,
-            lzss_mode,
+            mode: if format == :normal
+                    Compressors::LZSS::MODE_EXPAND
+                  else
+                    Compressors::LZSS::MODE_QBASIC
+                  end,
           )
 
           compressed_bytes = compressor.compress

data/lib/cabriolet/szdd/decompressor.rb

@@ -17,8 +17,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
@@ -70,16 +72,18 @@ module Cabriolet
                       end
 
           # Create LZSS decompressor
-          decompressor = Decompressors::LZSS.new(
+          decompressor = @algorithm_factory.create(
+            :lzss,
+            :decompressor,
             @io_system,
             input_handle,
             output_handle,
             @buffer_size,
-            lzss_mode,
+            mode: lzss_mode,
           )
 
-          # Decompress
-          bytes_written = decompressor.decompress(header.length)
+          # Decompress (SZDD reads until EOF, no compressed size stored)
+          bytes_written = decompressor.decompress(nil)
 
           # Verify decompressed size matches expected
           if bytes_written != header.length && Cabriolet.verbose && Cabriolet.verbose
@@ -118,16 +122,18 @@ module Cabriolet
                       end
 
           # Create LZSS decompressor
-          decompressor = Decompressors::LZSS.new(
+          decompressor = @algorithm_factory.create(
+            :lzss,
+            :decompressor,
             @io_system,
             input_handle,
             output_handle,
             @buffer_size,
-            lzss_mode,
+            mode: lzss_mode,
           )
 
-          # Decompress
-          decompressor.decompress(header.length)
+          # Decompress (SZDD reads until EOF, no compressed size stored)
+          decompressor.decompress(nil)
 
           # Return the decompressed data
           output_handle.data
@@ -175,6 +181,9 @@ module Cabriolet
         # Use header's suggested filename method
         suggested = header.suggested_filename(base)
 
+        # Strip null bytes which can occur in malformed SZDD files
+        suggested = suggested.delete("\0")
+
         # Combine with original directory
         dir = ::File.dirname(input_path)
         ::File.join(dir, suggested)

data/lib/cabriolet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cabriolet
-  VERSION = "0.1.2"
+  VERSION = "0.2.1"
 end

data/lib/cabriolet.rb

@@ -1,8 +1,32 @@
 # frozen_string_literal: true
 
+# Cabriolet - Pure Ruby implementation of Microsoft compression formats
 require_relative "cabriolet/version"
-require_relative "cabriolet/platform"
 require_relative "cabriolet/constants"
+require_relative "cabriolet/errors"
+require_relative "cabriolet/platform"
+
+# System layer
+require_relative "cabriolet/system/io_system"
+require_relative "cabriolet/system/file_handle"
+require_relative "cabriolet/system/memory_handle"
+
+# Binary structures
+require_relative "cabriolet/binary/bitstream"
+require_relative "cabriolet/binary/bitstream_writer"
+require_relative "cabriolet/binary/structures"
+require_relative "cabriolet/binary/chm_structures"
+require_relative "cabriolet/binary/szdd_structures"
+require_relative "cabriolet/binary/kwaj_structures"
+require_relative "cabriolet/binary/hlp_structures"
+require_relative "cabriolet/binary/lit_structures"
+require_relative "cabriolet/binary/oab_structures"
+
+# Foundation classes (architectural improvements)
+require_relative "cabriolet/file_entry"
+require_relative "cabriolet/file_manager"
+require_relative "cabriolet/base_compressor"
+require_relative "cabriolet/checksum"
 
 # Cabriolet is a pure Ruby library for extracting Microsoft Cabinet (.CAB) files,
 # CHM (Compiled HTML Help) files, and related compression formats.
@@ -13,40 +37,66 @@ module Cabriolet
 
     # Default buffer size for I/O operations (4KB)
     attr_accessor :default_buffer_size
+
+    # Get the global algorithm factory instance
+    #
+    # @return [AlgorithmFactory] The algorithm factory
+    def algorithm_factory
+      @algorithm_factory ||= AlgorithmFactory.new
+    end
+
+    # Set the global algorithm factory instance
+    #
+    # @param factory [AlgorithmFactory] The algorithm factory to use
+    # @return [AlgorithmFactory] The factory
+    def algorithm_factory=(factory)
+      @algorithm_factory = factory
+    end
+
+    # Get the global plugin manager instance
+    #
+    # @return [PluginManager] The plugin manager
+    def plugin_manager
+      PluginManager.instance
+    end
   end
 
   self.verbose = false
-  self.default_buffer_size = 4096
+  # Default buffer size of 64KB - better for modern systems
+  # Larger buffers reduce I/O syscall overhead significantly
+  self.default_buffer_size = 65_536
 end
 
-# Load core components
-require_relative "cabriolet/system/io_system"
-require_relative "cabriolet/system/file_handle"
-require_relative "cabriolet/system/memory_handle"
-
-require_relative "cabriolet/binary/structures"
-require_relative "cabriolet/binary/bitstream"
-require_relative "cabriolet/binary/bitstream_writer"
-require_relative "cabriolet/binary/chm_structures"
-require_relative "cabriolet/binary/szdd_structures"
-require_relative "cabriolet/binary/kwaj_structures"
-require_relative "cabriolet/binary/hlp_structures"
-require_relative "cabriolet/binary/lit_structures"
-require_relative "cabriolet/binary/oab_structures"
-
+# Models
 require_relative "cabriolet/models/cabinet"
 require_relative "cabriolet/models/folder"
+require_relative "cabriolet/models/folder_data"
 require_relative "cabriolet/models/file"
 require_relative "cabriolet/models/chm_header"
-require_relative "cabriolet/models/chm_file"
 require_relative "cabriolet/models/chm_section"
+require_relative "cabriolet/models/chm_file"
 require_relative "cabriolet/models/szdd_header"
 require_relative "cabriolet/models/kwaj_header"
 require_relative "cabriolet/models/hlp_header"
 require_relative "cabriolet/models/hlp_file"
+require_relative "cabriolet/models/winhelp_header"
 require_relative "cabriolet/models/lit_header"
 require_relative "cabriolet/models/oab_header"
 
+# Load errors first (needed by algorithm_factory)
+
+# Load plugin system
+require_relative "cabriolet/plugin"
+require_relative "cabriolet/plugin_validator"
+require_relative "cabriolet/plugin_manager"
+
+# Load algorithm factory
+require_relative "cabriolet/algorithm_factory"
+
+# Load core components
+
+require_relative "cabriolet/quantum_shared"
+
 require_relative "cabriolet/huffman/tree"
 require_relative "cabriolet/huffman/decoder"
 require_relative "cabriolet/huffman/encoder"
@@ -85,6 +135,11 @@ require_relative "cabriolet/hlp/parser"
 require_relative "cabriolet/hlp/decompressor"
 require_relative "cabriolet/hlp/compressor"
 
+require_relative "cabriolet/hlp/winhelp/parser"
+require_relative "cabriolet/hlp/winhelp/zeck_lz77"
+require_relative "cabriolet/hlp/winhelp/decompressor"
+require_relative "cabriolet/hlp/winhelp/compressor"
+
 require_relative "cabriolet/lit/decompressor"
 require_relative "cabriolet/lit/compressor"
 
@@ -93,12 +148,118 @@ require_relative "cabriolet/oab/compressor"
 
 # Load new advanced features
 require_relative "cabriolet/format_detector"
-require_relative "cabriolet/auto"
+require_relative "cabriolet/extraction/base_extractor"
+require_relative "cabriolet/extraction/extractor"
 require_relative "cabriolet/streaming"
 require_relative "cabriolet/validator"
 require_relative "cabriolet/repairer"
 require_relative "cabriolet/modifier"
-require_relative "cabriolet/parallel"
 
 # Load CLI (optional, for command-line usage)
 require_relative "cabriolet/cli"
+
+# Convenience methods at top level
+module Cabriolet
+  class << self
+    # Open and parse an archive with automatic format detection
+    #
+    # @param path [String] Path to the archive file
+    # @param options [Hash] Options to pass to the parser
+    # @return [Object] Parsed archive object
+    # @raise [UnsupportedFormatError] if format cannot be detected or is unsupported
+    #
+    # @example
+    #   archive = Cabriolet.open('unknown.archive')
+    #   archive.files.each { |f| puts f.name }
+    def open(path, **options)
+      parser_class = FormatDetector.parser_for(path)
+
+      unless parser_class
+        format = detect_format(path)
+        raise UnsupportedFormatError,
+              "Unable to detect format or no parser available for: #{path} (detected: #{format || 'unknown'})"
+      end
+
+      parser_class.new(**options).parse(path)
+    end
+
+    # Detect format of an archive file
+    #
+    # @param path [String] Path to the file
+    # @return [Symbol, nil] Detected format symbol or nil
+    #
+    # @example
+    #   format = Cabriolet.detect_format('file.cab')
+    #   # => :cab
+    def detect_format(path)
+      FormatDetector.detect(path)
+    end
+
+    # Extract files from an archive with automatic format detection
+    #
+    # @param archive_path [String] Path to the archive
+    # @param output_dir [String] Directory to extract to
+    # @param options [Hash] Extraction options
+    # @option options [Integer] :workers (4) Number of parallel workers (1 = sequential)
+    # @option options [Boolean] :preserve_paths (true) Preserve directory structure
+    # @option options [Boolean] :overwrite (false) Overwrite existing files
+    # @return [Hash] Extraction statistics
+    #
+    # @example Sequential extraction
+    #   Cabriolet.extract('archive.cab', 'output/')
+    #
+    # @example Parallel extraction with 8 workers
+    #   stats = Cabriolet.extract('file.chm', 'docs/', workers: 8)
+    #   puts "Extracted #{stats[:extracted]} files"
+    def extract(archive_path, output_dir, **options)
+      archive = open(archive_path)
+      extractor = Extraction::Extractor.new(archive, output_dir, **options)
+      extractor.extract_all
+    end
+
+    # Get information about an archive without full extraction
+    #
+    # @param path [String] Path to the archive
+    # @return [Hash] Archive information
+    #
+    # @example
+    #   info = Cabriolet.info('archive.cab')
+    #   # => { format: :cab, file_count: 145, total_size: 52428800, ... }
+    def info(path)
+      archive = open(path)
+      format = detect_format(path)
+
+      {
+        format: format,
+        path: path,
+        file_count: archive.files.count,
+        total_size: archive.files.sum { |f| f.size || 0 },
+        compressed_size: File.size(path),
+        compression_ratio: calculate_compression_ratio(archive, path),
+        files: archive.files.map { |f| file_info(f) },
+      }
+    end
+
+    private
+
+    def calculate_compression_ratio(archive, path)
+      total_uncompressed = archive.files.sum { |f| f.size || 0 }
+      compressed = File.size(path)
+
+      return 0 if total_uncompressed.zero?
+
+      ((compressed.to_f / total_uncompressed) * 100).round(2)
+    end
+
+    def file_info(file)
+      {
+        name: file.name,
+        size: file.size,
+        compressed_size: file.respond_to?(:compressed_size) ? file.compressed_size : nil,
+        attributes: file.respond_to?(:attributes) ? file.attributes : nil,
+        date: file.respond_to?(:date) ? file.date : nil,
+        time: file.respond_to?(:time) ? file.time : nil,
+      }
+    end
+  end
+end