cabriolet 0.1.2 → 0.2.0

data/lib/cabriolet/chm/decompressor.rb

@@ -13,8 +13,9 @@ module Cabriolet
 
       attr_reader :io_system, :chm
 
-      def initialize(io_system = nil)
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @chm = nil
         @input_handle = nil
         @lzx_state = nil
@@ -72,7 +73,7 @@ module Cabriolet
         when 1
           extract_compressed(file, output_path)
         else
-          raise Errors::FormatError, "Invalid section ID: #{file.section.id}"
+          raise Cabriolet::FormatError, "Invalid section ID: #{file.section.id}"
         end
       end
 
@@ -108,13 +109,20 @@ module Cabriolet
         while remaining.positive?
           chunk_size = [buffer_size, remaining].min
           data = @input_handle.read(chunk_size)
-          if data.nil? || data.length < chunk_size
-            raise Errors::ReadError,
+          if data.nil?
+            raise Cabriolet::ReadError,
+                  "Unexpected end of file"
+          end
+
+          # It's OK if we read less than chunk_size (e.g., last chunk or EOF)
+          # Only raise an error if we read nothing when we expected data
+          if data.empty? && remaining.positive?
+            raise Cabriolet::ReadError,
                   "Unexpected end of file"
           end
 
           output_handle.write(data)
-          remaining -= chunk_size
+          remaining -= data.length
         end
 
         output_handle.close
@@ -174,15 +182,18 @@ module Cabriolet
         control = sec.control || find_system_file(Parser::CONTROL_NAME)
 
         unless content
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "MSCompressed Content file not found"
         end
-        raise Errors::FormatError, "ControlData file not found" unless control
+        unless control
+          raise Cabriolet::FormatError,
+                "ControlData file not found"
+        end
 
         # Read control data
         control_data = read_system_file(control)
         unless control_data.length == 28
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "ControlData wrong size"
         end
 
@@ -198,13 +209,14 @@ module Cabriolet
                       when 0x100000 then 20
                       when 0x200000 then 21
                       else
-                        raise Errors::FormatError,
+                        raise Cabriolet::FormatError,
                               "Invalid window size: #{window_size}"
                       end
 
         # Validate reset interval
         if reset_interval.zero? || (reset_interval % LZX_FRAME_SIZE) != 0
-          raise Errors::FormatError, "Invalid reset interval: #{reset_interval}"
+          raise Cabriolet::FormatError,
+                "Invalid reset interval: #{reset_interval}"
         end
 
         # Find reset table entry for this file
@@ -227,7 +239,9 @@ module Cabriolet
         output_handle = System::MemoryHandle.new("")
 
         # Initialize LZX decompressor
