shoko 0.1.3 → 0.1.5

data/lib/shoko/application/use_cases/command_bus.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/inbound/command_bus'
+require_relative '../../core/ports/inbound/intent_dispatch_context'
+require_relative '../../core/ports/inbound/reader_intent_handler'
+require_relative '../../core/ports/inbound/menu_intent_handler'
+require_relative 'commands/navigation_commands'
+require_relative 'commands/bookmark_commands'
+require_relative 'commands/input_command_payload'
+require_relative 'commands/reader_intent_command'
+require_relative 'commands/menu_intent_command'
+require_relative 'commands/shared_intent_command'
+
+module Shoko
+  module Application
+    module UseCases
+      # Inbound application command bus used by driving adapters.
+      class CommandBus
+        include Core::Ports::Inbound::CommandBus
+
+        # Command namespace used by the registry factories.
+        Commands = Shoko::Application::UseCases::Commands
+
+        # Semantic application commands with explicit use-case behavior.
+        SEMANTIC_COMMAND_REGISTRY = {
+          # Navigation commands
+          next_page: -> { Commands::NavigationCommand.new(:next_page) },
+          prev_page: -> { Commands::NavigationCommand.new(:prev_page) },
+          next_chapter: -> { Commands::NavigationCommand.new(:next_chapter) },
+          prev_chapter: -> { Commands::NavigationCommand.new(:prev_chapter) },
+          scroll_up: -> { Commands::NavigationCommandFactory.scroll_up },
+          scroll_down: -> { Commands::NavigationCommandFactory.scroll_down },
+          go_to_start: -> { Commands::NavigationCommand.new(:go_to_start) },
+          go_to_end: -> { Commands::NavigationCommand.new(:go_to_end) },
+
+          # Bookmark commands
+          add_bookmark: -> { Commands::BookmarkCommandFactory.add_bookmark },
+        }.freeze
+
+        READER_INTENT_COMMAND_REGISTRY = Shoko::Core::Ports::Inbound::ReaderIntentHandler::INTENT_SYMBOLS
+          .to_h do |symbol|
+            [symbol, -> { Commands::ReaderIntentCommand.new(symbol) }]
+          end
+          .freeze
+
+        MENU_INTENT_COMMAND_REGISTRY = Shoko::Core::Ports::Inbound::MenuIntentHandler::INTENT_SYMBOLS
+          .to_h do |symbol|
+            [symbol, -> { Commands::MenuIntentCommand.new(symbol) }]
+          end
+          .freeze
+
+        SHARED_INTENT_SYMBOLS = (
+          READER_INTENT_COMMAND_REGISTRY.keys &
+          MENU_INTENT_COMMAND_REGISTRY.keys
+        ).freeze
+
+        SHARED_INTENT_COMMAND_REGISTRY = SHARED_INTENT_SYMBOLS
+          .to_h do |symbol|
+            [symbol, -> { Commands::SharedIntentCommand.new(symbol) }]
+          end
+          .freeze
+
+        # Full command registry mapping symbols to command factories.
+        COMMAND_REGISTRY = begin
+          reader_unique = READER_INTENT_COMMAND_REGISTRY.reject { |symbol, _| SHARED_INTENT_SYMBOLS.include?(symbol) }
+          menu_unique = MENU_INTENT_COMMAND_REGISTRY.reject { |symbol, _| SHARED_INTENT_SYMBOLS.include?(symbol) }
+
+          SEMANTIC_COMMAND_REGISTRY
+            .merge(SHARED_INTENT_COMMAND_REGISTRY)
+            .merge(reader_unique)
+            .merge(menu_unique)
+            .freeze
+        end
+
+        def initialize; end
+
+        # Build a command object from a command symbol.
+        #
+        # @param command_symbol [Symbol] The command identifier.
+        # @param _params [Hash] Optional parameters for the command.
+        # @return [Object, nil] A command object that responds to #execute.
+        def build_command(command_symbol, _params = {})
+          factory = COMMAND_REGISTRY[command_symbol]
+          factory&.call
+        end
+
+        # Execute a command directly by symbol.
+        #
+        # @param command_symbol [Symbol] The command identifier.
+        # @param context [Object] The execution context.
+        # @param params [Hash] Optional parameters for the command.
+        # @return [Object, nil] The result of command execution.
+        def execute_command(command_symbol, context, params = {})
+          payload = normalize_payload(params)
+          command = build_command(command_symbol, params)
+          unless command
+            log_command_error(context, 'command.unknown', command: command_symbol)
+            return :error
+          end
+
+          result = command.execute(context, payload)
+          result.nil? ? :handled : result
+        rescue Commands::ReaderIntentCommand::InvalidPayloadError,
+               Commands::SharedIntentCommand::InvalidPayloadError,
+               Commands::MenuIntentCommand::InvalidPayloadError,
+               ArgumentError => e
+          log_command_error(
+            context,
+            'command.invalid_payload',
+            command: command_symbol,
+            error_class: e.class.name,
+            error: e.message
+          )
+          :error
+        rescue Commands::ReaderIntentCommand::ContractMismatchError,
+               Commands::SharedIntentCommand::ContractMismatchError,
+               Commands::MenuIntentCommand::ContractMismatchError => e
+          log_command_error(
+            context,
+            'command.contract_mismatch',
+            command: command_symbol,
+            error_class: e.class.name,
+            error: e.message
+          )
+          :error
+        rescue Shoko::Error => e
+          log_command_error(
+            context,
+            'command.execution_error',
+            command: command_symbol,
+            error_class: e.class.name,
+            error: e.message
+          )
+          :error
+        end
+
+        # Check if a command exists.
+        #
+        # @param command_symbol [Symbol] The command identifier.
+        # @return [Boolean] True if the command exists.
+        def command_exists?(command_symbol)
+          COMMAND_REGISTRY.key?(command_symbol)
+        end
+
+        private
+
+        def normalize_payload(value)
+          Commands::InputCommandPayload.from(value)
+        end
+
+        def log_command_error(context, event, **metadata)
+          logger = command_logger(context)
+          return unless logger
+
+          logger.error(event, **metadata.merge(context: context_name(context)))
+        end
+
+        def command_logger(context)
+          return nil unless context.is_a?(Shoko::Core::Ports::Inbound::IntentDispatchContext)
+
+          context.command_logger
+        end
+
+        def context_name(context)
+          context ? context.class.name : 'nil'
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/commands/base_command.rb

