shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/runtime/session_state/actions/update_state_action.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'base_action'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        module Actions
+          # Generic action for updating state fields under a namespace.
+          # This consolidates the common pattern of updating fields in a specific
+          # state namespace (reader, menu, config, ui).
+          #
+          # @example Updating reader state
+          #   state.dispatch(UpdateStateAction.new(:reader, bookmarks: [...], current_chapter: 5))
+          #
+          # @example Updating config state
+          #   state.dispatch(UpdateStateAction.new(:config, theme: :dark, view_mode: :single))
+          #
+          # @example Updating with allowed fields filter
+          #   state.dispatch(UpdateStateAction.new(:reader,
+          #     { page_map: [...], total_pages: 100 },
+          #     allowed: [:page_map, :total_pages, :last_width, :last_height]
+          #   ))
+          class UpdateStateAction < BaseAction
+            # @param namespace [Symbol] The state namespace (:reader, :menu, :config, :ui)
+            # @param updates [Hash] Hash of field => value updates
+            # @param allowed [Array<Symbol>, nil] Optional allowlist of fields. If provided,
+            #   only these fields will be updated.
+            def initialize(namespace, updates = {}, allowed: nil)
+              super(namespace: namespace, updates: updates, allowed: allowed)
+            end
+
+            def apply(state)
+              namespace = payload[:namespace]
+              updates = payload[:updates]
+              allowed = payload[:allowed]
+
+              state_updates = {}
+              updates.each do |field, value|
+                next if allowed && !allowed.include?(field)
+
+                state_updates[[namespace, field]] = value
+              end
+
+              state.update(state_updates) unless state_updates.empty?
+            end
+          end
+
+          # Convenience classes for common namespaces - these provide a cleaner API
+          # while using UpdateStateAction internally.
+
+          # Action for updating reader state fields
+          #
+          # @example
+          #   state.dispatch(UpdateReaderAction.new(current_chapter: 5, bookmarks: [...]))
+          class UpdateReaderAction < UpdateStateAction
+            def initialize(allowed: nil, **updates)
+              super(:reader, updates, allowed: allowed)
+            end
+          end
+
+          # Action for updating UI state fields
+          #
+          # @example
+          #   state.dispatch(UpdateUIAction.new(loading_active: true, loading_message: 'Loading...'))
+          class UpdateUIAction < UpdateStateAction
+            def initialize(allowed: nil, **updates)
+              super(:ui, updates, allowed: allowed)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/actions/update_ui_loading_action.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'update_state_action'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        module Actions
+          # Action for updating UI loading indicators.
+          # Accepts any of: :loading_active, :loading_message, :loading_progress
+          class UpdateUILoadingAction < UpdateUIAction
+            ALLOWED = %i[loading_active loading_message loading_progress].freeze
+
+            def initialize(**updates)
+              super(allowed: ALLOWED, **updates)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/config_reader'
+require_relative 'selectors/config_selectors'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the ConfigReader port.
+        # Reads configuration from application state using ConfigSelectors.
+        class ConfigReaderAdapter
+          include Core::Ports::Outbound::ConfigReader
+
+          def initialize(state)
+            @state = state
+          end
+
+          # @return [Symbol] :dynamic or :absolute
+          def page_numbering_mode
+            Selectors::ConfigSelectors.page_numbering_mode(@state)
+          end
+
+          # @return [Symbol] :single or :split
+          def view_mode
+            Selectors::ConfigSelectors.view_mode(@state)
+          end
+
+          # @return [Integer]
+          def line_spacing
+            Selectors::ConfigSelectors.line_spacing(@state)
+          end
+
+          # @return [String, nil]
+          def dictionary_source_lang
+            Selectors::ConfigSelectors.dictionary_source_lang(@state)
+          end
+
+          # @return [String, nil]
+          def dictionary_target_lang
+            Selectors::ConfigSelectors.dictionary_target_lang(@state)
+          end
+
+          # @return [String, nil]
+          def dictionary_path
+            Selectors::ConfigSelectors.dictionary_path(@state)
+          end
+
+          # @return [Symbol, nil]
+          def dictionary_backend
+            Selectors::ConfigSelectors.dictionary_backend(@state)
+          end
+
+          # @return [Boolean]
+          def show_page_numbers
+            Selectors::ConfigSelectors.show_page_numbers(@state)
+          end
+
+          # @return [Boolean]
+          def kitty_images
+            Selectors::ConfigSelectors.kitty_images(@state)
+          end
+
+          # @return [Symbol, nil]
+          def theme
+            Selectors::ConfigSelectors.theme(@state)
+          end
+
+          # @return [Boolean, nil]
+          def highlight_quotes
+            @state.get(%i[config highlight_quotes])
+          end
+
+          # @return [Boolean]
+          def highlight_keywords
+            !!@state.get(%i[config highlight_keywords])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Thread-safe event bus for application-wide event handling.
+        # Complements ObserverStateStore by broadcasting application events.
+        class EventBus
+          # @param logger [Core::Ports::Outbound::Logging] Logger adapter (required)
+          def initialize(logger:)
+            @subscribers = Hash.new { |h, k| h[k] = [] }
+            @mutex = Mutex.new
+            @logger = logger
+          end
+
+          # Subscribe to specific event types
+          #
+          # @param subscriber [Object] Object responding to #handle_event(event)
+          # @param *event_types [Array<Symbol>] Event types to subscribe to
+          def subscribe(subscriber, *event_types)
+            @mutex.synchronize do
+              event_types.each do |event_type|
+                list = @subscribers[event_type]
+                list << subscriber unless list.include?(subscriber)
+              end
+            end
+          end
+
+          # Unsubscribe from all events
+          #
+          # @param subscriber [Object] Subscriber to remove
+          def unsubscribe(subscriber)
+            @mutex.synchronize do
+              @subscribers.each_value { |list| list.delete(subscriber) }
+            end
+          end
+
+          # Emit an event to all subscribers
+          #
+          # @param event [Event] Event to emit
+          def emit(event)
+            subscribers = @mutex.synchronize { @subscribers[event.type].dup }
+
+            subscribers.each do |subscriber|
+              safely_notify(subscriber, event)
+            end
+          end
+
+          # Create and emit an event
+          #
+          # @param type [Symbol] Event type
+          # @param data [Hash] Event data
+          def emit_event(type, data = {})
+            event = Event.new(type: type, data: data, timestamp: Time.now)
+            emit(event)
+          end
+
+          private
+
+          def safely_notify(subscriber, event)
+            subscriber.handle_event(event)
+            # resilient-boundary
+          rescue Shoko::Error => e
+            @logger.error(
+              'Event subscriber error',
+              subscriber: subscriber.class.name,
+              event_type: event.type,
+              error: e.message
+            )
+            raise
+          end
+        end
+
+        # Immutable event object
+        Event = Struct.new(:type, :data, :timestamp, keyword_init: true) do
+          def initialize(**args)
+            super
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/event_publisher'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Adapter that bridges the EventPublisher port to the legacy EventBus shape.
+        class EventPublisherAdapter
+          include Shoko::Core::Ports::Outbound::EventPublisher
+
+          def initialize(event_bus:)
+            @event_bus = event_bus
+          end
+
+          def publish_event(event_type, event_data = {})
+            @event_bus.emit_event(event_type, event_data)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/menu_launch_state'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # In-memory runtime launch state for menu->reader handoff metadata.
+        class MenuLaunchStateAdapter
+          include Shoko::Core::Ports::Outbound::MenuLaunchState
+
+          def initialize
+            @last_opened_path = nil
+          end
+
+          def last_opened_path
+            @last_opened_path
+          end
+
+          def set_last_opened_path(path)
+            @last_opened_path = path
+          end
+
+          def clear_last_opened_path
+            @last_opened_path = nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/menu_workflow_state_reader'
+require_relative 'selectors/menu_selectors'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing menu workflow state reads.
+        # Reads menu state from application state using MenuSelectors.
+        class MenuStateReaderAdapter
+          include Core::Ports::Outbound::MenuWorkflowStateReader
+
+          def initialize(state)
+            @state = state
+          end
+
+          # @return [Integer, nil]
+          def selected
+            Selectors::MenuSelectors.selected(@state)
+          end
+
+          # @return [Symbol, nil]
+          def mode
+            Selectors::MenuSelectors.mode(@state)
+          end
+
+          # @return [Integer, nil]
+          def browse_selected
+            Selectors::MenuSelectors.browse_selected(@state)
+          end
+
+          # @return [Boolean]
+          def library_details_open?
+            Selectors::MenuSelectors.library_details_open(@state)
+          end
+
+          # @return [String]
+          def search_query
+            Selectors::MenuSelectors.search_query(@state)
+          end
+
+          # @return [Integer, nil]
+          def search_cursor
+            Selectors::MenuSelectors.search_cursor(@state)
+          end
+
+          # @return [Boolean]
+          def search_active?
+            Selectors::MenuSelectors.search_active?(@state)
+          end
+
+          # @return [Integer, nil]
+          def settings_selected
+            @state.get(%i[menu settings_selected])
+          end
+
+          def wipe_cache_cached?
+            value = @state.get(%i[menu wipe_cache_cached])
+            value.nil? || !!value
+          end
+
+          def wipe_cache_downloads?
+            !!@state.get(%i[menu wipe_cache_downloads])
+          end
+
+          def wipe_cache_nuke?
+            !!@state.get(%i[menu wipe_cache_nuke])
+          end
+
+          def wipe_cache_annotations?
+            !!@state.get(%i[menu wipe_cache_annotations])
+          end
+
+          def wipe_cache_bookmarks?
+            !!@state.get(%i[menu wipe_cache_bookmarks])
+          end
+
+          def wipe_cache_config?
+            !!@state.get(%i[menu wipe_cache_config])
+          end
+
+          def wipe_cache_progress?
+            !!@state.get(%i[menu wipe_cache_progress])
+          end
+
+          # @return [String]
+          def download_query
+            Selectors::MenuSelectors.download_query(@state)
+          end
+
+          # @return [Integer, nil]
+          def download_cursor
+            Selectors::MenuSelectors.download_cursor(@state)
+          end
+
+          # @return [Integer, nil]
+          def download_selected
+            Selectors::MenuSelectors.download_selected(@state)
+          end
+
+          # @return [Symbol, nil]
+          def download_status
+            Selectors::MenuSelectors.download_status(@state)
+          end
+
+          # @return [Float, nil]
+          def download_progress
+            Selectors::MenuSelectors.download_progress(@state)
+          end
+
+          # @return [String]
+          def dictionary_query
+            Selectors::MenuSelectors.dictionary_query(@state)
+          end
+
+          # @return [Integer, nil]
+          def dictionary_cursor
+            Selectors::MenuSelectors.dictionary_cursor(@state)
+          end
+
+          # @return [Integer, nil]
+          def dictionary_selected
+            Selectors::MenuSelectors.dictionary_selected(@state)
+          end
+
+          # @return [Symbol, nil]
+          def dictionary_status
+            Selectors::MenuSelectors.dictionary_status(@state)
+          end
+
+          # @return [Float, nil]
+          def dictionary_progress
+            Selectors::MenuSelectors.dictionary_progress(@state)
+          end
+
+          # @return [Hash]
+          def annotations_all
+            @state.get(%i[menu annotations_all]) || {}
+          end
+
+          # @return [Hash, nil]
+          def selected_annotation
+            @state.get(%i[menu selected_annotation])
+          end
+
+          # @return [String, nil]
+          def selected_annotation_book
+            @state.get(%i[menu selected_annotation_book])
+          end
+
+          # @return [String]
+          def annotation_edit_text
+            @state.get(%i[menu annotation_edit_text]) || ''
+          end
+
+          # @return [Integer, nil]
+          def annotation_edit_cursor
+            @state.get(%i[menu annotation_edit_cursor])
+          end
+
+          # @return [String, nil]
+          def loading_path
+            @state.get(%i[menu loading_path])
+          end
+
+          # @return [Boolean]
+          def loading_active?
+            !!@state.get(%i[menu loading_active])
+          end
+
+          # @return [Float, nil]
+          def loading_progress
+            @state.get(%i[menu loading_progress])
+          end
+
+          # @return [String, nil]
+          def loading_message
+            @state.get(%i[menu loading_message])
+          end
+
+          # @return [String, nil]
+          def download_next
+            @state.get(%i[menu download_next])
+          end
+
+          # @return [String, nil]
+          def download_prev
+            @state.get(%i[menu download_prev])
+          end
+
+          # @return [Array]
+          def download_results
+            Array(@state.get(%i[menu download_results]))
+          end
+
+          # @return [String, nil]
+          def download_message
+            @state.get(%i[menu download_message])
+          end
+
+          # @return [Integer]
+          def download_count
+            (@state.get(%i[menu download_count]) || 0).to_i
+          end
+
+          # @return [Array]
+          def dictionary_results
+            Array(@state.get(%i[menu dictionary_results]))
+          end
+
+          # @return [String, nil]
+          def dictionary_message
+            @state.get(%i[menu dictionary_message])
+          end
+
+          # Domain-facing menu workflow readers
+          def current_menu_mode
+            mode
+          end
+
+          def selected_library_index
+            browse_selected
+          end
+
+          def selected_annotation_record
+            selected_annotation
+          end
+
+          def selected_annotation_book_path
+            selected_annotation_book
+          end
+
+          def annotation_editor_text
+            annotation_edit_text
+          end
+
+          def dictionary_entries
+            dictionary_results
+          end
+        end
+      end
+    end
+  end
+end