shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/runtime/session_state/menu_state_writer_adapter.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/menu_workflow_state_writer'
+require_relative 'actions/update_menu_action'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing menu workflow state writes.
+        # Dispatches UpdateMenuAction to update menu state.
+        class MenuStateWriterAdapter
+          include Core::Ports::Outbound::MenuWorkflowStateWriter
+
+          def initialize(state)
+            @state = state
+          end
+
+          # Update multiple menu state attributes at once
+          # @param attrs [Hash] Menu attributes to update
+          def update_menu(attrs)
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs))
+          end
+
+          # Update the selected menu item
+          # @param value [Integer] Selected item index
+          def update_selected(value)
+            @state.dispatch(Actions::UpdateMenuAction.new(selected: value))
+          end
+
+          # Update the browse selected item
+          # @param value [Integer] Browse selected index
+          def update_browse_selected(value)
+            @state.dispatch(Actions::UpdateMenuAction.new(browse_selected: value))
+          end
+
+          # Update the menu mode
+          # @param mode [Symbol] Menu mode
+          def update_mode(mode)
+            @state.dispatch(Actions::UpdateMenuAction.new(mode: mode))
+          end
+
+          # Update search state
+          # @param query [String, nil] Search query
+          # @param cursor [Integer, nil] Cursor position
+          # @param active [Boolean, nil] Whether search is active
+          def update_search(query: nil, cursor: nil, active: nil)
+            attrs = {}
+            attrs[:search_query] = query unless query.nil?
+            attrs[:search_cursor] = cursor unless cursor.nil?
+            attrs[:search_active] = active unless active.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Update settings selected item
+          # @param value [Integer] Settings selected index
+          def update_settings_selected(value)
+            @state.dispatch(Actions::UpdateMenuAction.new(settings_selected: value))
+          end
+
+          # Update download state
+          # @param query [String, nil] Download query
+          # @param cursor [Integer, nil] Cursor position
+          # @param selected [Integer, nil] Selected item index
+          # @param status [Symbol, nil] Download status
+          # @param progress [Float, nil] Progress percentage
+          def update_download(query: nil, cursor: nil, selected: nil, status: nil, progress: nil)
+            attrs = {}
+            attrs[:download_query] = query unless query.nil?
+            attrs[:download_cursor] = cursor unless cursor.nil?
+            attrs[:download_selected] = selected unless selected.nil?
+            attrs[:download_status] = status unless status.nil?
+            attrs[:download_progress] = progress unless progress.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Update dictionary state
+          # @param query [String, nil] Dictionary query
+          # @param cursor [Integer, nil] Cursor position
+          # @param selected [Integer, nil] Selected item index
+          # @param status [Symbol, nil] Dictionary status
+          # @param progress [Float, nil] Progress percentage
+          def update_dictionary(query: nil, cursor: nil, selected: nil, status: nil, progress: nil)
+            attrs = {}
+            attrs[:dictionary_query] = query unless query.nil?
+            attrs[:dictionary_cursor] = cursor unless cursor.nil?
+            attrs[:dictionary_selected] = selected unless selected.nil?
+            attrs[:dictionary_status] = status unless status.nil?
+            attrs[:dictionary_progress] = progress unless progress.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Update annotation edit state
+          # @param text [String, nil] Edit text
+          # @param cursor [Integer, nil] Cursor position
+          def update_annotation_edit(text: nil, cursor: nil)
+            attrs = {}
+            attrs[:annotation_edit_text] = text unless text.nil?
+            attrs[:annotation_edit_cursor] = cursor unless cursor.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Update selected annotation
+          # @param annotation [Hash, nil] Selected annotation data
+          # @param book_path [String, nil] Book path of selected annotation
+          def update_selected_annotation(annotation: nil, book_path: nil)
+            attrs = {}
+            attrs[:selected_annotation] = annotation unless annotation.nil?
+            attrs[:selected_annotation_book] = book_path unless book_path.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Update all annotations mapping
+          # @param annotations [Hash] Mapping of book paths to annotations
+          def update_annotations_all(annotations)
+            @state.dispatch(Actions::UpdateMenuAction.new(annotations_all: annotations))
+          end
+
+          # Update loading state
+          # @param path [String, nil] Path being loaded
+          # @param active [Boolean, nil] Whether loading is active
+          # @param progress [Float, nil] Progress percentage
+          # @param message [String, nil] Loading message
+          # @param index [Integer, nil] Loading index
+          # @param mode [Symbol, nil] Loading mode
+          def update_loading(path: nil, active: nil, progress: nil, message: nil, index: nil, mode: nil)
+            attrs = {}
+            attrs[:loading_path] = path unless path.nil?
+            attrs[:loading_active] = active unless active.nil?
+            attrs[:loading_progress] = progress unless progress.nil?
+            attrs[:loading_message] = message unless message.nil?
+            attrs[:loading_index] = index unless index.nil?
+            attrs[:loading_mode] = mode unless mode.nil?
+            @state.dispatch(Actions::UpdateMenuAction.new(**attrs)) unless attrs.empty?
+          end
+
+          # Domain-facing menu workflow writers
+          def set_download_state(attrs)
+            update_menu(attrs)
+          end
+
+          def set_dictionary_state(attrs)
+            update_menu(attrs)
+          end
+
+          def set_annotation_state(attrs)
+            update_menu(attrs)
+          end
+
+          def set_loading_state(path: nil, active: nil, progress: nil, message: nil, index: nil, mode: nil)
+            update_loading(path: path, active: active, progress: progress, message: message, index: index, mode: mode)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/notification_writer_adapter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/notification_writer'
+require_relative 'actions/update_message_action'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the NotificationWriter port.
+        # Dispatches UpdateMessageAction to display/clear user messages.
+        class NotificationWriterAdapter
+          include Core::Ports::Outbound::NotificationWriter
+
+          def initialize(state, text_sanitizer: nil)
+            @state = state
+            @text_sanitizer = text_sanitizer
+          end
+
+          # Display a message to the user
+          # @param text [String] Message text to display
+          def show_message(text)
+            safe = if text && @text_sanitizer
+                     @text_sanitizer.sanitize(text.to_s, preserve_newlines: false, max_length: nil)
+                   else
+                     text
+                   end
+            @state.dispatch(Actions::UpdateMessageAction.new(safe))
+          end
+
+          # Clear the current message
+          def clear_message
+            @state.dispatch(Actions::UpdateMessageAction.new(nil))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/observer_registry_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/observer_registry'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the ObserverRegistry port.
+        # Delegates observer registration to ObserverStateStore.
+        class ObserverRegistryAdapter
+          include Core::Ports::Outbound::ObserverRegistry
+
+          def initialize(state)
+            @state = state
+          end
+
+          # @param observer [Object] Object implementing state_changed method
+          # @param paths [Array<Array<Symbol>>] State paths to observe
+          def add_observer(observer, *paths)
+            @state.add_observer(observer, *paths)
+          end
+
+          # @param observer [Object] Observer to remove
+          def remove_observer(observer)
+            @state.remove_observer(observer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/observer_state_store.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'state_store'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # StateStore with observer pattern support; central app state with observer notifications
+        class ObserverStateStore < StateStore
+          # @param event_bus [EventBus] Event bus for state change events
+          # @param config_storage [Core::Ports::Outbound::ConfigStorage] Port for configuration persistence (required)
+          # @param terminal_capabilities [Core::Ports::Outbound::TerminalCapabilities] Port for terminal capability detection (required)
+          # @param logger [Core::Ports::Outbound::Logging, nil] Logger (optional)
+          def initialize(event_bus, config_storage:, terminal_capabilities:, logger: nil)
+            super
+            @observers_by_path = Hash.new { |h, k| h[k] = [] }
+            @observers_all = []
+            config_missing = !@config_storage.file_exist?(config_file)
+            load_config_from_file
+            save_config if config_missing
+          end
+
+          # Register an observer for specific state paths
+          # Observer should respond to `state_changed(path, old_value, new_value)`
+          #
+          # @param observer [Object] Object implementing state_changed method
+          # @param *paths [Array<Symbol|Array>] State paths to observe
+          def add_observer(observer, *paths)
+            if paths.empty?
+              @observers_all << observer unless @observers_all.include?(observer)
+            else
+              paths.each do |path|
+                normalized_path = normalize_path(path)
+                unless @observers_by_path[normalized_path].include?(observer)
+                  @observers_by_path[normalized_path] << observer
+                end
+              end
+            end
+          end
+
+          # Remove observer from all paths
+          #
+          # @param observer [Object] Observer to remove
+          def remove_observer(observer)
+            @observers_all.delete(observer)
+            @observers_by_path.each_value { |list| list.delete(observer) }
+          end
+
+          # Override update to include observer notifications.
+          # Accepts update({path => value, path2 => value2}) only.
+          def update(updates)
+            old_state = current_state
+            super(updates)
+            notify_observers_for_updates(old_state, updates)
+          end
+
+          # Override set to include observer notifications
+          def set(path, value)
+            normalized_path = normalize_path(path)
+            update({ normalized_path => value })
+            value
+          end
+
+          private
+
+          def notify_observers_for_updates(old_state, updates)
+            updates.each do |path, new_value|
+              arr = Array(path)
+              old_value = get_nested_value(old_state, arr)
+              next if old_value == new_value
+
+              normalized_path = normalize_path(arr)
+              notify_observers(normalized_path, old_value, new_value)
+            end
+          end
+
+          def notify_observers(path, old_value, new_value)
+            # Notify path-specific observers
+            @observers_by_path[path].each do |observer|
+              safe_notify(observer, path, old_value, new_value)
+            end
+
+            # Notify observers watching parent paths
+            notify_parent_path_observers(path, old_value, new_value)
+
+            # Notify global observers
+            @observers_all.each do |observer|
+              safe_notify(observer, path, old_value, new_value)
+            end
+          end
+
+          # Notify observers watching parent paths (e.g., [:reader] when [:reader, :mode] changes)
+          def notify_parent_path_observers(path, old_value, new_value)
+            len = path.length
+            return if len <= 1
+
+            (1...len).each do |i|
+              parent_path = path[0, i]
+              @observers_by_path[parent_path].each do |observer|
+                safe_notify(observer, path, old_value, new_value)
+              end
+            end
+          end
+
+          # Safely notify observer, catching any exceptions
+          def safe_notify(observer, path, old_value, new_value)
+            observer.state_changed(path, old_value, new_value)
+          rescue ArgumentError
+            raise ArgumentError, "#{observer.class} must implement #state_changed(path, old_value, new_value)"
+          # resilient-boundary
+          rescue Shoko::Error => e
+            log_debug('observer.notify failed', observer: observer.class.name, path: path, error: e.message)
+            nil
+          end
+
+          # Normalize path to array format
+          def normalize_path(path)
+            case path
+            when Array then path
+            when Symbol then [path]
+            else [path.to_sym]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/reader_launch_state_adapter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/reader_launch_state'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # In-memory runtime launch state used to pass reader warmup artifacts.
+        class ReaderLaunchStateAdapter
+          include Shoko::Core::Ports::Outbound::ReaderLaunchState
+
+          def initialize
+            @preloaded_document = nil
+            @background_worker = nil
+          end
+
+          def preloaded_document
+            @preloaded_document
+          end
+
+          def set_preloaded_document(document)
+            @preloaded_document = document
+          end
+
+          def clear_preloaded_document
+            @preloaded_document = nil
+          end
+
+          def background_worker
+            @background_worker
+          end
+
+          def set_background_worker(worker)
+            @background_worker = worker
+          end
+
+          def clear_background_worker
+            @background_worker = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/reader_state_reader_adapter.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/reader_navigation_reader'
+require_relative 'selectors/reader_selectors'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing reader navigation reads.
+        # Reads reader/navigation state using ReaderSelectors.
+        class ReaderStateReaderAdapter
+          include Core::Ports::Outbound::ReaderNavigationReader
+
+          def initialize(state)
+            @state = state
+          end
+
+          # @return [Integer] Current chapter index (0-based)
+          def current_chapter
+            Selectors::ReaderSelectors.current_chapter(@state) || 0
+          end
+
+          # @return [Integer] Total chapter count
+          def total_chapters
+            @state.get(%i[reader total_chapters]) || 0
+          end
+
+          # @return [Integer] Current page index (dynamic mode)
+          def current_page_index
+            Selectors::ReaderSelectors.current_page_index(@state) || 0
+          end
+
+          # @return [Integer] Left page line offset
+          def left_page
+            Selectors::ReaderSelectors.left_page(@state) || 0
+          end
+
+          # @return [Integer] Right page line offset
+          def right_page
+            Selectors::ReaderSelectors.right_page(@state) || 0
+          end
+
+          # @return [Integer] Single page line offset
+          def single_page
+            Selectors::ReaderSelectors.single_page(@state) || 0
+          end
+
+          # @return [Integer] Current page line offset
+          def current_page
+            @state.get(%i[reader current_page]) || 0
+          end
+
+          # @return [Array] Page map array
+          def page_map
+            Selectors::ReaderSelectors.page_map(@state)
+          end
+
+          # @return [String, nil] Book file path
+          def book_path
+            @state.get(%i[reader book_path])
+          end
+
+          # @return [Array] Array of bookmarks
+          def bookmarks
+            Selectors::ReaderSelectors.bookmarks(@state)
+          end
+
+          # @return [Integer] Total page count
+          def total_pages
+            Selectors::ReaderSelectors.total_pages(@state) || 0
+          end
+
+          # @return [Hash, nil] Pending progress hash
+          def pending_progress
+            @state.get(%i[reader pending_progress])
+          end
+
+          # @return [Array] Array of annotations
+          def annotations
+            Selectors::ReaderSelectors.annotations(@state)
+          end
+
+          # @return [Symbol] Current mode
+          def mode
+            Selectors::ReaderSelectors.mode(@state) || :normal
+          end
+
+          # @return [Hash, nil] Selection data
+          def selection
+            Selectors::ReaderSelectors.selection(@state)
+          end
+
+          # @return [Hash, nil] Popup menu data
+          def popup_menu
+            Selectors::ReaderSelectors.popup_menu(@state)
+          end
+
+          # @return [Hash, nil] In-book search popup data
+          def in_book_search_popup
+            Selectors::ReaderSelectors.in_book_search_popup(@state)
+          end
+
+          # @return [Hash, nil] Annotations overlay data
+          def annotations_overlay
+            Selectors::ReaderSelectors.annotations_overlay(@state)
+          end
+
+          # @return [Hash, nil] Annotation editor overlay data
+          def annotation_editor_overlay
+            Selectors::ReaderSelectors.annotation_editor_overlay(@state)
+          end
+
+          # @return [Hash, nil] Dictionary popup data
+          def dictionary_popup
+            Selectors::ReaderSelectors.dictionary_popup(@state)
+          end
+
+          # @return [Hash, nil] Dictionary panel data
+          def dictionary_panel
+            @state.get(%i[reader dictionary_panel])
+          end
+
+          # @return [String, nil] Status message
+          def message
+            Selectors::ReaderSelectors.message(@state)
+          end
+
+          # @return [Boolean] True if reader is active
+          def running?
+            Selectors::ReaderSelectors.running?(@state)
+          end
+
+          # @return [Integer, nil] Selected annotation index in sidebar
+          def sidebar_annotations_selected
+            Selectors::ReaderSelectors.sidebar_annotations_selected(@state)
+          end
+
+          # @return [Symbol, nil] Active sidebar tab
+          def sidebar_active_tab
+            Selectors::ReaderSelectors.sidebar_active_tab(@state)
+          end
+
+          # @return [Boolean] True if sidebar is visible
+          def sidebar_visible?
+            @state.get(%i[reader sidebar_visible]) == true
+          end
+
+          # @return [Hash, nil] Pending jump data
+          def pending_jump
+            @state.get(%i[reader pending_jump])
+          end
+
+          # @return [Integer, nil] Last terminal width
+          def last_width
+            @state.get(%i[reader last_width])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/render_state_writer_adapter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/render_state_writer'
+require_relative 'actions/update_rendered_lines_action'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the RenderStateWriter port.
+        # Manages render-related state updates with proper error logging.
+        class RenderStateWriterAdapter
+          include Shoko::Core::Ports::Outbound::RenderStateWriter
+
+          def initialize(state, render_registry: nil, logger: nil)
+            @state = state
+            @render_registry = render_registry
+            @logger = logger
+          end
+
+          # Clear rendered lines at the start of a new frame.
+          # @return [void]
+          def clear_rendered_lines
+            @state.dispatch(Actions::ClearRenderedLinesAction.new)
+          # resilient-boundary
+          rescue Shoko::Error => e
+            log_error('clear_rendered_lines', e)
+            raise
+          end
+
+          # Update rendered lines after rendering completes.
+          # @param rendered_lines [Hash] Line geometry data
+          # @return [void]
+          def update_rendered_lines(rendered_lines)
+            @render_registry&.write(rendered_lines)
+            @state.dispatch(Actions::UpdateRenderedLinesAction.new(rendered_lines))
+          # resilient-boundary
+          rescue Shoko::Error => e
+            log_error('update_rendered_lines', e)
+            raise
+          end
+
+          private
+
+          def log_error(operation, error)
+            @logger&.error(
+              "render_state_writer.#{operation}_failed",
+              error: error.class.name,
+              message: error.message,
+              backtrace: error.backtrace&.first(5)&.join("\n")
+            )
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/rendered_content_reader_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/rendered_content_reader'
+require_relative 'selectors/reader_selectors'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the RenderedContentReader port.
+        # Reads rendered content from application state using ReaderSelectors.
+        class RenderedContentReaderAdapter
+          include Core::Ports::Outbound::RenderedContentReader
+
+          def initialize(state, render_registry: nil)
+            @state = state
+            @render_registry = render_registry
+          end
+
+          # Get the currently rendered lines
+          # @return [Hash] Rendered lines data
+          def rendered_lines
+            Selectors::ReaderSelectors.rendered_lines(@state, render_registry: @render_registry)
+          end
+        end
+      end
+    end
+  end
+end