@@ -1,163 +1,153 @@
 # frozen_string_literal: true
 
+require_relative '../../../shared/errors'
+require_relative '../../../core/ports/inbound/intent_dispatch_context'
+require_relative 'input_command_payload'
+
 module Shoko
   module Application
-    module Commands
-      # Enhanced base command with proper error handling and validation.
-      # Replaces the mixed command patterns with consistent implementation.
-      class BaseCommand
-        # Base error type for command execution and validation failures.
-        class CommandError < StandardError
-          attr_reader :command_name, :context
-
-          def initialize(message, command_name: nil, context: nil)
-            super(message)
-            @command_name = command_name
-            @context = context
+    module UseCases
+      module Commands
+        # Enhanced base command with proper error handling and validation.
+        # Replaces the mixed command patterns with consistent implementation.
+        class BaseCommand
+          # Base error type for command execution and validation failures.
+          class CommandError < Shoko::Error
+            attr_reader :command_name, :context
+
+            def initialize(message, command_name: nil, context: nil)
+              super(message)
+              @command_name = command_name
+              @context = context
+            end
           end
-        end
 
-        class ValidationError < CommandError; end
-        class ExecutionError < CommandError; end
+          class ValidationError < CommandError; end
+          class ExecutionError < CommandError; end
 
-        attr_reader :name, :description
+          attr_reader :name, :description
 
-        def initialize(name: nil, description: nil, logger: nil)
-          @name = name || self.class.name.split('::').last
-          @description = description || @name
-          @logger = logger
-        end
-
-        # Execute command with full error handling and validation
-        #
-        # @param context [Object] Execution context (controller, service, etc.)
-        # @param params [Hash] Command parameters
-        # @return [Symbol] :handled, :pass, or :error
-        def execute(context, params = {})
-          validate_context(context)
-          validate_parameters(params)
-
-          return :pass unless can_execute?(context, params)
-
-          begin
-            result = perform(context, params)
-            handle_success(context, result)
-            :handled
-          rescue StandardError => e
-            handle_error(context, e, params)
-            :error
+          def initialize(name: nil, description: nil, logger: nil)
+            @name = name || self.class.name.split('::').last
+            @description = description || @name
+            @logger = logger
           end
