shoko 0.1.3 → 0.1.5

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/menu_intent_handler'
+require_relative '../../../core/ports/inbound/intent_dispatch_context'
+require_relative 'input_command_payload'
+
+module Shoko
+  module Application
+    module UseCases
+      module Commands
+        # Explicit intent command dispatch for menu-bound input symbols.
+        class MenuIntentCommand
+          class InvalidPayloadError < StandardError; end
+          class ContractMismatchError < StandardError; end
+
+          def initialize(intent_symbol)
+            @intent_symbol = intent_symbol.to_sym
+          end
+
+          def execute(context, payload = nil)
+            handler = resolve_handler(context)
+            normalized_payload = normalize_payload(payload)
+            result = handler.handle_menu_intent(@intent_symbol, normalized_payload)
+            result.nil? ? :handled : result
+          end
+
+          private
+
+          def resolve_handler(context)
+            unless context.is_a?(Shoko::Core::Ports::Inbound::IntentDispatchContext)
+              raise ContractMismatchError,
+                    "Context must implement #{Shoko::Core::Ports::Inbound::IntentDispatchContext}"
+            end
+
+            handler = context.intent_handler
+            return handler if handler.is_a?(Shoko::Core::Ports::Inbound::MenuIntentHandler)
+
+            raise ContractMismatchError,
+                  "Context intent_handler must implement #{Shoko::Core::Ports::Inbound::MenuIntentHandler}"
+          end
+
+          def normalize_payload(payload)
+            InputCommandPayload.from(payload)
+          rescue ArgumentError => e
+            raise InvalidPayloadError, e.message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,181 +1,198 @@
 # frozen_string_literal: true
 
 require_relative 'base_command'
+require_relative '../../../core/ports/inbound/reader_navigation_command_context'
 
 module Shoko
   module Application
-    module Commands
-      # Navigation commands using proper domain services.
-      # Eliminates direct controller coupling and state manipulation.
-      class NavigationCommand < BaseCommand
-        def initialize(action, name: nil, description: nil)
-          @action = action
-          super(
-            name: name || "navigate_#{action}",
-            description: description || "Navigate #{humanize_action(action)}"
-          )
-        end
+    module UseCases
+      module Commands
+        # Navigation commands using proper domain services.
+        # Eliminates direct controller coupling and state manipulation.
+        class NavigationCommand < BaseCommand
+          def initialize(action, name: nil, description: nil)
+            @action = action
+            super(
+              name: name || "navigate_#{action}",
+              description: description || "Navigate #{humanize_action(action)}"
+            )
+          end
 
-        def validate_context(context)
-          super
-          return if context.respond_to?(:dependencies)
+          def validate_context(context)
+            super
+            return if context.is_a?(Shoko::Core::Ports::Inbound::ReaderNavigationCommandContext)
 
-          raise ValidationError.new('Context must provide dependencies', command_name: name)
-        end
+            raise ValidationError.new(
+              'Context must implement Core::Ports::Inbound::ReaderNavigationCommandContext',
+              command_name: name
+            )
+          end
 
-        def can_execute?(context, _params = {})
-          deps = context.dependencies
-          deps.registered?(:navigation_service) && deps.registered?(:state_store)
-        end
+          protected
+
+          def perform(context, _params = {})
+            navigation_service = context.navigation_service
+            current_chapter = current_chapter_from(context.reader_state_reader)
+
+            case @action
+            when :next_page
+              navigation_service.next_page
+            when :prev_page
+              navigation_service.prev_page
+            when :next_chapter
+              navigation_service.jump_to_chapter(current_chapter + 1)
+            when :prev_chapter
+              navigation_service.jump_to_chapter([current_chapter - 1, 0].max)
+            when :go_to_start
+              navigation_service.go_to_start
+            when :go_to_end
+              navigation_service.go_to_end
+            else
+              raise ExecutionError.new("Unknown navigation action: #{@action}", command_name: name)
+            end
+
+            @action
+          end
 
-        protected
-
-        def perform(context, _params = {})
-          deps = context.dependencies
-          navigation_service = deps.resolve(:navigation_service)
-          state_store = deps.resolve(:state_store)
-          current_chapter = current_chapter_from(state_store)
-
-          case @action
-          when :next_page
-            navigation_service.next_page
-          when :prev_page
-            navigation_service.prev_page
-          when :next_chapter
-            navigation_service.jump_to_chapter(current_chapter + 1)
-          when :prev_chapter
-            navigation_service.jump_to_chapter([current_chapter - 1, 0].max)
-          when :go_to_start
-            navigation_service.go_to_start
-          when :go_to_end
-            navigation_service.go_to_end
-          else
-            raise ExecutionError.new("Unknown navigation action: #{@action}", command_name: name)
-          end
-
-          @action
-        end
+          private
 
