shoko 0.1.3 → 0.1.5

data/lib/shoko/application/services/reader/navigation/absolute_strategy.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Computes absolute-mode navigation offsets for single and split view.
+          # Returns hashes describing desired state field updates; facade applies.
+          module AbsoluteStrategy
+            module_function
+
+            def next_page(context)
+              if context.view_mode == :split
+                next_page_split(context)
+              else
+                next_page_single(context)
+              end
+            end
+
+            def prev_page(context)
+              if context.view_mode == :split
+                prev_page_split(context)
+              else
+                prev_page_single(context)
+              end
+            end
+
+            def scroll(context, direction, lines)
+              lines = lines.to_i
+              return {} if lines <= 0
+
+              if context.view_mode == :split
+                scroll_split(context, direction, lines)
+              else
+                scroll_single(context, direction, lines)
+              end
+            end
+
+            def go_to_start(context)
+              if context.view_mode == :split
+                stride = split_stride(context)
+                { current_chapter: 0, current_page: 0, single_page: 0, left_page: 0, right_page: stride }
+              else
+                { current_chapter: 0, current_page: 0, single_page: 0, left_page: 0, right_page: split_stride(context) }
+              end
+            end
+
+            def go_to_end(context)
+              # Facade will compute last_page for last chapter; provide intent only.
+              last_chapter = [context.total_chapters - 1, 0].max
+              { current_chapter: last_chapter, align_to_last: true }
+            end
+
+            def jump_to_chapter(context, index)
+              if context.view_mode == :split
+                stride = split_stride(context)
+                { current_chapter: index, current_page: 0, single_page: 0, left_page: 0, right_page: stride }
+              else
+                { current_chapter: index, current_page: 0, single_page: 0, left_page: 0,
+                  right_page: split_stride(context) }
+              end
+            end
+
+            # --- helpers ---
+            def next_page_single(context)
+              stride = single_stride(context)
+              cur = context.single_page.to_i
+              max_offset = max_offset(context)
+
+              if cur < max_offset
+                new_offset = [cur + stride, max_offset].min
+                { single_page: new_offset, current_page: new_offset }
+              elsif context.current_chapter < context.total_chapters - 1
+                { advance_chapter: :next }
+              else
+                {}
+              end
+            end
+
+            def prev_page_single(context)
+              stride = single_stride(context)
+              cur = context.single_page.to_i
+              if cur.positive?
+                new_offset = [cur - stride, 0].max
+                { single_page: new_offset, current_page: new_offset }
+              elsif context.current_chapter.positive?
+                { advance_chapter: :prev, stride: stride }
+              else
+                {}
+              end
+            end
+
+            def next_page_split(context)
+              stride = split_stride(context)
+              left = context.left_page.to_i
+              max_offset = max_offset(context)
+
+              if left < max_offset
+                new_left = [left + stride, max_offset].min
+                { left_page: new_left, right_page: new_left + stride, current_page: new_left }
+              elsif context.current_chapter < context.total_chapters - 1
+                { advance_chapter: :next }
+              else
+                {}
+              end
+            end
+
+            def prev_page_split(context)
+              stride = split_stride(context)
+              left = context.left_page.to_i
+              if left.positive?
+                new_left = [left - stride, 0].max
+                { left_page: new_left, right_page: new_left + stride, current_page: new_left }
+              elsif context.current_chapter.positive?
+                { advance_chapter: :prev, stride: stride }
+              else
+                {}
+              end
+            end
+
+            def scroll_single(context, direction, lines)
+              cur = context.single_page.to_i
+              max_offset = max_offset(context)
+              new_offset = case direction
+                           when :up
+                             [cur - lines, 0].max
+                           when :down
+                             [cur + lines, max_offset].min
+                           else
+                             raise ArgumentError, "Invalid scroll direction: #{direction}"
+                           end
+
+              return {} if new_offset == cur
+
+              { single_page: new_offset, current_page: new_offset }
+            end
+
+            def scroll_split(context, direction, lines)
+              cur = context.left_page.to_i
+              stride = split_stride(context)
+              max_offset = max_offset(context)
+              new_offset = case direction
+                           when :up
+                             [cur - lines, 0].max
+                           when :down
+                             [cur + lines, max_offset].min
+                           else
+                             raise ArgumentError, "Invalid scroll direction: #{direction}"
+                           end
+
+              return {} if new_offset == cur
+
+              { left_page: new_offset, right_page: new_offset + stride, current_page: new_offset }
+            end
+
+            def single_stride(context)
+              stride = context.lines_per_page.to_i
+              stride = context.column_lines_per_page.to_i if stride <= 0
+              stride = 1 if stride <= 0
+              stride
+            end
+
+            def split_stride(context)
+              stride = context.column_lines_per_page.to_i
+              stride = context.lines_per_page.to_i if stride <= 0
+              stride = 1 if stride <= 0
+              stride
+            end
+
+            def max_offset(context)
+              context.max_offset_in_chapter.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/context_builder.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+require_relative 'context_helpers'
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Builds navigation context snapshots from the current state.
+          # Uses hexagonal ports for reading state - no direct state_store access.
+          class ContextBuilder
+            # Construct with required ports
+            # @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 page_calculator [Object] Page calculator service (optional)
+            def initialize(config_reader:, reader_state_reader:, page_calculator: nil)
+              @config_reader = config_reader
+              @reader_state_reader = reader_state_reader
+              @page_calculator = page_calculator
+            end
+
+            # Factory method for port-based construction (alias for constructor)
+            # @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 page_calculator [Object] Page calculator service
+            def self.with_ports(config_reader:, reader_state_reader:, page_calculator: nil)
+              new(config_reader: config_reader, reader_state_reader: reader_state_reader,
+                  page_calculator: page_calculator)
+            end
+
+            def build
+              snapshot = build_snapshot
+              build_context_from_snapshot(snapshot)
+            end
+
+            private
+
+            attr_reader :page_calculator, :config_reader, :reader_state_reader
+
+            def build_snapshot
+              ContextHelpers.build_snapshot_from_ports(
+                config_reader: config_reader,
+                reader_state_reader: reader_state_reader
+              )
+            end
+
+            def build_context_from_snapshot(snapshot)
+              NavContext.new(
+                mode: ContextHelpers.dynamic_mode?(snapshot) ? :dynamic : :absolute,
+                view_mode: ContextHelpers.current_view_mode(snapshot),
+                current_chapter: ContextHelpers.current_chapter(snapshot),
+                total_chapters: ContextHelpers.total_chapters(snapshot),
+                current_page_index: ContextHelpers.current_page_index(snapshot),
+                dynamic_total_pages: dynamic_total_pages,
+                single_page: ContextHelpers.single_page(snapshot),
+                left_page: ContextHelpers.left_page(snapshot),
+                right_page: ContextHelpers.right_page(snapshot),
+                max_page_in_chapter: 0,
+                lines_per_page: 0,
+                column_lines_per_page: 0,
+                max_offset_in_chapter: 0
+              )
+            end
+
+            def dynamic_total_pages
+              return 0 unless page_calculator
+
+              page_calculator.total_pages.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/context_helpers.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Helpers for extracting navigation-relevant values from a state snapshot.
+          # These are pure functions that work on hash snapshots, keeping them
+          # decoupled from specific state store implementations.
+          module ContextHelpers
+            module_function
+
+            def dynamic_mode?(snapshot)
+              mode = snapshot[:page_numbering_mode]
+              mode == :dynamic
+            end
+
+            def current_view_mode(snapshot)
+              snapshot[:view_mode] || :single
+            end
+
+            def current_chapter(snapshot)
+              snapshot[:current_chapter] || 0
+            end
+
+            def total_chapters(snapshot)
+              snapshot[:total_chapters] || 0
+            end
+
+            def current_page_index(snapshot)
+              snapshot[:current_page_index] || 0
+            end
+
+            def current_page(snapshot)
+              snapshot[:current_page] || 0
+            end
+
+            def single_page(snapshot)
+              snapshot[:single_page] || current_page(snapshot)
+            end
+
+            def left_page(snapshot)
+              snapshot[:left_page] || current_page(snapshot)
+            end
+
+            def right_page(snapshot)
+              snapshot[:right_page] || 0
+            end
+
+            def page_map(snapshot)
+              snapshot[:page_map] || []
+            end
+
+            # Build a snapshot hash from ports (for migration to port-based access)
+            # This allows ContextBuilder to use ports while ContextHelpers remain pure
+            def build_snapshot_from_ports(config_reader:, reader_state_reader:)
+              {
+                page_numbering_mode: config_reader.page_numbering_mode,
+                view_mode: config_reader.view_mode,
+                line_spacing: config_reader.line_spacing,
+                current_chapter: reader_state_reader.current_chapter,
+                total_chapters: reader_state_reader.total_chapters,
+                current_page_index: reader_state_reader.current_page_index,
+                current_page: reader_state_reader.current_page,
+                single_page: reader_state_reader.single_page,
+                left_page: reader_state_reader.left_page,
+                right_page: reader_state_reader.right_page,
+                page_map: reader_state_reader.page_map,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/dynamic_change_applier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Applies dynamic-mode changes via the state updater.
+          # Uses hexagonal ports for reading state - no direct state_store access.
+          class DynamicChangeApplier
+            def initialize(reader_state_reader:, page_calculator:, state_updater:)
+              @reader_state_reader = reader_state_reader
+              @page_calculator = page_calculator
+              @state_updater = state_updater
+            end
+
+            def apply(changes)
+              return if changes.nil? || changes.empty?
+
+              update_page_index(changes[:current_page_index]) if changes.key?(:current_page_index)
+
+              return unless changes.key?(:current_chapter)
+
+              @state_updater.apply(current_chapter: changes[:current_chapter])
+            end
+
+            private
+
+            def update_page_index(new_index)
+              updates = { current_page_index: new_index }
+              page = @page_calculator&.get_page(new_index)
+              if page
+                current_chapter = page[:chapter_index]
+                current_chapter ||= current_chapter_from_state || 0
+                updates[:current_chapter] = current_chapter
+              end
+
+              @state_updater.apply(updates)
+            end
+
+            def current_chapter_from_state
+              @reader_state_reader.current_chapter
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/dynamic_strategy.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'nav_context'
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Computes dynamic-mode navigation targets from an immutable context.
+          # Returns simple hashes describing state changes; facade applies them.
+          module DynamicStrategy
+            module_function
+
+            def next_page(context)
+              inc = context.view_mode == :split ? 2 : 1
+              total = context.dynamic_total_pages.to_i
+              return {} if total <= 0
+
+              new_index = (context.current_page_index + inc).clamp(0, total - 1)
+              { current_page_index: new_index }
+            end
+
+            def prev_page(context)
+              dec = context.view_mode == :split ? 2 : 1
+              total = context.dynamic_total_pages.to_i
+              return {} if total <= 0
+
+              new_index = (context.current_page_index - dec).clamp(0, total - 1)
+              { current_page_index: new_index }
+            end
+
+            def go_to_start(_context)
+              { current_chapter: 0, current_page_index: 0 }
+            end
+
+            def go_to_end(context)
+              total = context.dynamic_total_pages.to_i
+              return {} if total <= 0
+
+              { current_page_index: total - 1 }
+            end
+
+            def jump_to_chapter(_context, index)
+              # Facade will map chapter -> page index precisely; here provide chapter intent.
+              { current_chapter: index, current_page_index: 0 }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/image_offset_snapper.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'context_helpers'
+require_relative 'absolute_layout'
+require_relative '../../../../core/models/content_block'
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Snaps absolute offsets so image blocks render from their first line.
+          # Uses hexagonal ports for reading state - no direct state_store access.
+          class ImageOffsetSnapper
+            # @param layout_service [Object] Layout service
+            # @param wrapped_lines_provider [Core::Ports::Outbound::WrappedLinesProvider, nil] Wrapped lines provider
+            # @param display_capabilities [Core::Ports::Outbound::DisplayCapabilities] Display capability adapter (required)
+            # @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 ui_state_reader [Core::Ports::Outbound::UiStateReader] Port for reading UI state
+            def initialize(layout_service:, wrapped_lines_provider:, display_capabilities:,
+                           config_reader:, reader_state_reader:, ui_state_reader:, logger: nil)
+              @layout_service = layout_service
+              @wrapped_lines_provider = wrapped_lines_provider
+              @config_reader = config_reader
+              @reader_state_reader = reader_state_reader
+              @ui_state_reader = ui_state_reader
+              @layout = AbsoluteLayout.new(
+                layout_service: layout_service,
+                config_reader: config_reader,
+                reader_state_reader: reader_state_reader,
+                ui_state_reader: ui_state_reader,
+                logger: logger
+              )
+              @display_capabilities = display_capabilities
+              @logger = logger
+            end
+
+            def snap(updates, layout_state)
+              return updates unless enabled?
+              return updates if updates.nil? || updates.empty?
+
+              snapshot = layout_state.snapshot
+              view_mode = layout_state.view_mode
+              stride = layout_state.stride
+              chapter_index = updates[:current_chapter] || ContextHelpers.current_chapter(snapshot)
+              col_width = @layout.column_width(snapshot, view_mode)
+
+              if view_mode == :split
+                snap_split(updates, chapter_index, col_width, stride, snapshot)
+              else
+                snap_single(updates, chapter_index, col_width, stride, snapshot)
+              end
+            rescue Shoko::Error => e
+              @logger&.debug("image_offset_snapper.snap failed: #{e.message}")
+              updates
+            end
+
+            private
+
+            def enabled?
+              return false unless @layout_service && @wrapped_lines_provider
+
+              @display_capabilities.kitty_images_enabled?(@config_reader)
+            end
+
+            def snap_split(updates, chapter_index, col_width, stride, snapshot)
+              left = (updates[:left_page] || snapshot[:left_page] || 0).to_i
+              snapped = snap_offset(chapter_index, col_width, left, stride)
+              return updates if snapped == left
+
+              updates[:left_page] = snapped
+              updates[:current_page] = snapped
+              updates[:right_page] = snapped + stride
+              updates
+            end
+
+            def snap_single(updates, chapter_index, col_width, stride, snapshot)
+              offset = (updates[:single_page] || snapshot[:single_page] || 0).to_i
+              snapped = snap_offset(chapter_index, col_width, offset, stride)
+              return updates if snapped == offset
+
+              updates[:single_page] = snapped
+              updates[:current_page] = snapped
+              updates
+            end
+
+            def snap_offset(chapter_index, col_width, offset, lines_per_page)
+              offset_i = offset.to_i
+              return offset_i if offset_i <= 0
+
+              lines = wrapped_lines(chapter_index, col_width, lines_per_page)
+              return offset_i unless lines && lines[offset_i]
+
+              image_start_for(lines, offset_i) || offset_i
+            rescue Shoko::Error => e
+              @logger&.debug("image_offset_snapper.snap_offset failed: #{e.message}")
+              offset_i
+            end
+
+            def wrapped_lines(chapter_index, col_width, lines_per_page)
+              @wrapped_lines_provider.wrapped_lines_for(
+                chapter_index: chapter_index,
+                col_width: col_width,
+                lines_per_page: lines_per_page,
+                config_reader: @config_reader
+              )
+            end
+
+            def image_start_for(lines, offset)
+              meta = line_metadata(lines[offset])
+              render = image_render(meta)
+              return nil unless render
+
+              src = image_src(meta)
+              return nil if src.to_s.empty?
+              return offset if render_line?(meta)
+
+              idx = offset
+              while idx.positive?
+                cur_meta = line_metadata(lines[idx])
+                break unless same_image?(cur_meta, src)
+                return idx if render_line?(cur_meta)
+
+                idx -= 1
+              end
+
+              0
+            end
+
+            def same_image?(meta, src)
+              return false unless image_render(meta)
+
+              image_src(meta).to_s == src.to_s
+            end
+
+            def render_line?(meta)
+              return false unless meta
+
+              meta[:image_render_line] == true
+            end
+
+            def image_render(meta)
+              return nil unless meta
+
+              render = meta[:image_render]
+              render.is_a?(Hash) ? render : nil
+            end
+
+            def line_metadata(line)
+              return nil unless line.is_a?(Shoko::Core::Models::DisplayLine)
+
+              meta = line.metadata
+              normalize_meta_hash(meta)
+            end
+
+            def image_src(meta)
+              image = meta[:image]
+              return nil unless image.is_a?(Hash)
+
+              image[:src]
+            end
+
+            def normalize_meta_hash(value)
+              return nil unless value.is_a?(Hash)
+
+              value.each_with_object({}) do |(key, raw), acc|
+                normalized_key = key.is_a?(String) ? key.to_sym : key
+                acc[normalized_key] = normalize_meta_value(raw)
+              end
+            end
+
+            def normalize_meta_value(value)
+              return value.each_with_object({}) { |(key, raw), acc| acc[key.is_a?(String) ? key.to_sym : key] = raw } if value.is_a?(Hash)
+
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/nav_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Immutable snapshot of navigation-relevant state.
+          NavContext = Struct.new(
+            :mode,                 # :dynamic or :absolute
+            :view_mode,            # :single or :split
+            :current_chapter,      # Integer
+            :total_chapters,       # Integer
+            :current_page_index,   # Integer (dynamic)
+            :dynamic_total_pages,  # Integer (dynamic total pages)
+            :single_page,          # Integer (absolute single)
+            :left_page,            # Integer (absolute split left)
+            :right_page,           # Integer (absolute split right)
+            :max_page_in_chapter,  # Integer (absolute page count)
+            :lines_per_page,       # Integer (absolute single stride)
+            :column_lines_per_page, # Integer (absolute split stride)
+            :max_offset_in_chapter, # Integer (absolute last offset)
+            keyword_init: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/services/reader/navigation/state_updater.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module Services
+      module Reader
+        module Navigation
+          # Applies state updates using focused reader state writer ports.
+          # Uses hexagonal ports for writing state - no direct state_store access.
+          class StateUpdater
+            # @param state_writer [Core::Ports::Outbound::ReaderStateWriter] Port for writing state
+            def initialize(state_writer)
+              @state_writer = state_writer
+            end
+
+            def apply(updates)
+              return if updates.nil? || updates.empty?
+
+              @state_writer.update_navigation(updates)
+            end
+          end
+        end
+      end
+    end
+  end
+end