-        end
 
-        # Check if command can be executed
-        #
-        # @param context [Object] Execution context
-        # @param params [Hash] Command parameters
-        # @return [Boolean]
-        def can_execute?(_context, _params = {})
-          true # Override in subclasses for conditional execution
-        end
+          # Execute command with full error handling and validation
+          #
+          # @param context [Object] Execution context (controller, service, etc.)
+          # @param params [Hash] Command parameters
+          # @return [Symbol] :handled, :pass, or :error
+          def execute(context, params = {})
+            normalized_params = normalize_params(params)
+            validate_context(context)
+            validate_parameters(normalized_params)
+
+            return :pass unless can_execute?(context, normalized_params)
+
+            begin
+              result = perform(context, normalized_params)
+              handle_success(context, result)
+              :handled
+            rescue Shoko::Error => e
+              handle_error(context, e, normalized_params)
+              :error
+            end
+          end
 
-        # Validate execution context
-        #
-        # @param context [Object] Execution context
-        # @raise [ValidationError] if context is invalid
-        def validate_context(context)
-          raise ValidationError.new('Context cannot be nil', command_name: name) if context.nil?
-        end
+          # Check if command can be executed
+          #
+          # @param context [Object] Execution context
+          # @param params [Hash] Command parameters
+          # @return [Boolean]
+          def can_execute?(_context, _params = {})
+            true # Override in subclasses for conditional execution
+          end
 
-        # Validate command parameters
-        #
-        # @param params [Hash] Command parameters
-        # @raise [ValidationError] if parameters are invalid
-        def validate_parameters(params)
-          # Override in subclasses for parameter validation
-        end
+          # Validate execution context
+          #
+          # @param context [Object] Execution context
+          # @raise [ValidationError] if context is invalid
+          def validate_context(context)
+            raise ValidationError.new('Context cannot be nil', command_name: name) if context.nil?
+          end
 
-        protected
+          # Validate command parameters
+          #
+          # @param params [Hash] Command parameters
+          # @raise [ValidationError] if parameters are invalid
+          def validate_parameters(params)
+            # Override in subclasses for parameter validation
+          end
 
-        # Perform the actual command logic
-        # Must be implemented by subclasses
-        #
-        # @param context [Object] Execution context
-        # @param params [Hash] Command parameters
-        # @return [Object] Command result
-        def perform(context, params = {})
-          raise NotImplementedError, "#{self.class.name} must implement #perform"
-        end
+          protected
 
-        # Handle successful command execution
-        #
-        # @param context [Object] Execution context
-        # @param result [Object] Command result
-        def handle_success(context, result)
-          log_success(context, result)
-        end
+          # Perform the actual command logic
+          # Must be implemented by subclasses
+          #
+          # @param context [Object] Execution context
+          # @param params [Hash] Command parameters
+          # @return [Object] Command result
+          def perform(context, params = {})
+            raise NotImplementedError, "#{self.class.name} must implement #perform"
+          end
 
-        # Handle command execution errors
-        #
-        # @param context [Object] Execution context
-        # @param error [StandardError] The error that occurred
-        # @param params [Hash] Command parameters
-        def handle_error(context, error, params = {})
-          log_error(context, error, params)
+          # Handle successful command execution
+          #
+          # @param context [Object] Execution context
+          # @param result [Object] Command result
+          def handle_success(context, result)
+            log_success(context, result)
+          end
 
-          # Show user-friendly error message if possible
-          return unless context.respond_to?(:show_error_message)
+          # Handle command execution errors
+          #
+          # @param context [Object] Execution context
+          # @param error [StandardError] The error that occurred
+          # @param params [Hash] Command parameters
+          def handle_error(context, error, params = {})
+            log_error(context, error, params)
+          end
 
-          context.show_error_message(user_friendly_error_message(error))
-        end
+          private
 