-        private
+          def humanize_action(action)
+            action.to_s.tr('_', ' ')
+          end
 
-        def humanize_action(action)
-          action.to_s.tr('_', ' ')
-        end
+          def current_chapter_from(reader_state_reader)
+            return 0 unless reader_state_reader
 
-        def current_chapter_from(state_store)
-          return 0 unless state_store.respond_to?(:current_state)
+            chapter = reader_state_reader.current_chapter
+            return 0 if chapter.nil?
 
-          (state_store.current_state || {}).dig(:reader, :current_chapter) || 0
-        rescue StandardError
-          0
+            Integer(chapter)
+          end
         end
-      end
 
-      # Command that scrolls within the current chapter by a number of lines.
-      class ScrollCommand < BaseCommand
-        def initialize(direction, lines: 1, name: nil, description: nil)
-          @direction = direction
-          @lines = lines
-          super(
-            name: name || "scroll_#{direction}",
-            description: description || "Scroll #{direction} #{lines} line(s)"
-          )
-        end
+        # Command that scrolls within the current chapter by a number of lines.
+        class ScrollCommand < BaseCommand
+          def initialize(direction, lines: 1, name: nil, description: nil)
+            @direction = direction
+            @lines = lines
+            super(
+              name: name || "scroll_#{direction}",
+              description: description || "Scroll #{direction} #{lines} line(s)"
+            )
+          end
 
-        def validate_parameters(params)
-          super
+          def validate_context(context)
+            super
+            return if context.is_a?(Shoko::Core::Ports::Inbound::ReaderNavigationCommandContext)
 
-          valid_directions = %i[up down]
-          unless valid_directions.include?(@direction)
-            raise ValidationError.new("Direction must be one of #{valid_directions}",
-                                      command_name: name)
+            raise ValidationError.new(
+              'Context must implement Core::Ports::Inbound::ReaderNavigationCommandContext',
+              command_name: name
+            )
           end
 
-          return if @lines.is_a?(Integer) && @lines.positive?
+          def validate_parameters(params)
+            super
 
-          raise ValidationError.new('Lines must be a positive integer', command_name: name)
-        end
+            valid_directions = %i[up down]
+            unless valid_directions.include?(@direction)
+              raise ValidationError.new("Direction must be one of #{valid_directions}",
+                                        command_name: name)
+            end
 
-        protected
+            return if @lines.is_a?(Integer) && @lines.positive?
 
-        def perform(context, _params = {})
-          navigation_service = context.dependencies.resolve(:navigation_service)
-          navigation_service.scroll(@direction, @lines)
+            raise ValidationError.new('Lines must be a positive integer', command_name: name)
+          end
 
-          { direction: @direction, lines: @lines }
-        end
-      end
+          protected
 
-      # Command that jumps to a specific chapter index.
-      class JumpToChapterCommand < BaseCommand
-        def initialize(chapter_index = nil, name: nil, description: nil)
-          @chapter_index = chapter_index
-          super(
-            name: name || 'jump_to_chapter',
-            description: description || 'Jump to specific chapter'
-          )
+          def perform(context, _params = {})
+            context.navigation_service.scroll(@direction, @lines)
+
+            { direction: @direction, lines: @lines }
+          end
         end
 
-        def validate_parameters(params)
-          super
+        # Command that jumps to a specific chapter index.
+        class JumpToChapterCommand < BaseCommand
+          def initialize(chapter_index = nil, name: nil, description: nil)
+            @chapter_index = chapter_index
+            super(
+              name: name || 'jump_to_chapter',
+              description: description || 'Jump to specific chapter'
+            )
+          end
 
-          # Chapter index can come from params or constructor
-          index = params[:chapter_index] || @chapter_index
+          def validate_context(context)
+            super
+            return if context.is_a?(Shoko::Core::Ports::Inbound::ReaderNavigationCommandContext)
 
-          return if index.is_a?(Integer) && index >= 0
+            raise ValidationError.new(
+              'Context must implement Core::Ports::Inbound::ReaderNavigationCommandContext',
+              command_name: name
+            )
+          end
 
-          raise ValidationError.new('Chapter index must be a non-negative integer',
-                                    command_name: name)
-        end
+          def validate_parameters(params)
+            super
 
