shoko 0.1.3 → 0.1.5

data/lib/shoko/application/services/pagination/page_info_calculator.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/config_reader'
+
+require_relative '../../../core/ports/outbound/reader_navigation_reader'
+
+require_relative '../../../core/ports/outbound/pagination_state_writer'
+require_relative '../../../core/ports/outbound/ui_loading_writer'
+require_relative '../../../core/ports/outbound/sidebar_state_reader'
+
+
+module Shoko
+  module Application
+    module Services
+      module Pagination
+        # Computes reader page information (current/total pages) for single and split view modes.
+        # Encapsulates sizing logic so ReaderController can delegate without duplicating calculations.
+        #
+        # This class follows hexagonal architecture principles:
+        # - Config reading goes through ConfigReader port
+        # - Reader state reading goes through ReaderNavigationReader port
+        # - State writing goes through PaginationStateWriter port
+        # Uses hexagonal ports for reading state - no direct state_store access.
+        class PageInfoCalculator
+          def initialize(doc:, page_calculator:, layout_service:, ui_state_reader:,
+                         pagination_orchestrator:, defer_page_map:,
+                         config_reader:, reader_state_reader:,
+                         pagination_state_writer:, ui_loading_writer:, sidebar_state_reader:)
+            raise ArgumentError, 'pagination_state_writer is required' unless pagination_state_writer
+            raise ArgumentError, 'ui_loading_writer is required' unless ui_loading_writer
+            raise ArgumentError, 'sidebar_state_reader is required' unless sidebar_state_reader
+
+            @doc = doc
+            @page_calculator = page_calculator
+            @layout_service = layout_service
+            @ui_state_reader = ui_state_reader
+            @pagination_orchestrator = pagination_orchestrator
+            @defer_page_map = defer_page_map
+            @config_reader = config_reader
+            @reader_state_reader = reader_state_reader
+            @pagination_state_writer = pagination_state_writer
+            @ui_loading_writer = ui_loading_writer
+            @sidebar_state_reader = sidebar_state_reader
+          end
+
+          def calculate
+            return default_single unless show_page_numbers?
+
+            view_mode = current_view_mode
+            if view_mode == :split
+              calculate_split_info
+            else
+              calculate_single_info
+            end
+          end
+
+          private
+
+          attr_reader :doc, :page_calculator, :layout_service, :ui_state_reader,
+                      :pagination_orchestrator, :defer_page_map, :config_reader,
+                      :reader_state_reader, :pagination_state_writer,
+                      :ui_loading_writer, :sidebar_state_reader
+
+          def calculate_single_info
+            if dynamic_mode?
+              calculate_dynamic_single
+            else
+              calculate_absolute_single
+            end
+          end
+
+          def calculate_split_info
+            if dynamic_mode?
+              calculate_dynamic_split
+            else
+              calculate_absolute_split
+            end
+          end
+
+          def calculate_dynamic_single
+            return default_single unless page_calculator
+
+            current_page = current_page_index + 1
+            total_pages = total_pages_from_calculator
+
+            {
+              type: :single,
+              current: current_page,
+              total: total_pages,
+            }
+          end
+
+          def calculate_dynamic_split
+            return default_split unless page_calculator
+
+            left_page = current_page_index + 1
+            total_pages = total_pages_from_calculator
+            right_page = [left_page + 1, total_pages].min
+
+            {
+              type: :split,
+              left: { current: left_page, total: total_pages },
+              right: { current: right_page, total: total_pages },
+            }
+          end
+
+          def calculate_absolute_single
+            layout = absolute_layout(current_view_mode)
+            lines_per_page = layout[:lines_per_page]
+            return default_single if lines_per_page <= 0
+
+            ensure_absolute_page_map(layout[:width], layout[:height])
+
+            page_map = page_map_from_state
+            pages_before = pages_before_current_chapter(page_map)
+            line_offset = line_offset_for_view(current_view_mode)
+            page_in_chapter = page_in_chapter_for_offset(line_offset, lines_per_page)
+            current_global_page = pages_before + page_in_chapter
+            total_pages = total_pages_from_state
+
+            {
+              type: :single,
+              current: current_global_page,
+              total: total_pages.positive? ? total_pages : 0,
+            }
+          end
+
+          def calculate_absolute_split
+            layout = absolute_layout(:split)
+            lines_per_page = layout[:lines_per_page]
+            return default_split if lines_per_page <= 0
+
+            ensure_absolute_page_map(layout[:width], layout[:height])
+
+            page_map = page_map_from_state
+            total_pages = total_pages_from_state
+            return default_split unless total_pages.positive?
+
+            pages_before = pages_before_current_chapter(page_map)
+
+            left_line_offset = reader_state_reader.left_page
+            left_page_in_chapter = page_in_chapter_for_offset(left_line_offset, lines_per_page)
+            left_current = pages_before + left_page_in_chapter
+
+            right_line_offset = reader_state_reader.right_page
+            right_line_offset = lines_per_page if right_line_offset.to_i.zero?
+            right_page_in_chapter = page_in_chapter_for_offset(right_line_offset, lines_per_page)
+            right_current = [pages_before + right_page_in_chapter, total_pages].min
+
+            {
+              type: :split,
+              left: { current: left_current, total: total_pages },
+              right: { current: right_current, total: total_pages },
+            }
+          end
+
+          def ensure_absolute_page_map(width, height)
+            return if defer_page_map
+            return unless page_calculator
+            return unless config_reader
+
+            return unless page_map_empty? || size_changed?(width, height)
+
+            pagination_orchestrator
+              .session(doc: doc, page_calculator: page_calculator,
+                       dimensions: [width, height], config_reader: config_reader,
+                       reader_state_reader: reader_state_reader,
+                       pagination_state_writer: pagination_state_writer,
+                       ui_loading_writer: ui_loading_writer,
+                       sidebar_state_reader: sidebar_state_reader)
+              &.build_full_map
+          end
+
+          def default_single
+            { type: :single, current: 0, total: 0 }
+          end
+
+          def default_split
+            {
+              type: :split,
+              left: { current: 0, total: 0 },
+              right: { current: 0, total: 0 },
+            }
+          end
+
+          def dynamic_mode?
+            (config_reader.page_numbering_mode || :dynamic) == :dynamic
+          end
+
+          def show_page_numbers?
+            config_reader.show_page_numbers
+          end
+
+          def current_view_mode
+            config_reader.view_mode || :single
+          end
+
+          def current_line_spacing
+            config_reader.line_spacing || Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+          end
+
+          def terminal_size
+            height = ui_state_reader.terminal_height.to_i
+            width = ui_state_reader.terminal_width.to_i
+            height = 24 if height <= 0
+            width = 80 if width <= 0
+            [height, width]
+          end
+
+          def size_changed?(width, height)
+            ui_state_reader.terminal_size_changed?(width, height)
+          end
+
+          def current_page_index
+            reader_state_reader.current_page_index.to_i
+          end
+
+          def total_pages_from_calculator
+            total = page_calculator.total_pages.to_i
+            total.positive? ? total : 0
+          end
+
+          def total_pages_from_state
+            reader_state_reader.total_pages.to_i
+          end
+
+          def page_map_from_state
+            Array(reader_state_reader.page_map || [])
+          end
+
+          def pages_before_current_chapter(page_map)
+            current_chapter = reader_state_reader.current_chapter.to_i
+            page_map[0...current_chapter].sum
+          end
+
+          def page_in_chapter_for_offset(line_offset, lines_per_page)
+            (line_offset.to_f / lines_per_page).floor + 1
+          end
+
+          def line_offset_for_view(view_mode)
+            if view_mode == :split
+              reader_state_reader.left_page
+            else
+              reader_state_reader.single_page
+            end
+          end
+
+          def absolute_layout(view_mode)
+            height, width = terminal_size
+            _, content_height = layout_service.calculate_metrics(width, height, view_mode)
+            lines_per_page = layout_service.adjust_for_line_spacing(content_height, current_line_spacing)
+            { width: width, height: height, lines_per_page: lines_per_page }
+          end
+
+          def page_map_empty?
+            page_map_from_state.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/pagination/pagination_cache_preloader.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/config_reader'
+
+require_relative '../../../core/ports/outbound/reader_navigation_reader'
+
+require_relative '../../../core/ports/outbound/pagination_state_writer'
+
+require_relative '../../../core/ports/outbound/reader_state_writer'
+
+require_relative '../../../core/ports/outbound/ui_state_reader'
+
+require_relative '../../../core/ports/outbound/sidebar_state_reader'
+
+
+module Shoko
+  module Application
+    module Services
+      module Pagination
+        # Centralises the logic for hydrating dynamic pagination from the cache.
+        #
+        # This class follows hexagonal architecture principles:
+        # - Config reading goes through ConfigReader port
+        # - Reader state reading goes through ReaderNavigationReader port
+        # - UI state reading goes through UIStateReader port
+        # - Pagination writes go through PaginationStateWriter port
+        # - Config and terminal writes go through ReaderStateWriter port
+        # - All dependencies must be injected (no fallback instantiation)
+        class PaginationCachePreloader
+          # Preload outcome with an optional cache key.
+          Result = Struct.new(:status, :key, keyword_init: true)
+          # Requested terminal dimensions (before defaults are applied).
+          Dimensions = Struct.new(:width, :height, keyword_init: true)
+          # Layout metadata used for pagination cache lookups.
+          LayoutSpec = Struct.new(:key, :width, :height, :view_mode, :line_spacing, :kitty_images, :layout_variant,
+                                  keyword_init: true)
+          private_constant :Result, :Dimensions, :LayoutSpec
+
+          # @param page_calculator [Object] Page calculator service
+          # @param pagination_cache [Object] Pagination cache storage
+          # @param config_reader [Core::Ports::Outbound::ConfigReader] Port for reading config
+          # @param reader_state_reader [Core::Ports::Outbound::ReaderNavigationReader] Port for reading reader state
+          # @param pagination_state_writer [Core::Ports::Outbound::PaginationStateWriter] Port for writing pagination state
+          # @param reader_state_writer [Core::Ports::Outbound::ReaderStateWriter] Port for config/terminal writes
+          # @param display_capabilities [Core::Ports::Outbound::DisplayCapabilities] Display capability adapter (required)
+          # @param ui_state_reader [Core::Ports::Outbound::UiStateReader] Port for reading UI state
+          # @param sidebar_state_reader [Core::Ports::Outbound::SidebarStateReader] Port for sidebar visibility
+          # @param logger [Object, nil] Optional logger
+          def initialize(page_calculator:, pagination_cache:, config_reader:, reader_state_reader:,
+                         pagination_state_writer:, reader_state_writer:,
+                         display_capabilities:, ui_state_reader:, sidebar_state_reader:,
+                         logger: nil)
+            @page_calculator = page_calculator
+            @pagination_cache = pagination_cache
+            @config_reader = config_reader
+            @reader_state_reader = reader_state_reader
+            @pagination_state_writer = pagination_state_writer
+            @reader_state_writer = reader_state_writer
+            @display_capabilities = display_capabilities
+            @ui_state_reader = ui_state_reader
+            @sidebar_state_reader = sidebar_state_reader
+            @logger = logger
+          end
+
+          def preload(doc, width:, height:)
+            guard = guard_preload(doc)
+            return guard if guard
+
+            dimensions = resolve_dimensions(Dimensions.new(width: width, height: height))
+            layout, miss_key = resolve_layout(doc, dimensions)
+            return Result.new(status: :miss, key: miss_key) unless layout
+
+            apply_layout_config(layout)
+            cached_pages = load_cached_pages(doc, layout.key)
+            return Result.new(status: :miss, key: layout.key) unless cached_pages
+
+            hydrate_from_cache(cached_pages, dimensions, layout)
+            Result.new(status: :hit, key: layout.key)
+          rescue Shoko::Error => e
+            log_failure(e)
+            Result.new(status: :error)
+          end
+
+          private
+
+          attr_reader :page_calculator, :pagination_cache, :config_reader, :reader_state_reader,
+                      :pagination_state_writer, :reader_state_writer, :display_capabilities, :ui_state_reader,
+                      :sidebar_state_reader, :logger
+
+          def guard_preload(doc)
+            return Result.new(status: :invalid) unless doc
+            return Result.new(status: :unavailable) unless dynamic_mode?
+
+            Result.new(status: :no_calculator) unless page_calculator
+          end
+
+          def resolve_dimensions(requested)
+            width = requested.width || ui_state_reader&.terminal_width || 80
+            height = requested.height || ui_state_reader&.terminal_height || 24
+            Dimensions.new(width: width, height: height)
+          end
+
+          def resolve_layout(doc, dimensions)
+            layout = build_layout_spec(dimensions)
+            miss_key = layout.key
+            return [layout, miss_key] if pagination_cache.exists_for_document?(doc, layout.key)
+
+            [find_fallback_layout(doc, layout), miss_key]
+          end
+
+          def dynamic_mode?
+            config_reader.page_numbering_mode == :dynamic
+          end
+
+          def build_layout_spec(dimensions)
+            view_mode = current_view_mode
+            line_spacing = current_line_spacing
+            kitty_images = display_capabilities.kitty_images_enabled?(config_reader)
+            layout_variant = current_layout_variant
+            key = pagination_cache.layout_key(
+              dimensions.width,
+              dimensions.height,
+              view_mode,
+              line_spacing,
+              kitty_images: kitty_images,
+              layout_variant: layout_variant
+            )
+            LayoutSpec.new(
+              key: key,
+              width: dimensions.width,
+              height: dimensions.height,
+              view_mode: view_mode,
+              line_spacing: line_spacing,
+              kitty_images: kitty_images,
+              layout_variant: layout_variant
+            )
+          end
+
+          def apply_layout_config(layout)
+            reader_state_writer.update_terminal_size(layout.width, layout.height)
+            update_config(layout)
+          end
+
+          def update_config(layout)
+            updates = {}
+            updates[:view_mode] = layout.view_mode if layout.view_mode
+            updates[:line_spacing] = layout.line_spacing if layout.line_spacing
+            reader_state_writer.update_config(updates) unless updates.empty?
+          end
+
+          def load_cached_pages(doc, key)
+            cached_pages = pagination_cache.load_for_document(doc, key)
+            cached_pages if cached_pages&.any?
+          end
+
+          def hydrate_from_cache(cached_pages, dimensions, layout)
+            payload = page_calculator.hydrate_from_cache(
+              cached_pages,
+              width: dimensions.width,
+              height: dimensions.height,
+              sidebar_visible: layout&.layout_variant == :sidebar
+            )
+            pagination_state_writer.update_pagination_state(payload) if payload
+            restore = page_calculator.apply_pending_precise_restore!(reader_state_reader)
+            return unless restore
+
+            index = restore[:current_page_index]
+            pagination_state_writer.update_page(current_page_index: index) if index
+            pagination_state_writer.update_selections(pending_progress: nil) if restore[:clear_pending_progress]
+          end
+
+          def log_failure(error)
+            logger&.debug('PaginationCachePreloader: failed', error: error.message)
+          end
+
+          def find_fallback_layout(doc, layout)
+            keys = pagination_cache.layout_keys_for_document(doc)
+            return nil if keys.empty?
+
+            preferred = preferred_key(keys, layout)
+            return nil unless preferred
+
+            layout_from_key(preferred)
+          end
+
+          def preferred_key(keys, layout)
+            keys.find { |candidate| layout_key_matches?(candidate, layout) }
+          end
+
+          def layout_key_matches?(candidate, layout)
+            parsed = pagination_cache.parse_layout_key(candidate)
+            return false unless parsed
+
+            parsed[:view_mode] == layout.view_mode &&
+              parsed[:line_spacing] == layout.line_spacing &&
+              parsed[:kitty_images] == layout.kitty_images &&
+              parsed[:layout_variant] == layout.layout_variant
+          end
+
+          def layout_from_key(key)
+            parsed = pagination_cache.parse_layout_key(key)
+            return nil unless parsed
+
+            LayoutSpec.new(
+              key: key,
+              width: parsed[:width],
+              height: parsed[:height],
+              view_mode: parsed[:view_mode],
+              line_spacing: parsed[:line_spacing],
+              kitty_images: parsed[:kitty_images],
+              layout_variant: parsed[:layout_variant]
+            )
+          end
+
+          def current_view_mode
+            config_reader.view_mode
+          end
+
+          def current_line_spacing
+            config_reader.line_spacing
+          end
+
+          def current_layout_variant
+            return :base unless dynamic_mode?
+
+            sidebar_state_reader&.sidebar_visible? == true ? :sidebar : :base
+          end
+        end
+      end
+    end
+  end
+end