shoko 0.1.0

data/lib/shoko/adapters/input/command_bridge.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative '../../application/use_cases/commands/application_commands.rb'
+require_relative '../../application/use_cases/commands/navigation_commands.rb'
+require_relative '../../application/use_cases/commands/sidebar_commands.rb'
+require_relative '../../application/use_cases/commands/conditional_navigation_commands.rb'
+require_relative '../../application/use_cases/commands/menu_commands.rb'
+require_relative '../../application/use_cases/commands/bookmark_commands.rb'
+require_relative '../../application/use_cases/commands/reader_commands.rb'
+
+module Shoko
+  module Adapters::Input
+    # Bridge to create Application commands for Input system usage.
+    # Provides a clean interface for the Input system to use Application commands
+    # while maintaining backward compatibility during the migration.
+    class CommandBridge
+      class << self
+        # Create navigation commands for reader movement
+        #
+        # @param action [Symbol] Navigation action (:next_page, :prev_page, etc.)
+        # @return [Application::Commands::NavigationCommand]
+        def navigation_command(action)
+          Application::Commands::NavigationCommand.new(action)
+        end
+
+        # Create application lifecycle commands
+        #
+        # @param action [Symbol] Application action (:quit, :switch_mode, etc.)
+        # @return [Application::Commands::ApplicationCommand]
+        def application_command(action)
+          Application::Commands::ApplicationCommand.new(action)
+        end
+
+        # Create bookmark operation commands
+        #
+        # @param action [Symbol] Bookmark action (:add, :remove, :navigate, etc.)
+        # @return [Application::Commands::BookmarkCommand]
+        def bookmark_command(action)
+          Application::Commands::BookmarkCommand.new(action)
+        end
+
+        # Create sidebar navigation commands
+        #
+        # @param action [Symbol] Sidebar action (:up, :down, :select)
+        # @return [Application::Commands::SidebarCommand]
+        def sidebar_command(action)
+          Application::Commands::SidebarCommand.new(action)
+        end
+
+        # Create conditional navigation commands
+        #
+        # @param type [Symbol] Type of conditional navigation
+        # @return [Application::Commands::ConditionalNavigationCommand]
+        def conditional_navigation_command(type)
+          case type
+          when :up_or_sidebar then Application::Commands::ConditionalNavigationCommand.up_or_sidebar
+          when :down_or_sidebar then Application::Commands::ConditionalNavigationCommand.down_or_sidebar
+          when :select_or_sidebar then Application::Commands::ConditionalNavigationCommand.select_or_sidebar
+          else
+            raise ArgumentError, "Unknown conditional navigation type: #{type}"
+          end
+        end
+
+        # Convert Input system symbols to appropriate Application commands
+        # This method helps during migration by automatically routing
+        # common input symbols to their Application command equivalents.
+        #
+        # @param symbol [Symbol] Input symbol
+        # @param context [Object] Execution context
+        # @return [Application::Commands::BaseCommand, nil] Command or nil if no mapping
+        def symbol_to_command(symbol, _context = nil)
+          case symbol
+          # Navigation commands - now use Application commands
+          when :next_page then navigation_command(:next_page)
+          when :prev_page then navigation_command(:prev_page)
+          when :next_chapter then navigation_command(:next_chapter)
+          when :prev_chapter then navigation_command(:prev_chapter)
+          when :scroll_up then Application::Commands::NavigationCommandFactory.scroll_up
+          when :scroll_down then Application::Commands::NavigationCommandFactory.scroll_down
+          when :go_to_start then navigation_command(:go_to_start)
+          when :go_to_end then navigation_command(:go_to_end)
+          # Application commands
+          when :show_help then application_command(:show_help)
+          when :open_toc then application_command(:show_toc)
+          when :open_bookmarks then application_command(:show_bookmarks)
+          when :open_annotations then application_command(:show_annotations)
+          when :quit_to_menu then application_command(:quit_to_menu)
+          when :add_bookmark then Application::Commands::BookmarkCommandFactory.add_bookmark
+          # Conditional navigation commands
+          when :conditional_up then conditional_navigation_command(:up_or_sidebar)
+          when :conditional_down then conditional_navigation_command(:down_or_sidebar)
+          when :conditional_select then conditional_navigation_command(:select_or_sidebar)
+          # Direct sidebar commands
+          when :sidebar_up then sidebar_command(:up)
+          when :sidebar_down then sidebar_command(:down)
+          when :sidebar_select then sidebar_command(:select)
+          # Menu commands
+          when :menu_up then Application::Commands::MenuCommand.new(:menu_up)
+          when :menu_down then Application::Commands::MenuCommand.new(:menu_down)
+          when :menu_select then Application::Commands::MenuCommand.new(:menu_select)
+          when :menu_quit then Application::Commands::MenuCommand.new(:menu_quit)
+          when :back_to_menu then Application::Commands::MenuCommand.new(:back_to_menu)
+          when :browse_up then Application::Commands::MenuCommand.new(:browse_up)
+          when :browse_down then Application::Commands::MenuCommand.new(:browse_down)
+          when :browse_select then Application::Commands::MenuCommand.new(:browse_select)
+          when :library_up then Application::Commands::MenuCommand.new(:library_up)
+          when :library_down then Application::Commands::MenuCommand.new(:library_down)
+          when :library_select then Application::Commands::MenuCommand.new(:library_select)
+          when :settings_up then Application::Commands::MenuCommand.new(:settings_up)
+          when :settings_down then Application::Commands::MenuCommand.new(:settings_down)
+          when :settings_select then Application::Commands::MenuCommand.new(:settings_select)
+          # recent_* commands removed
+          when :start_search then Application::Commands::MenuCommand.new(:start_search)
+          when :exit_search then Application::Commands::MenuCommand.new(:exit_search)
+          # Annotations-related menu commands
+          when :annotations_up then Application::Commands::MenuCommand.new(:annotations_up)
+          when :annotations_down then Application::Commands::MenuCommand.new(:annotations_down)
+          when :annotations_select then Application::Commands::MenuCommand.new(:annotations_select)
+          when :annotations_edit then Application::Commands::MenuCommand.new(:annotations_edit)
+          when :annotations_delete then Application::Commands::MenuCommand.new(:annotations_delete)
+          when :annotation_detail_open then Application::Commands::MenuCommand.new(:annotation_detail_open)
+          when :annotation_detail_edit then Application::Commands::MenuCommand.new(:annotation_detail_edit)
+          when :annotation_detail_delete then Application::Commands::MenuCommand.new(:annotation_detail_delete)
+          when :annotation_detail_back then Application::Commands::MenuCommand.new(:annotation_detail_back)
+          # Settings actions
+          when :toggle_view_mode then Application::Commands::MenuCommand.new(:toggle_view_mode)
+          when :cycle_line_spacing then Application::Commands::MenuCommand.new(:cycle_line_spacing)
+          when :toggle_page_numbers then Application::Commands::MenuCommand.new(:toggle_page_numbers)
+          when :toggle_page_numbering_mode then Application::Commands::MenuCommand.new(:toggle_page_numbering_mode)
+          when :toggle_highlight_quotes then Application::Commands::MenuCommand.new(:toggle_highlight_quotes)
+          when :toggle_kitty_images then Application::Commands::MenuCommand.new(:toggle_kitty_images)
+          when :wipe_cache then Application::Commands::MenuCommand.new(:wipe_cache)
+          # Reader mode transitions
+          when :exit_help then Application::Commands::ReaderModeCommand.new(:exit_help)
+          end
+        end
+
+        # Check if a symbol can be converted to an Application command
+        #
+        # @param symbol [Symbol] Input symbol to check
+        # @return [Boolean] True if symbol has Application command equivalent
+        def command?(symbol)
+          !symbol_to_command(symbol).nil?
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/command_factory.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require_relative 'key_definitions'
+require_relative '../output/terminal/terminal_sanitizer.rb'
+
+module Shoko
+  module Adapters::Input
+    # Factory for creating common input command patterns.
+    module CommandFactory
+      module_function
+
+      def navigation_commands(_context, selection_field, max_value_proc)
+        selection_field = selection_field.to_sym
+        action_type = case selection_field
+                      when :selected, :browse_selected
+                        :menu
+                      when :sidebar_toc_selected, :sidebar_bookmarks_selected, :sidebar_annotations_selected
+                        :sidebar
+                      end
+        return {} unless action_type
+
+        commands = {}
+        register_navigation(commands, :up, -1, selection_field, action_type, max_value_proc)
+        register_navigation(commands, :down, +1, selection_field, action_type, max_value_proc)
+        commands
+      end
+
+      def exit_commands(exit_action)
+        commands = {}
+        KeyDefinitions::ACTIONS[:cancel].each { |key| commands[key] = exit_action }
+        commands
+      end
+
+      def menu_selection_commands
+        commands = {}
+        KeyDefinitions::ACTIONS[:confirm].each do |key|
+          commands[key] = lambda do |ctx, _|
+            ctx.handle_menu_selection
+            :handled
+          end
+        end
+        commands
+      end
+
+      def reader_navigation_commands
+        reader = KeyDefinitions::READER
+        commands = {}
+        map_keys!(commands, reader[:next_page], :next_page)
+        map_keys!(commands, reader[:prev_page], :prev_page)
+        map_keys!(commands, reader[:scroll_down], :scroll_down)
+        map_keys!(commands, reader[:scroll_up], :scroll_up)
+        map_keys!(commands, reader[:next_chapter], :next_chapter)
+        map_keys!(commands, reader[:prev_chapter], :prev_chapter)
+        map_keys!(commands, reader[:go_to_start], :go_to_start)
+        map_keys!(commands, reader[:go_to_end], :go_to_end)
+        commands
+      end
+
+      def reader_control_commands
+        reader = KeyDefinitions::READER
+        actions = KeyDefinitions::ACTIONS
+        commands = {}
+
+        map_keys!(commands, reader[:toggle_view], :toggle_view_mode)
+        map_keys!(commands, reader[:toggle_page_mode], :toggle_page_numbering_mode)
+        map_keys!(commands, reader[:increase_spacing], :increase_line_spacing)
+        map_keys!(commands, reader[:decrease_spacing], :decrease_line_spacing)
+        map_keys!(commands, reader[:show_toc], :open_toc)
+        map_keys!(commands, reader[:add_bookmark], :add_bookmark)
+        map_keys!(commands, reader[:show_bookmarks], :open_bookmarks)
+        map_keys!(commands, reader[:show_help], :show_help)
+
+        map_keys!(commands, reader[:show_annotations], :open_annotations) if reader.key?(:show_annotations)
+        if reader.key?(:show_annotations_tab)
+          map_keys!(commands, reader[:show_annotations_tab], :open_annotations_tab)
+        end
+        map_keys!(commands, reader[:rebuild_pagination], :rebuild_pagination) if reader.key?(:rebuild_pagination)
+        if reader.key?(:invalidate_pagination)
+          map_keys!(commands, reader[:invalidate_pagination], :invalidate_pagination_cache)
+        end
+
+        map_keys!(commands, actions[:quit], :quit_to_menu)
+        map_keys!(commands, actions[:force_quit], :quit_application)
+        commands
+      end
+
+      def text_input_commands(input_field, context_method = nil, cursor_field: nil)
+        input_field = input_field.to_sym
+        input_path = input_path_for(input_field)
+
+        commands = {}
+        KeyDefinitions::ACTIONS[:backspace].each do |key|
+          commands[key] = lambda do |ctx, _|
+            handle_backspace(ctx, key, input_field, input_path, context_method, cursor_field)
+          end
+        end
+        KeyDefinitions::ACTIONS[:delete].each do |key|
+          commands[key] = lambda do |ctx, _|
+            current, cursor = current_and_cursor(ctx, input_path, cursor_field)
+            new_value = splice_delete(current, cursor)
+            apply_value(ctx, input_field, new_value, cursor_field, cursor)
+            :handled
+          end
+        end
+
+        commands[:__default__] = lambda do |ctx, key|
+          char = key.to_s
+          if Shoko::Adapters::Output::Terminal::TerminalSanitizer.printable_char?(char)
+            handle_character(ctx, key, input_field, input_path, context_method, cursor_field)
+          else
+            :pass
+          end
+        end
+
+        commands
+      end
+
+      def handle_backspace(ctx, key, input_field, input_path, context_method, cursor_field)
+        if context_method
+          ctx.send(context_method, key)
+        elsif input_path
+          current, cursor_pos = current_and_cursor(ctx, input_path, cursor_field)
+          new_value, new_cursor = splice_backspace(current, cursor_pos)
+          apply_value(ctx, input_field, new_value, cursor_field, new_cursor)
+        end
+        :handled
+      end
+      private_class_method :handle_backspace
+
+      def handle_character(ctx, key, input_field, input_path, context_method, cursor_field)
+        if context_method
+          ctx.send(context_method, key)
+        elsif input_path
+          current, cursor_pos = current_and_cursor(ctx, input_path, cursor_field)
+          new_value, new_cursor = splice_insert(current, cursor_pos, key.to_s)
+          apply_value(ctx, input_field, new_value, cursor_field, new_cursor)
+        end
+        :handled
+      end
+      private_class_method :handle_character
+
+      def input_path_for(input_field)
+        {
+          search_query: %i[menu search_query],
+          download_query: %i[menu download_query],
+        }[input_field]
+      end
+      private_class_method :input_path_for
+
+      def current_and_cursor(ctx, input_path, cursor_field)
+        return ['', 0] unless input_path
+
+        current = current_value(ctx, input_path)
+        cursor_pos = determine_cursor(ctx, cursor_field, current)
+        [current, cursor_pos]
+      end
+      private_class_method :current_and_cursor
+
+      def determine_cursor(ctx, cursor_field, current)
+        if cursor_field
+          (ctx.state.get([:menu, cursor_field]) || current.length).to_i
+        else
+          current.length
+        end
+      end
+      private_class_method :determine_cursor
+
+      def apply_value(ctx, input_field, new_value, cursor_field, new_cursor)
+        if cursor_field && !new_cursor.nil?
+          dispatch_menu(ctx, input_field => new_value, cursor_field => new_cursor)
+        else
+          dispatch_menu(ctx, input_field => new_value)
+        end
+      end
+      private_class_method :apply_value
+
+      def register_navigation(commands, direction, step, selection_field, action_type, max_value_proc)
+        handler = navigation_handler(step, selection_field, action_type, max_value_proc)
+        Array(KeyDefinitions::NAVIGATION[direction]).each { |key| commands[key] = handler }
+      end
+      private_class_method :register_navigation
+
+      def navigation_handler(step, selection_field, action_type, max_value_proc)
+        lambda do |ctx, _|
+          current = value_at(ctx, action_type == :menu ? :menu : :reader, selection_field)
+          target = if step.negative?
+                     [current + step, 0].max
+                   else
+                     max_val = max_value_proc.call(ctx)
+                     (current + step).clamp(0, max_val)
+                   end
+          dispatch_for(ctx, action_type, selection_field, target)
+          :handled
+        end
+      end
+      private_class_method :navigation_handler
+
+      def map_keys!(commands, keys, action)
+        Array(keys).each { |key| commands[key] = action }
+        commands
+      end
+      private_class_method :map_keys!
+
+      def dispatch_for(ctx, action_type, field, value)
+        case action_type
+        when :menu
+          dispatch_menu(ctx, field => value)
+        when :sidebar
+          ctx.state.dispatch(Shoko::Application::Actions::UpdateSidebarAction.new(field => value))
+        end
+      end
+      private_class_method :dispatch_for
+
+      def dispatch_menu(ctx, hash)
+        ctx.state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(hash))
+      end
+      private_class_method :dispatch_menu
+
+      def value_at(ctx, base, field)
+        ctx.state.get([base, field]) || 0
+      end
+      private_class_method :value_at
+
+      def current_value(ctx, input_path)
+        (ctx.state.get(input_path) || '').to_s
+      end
+      private_class_method :current_value
+
+      def splice_backspace(current, cursor)
+        return [current, cursor] unless cursor.positive?
+
+        before = current[0, cursor - 1] || ''
+        after = current[cursor..] || ''
+        [before + after, cursor - 1]
+      end
+      private_class_method :splice_backspace
+
+      def splice_insert(current, cursor, char)
+        before = current[0, cursor] || ''
+        after = current[cursor..] || ''
+        [before + char + after, cursor + 1]
+      end
+      private_class_method :splice_insert
+
+      def splice_delete(current, cursor)
+        return current unless cursor < current.length
+
+        before = current[0, cursor] || ''
+        after = current[(cursor + 1)..] || ''
+        before + after
+      end
+      private_class_method :splice_delete
+    end
+  end
+end