-        private
+          def log_success(context, result)
+            logger = resolve_logger(context)
+            logger&.debug(
+              'Command executed successfully',
+              command: name,
+              context: context.class.name,
+              result: result.inspect
+            )
+          end
 
-        def log_success(context, result)
-          logger = resolve_logger(context)
-          logger&.debug(
-            'Command executed successfully',
-            command: name,
-            context: context.class.name,
-            result: result.inspect
-          )
-        end
+          def log_error(context, error, params)
+            logger = resolve_logger(context)
+            logger&.error(
+              'Command execution failed',
+              command: name,
+              context: context.class.name,
+              error: error.message,
+              params: params,
+              backtrace: error.backtrace.first(5)
+            )
+          end
 
-        def log_error(context, error, params)
-          logger = resolve_logger(context)
-          logger&.error(
-            'Command execution failed',
-            command: name,
-            context: context.class.name,
-            error: error.message,
-            params: params,
-            backtrace: error.backtrace.first(5)
-          )
-        end
+          def resolve_logger(context)
+            return @logger if defined?(@logger) && @logger
 
-        def resolve_logger(context)
-          return @logger if defined?(@logger) && @logger
+            return nil unless context.is_a?(Shoko::Core::Ports::Inbound::IntentDispatchContext)
 
-          candidate = begin
-            if context.respond_to?(:dependencies)
-              deps = context.dependencies
-              deps.resolve(:logger) if deps.respond_to?(:resolve)
-            elsif context.respond_to?(:logger)
-              context.logger
-            end
-          rescue StandardError
-            nil
+            candidate = context.command_logger
+            @logger = candidate if candidate
+            candidate
           end
-          @logger = candidate if candidate
-          candidate
-        end
 
-        def user_friendly_error_message(error)
-          msg = error.message
-          case error
-          when ValidationError
-            "Invalid input: #{msg}"
-          when CommandError
-            msg
-          else
-            'An unexpected error occurred'
+          def normalize_params(value)
+            payload = InputCommandPayload.from(value)
+            payload.to_h.merge(payload.metadata)
+          rescue ArgumentError => e
+            raise ValidationError.new(e.message, command_name: name)
           end
         end
       end

data/lib/shoko/application/use_cases/commands/bookmark_commands.rb

@@ -1,111 +1,97 @@
 # frozen_string_literal: true
 
 require_relative 'base_command'
+require_relative '../../../core/ports/inbound/reader_bookmark_command_context'
 
 module Shoko
   module Application
-    module Commands
-      # Bookmark management commands using domain services.
-      class BookmarkCommand < BaseCommand
-        def initialize(action, name: nil, description: nil)
-          @action = action
-          super(
-            name: name || "bookmark_#{action}",
-            description: description || "Bookmark #{action.to_s.tr('_', ' ')}"
-          )
-        end
-
-        def can_execute?(context, _params = {})
-          deps = context.dependencies
-          deps.registered?(:bookmark_service) && deps.registered?(:state_store)
-        end
-
-        protected
-
-        def perform(context, params = {})
-          deps = context.dependencies
-          bookmark_service = deps.resolve(:bookmark_service)
-
-          case @action
-          when :add
-            handle_add_bookmark(bookmark_service, params)
-          when :remove
-            handle_remove_bookmark(bookmark_service, params)
-          when :toggle
-            handle_toggle_bookmark(bookmark_service, params)
-          when :jump_to
-            handle_jump_to_bookmark(bookmark_service, params)
-          else
-            raise ExecutionError.new("Unknown bookmark action: #{@action}", command_name: name)
+    module UseCases
+      module Commands
+        # Bookmark management commands using domain services.
+        class BookmarkCommand < BaseCommand
+          def initialize(action, name: nil, description: nil)
+            @action = action
+            super(
+              name: name || "bookmark_#{action}",
+              description: description || "Bookmark #{action.to_s.tr('_', ' ')}"
+            )
           end
 
-          @action
-        end
-
-        private
+          def validate_context(context)
+            super
+            return if context.is_a?(Shoko::Core::Ports::Inbound::ReaderBookmarkCommandContext)
 
