shoko 0.1.0

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

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      # Handles all input processing: key handling, popup management, mode switching
+      class InputController
+      def initialize(state, dependencies)
+        @state = state
+        @dependencies = dependencies
+        @dispatcher = nil
+        @modal_mode_stack = []
+      end
+
+      def setup_input_dispatcher(reader_controller)
+        @dispatcher = Adapters::Input::Dispatcher.new(reader_controller)
+        setup_consolidated_reader_bindings(reader_controller)
+        @dispatcher.activate_stack([:read])
+      end
+
+      def handle_key(key)
+        @dispatcher&.handle_key(key)
+      end
+
+      # Enhanced popup navigation handlers for direct key routing
+      def handle_popup_navigation(key)
+        with_popup_menu do |menu|
+          res = menu.handle_key(key)
+          next :pass unless res
+
+          :handled
+        end
+      end
+
+      def handle_popup_action_key(key)
+        with_popup_menu do |menu|
+          res = menu.handle_key(key) || { type: :noop }
+          process_popup_result(res)
+        end
+      end
+
+      def handle_popup_cancel(key)
+        with_popup_menu do |menu|
+          res = menu.handle_key(key) || { type: :noop }
+          process_popup_result(res)
+        end
+      end
+
+      def handle_popup_menu_input(keys)
+        popup_menu = Shoko::Application::Selectors::ReaderSelectors.popup_menu(@state)
+        return unless popup_menu
+
+        ui_controller = @dependencies.resolve(:ui_controller)
+        keys.each do |key|
+          res = popup_menu.handle_key(key) || { type: :noop }
+          process_popup_result(res, ui_controller)
+        end
+      end
+
+      def handle_annotations_overlay_input(keys)
+        overlay = Shoko::Application::Selectors::ReaderSelectors.annotations_overlay(@state)
+        return unless overlay
+
+        ui_controller = @dependencies.resolve(:ui_controller)
+        keys.each do |key|
+          result = overlay.handle_key(key)
+          next unless result
+
+          case result[:type]
+          when :selection_change
+            index = result[:index]
+            @state.dispatch(Shoko::Application::Actions::UpdateSidebarAction.new(
+                              annotations_selected: index,
+                              sidebar_annotations_selected: index
+                            ))
+          when :open
+            if ui_controller.respond_to?(:open_annotation_from_overlay)
+              ui_controller.open_annotation_from_overlay(result[:annotation])
+            end
+          when :edit
+            if ui_controller.respond_to?(:edit_annotation_from_overlay)
+              ui_controller.edit_annotation_from_overlay(result[:annotation])
+            end
+          when :delete
+            if ui_controller.respond_to?(:delete_annotation_from_overlay)
+              ui_controller.delete_annotation_from_overlay(result[:annotation])
+            end
+          when :close
+            ui_controller.close_annotations_overlay if ui_controller.respond_to?(:close_annotations_overlay)
+          end
+        end
+      end
+
+      private
+
+      def with_popup_menu
+        popup_menu = Shoko::Application::Selectors::ReaderSelectors.popup_menu(@state)
+        return :pass unless popup_menu
+
+        yield popup_menu
+      end
+
+      def process_popup_result(result, ui_controller = @dependencies.resolve(:ui_controller))
+        case result[:type]
+        when :selection_change
+          # Selection change handled by popup itself
+          :handled
+        when :action
+          ui_controller.handle_popup_action(result)
+          :handled
+        when :cancel
+          ui_controller.cleanup_popup_state
+          ui_controller.switch_mode(:read)
+          :handled
+        else
+          :pass
+        end
+      end
+
+      def setup_consolidated_reader_bindings(reader_controller)
+        # Register reader mode bindings using Adapters::Input::CommandFactory patterns
+        register_read_bindings(reader_controller)
+        register_popup_menu_bindings(reader_controller)
+
+        # Keep legacy bindings for modes not yet converted
+        register_help_bindings_new(reader_controller)
+        register_annotation_editor_bindings_new(reader_controller)
+        register_library_bindings_new(reader_controller)
+      end
+
+      def register_read_bindings(_reader_controller)
+        bindings = Adapters::Input::CommandFactory.reader_navigation_commands
+        bindings.merge!(Adapters::Input::CommandFactory.reader_control_commands)
+
+        # When sidebar is visible, redirect up/down/enter to sidebar handlers
+        nav_down = Adapters::Input::KeyDefinitions::NAVIGATION[:down]
+        nav_down.each do |key|
+          bindings[key] = :conditional_down
+        end
+
+        nav_up = Adapters::Input::KeyDefinitions::NAVIGATION[:up]
+        nav_up.each do |key|
+          bindings[key] = :conditional_up
+        end
+
+        confirm_keys = Adapters::Input::KeyDefinitions::ACTIONS[:confirm]
+        confirm_keys.each do |key|
+          bindings[key] = :conditional_select
+        end
+
+        # Ensure TOC toggle is bound explicitly and marked handled
+        %w[t T].each do |key|
+          bindings[key] = :open_toc
+        end
+
+        @dispatcher.register_mode(:read, bindings)
+      end
+
+      def register_popup_menu_bindings(_reader_controller)
+        # Popup menu navigation is now handled directly in main_loop via handle_popup_menu_input
+        bindings = {}
+        bindings.merge!(Adapters::Input::CommandFactory.menu_selection_commands)
+        bindings.merge!(Adapters::Input::CommandFactory.exit_commands(:exit_popup_menu))
+        @dispatcher.register_mode(:popup_menu, bindings)
+      end
+
+      def register_help_bindings_new(_reader_controller)
+        bindings = { __default__: :exit_help }
+        @dispatcher.register_mode(:help, bindings)
+      end
+
+      def register_library_bindings_new(_reader_controller)
+        # Keys are registered in MainMenu#register_library_bindings; this hook ensures mode exists
+        # No-op here as dispatcher registration happens in MainMenu.
+      end
+
+      def register_annotation_editor_bindings_new(_reader_controller)
+        bindings = {}
+
+        cancel_cmd = Shoko::Application::Commands::AnnotationEditorCommandFactory.cancel
+        save_cmd   = Shoko::Application::Commands::AnnotationEditorCommandFactory.save
+        back_cmd   = Shoko::Application::Commands::AnnotationEditorCommandFactory.backspace
+        enter_cmd  = Shoko::Application::Commands::AnnotationEditorCommandFactory.enter
+        insert_cmd = Shoko::Application::Commands::AnnotationEditorCommandFactory.insert_char
+
+        # Cancel editor
+        bindings["\e"] = cancel_cmd
+
+        # Save: Ctrl+S and 'S'
+        bindings["\x13"] = save_cmd
+        bindings['S'] = save_cmd
+
+        # Backspace (both variants)
+        bindings["\x7F"] = back_cmd
+        bindings["\b"]   = back_cmd
+
+        # Enter (CR and LF)
+        confirm_keys = Adapters::Input::KeyDefinitions::ACTIONS[:confirm]
+        confirm_keys.each { |k| bindings[k] = enter_cmd }
+
+        # Default: insert printable characters
+        bindings[:__default__] = insert_cmd
+
+        @dispatcher.register_mode(:annotation_editor, bindings)
+      end
+
+      public
+
+      # Switch active bindings according to mode
+      def activate_for_mode(mode)
+        return unless @dispatcher
+
+        @modal_mode_stack.clear
+        case mode
+        when :annotation_editor
+          @dispatcher.activate(:annotation_editor)
+        when :help
+          @dispatcher.activate(:help)
+        else
+          @dispatcher.activate_stack([:read])
+        end
+      end
+
+      def enter_modal_mode(mode)
+        return unless @dispatcher
+
+        current_stack = @dispatcher.mode_stack
+        return if current_stack.last == mode
+
+        @modal_mode_stack << current_stack
+        new_stack = current_stack.empty? ? [mode] : current_stack + [mode]
+        @dispatcher.activate_stack(new_stack)
+      end
+
+      def exit_modal_mode(_mode)
+        return unless @dispatcher
+
+        previous_stack = @modal_mode_stack.pop
+        if previous_stack&.any?
+          @dispatcher.activate_stack(previous_stack)
+        else
+          activate_for_mode(@state.get(%i[reader mode]) || :read)
+        end
+      end
+
+      # Removed reader annotations list bindings; annotations are managed via the sidebar
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Input
+    # Centralized key definitions to eliminate duplication and inconsistencies
+    # across the codebase. All input handling should reference these definitions.
+    module KeyDefinitions
+      # Navigation keys
+      NAVIGATION = {
+        up: ['k', "\e[A", "\eOA"].freeze,
+        down: ['j', "\e[B", "\eOB"].freeze,
+        left: ['h', "\e[D", "\eOD"].freeze,
+        right: ['l', "\e[C", "\eOC"].freeze,
+      }.freeze
+
+      # Action keys
+      ACTIONS = {
+        confirm: ["\r", "\n"].freeze,
+        cancel: ["\e", "\x1B"].freeze,
+        quit: ['q'].freeze,
+        force_quit: ['Q'].freeze,
+        space: [' '].freeze,
+        backspace: ['\b', "\x7F", "\x08"].freeze,
+        delete: ["\e[3~"].freeze,
+      }.freeze
+
+      # Reader-specific keys
+      READER = {
+        next_page: ['l', ' ', "\e[C", "\eOC"].freeze,
+        prev_page: ['h', "\e[D", "\eOD"].freeze,
+        scroll_down: ['j', "\e[B", "\eOB"].freeze,
+        scroll_up: ['k', "\e[A", "\eOA"].freeze,
+        next_chapter: %w[n N].freeze,
+        prev_chapter: ['p'].freeze,
+        go_to_start: ['g'].freeze,
+        go_to_end: ['G'].freeze,
+        toggle_view: %w[v V].freeze,
+        toggle_page_mode: ['P'].freeze,
+        increase_spacing: ['+'].freeze,
+        decrease_spacing: ['-'].freeze,
+        show_toc: %w[t T].freeze,
+        add_bookmark: ['b'].freeze,
+        show_bookmarks: ['B'].freeze,
+        show_annotations_tab: ['A'].freeze,
+        show_help: ['?'].freeze,
+        show_annotations: ["\u0001"].freeze,
+        rebuild_pagination: ['R'].freeze,
+        invalidate_pagination: ['I'].freeze,
+      }.freeze
+
+      # Menu navigation keys
+      MENU = {
+        browse: ['f'].freeze,
+        download_books: ['d'].freeze,
+        settings: ['s'].freeze,
+        search: ['S'].freeze,
+        refresh_scan: ['r'].freeze,
+      }.freeze
+
+      # Utility methods for checking key membership
+      module Helpers
+        def self.navigation_key?(key)
+          NAVIGATION.values.flatten.include?(key)
+        end
+
+        def self.up_key?(key)
+          NAVIGATION[:up].include?(key)
+        end
+
+        def self.down_key?(key)
+          NAVIGATION[:down].include?(key)
+        end
+
+        def self.confirm_key?(key)
+          ACTIONS[:confirm].include?(key)
+        end
+
+        def self.cancel_key?(key)
+          ACTIONS[:cancel].include?(key)
+        end
+
+        def self.quit_key?(key)
+          ACTIONS[:quit].include?(key)
+        end
+
+        def self.backspace_key?(key)
+          ACTIONS[:backspace].include?(key)
+        end
+
+        def self.escape_key?(key)
+          ACTIONS[:cancel].include?(key)
+        end
+
+        # Check if key matches any keys in a definition
+        def self.matches_keys?(key, key_list)
+          key_list.include?(key)
+        end
+
+        # Create binding hash from key list and command
+        def self.create_bindings(key_list, command)
+          key_list.each_with_object({}) do |k, bindings|
+            bindings[k] = command
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/validators/file_path_validator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/validator.rb'
+require_relative '../../storage/epub_cache.rb'
+
+module Shoko
+  module Adapters::Input::Validators
+    # Validates file paths for EPUB files.
+    # Ensures paths exist, are readable, and have correct extension.
+    #
+    # @example
+    #   validator = FilePathValidator.new
+    #   if validator.validate?("/path/to/book.epub")
+    #     # Path is valid
+    #   else
+    #     puts validator.errors
+    #   end
+    class FilePathValidator < Core::Validator
+      # Validate a file path
+      #
+      # @param path [String] File path to validate
+      # @return [Boolean] Validation result
+      def validate?(path)
+        clear_errors
+
+        presence_valid?(path, :path) &&
+          exists?(path) &&
+          readable?(path) &&
+          extension_valid?(path) &&
+          not_empty?(path)
+      end
+
+      private
+
+      # Check if file exists
+      #
+      # @param path [String] File path
+      # @return [Boolean] true if exists
+      def exists?(path)
+        return true if File.exist?(path)
+
+        add_error(:path, "file does not exist: #{path}")
+        false
+      end
+
+      # Check if file is readable
+      #
+      # @param path [String] File path
+      # @return [Boolean] true if readable
+      def readable?(path)
+        return true if File.readable?(path)
+
+        add_error(:path, "file is not readable: #{path}")
+        false
+      end
+
+      # Check if file has EPUB extension
+      #
+      # @param path [String] File path
+      # @return [Boolean] true if EPUB
+      def extension_valid?(path)
+        return true if path.downcase.end_with?('.epub')
+        return true if Shoko::Adapters::Storage::EpubCache.cache_file?(path)
+
+        add_error(:path, 'file must have .epub or .cache extension')
+        false
+      end
+
+      # Check if file is not empty
+      #
+      # @param path [String] File path
+      # @return [Boolean] true if not empty
+      def not_empty?(path)
+        return true if File.size(path).positive?
+
+        add_error(:path, 'file is empty')
+        false
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/validators/terminal_size_validator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/validator.rb'
+
+module Shoko
+  module Adapters::Input::Validators
+    # Validates terminal dimensions for proper display.
+    # Ensures terminal is large enough for the reader interface.
+    class TerminalSizeValidator < Core::Validator
+      # Minimum terminal dimensions
+      MIN_WIDTH = Adapters::Output::Ui::Constants::UI::MIN_WIDTH
+      MIN_HEIGHT = Adapters::Output::Ui::Constants::UI::MIN_HEIGHT
+
+      # Recommended terminal dimensions for optimal experience
+      RECOMMENDED_WIDTH = 80
+      RECOMMENDED_HEIGHT = 24
+
+      # Validate terminal size
+      #
+      # @param width [Integer] Terminal width
+      # @param height [Integer] Terminal height
+      # @return [Boolean] Validation result
+      def validate?(width, height)
+        clear_errors
+
+        validate_minimum_width?(width) &
+          validate_minimum_height?(height)
+      end
+
+      # Check if terminal meets recommended size
+      #
+      # @param width [Integer] Terminal width
+      # @param height [Integer] Terminal height
+      # @return [Boolean] true if recommended size or larger
+      def recommended_size?(width, height)
+        width >= RECOMMENDED_WIDTH && height >= RECOMMENDED_HEIGHT
+      end
+
+      # Get size recommendations
+      #
+      # @param width [Integer] Current width
+      # @param height [Integer] Current height
+      # @return [Hash] Recommendations
+      def recommendations(width, height)
+        {
+          current: { width:, height: },
+          minimum: { width: MIN_WIDTH, height: MIN_HEIGHT },
+          recommended: { width: RECOMMENDED_WIDTH, height: RECOMMENDED_HEIGHT },
+          needs_resize: !recommended_size?(width, height),
+        }
+      end
+
+      private
+
+      def validate_minimum_width?(width)
+        context = RangeValidationContext.new(
+          width,
+          MIN_WIDTH..Float::INFINITY,
+          :width,
+          "Terminal width must be at least #{MIN_WIDTH} columns"
+        )
+        range_valid?(context)
+      end
+
+      def validate_minimum_height?(height)
+        context = RangeValidationContext.new(
+          height,
+          MIN_HEIGHT..Float::INFINITY,
+          :height,
+          "Terminal height must be at least #{MIN_HEIGHT} rows"
+        )
+        range_valid?(context)
+      end
+    end
+  end
+end

