cabriolet 0.1.2 → 0.2.1

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