-        def handle_add_bookmark(service, params)
-          text_snippet = params[:text_snippet]
-          service.add_bookmark(text_snippet)
-        end
-
-        def handle_remove_bookmark(service, params)
-          bookmark = params[:bookmark]
+            raise ValidationError.new(
+              'Context must implement Core::Ports::Inbound::ReaderBookmarkCommandContext',
+              command_name: name
+            )
+          end
 
-          raise ValidationError.new('Bookmark required for remove action', command_name: name) unless bookmark
+          protected
+
+          def perform(context, params = {})
+            bookmark_service = context.bookmark_service
+
+            case @action
+            when :add
+              handle_add_bookmark(bookmark_service, params)
+            when :remove
+              handle_remove_bookmark(bookmark_service, params)
+            when :toggle
+              handle_toggle_bookmark(bookmark_service, params)
+            when :jump_to
+              handle_jump_to_bookmark(bookmark_service, params)
+            else
+              raise ExecutionError.new("Unknown bookmark action: #{@action}", command_name: name)
+            end
 
-          service.remove_bookmark(bookmark)
-        end
+            @action
+          end
 
-        def handle_toggle_bookmark(service, params)
-          text_snippet = params[:text_snippet]
-          result = service.toggle_bookmark(text_snippet)
+          private
 
-          { result: result }
-        end
+          def handle_add_bookmark(service, params)
+            text_snippet = params[:text_snippet]
+            service.add_bookmark(text_snippet)
+          end
 
-        def handle_jump_to_bookmark(service, params)
-          bookmark = params[:bookmark]
+          def handle_remove_bookmark(service, params)
+            bookmark = params[:bookmark]
 
-          raise ValidationError.new('Bookmark required for jump_to action', command_name: name) unless bookmark
+            raise ValidationError.new('Bookmark required for remove action', command_name: name) unless bookmark
 
-          service.jump_to_bookmark(bookmark)
-        end
-      end
+            service.remove_bookmark(bookmark)
+          end
 
-      # Factory methods for bookmark commands
-      module BookmarkCommandFactory
-        def self.add_bookmark(text_snippet = nil)
-          command = BookmarkCommand.new(:add)
+          def handle_toggle_bookmark(service, params)
+            text_snippet = params[:text_snippet]
+            result = service.toggle_bookmark(text_snippet)
 
-          # If text_snippet provided, create a wrapper that includes it in params
-          if text_snippet
-            lambda do |context, params = {}|
-              command.execute(context, params.merge(text_snippet: text_snippet))
-            end
-          else
-            command
+            { result: result }
           end
-        end
 
-        def self.remove_bookmark(bookmark)
-          command = BookmarkCommand.new(:remove)
-          lambda do |context, params = {}|
-            command.execute(context, params.merge(bookmark: bookmark))
-          end
-        end
+          def handle_jump_to_bookmark(service, params)
+            bookmark = params[:bookmark]
 
-        def self.toggle_bookmark(text_snippet = nil)
-          command = BookmarkCommand.new(:toggle)
-          lambda do |context, params = {}|
-            command.execute(context, params.merge(text_snippet: text_snippet))
+            raise ValidationError.new('Bookmark required for jump_to action', command_name: name) unless bookmark
+
+            service.jump_to_bookmark(bookmark)
           end
         end
 
-        def self.jump_to_bookmark(bookmark)
-          command = BookmarkCommand.new(:jump_to)
-          lambda do |context, params = {}|
-            command.execute(context, params.merge(bookmark: bookmark))
+        # Factory methods for bookmark commands
+        module BookmarkCommandFactory
+          def self.add_bookmark(text_snippet = nil)
+            command = BookmarkCommand.new(:add)
+
+            # If text_snippet provided, create a wrapper that includes it in params
+            if text_snippet
+              lambda do |context, params = {}|
+                command.execute(context, params.merge(text_snippet: text_snippet))
+              end
+            else
+              command
+            end
           end
         end
       end

data/lib/shoko/application/use_cases/commands/input_command_payload.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/input_command_payload'
+
+module Shoko
+  module Application
+    module UseCases
+      module Commands
+        InputCommandPayload = Shoko::Core::Ports::Inbound::InputCommandPayload
+      end
+    end
+  end
+end