-        @lzx_state = Decompressors::LZX.new(
+        @lzx_state = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
           @io_system,
           @input_handle,
           output_handle,
@@ -242,7 +256,7 @@ module Cabriolet
       def parse_control_data(data)
         signature = data[4, 4]
         unless signature == "LZXC"
-          raise Errors::SignatureError,
+          raise Cabriolet::SignatureError,
                 "Invalid LZXC signature"
         end
 
@@ -255,7 +269,8 @@ module Cabriolet
           reset_interval *= LZX_FRAME_SIZE
           window_size *= LZX_FRAME_SIZE
         elsif version != 1
-          raise Errors::FormatError, "Unknown ControlData version: #{version}"
+          raise Cabriolet::FormatError,
+                "Unknown ControlData version: #{version}"
         end
 
         [window_size, reset_interval]
@@ -272,7 +287,7 @@ module Cabriolet
           # Fall back to SpanInfo
           spaninfo = sec.spaninfo || find_system_file(Parser::SPANINFO_NAME)
           unless spaninfo
-            raise Errors::FormatError,
+            raise Cabriolet::FormatError,
                   "Neither ResetTable nor SpanInfo found"
           end
 
@@ -284,12 +299,12 @@ module Cabriolet
       # Read an entry from the reset table
       def read_reset_table_entry(rtable, entry, reset_interval)
         data = read_system_file(rtable)
-        raise Errors::FormatError, "ResetTable too short" if data.length < 40
+        raise Cabriolet::FormatError, "ResetTable too short" if data.length < 40
 
         # Check frame length
         frame_len = data[32, 8].unpack1("Q<")
         unless frame_len == LZX_FRAME_SIZE
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "Invalid frame length"
         end
 
@@ -307,7 +322,7 @@ module Cabriolet
                    when 4 then data[pos, 4].unpack1("V")
                    when 8 then data[pos, 8].unpack1("Q<")
                    else
-                     raise Errors::FormatError,
+                     raise Cabriolet::FormatError,
                            "Invalid entry size: #{entry_size}"
                    end
 
@@ -325,11 +340,14 @@ module Cabriolet
       # Read SpanInfo to get uncompressed length
       def read_spaninfo(spaninfo)
         data = read_system_file(spaninfo)
-        raise Errors::FormatError, "SpanInfo wrong size" unless data.length == 8
+        unless data.length == 8
+          raise Cabriolet::FormatError,
+                "SpanInfo wrong size"
+        end
 
         length = data.unpack1("Q<")
         unless length.positive?
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "Invalid SpanInfo length"
         end
 
@@ -350,7 +368,7 @@ module Cabriolet
       # Read a system file's contents
       def read_system_file(file)
         unless file.section.id.zero?
-          raise Errors::FormatError,
+          raise Cabriolet::FormatError,
                 "System file must be in section 0"
         end
 
@@ -417,7 +435,7 @@ module Cabriolet
               file.length = length
               return file
             end
-          rescue Errors::FormatError
+          rescue Cabriolet::FormatError
             break
           end
         end

data/lib/cabriolet/chm/parser.rb

@@ -56,9 +56,12 @@ module Cabriolet
         end
 
         # Check GUIDs
-        unless header.guid1 == GUID1 && header.guid2 == GUID2
+        # Note: Some CHM files have both GUIDs set to GUID1 (unusual but valid)
+        # Standard files have GUID1 and GUID2 as expected
+        # We validate that guid2 matches either GUID1 or GUID2
+        unless [GUID1, GUID2].include?(header.guid2)
           raise SignatureError,
-                "Invalid CHM GUIDs"
+                "Invalid CHM GUIDs (guid2 should match CHM format GUID)"
         end
 
         @chm.version = header.version

data/lib/cabriolet/cli/base_command_handler.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Commands
+    # Abstract base class for format-specific command handlers
+    #
+    # This class defines the interface that all format command handlers must implement.
+    # Each format (CAB, CHM, SZDD, KWAJ, HLP, LIT, OAB) should have its own
+    # CommandHandler subclass that inherits from this base class.
+    #
+    # The base class provides common functionality and enforces a consistent
+    # interface across all format handlers, following the Template Method pattern.
+    #
+    # @example Creating a format handler
+    #   module Cabriolet
+    #     module CAB
+    #       class CommandHandler < CLI::BaseCommandHandler
+    #         def list(file, options = {})
+    #           # Implementation for listing CAB files
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    class BaseCommandHandler
+      # Initialize the command handler
+      #
+      # @param verbose [Boolean] Enable verbose output
+      def initialize(verbose: false)
+        @verbose = verbose
+      end
+
+      # List archive contents
+      #
+      # @param file [String] Path to the archive file
+      # @param options [Hash] Additional options
+      # @raise [NotImplementedError] Subclass must implement
+      def list(file, options = {})
+        raise NotImplementedError,
+              "#{self.class} must implement #list"
+      end
+
+      # Extract files from archive
+      #
+      # @param file [String] Path to the archive file
+      # @param output_dir [String] Output directory path
+      # @param options [Hash] Additional options
+      # @raise [NotImplementedError] Subclass must implement
+      def extract(file, output_dir, options = {})
+        raise NotImplementedError,
+              "#{self.class} must implement #extract"
+      end
+
+      # Create a new archive
+      #
+      # @param output [String] Output file path
+      # @param files [Array<String>] List of input files
+      # @param options [Hash] Additional options
+      # @raise [NotImplementedError] Subclass must implement
+      def create(output, files, options = {})
+        raise NotImplementedError,
+              "#{self.class} must implement #create"
+      end
+
+      # Display archive information
+      #
+      # @param file [String] Path to the archive file
+      # @param options [Hash] Additional options
+      # @raise [NotImplementedError] Subclass must implement
+      def info(file, options = {})
+        raise NotImplementedError,
+              "#{self.class} must implement #info"
+      end
+
+      # Test archive integrity
+      #
+      # @param file [String] Path to the archive file
+      # @param options [Hash] Additional options
+      # @raise [NotImplementedError] Subclass must implement
+      def test(file, options = {})
+        raise NotImplementedError,
+              "#{self.class} must implement #test"
+      end
+
+      protected
+
+      # Check if verbose output is enabled
+      #
+      # @return [Boolean] true if verbose mode is active
+      def verbose?
+        @verbose
+      end
+
+      # Detect format from file using FormatDetector
+      #
+      # This is a convenience method for handlers that need to perform
+      # format detection within their operations.
+      #
+      # @param file [String] Path to the file
+      # @return [Symbol, nil] Detected format symbol
+      def detect_format(file)
+        require_relative "../format_detector"
+        FormatDetector.detect(file)
+      end
+
+      # Validate that a file exists
+      #
+      # @param file [String] Path to the file
+      # @raise [ArgumentError] if file doesn't exist
+      def validate_file_exists(file)
+        return if File.exist?(file)
+
+        raise ArgumentError, "File does not exist: #{file}"
+      end
+
+      # Ensure output directory exists
+      #
+      # @param output_dir [String] Output directory path
+      # @return [String] The output directory path
+      def ensure_output_dir(output_dir)
+        require "fileutils"
+        FileUtils.mkdir_p(output_dir)
+        output_dir
+      end
+    end
+  end
+end

data/lib/cabriolet/cli/command_dispatcher.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "command_registry"
+require_relative "base_command_handler"
+require_relative "../format_detector"
+
+module Cabriolet
+  module Commands
+    # Unified command dispatcher that routes commands to format-specific handlers
+    #
+    # The dispatcher is responsible for:
+    # 1. Detecting the format of input files (or using manual override)
+    # 2. Selecting the appropriate format handler from the registry
+    # 3. Delegating command execution to the handler
+    #
+    # This class implements the Strategy pattern, where the format handler
+    # is the strategy selected based on the detected format.
+    #
+    # @example Using the dispatcher
+    #   dispatcher = CLI::CommandDispatcher.new(format: :cab, verbose: true)
+    #   dispatcher.dispatch(:list, "archive.cab")
+    #
+    class CommandDispatcher
+      # Initialize the command dispatcher
+      #
+      # @param options [Hash] Configuration options
+      # @option options [String, Symbol] :format Manual format override
+      # @option options [Boolean] :verbose Enable verbose output
+      def initialize(options = {})
+        @format_override = parse_format_option(options[:format])
+        @verbose = options[:verbose] || false
+      end
+
+      # Dispatch a command to the appropriate format handler
+      #
+      # This method detects the format (if not manually specified),
+      # retrieves the appropriate handler, and delegates the command execution.
+      #
+      # @param command [Symbol] The command to execute (:list, :extract, etc.)
+      # @param file [String] Path to the archive file
+      # @param args [Array] Additional positional arguments for the command
+      # @param options [Hash] Additional options to pass to the handler
+      # @raise [Cabriolet::Error] if format detection fails or handler not found
+      # @return [void]
+      def dispatch(command, file, *args, **options)
+        format = detect_format(file)
+        handler = get_handler_for(format)
+
+        execute_command(handler, command, file, args, options)
+      end
+
+      # Check if a format is supported
+      #
+      # @param format [Symbol] The format to check
+      # @return [Boolean] true if the format has a registered handler
+      def self.format_supported?(format)
+        CommandRegistry.format_registered?(format)
+      end
+
+      # Get list of supported formats
+      #
+      # @return [Array<Symbol>] List of supported format symbols
+      def self.supported_formats
+        CommandRegistry.registered_formats
+      end
+
+      private
+
+      # Parse format option to symbol
+      #
+      # @param format_value [String, Symbol, nil] The format option value
+      # @return [Symbol, nil] The format as a symbol
+      def parse_format_option(format_value)
+        return nil if format_value.nil?
+
+        format_value.to_sym
+      end
+
+      # Detect format from file with fallback to manual override
+      #
+      # @param file [String] Path to the archive file
+      # @return [Symbol] The detected format symbol
+      # @raise [Cabriolet::Error] if format cannot be detected
+      def detect_format(file)
+        return @format_override if @format_override
+
+        format = FormatDetector.detect(file)
+        if format.nil?
+          supported = CommandRegistry.registered_formats.join(", ")
+          raise Error,
+                "Cannot detect format for: #{file}. " \
+                "Use --format to specify (supported: #{supported})"
+        end
+
+        format
+      end
+
+      # Get the handler class for a format
+      #
+      # @param format [Symbol] The format symbol
+      # @return [Class] The handler class
+      # @raise [Cabriolet::Error] if no handler is registered
+      def get_handler_for(format)
+        handler = CommandRegistry.handler_for(format)
+
+        unless handler
+          raise Error,
+                "No command handler registered for format: #{format}"
+        end
+
+        handler
+      end
+
+      # Execute the command on the handler
+      #
+      # @param handler_class [Class] The handler class
+      # @param command [Symbol] The command to execute
+      # @param file [String] Path to the archive file
+      # @param args [Array] Additional positional arguments
+      # @param options [Hash] Additional options
+      # @return [void]
+      def execute_command(handler_class, command, file, args, options)
+        handler = handler_class.new(verbose: @verbose)
+
+        # Call the command method with appropriate arguments
+        case command
+        when :extract
+          output_dir = args.first || options[:output_dir]
+          handler.extract(file, output_dir, options)
+        when :create
+          files = args.first || options[:files] || []
+          handler.create(file, files, options)
+        else
+          # For commands that take just file and options
+          handler.public_send(command, file, options)
+        end
+      end
+    end
+  end
+end

data/lib/cabriolet/cli/command_registry.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  module Commands
+    # Registry for mapping format symbols to command handler classes
+    #
+    # This registry provides a centralized location for managing format handlers,
+    # following the Open/Closed Principle - new formats can be added without
+    # modifying existing command logic.
+    #
+    # @example Registering a format handler
+    #   CLI::CommandRegistry.register_format(:cab, CAB::CommandHandler)
+    #
+    # @example Getting a handler for a format
+    #   handler = CLI::CommandRegistry.handler_for(:cab)
+    #
+    class CommandRegistry
+      @handlers = {}
+
+      class << self
+        # Get the command handler class for a given format
+        #
+        # @param format [Symbol] The format symbol (e.g., :cab, :chm, :szdd)
+        # @return [Class, nil] The handler class or nil if not registered
+        def handler_for(format)
+          @handlers[format]
+        end
+
+        # Register a command handler for a format
+        #
+        # This allows for dynamic registration of format handlers,
+        # supporting extensibility and plugin architectures.
+        #
+        # @param format [Symbol] The format symbol
+        # @param handler_class [Class] The command handler class
+        # @raise [ArgumentError] if handler_class doesn't implement required interface
+        def register_format(format, handler_class)
+          validate_handler_interface(handler_class)
+          @handlers[format] = handler_class
+        end
+
+        # Get all registered formats
+        #
+        # @return [Array<Symbol>] List of registered format symbols
+        def registered_formats
+          @handlers.keys
+        end
+
+        # Check if a format is registered
+        #
+        # @param format [Symbol] The format symbol
+        # @return [Boolean] true if the format has a registered handler
+        def format_registered?(format)
+          @handlers.key?(format)
+        end
+
+        # Clear all registered formats (primarily for testing)
+        #
+        # @return [void]
+        def clear
+          @handlers = {}
+        end
+
+        private
+
+        # Validate that a handler class implements the required interface
+        #
+        # @param handler_class [Class] The class to validate
+        # @raise [ArgumentError] if the class doesn't implement required methods
+        def validate_handler_interface(handler_class)
+          required_methods = %i[list extract create info test]
+
+          required_methods.each do |method|
+            unless handler_class.method_defined?(method)
+              raise ArgumentError,
+                    "Handler class #{handler_class} must implement ##{method}"
+            end
+          end
+        end
+      end
+    end
+  end
+end