-        protected
+            # Chapter index can come from params or constructor
+            index = params[:chapter_index] || @chapter_index
 
-        def perform(context, params = {})
-          navigation_service = context.dependencies.resolve(:navigation_service)
-          index = params[:chapter_index] || @chapter_index
+            return if index.is_a?(Integer) && index >= 0
 
-          navigation_service.jump_to_chapter(index)
+            raise ValidationError.new('Chapter index must be a non-negative integer',
+                                      command_name: name)
+          end
 
-          { chapter_index: index }
-        end
-      end
+          protected
 
-      # Factory methods for common navigation commands
-      module NavigationCommandFactory
-        def self.next_page
-          NavigationCommand.new(:next_page)
-        end
+          def perform(context, params = {})
+            index = params[:chapter_index] || @chapter_index
+            context.navigation_service.jump_to_chapter(index)
 
-        def self.prev_page
-          NavigationCommand.new(:prev_page)
+            { chapter_index: index }
+          end
         end
 
-        def self.next_chapter
-          NavigationCommand.new(:next_chapter)
-        end
+        # Factory methods for common navigation commands
+        module NavigationCommandFactory
+          def self.next_page
+            NavigationCommand.new(:next_page)
+          end
 
-        def self.prev_chapter
-          NavigationCommand.new(:prev_chapter)
-        end
+          def self.prev_page
+            NavigationCommand.new(:prev_page)
+          end
 
-        def self.go_to_start
-          NavigationCommand.new(:go_to_start)
-        end
+          def self.next_chapter
+            NavigationCommand.new(:next_chapter)
+          end
 
-        def self.go_to_end
-          NavigationCommand.new(:go_to_end)
-        end
+          def self.prev_chapter
+            NavigationCommand.new(:prev_chapter)
+          end
 
-        def self.scroll_up(lines = 1)
-          ScrollCommand.new(:up, lines: lines)
-        end
+          def self.go_to_start
+            NavigationCommand.new(:go_to_start)
+          end
 
-        def self.scroll_down(lines = 1)
-          ScrollCommand.new(:down, lines: lines)
-        end
+          def self.go_to_end
+            NavigationCommand.new(:go_to_end)
+          end
 
-        def self.jump_to_chapter(index)
-          JumpToChapterCommand.new(index)
+          def self.scroll_up(lines = 1)
+            ScrollCommand.new(:up, lines: lines)
+          end
+
+          def self.scroll_down(lines = 1)
+            ScrollCommand.new(:down, lines: lines)
+          end
+
+          def self.jump_to_chapter(index)
+            JumpToChapterCommand.new(index)
+          end
         end
       end
     end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/reader_intent_handler'