data/lib/shoko/adapters/input/commands.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'command_bridge'
+
+module Shoko
+  module Adapters::Input
+    # Generic command execution helpers used by the input system.
+    module Commands
+      module_function
+
+      # Execute a command against the given context.
+      # Supports multiple command types:
+      # - Symbol: calls context.public_send(symbol, key) if arity allows, else without args
+      # - Proc/Lambda: calls with (context, key) if arity 2, else with (key)
+      # - Array [Symbol, *args]: calls method with args splat
+      # - BaseCommand instance: calls command.execute(context, key)
+      def execute(command, context, key = nil)
+        case command
+        when Shoko::Application::Commands::BaseCommand
+          # Support application commands with parameter conversion
+          params = { key: key, triggered_by: :input }
+          command.execute(context, params)
+        when Symbol
+          # Route all symbols through the command bridge
+          if CommandBridge.command?(command)
+            mapped_command = CommandBridge.symbol_to_command(command, context)
+            return :pass unless mapped_command
+
+            execute(mapped_command, context, key)
+          else
+            execute_symbol(command, context, key)
+          end
+        when Proc
+          ar = command.arity
+          ar_abs = ar.abs
+          return command.call(context, key) if ar_abs >= 2
+          return command.call(key) if ar_abs >= 1
+
+          command.call
+        when Array
+          sym, *args = command
+          return :pass unless sym.is_a?(Symbol) && context.respond_to?(sym)
+
+          context.public_send(sym, *args)
+        else
+          :pass
+        end
+      end
+
+      def execute_symbol(command, context, key)
+        return :pass unless context.respond_to?(command)
+
+        method = context.method(command)
+        return context.public_send(command) if method.arity.zero?
+
+        context.public_send(command, key)
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/dispatcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'commands'
+
+module Shoko
+  module Adapters::Input
+    # Dispatches keys through a stack of active input modes.
+    class Dispatcher
+      def initialize(context)
+        @context = context
+        @command_map = {}
+        @mode_stack = []
+      end
+
+      def handle_key(key)
+        return if key.nil?
+
+        @mode_stack.reverse_each do |mode|
+          bindings = @command_map[mode] || {}
+          cmd = bindings[key] || bindings[:__default__]
+          next unless cmd
+
+          result = Commands.execute(cmd, @context, key)
+          return result if result == :handled
+        end
+        :pass
+      end
+
+      def push_mode(mode, bindings = {})
+        @mode_stack << mode
+        @command_map[mode] = bindings if bindings && !bindings.empty?
+      end
+
+      def pop_mode
+        @mode_stack.pop
+      end
+
+      def remove_mode(mode)
+        @mode_stack.delete(mode)
+        @command_map.delete(mode)
+      end
+
+      def clear
+        @mode_stack.clear
+      end
+
+      # Register bindings for a mode without activating it
+      def register_mode(mode, bindings)
+        @command_map[mode] = bindings
+      end
+
+      # Activate a single mode (clears the stack, then pushes)
+      def activate(mode)
+        clear
+        push_mode(mode, @command_map[mode] || {})
+      end
+
+      # Activate a full stack of modes in order; last wins on dispatch
+      def activate_stack(modes)
+        clear
+        modes.each { |m| push_mode(m, @command_map[m] || {}) }
+      end
+
+      def mode_stack
+        @mode_stack.dup
+      end
+    end
+  end
+end