data/lib/shoko/adapters/monitoring/logger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module Shoko
+  module Adapters::Monitoring
+    # Centralized logging system for the Shoko application.
+    # Provides structured logging with different severity levels and
+    # contextual information for debugging and monitoring.
+    #
+    # @example Basic usage
+    #   Logger.info("Application started")
+    #   Logger.error("Failed to parse EPUB", error: e, path: epub_path)
+    #
+    # @example With context
+    #   Logger.with_context(user_id: 123) do
+    #     Logger.info("Opening book", book_id: 456)
+    #   end
+    class Logger
+      LEVELS = {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        fatal: 4,
+      }.freeze
+
+      class << self
+        # Current logging level (default: info)
+        attr_accessor :level
+
+        # Output destination (default: STDERR)
+        attr_accessor :output
+
+        # Thread-local context storage
+        def context
+          Thread.current[:logger_context] ||= {}
+        end
+
+        # Add context for a block of code
+        #
+        # @param ctx [Hash] Context to add
+        # @yield Block to execute with added context
+        def with_context(ctx)
+          old_context = context.dup
+          context.merge!(ctx)
+          yield
+        ensure
+          Thread.current[:logger_context] = old_context
+        end
+
+        # Log at debug level
+        #
+        # @param message [String] Log message
+        # @param metadata [Hash] Additional metadata
+        def debug(message, **metadata)
+          log(:debug, message, metadata)
+        end
+
+        # Log at info level
+        #
+        # @param message [String] Log message
+        # @param metadata [Hash] Additional metadata
+        def info(message, **metadata)
+          log(:info, message, metadata)
+        end
+
+        # Log at warn level
+        #
+        # @param message [String] Log message
+        # @param metadata [Hash] Additional metadata
+        def warn(message, **metadata)
+          log(:warn, message, metadata)
+        end
+
+        # Log at error level
+        #
+        # @param message [String] Log message
+        # @param metadata [Hash] Additional metadata
+        def error(message, **metadata)
+          log(:error, message, metadata)
+        end
+
+        # Log at fatal level
+        #
+        # @param message [String] Log message
+        # @param metadata [Hash] Additional metadata
+        def fatal(message, **metadata)
+          log(:fatal, message, metadata)
+        end
+
+        private
+
+        def log(severity, message, metadata)
+          return if LEVELS[severity] < LEVELS[@level || :info]
+
+          entry = build_log_entry(severity, message, metadata)
+          (@output || $stderr).puts(entry)
+        rescue StandardError
+          # Logging should never crash the application
+        end
+
+        def build_log_entry(severity, message, metadata)
+          {
+            timestamp: Time.now.iso8601,
+            severity: severity.upcase,
+            message: normalize_string(message),
+            context: sanitize_payload(context),
+            metadata: sanitize_payload(metadata),
+            thread_id: Thread.current.object_id,
+          }.to_json
+        end
+
+        def sanitize_payload(value)
+          case value
+          when String
+            normalize_string(value)
+          when Hash
+            value.each_with_object({}) do |(key, val), acc|
+              safe_key = key.is_a?(String) ? normalize_string(key) : key
+              acc[safe_key] = sanitize_payload(val)
+            end
+          when Array
+            value.map { |item| sanitize_payload(item) }
+          else
+            value
+          end
+        end
+
+        def normalize_string(value)
+          str = value.to_s
+          return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
+
+          str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '?')
+        rescue StandardError
+          value.to_s
+        end
+
+        # Clear logger state (used in tests)
+        def clear
+          @output = nil
+          @level = nil
+          Thread.current[:logger_context] = {}
+        end
+        public :clear
+      end
+    end
+  end
+end