shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/runtime/session_state/selectors/config_selectors.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        module Selectors
+          # Selectors for configuration state
+          module ConfigSelectors
+            def self.view_mode(state)
+              state.get(%i[config view_mode])
+            end
+
+            def self.line_spacing(state)
+              state.get(%i[config line_spacing])
+            end
+
+            def self.page_numbering_mode(state)
+              state.get(%i[config page_numbering_mode])
+            end
+
+            def self.theme(state)
+              state.get(%i[config theme])
+            end
+
+            def self.show_page_numbers(state)
+              state.get(%i[config show_page_numbers])
+            end
+
+            def self.show_page_numbers?(state)
+              show_page_numbers(state)
+            end
+
+            def self.highlight_quotes(state)
+              state.get(%i[config highlight_quotes])
+            end
+
+            def self.highlight_quotes?(state)
+              highlight_quotes(state)
+            end
+
+            def self.highlight_keywords(state)
+              state.get(%i[config highlight_keywords])
+            end
+
+            def self.highlight_keywords?(state)
+              highlight_keywords(state)
+            end
+
+            def self.kitty_images(state)
+              state.get(%i[config kitty_images])
+            end
+
+            def self.kitty_images?(state)
+              !!kitty_images(state)
+            end
+
+            def self.config_hash(state)
+              state.get([:config])
+            end
+
+            def self.dictionary_source_lang(state)
+              state.get(%i[config dictionary_source_lang])
+            end
+
+            def self.dictionary_target_lang(state)
+              state.get(%i[config dictionary_target_lang])
+            end
+
+            def self.dictionary_path(state)
+              state.get(%i[config dictionary_path])
+            end
+
+            def self.dictionary_backend(state)
+              state.get(%i[config dictionary_backend])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/selectors/menu_selectors.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        module Selectors
+          # Selectors for menu state - provides read-only access to state
+          module MenuSelectors
+            def self.selected(state)
+              state.get(%i[menu selected])
+            end
+
+            def self.selected_item(state)
+              selected(state)
+            end
+
+            def self.mode(state)
+              state.get(%i[menu mode])
+            end
+
+            def self.browse_selected(state)
+              state.get(%i[menu browse_selected])
+            end
+
+            def self.library_details_open(state)
+              !!state.get(%i[menu library_details_open])
+            end
+
+            def self.search_query(state)
+              state.get(%i[menu search_query]) || ''
+            end
+
+            def self.search_cursor(state)
+              state.get(%i[menu search_cursor])
+            end
+
+            def self.search_active(state)
+              state.get(%i[menu search_active])
+            end
+
+            def self.search_active?(state)
+              search_active(state)
+            end
+
+            def self.download_query(state)
+              state.get(%i[menu download_query]) || ''
+            end
+
+            def self.download_cursor(state)
+              state.get(%i[menu download_cursor])
+            end
+
+            def self.download_selected(state)
+              state.get(%i[menu download_selected])
+            end
+
+            def self.download_status(state)
+              state.get(%i[menu download_status])
+            end
+
+            def self.download_progress(state)
+              state.get(%i[menu download_progress])
+            end
+
+            def self.dictionary_selected(state)
+              state.get(%i[menu dictionary_selected])
+            end
+
+            def self.dictionary_query(state)
+              state.get(%i[menu dictionary_query]) || ''
+            end
+
+            def self.dictionary_cursor(state)
+              state.get(%i[menu dictionary_cursor])
+            end
+
+            def self.dictionary_status(state)
+              state.get(%i[menu dictionary_status])
+            end
+
+            def self.dictionary_progress(state)
+              state.get(%i[menu dictionary_progress])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/selectors/reader_selectors.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        module Selectors
+          # Selectors for reader state - provides read-only access to state
+          # Replaces direct state access and convenience methods
+          module ReaderSelectors
+            module_function
+
+            # Chapter and page selectors
+            def current_chapter(state)
+              state.get(%i[reader current_chapter])
+            end
+
+            def current_page_index(state)
+              state.get(%i[reader current_page_index])
+            end
+
+            def left_page(state)
+              state.get(%i[reader left_page])
+            end
+
+            def right_page(state)
+              state.get(%i[reader right_page])
+            end
+
+            def single_page(state)
+              state.get(%i[reader single_page])
+            end
+
+            def current_page(state)
+              current_page_index(state) + 1
+            end
+
+            # Mode and UI state selectors
+            def mode(state)
+              state.get(%i[reader mode])
+            end
+
+            def selection(state)
+              state.get(%i[reader selection])
+            end
+
+            def message(state)
+              state.get(%i[reader message])
+            end
+
+            def running(state)
+              state.get(%i[reader running])
+            end
+
+            def running?(state)
+              running(state)
+            end
+
+            # List selectors
+            def bookmarks(state)
+              state.get(%i[reader bookmarks]) || []
+            end
+
+            def annotations(state)
+              state.get(%i[reader annotations]) || []
+            end
+
+            # Pagination selectors
+            def page_map(state)
+              state.get(%i[reader page_map]) || []
+            end
+
+            def total_pages(state)
+              state.get(%i[reader total_pages])
+            end
+
+            def pages_per_chapter(state)
+              state.get(%i[reader pages_per_chapter]) || []
+            end
+
+            # Dynamic pagination selectors
+            def dynamic_page_map(state)
+              state.get(%i[reader dynamic_page_map])
+            end
+
+            def dynamic_total_pages(state)
+              state.get(%i[reader dynamic_total_pages])
+            end
+
+            def dynamic_chapter_starts(state)
+              state.get(%i[reader dynamic_chapter_starts]) || []
+            end
+
+            # Terminal sizing selectors
+            def last_width(state)
+              state.get(%i[reader last_width])
+            end
+
+            def last_height(state)
+              state.get(%i[reader last_height])
+            end
+
+            def last_dynamic_width(state)
+              state.get(%i[reader last_dynamic_width])
+            end
+
+            def last_dynamic_height(state)
+              state.get(%i[reader last_dynamic_height])
+            end
+
+            def terminal_size_changed?(state, width, height)
+              width != last_width(state) || height != last_height(state)
+            end
+
+            # UI state selectors
+            def rendered_lines(state, render_registry: nil)
+              lines = render_registry&.lines
+              return lines if lines.is_a?(Hash)
+
+              fallback = state.get(%i[reader rendered_lines])
+              return {} if fallback == :render_registry
+
+              fallback.is_a?(Hash) ? fallback : {}
+            end
+
+            def popup_menu(state)
+              state.get(%i[reader popup_menu])
+            end
+
+            def in_book_search_popup(state)
+              state.get(%i[reader in_book_search_popup])
+            end
+
+            def annotations_overlay(state)
+              state.get(%i[reader annotations_overlay])
+            end
+
+            def annotation_editor_overlay(state)
+              state.get(%i[reader annotation_editor_overlay])
+            end
+
+            def dictionary_popup(state)
+              state.get(%i[reader dictionary_popup])
+            end
+
+            # Sidebar selectors
+            def sidebar_visible(state)
+              state.get(%i[reader sidebar_visible])
+            end
+
+            def sidebar_visible?(state)
+              sidebar_visible(state)
+            end
+
+            def sidebar_active_tab(state)
+              state.get(%i[reader sidebar_active_tab])
+            end
+
+            def sidebar_toc_selected(state)
+              state.get(%i[reader sidebar_toc_selected])
+            end
+
+            def sidebar_toc_collapsed(state)
+              state.get(%i[reader sidebar_toc_collapsed])
+            end
+
+            def sidebar_annotations_selected(state)
+              state.get(%i[reader sidebar_annotations_selected])
+            end
+
+            def sidebar_bookmarks_selected(state)
+              state.get(%i[reader sidebar_bookmarks_selected])
+            end
+
+            def sidebar_toc_filter(state)
+              state.get(%i[reader sidebar_toc_filter])
+            end
+
+            def sidebar_toc_filter_active(state)
+              state.get(%i[reader sidebar_toc_filter_active])
+            end
+
+            def sidebar_toc_filter_active?(state)
+              sidebar_toc_filter_active(state)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/sidebar_state_reader'
+require_relative 'selectors/reader_selectors'
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        # Application adapter implementing the SidebarStateReader port.
+        # Reads sidebar state from application state using ReaderSelectors.
+        class SidebarStateReaderAdapter
+          include Core::Ports::Outbound::SidebarStateReader
+
+          def initialize(state)
+            @state = state
+          end
+
+          # @return [Boolean] True if sidebar is visible
+          def sidebar_visible?
+            Selectors::ReaderSelectors.sidebar_visible?(@state)
+          end
+
+          # @return [Symbol] Active tab
+          def sidebar_active_tab
+            Selectors::ReaderSelectors.sidebar_active_tab(@state) || :toc
+          end
+
+          # @return [Integer] Selected TOC index
+          def sidebar_toc_selected
+            Selectors::ReaderSelectors.sidebar_toc_selected(@state) || 0
+          end
+
+          # @return [Hash] Hash of collapsed TOC item indices
+          def sidebar_toc_collapsed
+            Selectors::ReaderSelectors.sidebar_toc_collapsed(@state) || {}
+          end
+
+          # @return [Integer] Selected bookmarks index
+          def sidebar_bookmarks_selected
+            Selectors::ReaderSelectors.sidebar_bookmarks_selected(@state) || 0
+          end
+
+          # @return [Integer] Selected annotations index
+          def sidebar_annotations_selected
+            Selectors::ReaderSelectors.sidebar_annotations_selected(@state) || 0
+          end
+
+          # @return [Symbol, nil] Previous view mode
+          def sidebar_prev_view_mode
+            @state.get(%i[reader sidebar_prev_view_mode])
+          end
+
+          # @return [String, nil] TOC filter text
+          def sidebar_toc_filter
+            Selectors::ReaderSelectors.sidebar_toc_filter(@state)
+          end
+
+          # @return [Boolean] True if TOC filter is active
+          def sidebar_toc_filter_active?
+            Selectors::ReaderSelectors.sidebar_toc_filter_active?(@state)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/state_store/change_event_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        class StateStore
+          # Builds state_changed event payloads from committed updates.
+          class ChangeEventBuilder
+            def build(old_state:, new_state:, updates:)
+              updates.each_with_object([]) do |(path, new_value), events|
+                arr_path = Array(path)
+                old_value = nested_value(old_state, arr_path)
+                next if old_value == new_value
+
+                events << {
+                  path: arr_path,
+                  old_value: old_value,
+                  new_value: new_value,
+                  full_state: new_state
+                }
+              end
+            end
+
+            private
+
+            def nested_value(hash, path)
+              path.reduce(hash) { |h, key| h&.dig(key) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/state_store/config_persistence.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        class StateStore
+          # Encapsulates configuration load/save concerns for the runtime state.
+          class ConfigPersistence
+            def initialize(config_storage:, symbol_keys:, line_spacing_aliases:, log_warn:, log_error:)
+              @config_storage = config_storage
+              @symbol_keys = symbol_keys
+              @line_spacing_aliases = line_spacing_aliases
+              @log_warn = log_warn
+              @log_error = log_error
+            end
+
+            def save(config:, config_file:, config_dir:)
+              ensure_config_dir(config_dir)
+              payload = JSON.pretty_generate(config)
+              @config_storage.atomic_write(config_file, payload)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @log_error.call('config.write failed', error: e.message, path: config_file)
+            end
+
+            def load(config:, config_file:)
+              return {} unless @config_storage.file_exist?(config_file)
+
+              data = parse_config_file(config_file)
+              return {} unless data.is_a?(Hash)
+
+              extract_updates(data, config)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @log_warn.call('config.load failed; using defaults', error: e.message, path: config_file)
+              {}
+            end
+
+            private
+
+            def ensure_config_dir(config_dir)
+              @config_storage.ensure_config_dir
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @log_warn.call('config.ensure_dir failed', error: e.message, path: config_dir)
+            end
+
+            def parse_config_file(path)
+              content = @config_storage.read_file(path)
+              return nil unless content
+
+              JSON.parse(content, symbolize_names: true)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @log_warn.call('config.parse failed; using defaults', error: e.message, path: path)
+              nil
+            end
+
+            def extract_updates(data, current_config)
+              config_updates = {}
+              data.each do |key, value|
+                next unless current_config.key?(key)
+
+                if @symbol_keys.include?(key)
+                  value = value.to_s.to_sym unless value.nil? || value.is_a?(Symbol)
+                end
+                value = @line_spacing_aliases.fetch(value, value) if key == :line_spacing
+                next unless valid_config_value?(key, value)
+
+                config_updates[[:config, key]] = value
+              end
+              config_updates
+            end
+
+            def valid_config_value?(key, value)
+              case key
+              when :view_mode
+                %i[single split].include?(value)
+              when :kitty_images
+                value.is_a?(TrueClass) || value.is_a?(FalseClass)
+              else
+                true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/session_state/state_store/initial_state_builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Runtime
+      module SessionState
+        class StateStore
+          # Builds the canonical initial runtime state tree.
+          class InitialStateBuilder
+            def initialize(terminal_capabilities:)
+              @terminal_capabilities = terminal_capabilities
+            end
+
+            def build
+              {
+                reader: {
+                  current_chapter: 0,
+                  left_page: 0,
+                  right_page: 0,
+                  single_page: 0,
+                  current_page_index: 0,
+                  mode: :read,
+                  selection: nil,
+                  message: nil,
+                  running: true,
+                  bookmarks: [],
+                  annotations: [],
+                  page_map: [],
+                  total_pages: 0,
+                  pages_per_chapter: [],
+                  last_width: 0,
+                  last_height: 0,
+                  page_offset: 0,
+                  dynamic_page_map: nil,
+                  dynamic_total_pages: 0,
+                  dynamic_chapter_starts: [],
+                  last_dynamic_width: 0,
+                  last_dynamic_height: 0,
+                  rendered_lines: {},
+                  popup_menu: nil,
+                  in_book_search_popup: nil,
+                  annotations_overlay: nil,
+                  annotation_editor_overlay: nil,
+                  sidebar_visible: false,
+                  sidebar_active_tab: :toc,
+                  sidebar_toc_selected: 0,
+                  sidebar_annotations_selected: 0,
+                  sidebar_bookmarks_selected: 0,
+                  sidebar_toc_filter: nil,
+                  sidebar_toc_filter_active: false,
+                  sidebar_toc_collapsed: nil
+                },
+                menu: {
+                  selected: 0,
+                  mode: :menu,
+                  browse_selected: 0,
+                  library_details_open: false,
+                  settings_selected: 1,
+                  wipe_cache_cached: true,
+                  wipe_cache_downloads: false,
+                  wipe_cache_nuke: false,
+                  wipe_cache_annotations: false,
+                  wipe_cache_bookmarks: false,
+                  wipe_cache_config: false,
+                  wipe_cache_progress: false,
+                  search_query: '',
+                  search_cursor: 0,
+                  search_active: false,
+                  download_query: '',
+                  download_cursor: 0,
+                  download_selected: 0,
+                  download_results: [],
+                  download_count: 0,
+                  download_next: nil,
+                  download_prev: nil,
+                  download_status: :idle,
+                  download_message: '',
+                  download_progress: 0.0,
+                  dictionary_selected: 0,
+                  dictionary_query: '',
+                  dictionary_cursor: 0,
+                  dictionary_results: [],
+                  dictionary_status: :idle,
+                  dictionary_message: '',
+                  dictionary_progress: 0.0
+                },
+                config: {
+                  view_mode: :single,
+                  line_spacing: :normal,
+                  page_numbering_mode: :dynamic,
+                  theme: :dark,
+                  show_page_numbers: true,
+                  highlight_quotes: true,
+                  highlight_keywords: false,
+                  prefetch_pages: 20,
+                  kitty_images: @terminal_capabilities.kitty_graphics_supported?,
+                  dictionary_source_lang: 'auto',
+                  dictionary_target_lang: 'en',
+                  dictionary_path: nil,
+                  dictionary_backend: nil
+                },
+                ui: {
+                  terminal_width: 80,
+                  terminal_height: 24
+                }
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end