shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/sessions/annotation_overlay_ui_session_adapter.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require_relative '../../../shared/contracts/session_outcome'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Sessions
+        # Adapter-owned lifecycle for annotations/editor overlays.
+        class AnnotationOverlayUiSessionAdapter
+          RESCUABLE_ERRORS = [ArgumentError, TypeError, RuntimeError].freeze
+
+          def initialize(reader_state_reader:, state_writer:, ui_component_factory:, logger: nil)
+            @reader_state_reader = reader_state_reader
+            @state_writer = state_writer
+            @ui_component_factory = ui_component_factory
+            @logger = logger
+          end
+
+          def annotations_visible?
+            overlay = annotations_overlay
+            overlay && overlay.visible?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.annotations_visible?', e)
+            false
+          end
+
+          def annotation_editor_visible?
+            overlay = annotation_editor_overlay
+            overlay && overlay.visible?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.annotation_editor_visible?', e)
+            false
+          end
+
+          def toggle_annotations
+            annotations_visible? ? close_annotations : open_annotations
+          end
+
+          def open_annotations
+            overlay = @ui_component_factory.annotations_overlay(@reader_state_reader)
+            return failure_outcome(:error, :annotations_overlay_unavailable, 'Annotations overlay component unavailable') unless overlay
+
+            @state_writer.update_reader(annotations_overlay: overlay)
+            success_outcome(:opened, :annotations_overlay_opened)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.open_annotations', e)
+            failure_outcome(:error, :annotations_overlay_open_failed, e.message)
+          end
+
+          def close_annotations
+            overlay = annotations_overlay
+            overlay.hide if overlay
+            @state_writer.update_reader(annotations_overlay: nil)
+            success_outcome(:closed, :annotations_overlay_closed)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.close_annotations', e)
+            failure_outcome(:error, :annotations_overlay_close_failed, e.message)
+          end
+
+          def annotations_up
+            invoke_annotations_action(:annotations_up, :scroll_up)
+          end
+
+          def annotations_down
+            invoke_annotations_action(:annotations_down, :scroll_down)
+          end
+
+          def annotations_open
+            annotation = current_annotation
+            return failure_outcome(:ignored, :annotations_open_unavailable, 'No annotation selected') unless annotation
+
+            success_outcome(:handled, :annotations_open_handled, payload: { type: :open, annotation: annotation })
+          end
+
+          def annotations_edit
+            annotation = current_annotation
+            return failure_outcome(:ignored, :annotations_edit_unavailable, 'No annotation selected') unless annotation
+
+            success_outcome(:handled, :annotations_edit_handled, payload: { type: :edit, annotation: annotation })
+          end
+
+          def annotations_delete
+            annotation = current_annotation
+            return failure_outcome(:ignored, :annotations_delete_unavailable, 'No annotation selected') unless annotation
+
+            success_outcome(:handled, :annotations_delete_handled, payload: { type: :delete, annotation: annotation })
+          end
+
+          def annotations_cancel
+            success_outcome(:handled, :annotations_cancel_handled, payload: { type: :close })
+          end
+
+          def set_annotations_selected_index(index)
+            overlay = annotations_overlay
+            return failure_outcome(:ignored, :annotations_selection_unavailable, 'Annotations overlay selection is unavailable') unless overlay
+
+            overlay.selected_index = index
+            success_outcome(:handled, :annotations_selection_updated)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.set_annotations_selected_index', e)
+            failure_outcome(:error, :annotations_selection_update_failed, e.message)
+          end
+
+          def open_editor(text:, range:, chapter_index:, annotation: nil)
+            overlay = @ui_component_factory.annotation_editor_overlay(
+              selected_text: text,
+              range: range,
+              chapter_index: chapter_index,
+              annotation: annotation
+            )
+            return failure_outcome(:error, :annotation_editor_unavailable, 'Annotation editor overlay unavailable') unless overlay
+
+            @state_writer.update_reader(annotation_editor_overlay: overlay)
+            success_outcome(:opened, :annotation_editor_opened)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.open_editor', e)
+            failure_outcome(:error, :annotation_editor_open_failed, e.message)
+          end
+
+          def close_editor
+            overlay = annotation_editor_overlay
+            overlay.hide if overlay
+            @state_writer.update_reader(annotation_editor_overlay: nil)
+            success_outcome(:closed, :annotation_editor_closed)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.close_editor', e)
+            failure_outcome(:error, :annotation_editor_close_failed, e.message)
+          end
+
+          def editor_insert_char(char)
+            invoke_editor_action(:editor_insert_char, :handle_character, char.to_s)
+          end
+
+          def editor_backspace
+            invoke_editor_action(:editor_backspace, :handle_backspace)
+          end
+
+          def editor_enter
+            invoke_editor_action(:editor_enter, :handle_enter)
+          end
+
+          def editor_move_left
+            invoke_editor_action(:editor_move_left, :handle_move_left)
+          end
+
+          def editor_move_right
+            invoke_editor_action(:editor_move_right, :handle_move_right)
+          end
+
+          def editor_move_up
+            invoke_editor_action(:editor_move_up, :handle_move_up)
+          end
+
+          def editor_move_down
+            invoke_editor_action(:editor_move_down, :handle_move_down)
+          end
+
+          def editor_cancel
+            success_outcome(:handled, :annotation_editor_cancelled, payload: { type: :cancel })
+          end
+
+          def editor_save
+            invoke_editor_action(:editor_save, :handle_save)
+          end
+
+          def handle_editor_click(col, row)
+            invoke_editor_action(:editor_click, :handle_click, col, row)
+          end
+
+          def editor_context
+            overlay = annotation_editor_overlay
+            return nil unless overlay
+
+            {
+              annotation_id: overlay.annotation_id,
+              selected_text: overlay.selected_text,
+              note: overlay.note,
+              selection_range: overlay.selection_range,
+              chapter_index: overlay.chapter_index,
+            }
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.editor_context', e)
+            nil
+          end
+
+          private
+
+          def annotations_overlay
+            @reader_state_reader.annotations_overlay
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.annotations_overlay', e)
+            nil
+          end
+
+          def annotation_editor_overlay
+            @reader_state_reader.annotation_editor_overlay
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.annotation_editor_overlay', e)
+            nil
+          end
+
+          def current_annotation
+            overlay = annotations_overlay
+            return nil unless overlay
+
+            overlay.current_annotation
+          rescue *RESCUABLE_ERRORS => e
+            log_error('annotation.session.current_annotation', e)
+            nil
+          end
+
+          def invoke_annotations_action(command, method_name)
+            overlay = annotations_overlay
+            return failure_outcome(:ignored, "#{command}_unavailable".to_sym, 'Annotations overlay unavailable') unless overlay
+
+            payload = invoke_annotations_method(overlay, method_name)
+            success_outcome(:handled, "#{command}_handled".to_sym, payload: payload)
+          rescue *RESCUABLE_ERRORS => e
+            log_error("annotation.session.#{command}", e)
+            failure_outcome(:error, "#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_editor_action(command, method_name, *args)
+            overlay = annotation_editor_overlay
+            return failure_outcome(:ignored, "#{command}_unavailable".to_sym, 'Annotation editor overlay unavailable') unless overlay
+
+            payload = invoke_editor_method(overlay, method_name, *args)
+            success_outcome(:handled, "#{command}_handled".to_sym, payload: payload)
+          rescue *RESCUABLE_ERRORS => e
+            log_error("annotation.session.#{command}", e)
+            failure_outcome(:error, "#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_annotations_method(overlay, method_name)
+            case method_name
+            when :scroll_up then overlay.scroll_up
+            when :scroll_down then overlay.scroll_down
+            else
+              raise ArgumentError, "Unsupported annotations overlay method: #{method_name}"
+            end
+          end
+
+          def invoke_editor_method(overlay, method_name, *args)
+            case method_name
+            when :handle_character
+              overlay.handle_character(*args)
+              nil
+            when :handle_backspace
+              overlay.handle_backspace
+              nil
+            when :handle_enter
+              overlay.handle_enter
+              nil
+            when :handle_move_left
+              overlay.handle_move_left
+              nil
+            when :handle_move_right
+              overlay.handle_move_right
+              nil
+            when :handle_move_up
+              overlay.handle_move_up
+              nil
+            when :handle_move_down
+              overlay.handle_move_down
+              nil
+            when :handle_save then overlay.handle_save
+            when :handle_click then overlay.handle_click(*args)
+            else
+              raise ArgumentError, "Unsupported annotation editor overlay method: #{method_name}"
+            end
+          end
+
+          def success_outcome(status, code, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.success(status: status, code: code, payload: payload)
+          end
+
+          def failure_outcome(status, code, message, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.failure(
+              status: status,
+              code: code,
+              message: message,
+              payload: payload
+            )
+          end
+
+          def log_error(event, error)
+            @logger&.error(event, error: error.class.name, message: error.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/sessions/dictionary_ui_session_adapter.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require_relative '../../../shared/contracts/session_outcome'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Sessions
+        # Adapter-owned lifecycle for dictionary panel/popup UI components.
+        class DictionaryUiSessionAdapter
+          RESCUABLE_ERRORS = [ArgumentError, TypeError, RuntimeError].freeze
+
+          def initialize(reader_state_reader:, state_writer:, ui_component_factory:, logger: nil)
+            @reader_state_reader = reader_state_reader
+            @state_writer = state_writer
+            @ui_component_factory = ui_component_factory
+            @logger = logger
+          end
+
+          def show_panel(result)
+            panel = current_panel || @ui_component_factory.dictionary_panel(@reader_state_reader)
+            return failure_outcome(:show_panel, :dictionary_panel_unavailable, 'Dictionary panel component unavailable') unless panel
+
+            popup = current_popup
+            popup.hide if popup
+            panel.show(result)
+            @state_writer.update_reader(
+              dictionary_panel: panel,
+              dictionary_popup: nil,
+              dictionary_visible: true,
+              mode: :dictionary,
+              popup_menu: nil
+            )
+            success_outcome(:shown, :dictionary_panel_shown)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.show_panel', e)
+            failure_outcome(:error, :dictionary_panel_failed, e.message)
+          end
+
+          def show_popup(result)
+            popup = current_popup || @ui_component_factory.dictionary_popup
+            return failure_outcome(:show_popup, :dictionary_popup_unavailable, 'Dictionary popup component unavailable') unless popup
+
+            panel = current_panel
+            panel.hide if panel
+            popup.show(result)
+            @state_writer.update_reader(
+              dictionary_panel: nil,
+              dictionary_popup: popup,
+              dictionary_visible: true,
+              mode: :dictionary,
+              popup_menu: nil
+            )
+            success_outcome(:shown, :dictionary_popup_shown)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.show_popup', e)
+            failure_outcome(:error, :dictionary_popup_failed, e.message)
+          end
+
+          def close
+            panel = current_panel
+            popup = current_popup
+            panel.hide if panel
+            popup.hide if popup
+            @state_writer.update_reader(
+              dictionary_panel: nil,
+              dictionary_popup: nil,
+              dictionary_visible: false,
+              mode: :read
+            )
+            success_outcome(:closed, :dictionary_closed)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.close', e)
+            failure_outcome(:error, :dictionary_close_failed, e.message)
+          end
+
+          def visible?
+            panel_visible? || popup_visible?
+          end
+
+          def panel_visible?
+            component_visible?(current_panel)
+          end
+
+          def popup_visible?
+            component_visible?(current_popup)
+          end
+
+          def active_result
+            panel = current_panel
+            popup = current_popup
+            return panel.result if panel && panel.visible?
+            return popup.result if popup && popup.visible?
+
+            nil
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.active_result', e)
+            nil
+          end
+
+          def active_kind
+            return :panel if panel_visible?
+            return :popup if popup_visible?
+
+            nil
+          end
+
+          def insert_char(char)
+            invoke_active_component(
+              command: :insert_char,
+              method_name: :insert_char,
+              args: [char.to_s],
+              unavailable_code: :dictionary_insert_char_unavailable
+            )
+          end
+
+          def backspace
+            invoke_active_component(
+              command: :backspace,
+              method_name: :backspace,
+              unavailable_code: :dictionary_backspace_unavailable
+            )
+          end
+
+          def confirm
+            invoke_active_component(
+              command: :confirm,
+              method_name: :confirm,
+              unavailable_code: :dictionary_confirm_unavailable
+            )
+          end
+
+          def cancel
+            invoke_active_component(
+              command: :cancel,
+              method_name: :cancel,
+              unavailable_code: :dictionary_cancel_unavailable
+            )
+          end
+
+          def tab
+            invoke_active_component(
+              command: :tab,
+              method_name: :tab,
+              unavailable_code: :dictionary_tab_unavailable
+            )
+          end
+
+          def swap_languages
+            invoke_active_component(
+              command: :swap_languages,
+              method_name: :swap_languages,
+              unavailable_code: :dictionary_swap_languages_unavailable
+            )
+          end
+
+          def scroll_up
+            invoke_scroll(command: :scroll_up, action_method: :scroll_up_action)
+          end
+
+          def scroll_down
+            invoke_scroll(command: :scroll_down, action_method: :scroll_down_action)
+          end
+
+          def setup_mode?
+            popup = current_popup
+            popup && popup.visible? && popup.setup_mode?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.setup_mode?', e)
+            false
+          end
+
+          def fuzzy_mode?
+            component = active_component
+            component && component.fuzzy_mode?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.fuzzy_mode?', e)
+            false
+          end
+
+          def toggle_fuzzy(matches = nil)
+            invoke_active_component(
+              command: :toggle_fuzzy,
+              method_name: :toggle_fuzzy,
+              args: [matches],
+              unavailable_code: :dictionary_toggle_fuzzy_unavailable
+            )
+          end
+
+          def next_entry
+            invoke_active_component(
+              command: :next_entry,
+              method_name: :next_entry,
+              unavailable_code: :dictionary_next_entry_unavailable
+            )
+          end
+
+          def prepare_setup_popup
+            popup = ensure_setup_popup
+            return failure_outcome(:error, :dictionary_setup_popup_unavailable, 'Dictionary setup popup unavailable') unless popup
+
+            success_outcome(:ready, :dictionary_setup_popup_ready)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.prepare_setup_popup', e)
+            failure_outcome(:error, :dictionary_setup_popup_failed, e.message)
+          end
+
+          def show_setup(**kwargs)
+            popup = ensure_setup_popup
+            return failure_outcome(:error, :dictionary_show_setup_unavailable, 'Dictionary setup popup unavailable') unless popup
+
+            popup.show_setup(**kwargs)
+            success_outcome(:handled, :dictionary_show_setup_handled)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.show_setup', e)
+            failure_outcome(:error, :dictionary_show_setup_failed, e.message)
+          end
+
+          def update_setup(**kwargs)
+            popup = ensure_setup_popup
+            return failure_outcome(:error, :dictionary_update_setup_unavailable, 'Dictionary setup popup unavailable') unless popup
+
+            popup.update_setup(**kwargs)
+            success_outcome(:handled, :dictionary_update_setup_handled)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.update_setup', e)
+            failure_outcome(:error, :dictionary_update_setup_failed, e.message)
+          end
+
+          private
+
+          def ensure_setup_popup
+            popup = current_popup || @ui_component_factory.dictionary_popup
+            return nil unless popup
+
+            panel = current_panel
+            panel.hide if panel
+            @state_writer.update_reader(
+              dictionary_panel: nil,
+              dictionary_popup: popup,
+              dictionary_visible: true,
+              mode: :dictionary,
+              popup_menu: nil
+            )
+            popup
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.ensure_setup_popup', e)
+            nil
+          end
+
+          def invoke_active_component(command:, method_name:, args: [], unavailable_code:)
+            component = active_component
+            return failure_outcome(:ignored, unavailable_code, "#{method_name} unavailable for active dictionary component") unless component
+
+            payload = invoke_component_method(component, method_name, *args)
+            success_outcome(:handled, "dictionary_#{command}_handled".to_sym, payload: payload)
+          rescue *RESCUABLE_ERRORS => e
+            log_error("dictionary.session.#{command}", e)
+            failure_outcome(:error, "dictionary_#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_scroll(command:, action_method:)
+            component = active_component
+            return failure_outcome(:ignored, "dictionary_#{command}_unavailable".to_sym, 'No active dictionary component') unless component
+
+            handled = !!invoke_component_method(component, action_method)
+            if handled
+              success_outcome(:handled, "dictionary_#{command}_handled".to_sym, payload: true)
+            else
+              failure_outcome(:ignored, "dictionary_#{command}_ignored".to_sym, 'Dictionary scroll event was not handled', payload: false)
+            end
+          rescue *RESCUABLE_ERRORS => e
+            log_error("dictionary.session.#{command}", e)
+            failure_outcome(:error, "dictionary_#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_component_method(component, method_name, *args)
+            case method_name
+            when :insert_char then component.insert_char(*args)
+            when :backspace then component.backspace
+            when :confirm then component.confirm
+            when :cancel then component.cancel
+            when :tab then component.tab
+            when :swap_languages then component.swap_languages
+            when :toggle_fuzzy then component.toggle_fuzzy(*args)
+            when :next_entry then component.next_entry
+            when :scroll_up_action then component.scroll_up_action
+            when :scroll_down_action then component.scroll_down_action
+            else
+              raise ArgumentError, "Unsupported dictionary component method: #{method_name}"
+            end
+          end
+
+          def active_component
+            return current_panel if panel_visible?
+            return current_popup if popup_visible?
+
+            nil
+          end
+
+          def current_panel
+            @reader_state_reader.dictionary_panel
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.current_panel', e)
+            nil
+          end
+
+          def current_popup
+            @reader_state_reader.dictionary_popup
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.current_popup', e)
+            nil
+          end
+
+          def component_visible?(component)
+            component && component.visible?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('dictionary.session.component_visible?', e)
+            false
+          end
+
+          def success_outcome(status, code, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.success(status: status, code: code, payload: payload)
+          end
+
+          def failure_outcome(status, code, message, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.failure(
+              status: status,
+              code: code,
+              message: message,
+              payload: payload
+            )
+          end
+
+          def log_error(event, error)
+            @logger&.error(event, error: error.class.name, message: error.message)
+          end
+        end
+      end
+    end
+  end
+end