+require_relative '../../../core/ports/inbound/intent_dispatch_context'
+require_relative 'input_command_payload'
+
+module Shoko
+  module Application
+    module UseCases
+      module Commands
+        # Explicit intent command dispatch for reader-bound input symbols.
+        class ReaderIntentCommand
+          class InvalidPayloadError < StandardError; end
+          class ContractMismatchError < StandardError; end
+
+          def initialize(intent_symbol)
+            @intent_symbol = intent_symbol.to_sym
+          end
+
+          def execute(context, payload = nil)
+            handler = resolve_handler(context)
+            normalized_payload = normalize_payload(payload)
+            result = handler.handle_reader_intent(@intent_symbol, normalized_payload)
+            result.nil? ? :handled : result
+          end
+
+          private
+
+          def resolve_handler(context)
+            unless context.is_a?(Shoko::Core::Ports::Inbound::IntentDispatchContext)
+              raise ContractMismatchError,
+                    "Context must implement #{Shoko::Core::Ports::Inbound::IntentDispatchContext}"
+            end
+
+            handler = context.intent_handler
+            return handler if handler.is_a?(Shoko::Core::Ports::Inbound::ReaderIntentHandler)
+
+            raise ContractMismatchError,
+                  "Context intent_handler must implement #{Shoko::Core::Ports::Inbound::ReaderIntentHandler}"
+          end
+
+          def normalize_payload(payload)
+            InputCommandPayload.from(payload)
+          rescue ArgumentError => e
+            raise InvalidPayloadError, e.message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/reader_intent_handler'
+require_relative '../../../core/ports/inbound/menu_intent_handler'
+require_relative '../../../core/ports/inbound/intent_dispatch_context'
+require_relative 'input_command_payload'
+
+module Shoko
+  module Application
+    module UseCases
+      module Commands
+        # Explicit command for symbols shared across reader and menu intents.
+        class SharedIntentCommand
+          class InvalidPayloadError < StandardError; end
+          class ContractMismatchError < StandardError; end
+
+          def initialize(intent_symbol)
+            @intent_symbol = intent_symbol.to_sym
+          end
+
+          def execute(context, payload = nil)
+            normalized_payload = normalize_payload(payload)
+            result = dispatch(context, normalized_payload)
+            result.nil? ? :handled : result
+          end
+
+          private
+
+          def normalize_payload(payload)
+            InputCommandPayload.from(payload)
+          rescue ArgumentError => e
+            raise InvalidPayloadError, e.message
+          end
+
+          def dispatch(context, normalized_payload)
+            unless context.is_a?(Shoko::Core::Ports::Inbound::IntentDispatchContext)
+              raise ContractMismatchError,
+                    "Context must implement #{Shoko::Core::Ports::Inbound::IntentDispatchContext}"
+            end
+
+            handler = context.intent_handler
+            if handler.is_a?(Shoko::Core::Ports::Inbound::ReaderIntentHandler)
+              handler.handle_reader_intent(@intent_symbol, normalized_payload)
+            elsif handler.is_a?(Shoko::Core::Ports::Inbound::MenuIntentHandler)
+              handler.handle_menu_intent(@intent_symbol, normalized_payload)
+            else
+              raise ContractMismatchError,
+                    'Context intent_handler must implement ReaderIntentHandler or MenuIntentHandler'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/intents/menu_intent_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/menu_intent_handler'
+require_relative '../../../core/ports/outbound/menu_intent_executor'
+
+module Shoko
+  module Application
+    module UseCases
+      module Intents
+        # Application-level menu intent dispatcher.
+        class MenuIntentHandler
+          include Shoko::Core::Ports::Inbound::MenuIntentHandler
+
+          Dependencies = Data.define(:intent_executor, :command_logger) do
+            def validate!
+              raise ArgumentError, 'Missing intent_executor dependency' if intent_executor.nil?
+              raise ArgumentError, 'Missing command_logger dependency' if command_logger.nil?
+
+              unless intent_executor.is_a?(Shoko::Core::Ports::Outbound::MenuIntentExecutor)
+                raise ArgumentError, "intent_executor must implement #{Shoko::Core::Ports::Outbound::MenuIntentExecutor}"
+              end
+
+              self
+            end
+          end
+
+          def initialize(deps:)
+            dependencies = deps.validate!
+            @intent_executor = dependencies.intent_executor
+            @command_logger = dependencies.command_logger
+          end
+
+          def command_logger
+            @command_logger
+          end
+
+          def handle_menu_intent(intent_symbol, payload = nil)
+            intent = intent_symbol.to_sym
+            raise ArgumentError, "Unsupported menu intent: #{intent_symbol}" unless INTENT_SYMBOLS.include?(intent)
+
+            @intent_executor.execute(intent_symbol: intent, payload: payload)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/intents/reader_intent_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/inbound/reader_intent_handler'
+require_relative '../../../core/ports/outbound/reader_intent_executor'
+
+module Shoko
+  module Application
+    module UseCases
+      module Intents
+        # Application-level reader intent dispatcher.
+        class ReaderIntentHandler
+          include Shoko::Core::Ports::Inbound::ReaderIntentHandler
+
+          Dependencies = Data.define(:intent_executor, :command_logger) do
+            def validate!
+              raise ArgumentError, 'Missing intent_executor dependency' if intent_executor.nil?
+              raise ArgumentError, 'Missing command_logger dependency' if command_logger.nil?
+
+              unless intent_executor.is_a?(Shoko::Core::Ports::Outbound::ReaderIntentExecutor)
+                raise ArgumentError, "intent_executor must implement #{Shoko::Core::Ports::Outbound::ReaderIntentExecutor}"
+              end
+
+              self
+            end
+          end
+
+          def initialize(deps:)
+            dependencies = deps.validate!
+            @intent_executor = dependencies.intent_executor
+            @command_logger = dependencies.command_logger
+          end
+
+          def command_logger
+            @command_logger
+          end
+
+          def handle_reader_intent(intent_symbol, payload = nil)
+            intent = intent_symbol.to_sym
+            raise ArgumentError, "Unsupported reader intent: #{intent_symbol}" unless INTENT_SYMBOLS.include?(intent)
+
+            @intent_executor.execute(intent_symbol: intent, payload: payload)
+          end
+        end
+      end
+    end
+  end
+end