shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/input/controllers/menu/intent_executor_bridge.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/ports/outbound/menu_intent_executor'
+require_relative '../../../../core/ports/inbound/menu_intent_handler'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          # Adapter-owned execution bridge for menu intent dispatch.
+          class IntentExecutorBridge
+            include Shoko::Core::Ports::Outbound::MenuIntentExecutor
+
+            INTENT_DISPATCH = {
+              annotation_editor_backspace: :annotation_editor_backspace,
+              annotation_editor_cancel: :annotation_editor_cancel,
+              annotation_editor_enter: :annotation_editor_enter,
+              annotation_editor_insert_char: :annotation_editor_insert_char,
+              annotation_editor_move_down: :annotation_editor_move_down,
+              annotation_editor_move_left: :annotation_editor_move_left,
+              annotation_editor_move_right: :annotation_editor_move_right,
+              annotation_editor_move_up: :annotation_editor_move_up,
+              annotation_editor_save: :annotation_editor_save,
+              annotations_down: :annotations_down,
+              annotations_select: :annotations_select,
+              annotations_up: :annotations_up,
+              browse_down: :browse_down,
+              browse_up: :browse_up,
+              delete_selected_annotation: :delete_selected_annotation,
+              dictionary_back: :dictionary_back,
+              dictionary_down: :dictionary_down,
+              dictionary_exit_search: :dictionary_exit_search,
+              dictionary_refresh: :dictionary_refresh,
+              dictionary_search_backspace: :dictionary_search_backspace,
+              dictionary_search_delete: :dictionary_search_delete,
+              dictionary_search_insert_char: :dictionary_search_insert_char,
+              dictionary_select: :dictionary_select,
+              dictionary_start_search: :dictionary_start_search,
+              dictionary_submit_search: :dictionary_submit_search,
+              dictionary_up: :dictionary_up,
+              download_confirm: :download_confirm,
+              download_down: :download_down,
+              download_exit_search: :download_exit_search,
+              download_next_page: :download_next_page,
+              download_prev_page: :download_prev_page,
+              download_refresh: :download_refresh,
+              download_search_backspace: :download_search_backspace,
+              download_search_delete: :download_search_delete,
+              download_search_insert_char: :download_search_insert_char,
+              download_start_search: :download_start_search,
+              download_submit_search: :download_submit_search,
+              download_up: :download_up,
+              library_down: :library_down,
+              library_select: :library_select,
+              library_toggle_details: :library_toggle_details,
+              library_up: :library_up,
+              menu_back_to_root: :menu_back_to_root,
+              menu_nav_down: :menu_nav_down,
+              menu_nav_up: :menu_nav_up,
+              menu_quit: :menu_quit,
+              menu_select: :menu_select,
+              open_selected_annotation: :open_selected_annotation,
+              open_selected_annotation_for_edit: :open_selected_annotation_for_edit,
+              open_selected_book: :open_selected_book,
+              search_backspace: :search_backspace,
+              search_delete: :search_delete,
+              search_insert_char: :search_insert_char,
+              settings_down: :settings_down,
+              settings_select: :settings_select,
+              settings_up: :settings_up,
+              switch_to_annotations_mode: :switch_to_annotations_mode,
+              switch_to_browse: :switch_to_browse,
+              switch_to_search: :switch_to_search
+            }.freeze
+
+            def initialize(menu_controller:)
+              @menu_controller = menu_controller
+              validate_dispatch_contract!
+              validate_controller_methods!
+            end
+
+            def execute(intent_symbol:, payload: nil)
+              key = payload&.key
+              intent = intent_symbol.to_sym
+              method_name = INTENT_DISPATCH[intent]
+              raise ArgumentError, "Unsupported menu intent: #{intent_symbol}" unless method_name
+
+              @menu_controller.public_send(method_name, key)
+            end
+
+            private
+
+            def validate_dispatch_contract!
+              expected = Shoko::Core::Ports::Inbound::MenuIntentHandler::INTENT_SYMBOLS.sort
+              actual = INTENT_DISPATCH.keys.sort
+              return if expected == actual
+
+              missing = expected - actual
+              extra = actual - expected
+              raise ArgumentError, "Menu intent dispatch mismatch missing=#{missing.inspect} extra=#{extra.inspect}"
+            end
+
+            def validate_controller_methods!
+              missing = INTENT_DISPATCH.values.uniq.reject { |method_name| @menu_controller.respond_to?(method_name, true) }
+              return if missing.empty?
+
+              raise ArgumentError, "Menu controller missing dispatch methods: #{missing.join(', ')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/menu_workflow_bridges.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/ports/outbound/menu_workflow_runtime'
+require_relative '../../../../core/ports/outbound/menu_mode_switcher'
+require_relative '../../../../core/ports/outbound/annotation_selection_reader'
+require_relative '../../../../core/ports/outbound/annotation_view_refresher'
+require_relative '../../../../core/ports/outbound/reader_runner'
+require_relative '../../../../core/models/annotation_selection'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          # Adapter bridge for menu workflow UI/runtime operations.
+          class MenuWorkflowRuntimeBridge
+            include Shoko::Core::Ports::Outbound::MenuWorkflowRuntime
+
+            def initialize(menu:, catalog:)
+              @menu = menu
+              @catalog = catalog
+            end
+
+            def draw_screen
+              @menu.draw_screen
+            end
+
+            def refresh_scan(force:)
+              @catalog.start_scan(force: force)
+            end
+          end
+
+          # Adapter bridge for mode switching used by annotation workflows.
+          class MenuModeSwitcherBridge
+            include Shoko::Core::Ports::Outbound::MenuModeSwitcher
+
+            def initialize(menu:)
+              @menu = menu
+            end
+
+            def switch_mode(mode)
+              @menu.switch_to_mode(mode)
+            end
+          end
+
+          # Adapter bridge for reading selected annotation context.
+          class AnnotationSelectionBridge
+            include Shoko::Core::Ports::Outbound::AnnotationSelectionReader
+
+            def initialize(menu:, logger: nil)
+              @menu = menu
+              @logger = logger
+            end
+
+            def selected_annotation
+              selection = @menu.selected_annotation_for_workflow
+              return nil if selection.nil?
+              unless selection.is_a?(Hash)
+                raise ArgumentError, "selected_annotation_for_workflow must return Hash, got #{selection.class}"
+              end
+
+              annotation = selection[:annotation]
+              book_path = selection[:book_path]
+              return nil unless annotation && book_path
+
+              Shoko::Core::Models::AnnotationSelection.from_h(annotation: annotation, book_path: book_path)
+            end
+          end
+
+          # Adapter bridge for refreshing annotation view after mutations.
+          class AnnotationViewRefreshBridge
+            include Shoko::Core::Ports::Outbound::AnnotationViewRefresher
+
+            def initialize(menu:, logger: nil)
+              @menu = menu
+              @logger = logger
+            end
+
+            def refresh_annotations_view
+              @menu.refresh_annotations_view_for_workflow
+            end
+          end
+
+          # Adapter bridge for launching reader by book path.
+          class ReaderRunnerBridge
+            include Shoko::Core::Ports::Outbound::ReaderRunner
+
+            def initialize(menu:)
+              @menu = menu
+            end
+
+            def run_reader(path)
+              @menu.state_controller.run_reader(path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/reader_launch_bridges.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/ports/outbound/menu_reader_runtime'
+require_relative '../../../../core/ports/outbound/menu_book_selection'
+require_relative '../../../../core/ports/outbound/menu_progress_presenters'
+require_relative '../../../../core/models/menu_book'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          # Adapter bridge for menu-driven reader runtime operations.
+          class ReaderLaunchRuntimeBridge
+            include Shoko::Core::Ports::Outbound::MenuReaderRuntime
+
+            def initialize(menu:, reader_controller_builder:)
+              @menu = menu
+              @reader_controller_builder = reader_controller_builder
+            end
+
+            def run_reader(path:, preloaded_document:, background_worker:)
+              @reader_controller_builder.call(
+                path,
+                preloaded_document: preloaded_document,
+                background_worker: background_worker
+              ).run
+            end
+
+            def draw_screen
+              @menu.draw_screen
+            end
+
+            def switch_mode(mode)
+              @menu.switch_to_mode(mode)
+            end
+          end
+
+          # Adapter bridge for selected/filtered menu books.
+          class ReaderLaunchBookSelectionBridge
+            include Shoko::Core::Ports::Outbound::MenuBookSelection
+
+            def initialize(menu:, logger: nil)
+              @menu = menu
+              @logger = logger
+            end
+
+            def selected_book
+              raw = @menu.selected_book_for_reader_launch
+              return nil if raw.nil?
+
+              Shoko::Core::Models::MenuBook.from_h(raw)
+            end
+
+            def filtered_books
+              Array(@menu.filtered_epubs).map do |entry|
+                Shoko::Core::Models::MenuBook.from_h(entry)
+              end
+            end
+          end
+
+          # Adapter bridge for progress presenter construction.
+          class ReaderLaunchProgressPresenters
+            include Shoko::Core::Ports::Outbound::MenuProgressPresenters
+
+            def initialize(presenter_builder:)
+              @presenter_builder = presenter_builder
+            end
+
+            def build
+              @presenter_builder.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/state_controller.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          # Coordinates menu workflows via precomposed collaborators.
+          class StateController
+            Dependencies = Data.define(
+              :menu_state_reader,
+              :menu_state_writer,
+              :reader_launch_service,
+              :download_workflow,
+              :dictionary_workflow,
+              :annotation_workflow,
+              :catalog,
+              :logger
+            ) do
+              REQUIRED_FIELDS = %i[
+                menu_state_reader
+                menu_state_writer
+                reader_launch_service
+                download_workflow
+                dictionary_workflow
+                annotation_workflow
+                catalog
+              ].freeze
+
+              def validate!
+                values = to_h
+                missing = REQUIRED_FIELDS.select { |field| values[field].nil? }
+                return self if missing.empty?
+
+                raise ArgumentError, "Missing required menu state controller dependencies: #{missing.join(', ')}"
+              end
+            end
+
+            def initialize(menu:, deps:)
+              raise ArgumentError, 'menu is required' if menu.nil?
+              raise ArgumentError, 'deps is required' if deps.nil?
+
+              dependencies = deps.validate!
+              @menu = menu
+              @menu_state_reader = dependencies.menu_state_reader
+              @menu_state_writer = dependencies.menu_state_writer
+              @reader_launch_service = dependencies.reader_launch_service
+              @download_workflow = dependencies.download_workflow
+              @dictionary_workflow = dependencies.dictionary_workflow
+              @annotation_workflow = dependencies.annotation_workflow
+              @catalog = dependencies.catalog
+              @logger = dependencies.logger
+            end
+
+            def open_selected_book
+              @reader_launch_service.open_selected_book
+            end
+
+            def open_book(path)
+              @reader_launch_service.open_book(path)
+            end
+
+            def run_reader(path)
+              @reader_launch_service.run_reader(path)
+            end
+
+            def load_and_open_with_progress(path)
+              @reader_launch_service.load_and_open_with_progress(path)
+            end
+
+            def file_not_found
+              @reader_launch_service.file_not_found
+            end
+
+            def handle_reader_error(path, error)
+              @reader_launch_service.handle_reader_error(path, error)
+            end
+
+            def valid_cache_path?(path)
+              @reader_launch_service.valid_cache_path?(path)
+            end
+
+            def refresh_scan(force: false)
+              @catalog.start_scan(force: force)
+            end
+
+            def search_downloads(query:, page_url: nil)
+              @download_workflow.search_downloads(query: query, page_url: page_url)
+            end
+
+            def download_book(book)
+              @download_workflow.download_book(book)
+            end
+
+            def fetch_dictionary_catalog
+              @dictionary_workflow.fetch_dictionary_catalog
+            end
+
+            def download_dictionary(entry)
+              @dictionary_workflow.download_dictionary(entry)
+            end
+
+            def open_selected_annotation
+              @annotation_workflow.open_selected_annotation
+            end
+
+            def open_selected_annotation_for_edit
+              @annotation_workflow.open_selected_annotation_for_edit
+            end
+
+            def delete_selected_annotation
+              @annotation_workflow.delete_selected_annotation
+            end
+
+            def save_current_annotation_edit
+              @annotation_workflow.save_current_annotation_edit
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/mouseable_reader.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require_relative 'reader_controller'
+require_relative 'sidebar_mouse_handler'
+require_relative 'selection_mouse_handler'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        # A Reader that supports mouse interactions for annotations.
+        class MouseableReader < ReaderController
+          include SidebarMouseHandler
+          include SelectionMouseHandler
+
+          def initialize(epub_path, deps:, mouse_handler:, render_state_writer: nil, runtime_components_factory:)
+            super(
+              epub_path,
+              deps: deps,
+              runtime_components_factory: runtime_components_factory
+            )
+
+            @coordinate_service = @coordinate_service_ref
+            @popup_position_service = @popup_position_service_ref
+            @render_state_writer = render_state_writer
+            @mouse_handler = mouse_handler
+            @selection_service = @selection_service_ref
+            @rendered_content_reader = deps.rendered_content_reader
+            @render_registry = @render_registry_ref
+            @clipboard_service = deps.clipboard_service
+            @dictionary_availability = deps.dictionary_availability
+            @ui_component_factory = deps.ui_component_factory
+            raise ArgumentError, 'render_state_writer is required' if @render_state_writer.nil?
+            raise ArgumentError, 'annotation_service is required' if @annotation_service_ref.nil?
+            @mouse_input_buffer = nil
+            @sidebar_scroll_drag_active = false
+            @state_writer.update_reader(popup_menu: nil)
+            @selected_text = nil
+            @state_writer.clear_selection
+            clear_rendered_lines_on_init
+            refresh_annotations
+          end
+
+          def run
+            terminal_service.enable_mouse
+            # Clear any stale input from the terminal buffer to prevent
+            # spurious keys (like 'q') from immediately triggering actions
+            drain_input_buffer
+            super
+          ensure
+            terminal_service.disable_mouse
+          end
+
+          # Drain any pending input from the terminal buffer
+          # This prevents stale keypresses from being processed as commands
+          def drain_input_buffer
+            drained = 0
+            while terminal_service.read_key
+              drained += 1
+              break if drained > 20 # Safety limit
+            end
+          end
+
+          def read_input_keys(timeout: nil)
+            key = terminal_service.read_input_with_mouse(timeout: timeout)
+            return [] unless key
+
+            keys = [key]
+            while (extra = terminal_service.read_key)
+              keys << extra
+              break if keys.size > 10
+            end
+
+            filter_mouse_sequences(keys)
+          end
+
+          # Clear any active text selection and hide popup
+          def clear_selection!
+            @state_writer.update_reader(popup_menu: nil)
+            @mouse_handler&.reset
+            @state_writer.clear_selection
+          end
+
+          private
+
+          def filter_mouse_sequences(keys)
+            ctx = { remaining: [], saw_mouse: false, saw_prefix: false }
+            keys.each { |token| process_mouse_token(token, ctx) }
+            ctx[:remaining]
+          end
+
+          def process_mouse_token(token, ctx)
+            if @mouse_input_buffer
+              process_buffered_token(token, ctx)
+            else
+              process_unbuffered_token(token, ctx)
+            end
+          end
+
+          def process_buffered_token(token, ctx)
+            @mouse_input_buffer << token
+
+            if @mouse_handler.mouse_sequence?(@mouse_input_buffer)
+              handle_mouse_input(@mouse_input_buffer)
+              @mouse_input_buffer = nil
+              ctx[:saw_mouse] = true
+            elsif @mouse_handler.mouse_prefix?(@mouse_input_buffer)
+              ctx[:saw_prefix] = true
+            else
+              # Discard stale prefix noise and reprocess the latest token normally
+              # so user commands like 'q' are never trapped in an invalid buffer.
+              @mouse_input_buffer = nil
+              process_unbuffered_token(token, ctx)
+            end
+          end
+
+          def process_unbuffered_token(token, ctx)
+            if @mouse_handler.mouse_sequence?(token)
+              handle_mouse_input(token)
+              ctx[:saw_mouse] = true
+            elsif @mouse_handler.mouse_prefix?(token)
+              @mouse_input_buffer = String(token)
+              ctx[:saw_prefix] = true
+            elsif spurious_post_mouse_key?(token, ctx)
+              # Skip spurious keys after mouse events
+            else
+              ctx[:remaining] << token
+            end
+          end
+
+          def spurious_post_mouse_key?(token, ctx)
+            # Keep explicit quit behavior deterministic: never drop 'q' here.
+            # Only ignore a stray Escape that can be emitted alongside mouse prefixes.
+            (ctx[:saw_mouse] || ctx[:saw_prefix]) && token == "\e"
+          end
+
+          def handle_mouse_input(input)
+            event = @mouse_handler.parse_mouse_event(input)
+            return unless event
+
+            return if handle_overlay_click(event)
+            return if handle_sidebar_mouse(event)
+
+            handle_content_mouse_event(event)
+          end
+
+          def handle_overlay_click(event)
+            if popup_menu_active?
+              if event[:released]
+                if consume_suppressed_popup_release?
+                  # Consume the release event that follows context-click open.
+                else
+                  handle_popup_click(event)
+                end
+              else
+                handle_popup_hover(event)
+              end
+              return true
+            end
+
+            return true if handle_popup_context_click(event)
+            return false unless event[:released]
+
+            if annotation_editor_visible?
+              handle_annotation_editor_click(event)
+              return true
+            end
+
+            # Block all mouse events when dictionary popup is open
+            return true if dictionary_popup_visible? || in_book_search_popup_visible?
+
+            false
+          end
+
+          def consume_suppressed_popup_release?
+            return false unless @suppress_popup_release_once
+
+            @suppress_popup_release_once = false
+            true
+          end
+
+          def dictionary_popup_visible?
+            controller = ui_controller
+            controller.dictionary_visible?
+          end
+
+          def annotation_editor_visible?
+            controller = ui_controller
+            controller.annotation_editor_visible?
+          end
+
+          def in_book_search_popup_visible?
+            controller = ui_controller
+            controller.in_book_search_visible?
+          end
+
+          def popup_menu_active?
+            popup = @reader_state_reader.popup_menu
+            popup&.visible
+          end
+
+          def handle_content_mouse_event(event)
+            # Block all content mouse events when dictionary popup is open
+            return if dictionary_popup_visible? || in_book_search_popup_visible?
+
+            result = @mouse_handler.handle_event(event)
+            return unless result
+
+            case result[:type]
+            when :selection_drag
+              update_state_selection(@mouse_handler.selection_range)
+              refresh_highlighting
+            when :selection_end
+              handle_selection_end
+              draw_screen
+            else
+              draw_screen
+            end
+          end
+
+          def handle_annotation_editor_click(event)
+            coords = @coordinate_service.mouse_to_terminal(event[:x], event[:y])
+            controller = ui_controller
+            result = controller.handle_annotation_editor_overlay_click(coords[:x], coords[:y])
+            controller.handle_annotation_editor_overlay_event(result) if result
+            @mouse_handler.reset
+          ensure
+            draw_screen
+          end
+
+          def refresh_annotations
+            annotations = @annotation_service_ref.list_for_book(path)
+            @state_writer.update_reader(annotations: annotations)
+          end
+
+          def clear_rendered_lines_on_init
+            @render_state_writer.clear_rendered_lines
+          end
+        end
+      end
+    end
+  end
+end