shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/output/formatting/wrapping_service.rb

@@ -1,226 +1,249 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/services/base_service.rb'
-require_relative '../../../core/services/pagination/internal/chapter_cache.rb'
-require_relative '../terminal/text_metrics.rb'
+require_relative '../../base_adapter'
+require_relative '../../../core/ports/outbound/line_wrapper'
+require_relative '../../../core/ports/outbound/runtime_config'
+require_relative '../../../core/ports/outbound/chapter_formatter'
+require_relative '../../../core/ports/outbound/reader_launch_state'
+require_relative '../../../core/models/content_block'
+require_relative '../../../core/services/pagination/internal/chapter_cache'
 
 module Shoko
   module Adapters
     module Output
       module Formatting
         # Service responsible for wrapping chapter lines to a column width.
-        # Uses the shared ChapterCache to avoid recomputation across frames.
-        class WrappingService < BaseService
+        # Uses an adapter-local chapter cache to avoid recomputation across frames.
+        class WrappingService < Shoko::Adapters::BaseAdapter
+          include Shoko::Core::Ports::Outbound::LineWrapper
+
           WINDOW_CACHE_LIMIT = 200
 
-          def initialize(dependencies)
-            super
-            @chapter_cache = Shoko::Core::Services::Pagination::Internal::ChapterCache.new
+          # @param text_metrics [Object] Text metrics for measuring/wrapping
+          # @param async_executor [Object] Executor for background work
+          # @param reader_launch_state [Core::Ports::Outbound::ReaderLaunchState]
+          # @param config_reader [Object, nil] Optional config reader port
+          # @param runtime_config [Core::Ports::Outbound::RuntimeConfig] Runtime configuration
+          # @param formatting_service [Core::Ports::Outbound::ChapterFormatter] Formatting service
+          # @param logger [Object, nil] Optional logger
+          def initialize(text_metrics:, async_executor:, reader_launch_state:, config_reader: nil,
+                         runtime_config:, formatting_service:, logger: nil)
+            super(logger: logger)
+            unless reader_launch_state.is_a?(Shoko::Core::Ports::Outbound::ReaderLaunchState)
+              raise ArgumentError, 'reader_launch_state must implement Core::Ports::Outbound::ReaderLaunchState'
+            end
+            unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+              raise ArgumentError, 'runtime_config must implement Core::Ports::Outbound::RuntimeConfig'
+            end
+            unless formatting_service.is_a?(Shoko::Core::Ports::Outbound::ChapterFormatter)
+              raise ArgumentError, 'formatting_service must implement Core::Ports::Outbound::ChapterFormatter'
+            end
+
+            @text_metrics = text_metrics
+            @async_executor = async_executor
+            @reader_launch_state = reader_launch_state
+            @config_reader = config_reader
+            @runtime_config = runtime_config
+            @formatting_service = formatting_service
+            @chapter_cache = build_chapter_cache
             @window_cache = Hash.new { |h, k| h[k] = { store: {}, order: [] } }
           end
 
-        # Wrap raw lines for a chapter to the given width.
-        # Falls back to a local wrapper if cache is unavailable.
-        #
-        # @param lines [Array<String>] raw chapter lines
-        # @param chapter_index [Integer] chapter index for caching keying
-        # @param width [Integer] column width
-        # @return [Array<String>] wrapped lines
-        def wrap_lines(lines, chapter_index, width)
-          return [] if lines.nil? || width.to_i < 10
-
-          formatted = fetch_formatted_lines(chapter_index, width, 0, lines.length)
-          return formatted if formatted
-
-          cache = begin
-            registered?(:chapter_cache) ? resolve(:chapter_cache) : @chapter_cache
-          rescue StandardError
-            @chapter_cache
-          end
-          cache.get_wrapped_lines(chapter_index, lines, width)
-        end
+          # Wrap raw lines for a chapter to the given width.
+          # Falls back to a local wrapper if cache is unavailable.
+          #
+          # @param lines [Array<String>] raw chapter lines
+          # @param chapter_index [Integer] chapter index for caching keying
+          # @param width [Integer] column width
+          # @return [Array<String>] wrapped lines
+          def wrap_lines(lines, chapter_index, width, document: nil)
+            return [] if lines.nil? || width.to_i < 10
 
-        # Wrap only a window of text sufficient for immediate display.
-        # This avoids wrapping the entire chapter on first render.
-        #
-        # @param lines [Array<String>] raw chapter lines
-        # @param chapter_index [Integer] chapter index (for caching semantics if needed)
-        # @param width [Integer] column width
-        # @param start [Integer] wrapped-lines start offset
-        # @param length [Integer] number of wrapped lines to return
-        # @return [Array<String>] slice of wrapped lines covering the requested window
-        def wrap_window(lines, chapter_index, width, start, length)
-          width_i = width.to_i
-          length_i = length.to_i
-          start_i = start.to_i
-          return [] if lines.nil? || width_i <= 0 || length_i <= 0
-
-          formatted = fetch_formatted_lines(chapter_index, width_i, start_i, length_i)
-          return formatted if formatted
-
-          target_end = [start_i, 0].max + length_i - 1
-          key = [lines.object_id, chapter_index, width_i]
-          cached = @window_cache[key][:store][[start_i, length_i]]
-          return cached if cached
-
-          wrapped = []
-
-          lines.each do |line|
-            break if wrapped.length >= (target_end + 1)
-
-            next if line.nil?
-
-            if line.strip.empty?
-              wrapped << ''
-              next
-            end
+            formatted = fetch_formatted_lines(chapter_index, width, 0, lines.length, document: document)
+            return formatted if formatted
 
-            segments = Shoko::Adapters::Output::Terminal::TextMetrics.wrap_plain_text(line, width_i)
-            wrapped.concat(segments)
+            @chapter_cache.get_wrapped_lines(chapter_index, lines, width)
           end
 
-          start_index = [start_i, 0].max
-          return [] if start_index >= wrapped.length
+          # Wrap only a window of text sufficient for immediate display.
+          # This avoids wrapping the entire chapter on first render.
+          #
+          # @param lines [Array<String>] raw chapter lines
+          # @param chapter_index [Integer] chapter index (for caching semantics if needed)
+          # @param width [Integer] column width
+          # @param start [Integer] wrapped-lines start offset
+          # @param length [Integer] number of wrapped lines to return
+          # @return [Array<String>] slice of wrapped lines covering the requested window
+          def wrap_window(lines, chapter_index, width, start, length, document: nil)
+            width_i = width.to_i
+            length_i = length.to_i
+            start_i = [start.to_i, 0].max
+            return [] if lines.nil? || width_i <= 0 || length_i <= 0
+
+            formatted = fetch_formatted_lines(chapter_index, width_i, start_i, length_i, document: document)
+            return formatted if formatted
+
+            target_end = start_i + length_i - 1
+            key = [lines.object_id, chapter_index, width_i]
+            cached = cached_window_for(key, start_i, length_i)
+            return cached if cached
+
+            wrapped = []
+
+            lines.each do |line|
+              break if wrapped.length >= (target_end + 1)
+
+              next if line.nil?
+
+              if line.strip.empty?
+                wrapped << ''
+                next
+              end
 
-          slice = wrapped[start_index, length_i] || []
-          cache_put(key, [start_i, length_i], slice)
-          slice
-        end
+              segments = @text_metrics.wrap_plain_text(line, width_i)
+              wrapped.concat(segments)
+            end
 
-        def prefetch_windows(lines, chapter_index, width, start, length)
-          wrap_window(lines, chapter_index, width, start, length)
-        end
+            return [] if start_i >= wrapped.length
 
-        # Wrap the visible window and prefetch ±N pages around it in the background.
-        # This centralizes the behavior that was previously embedded in ReaderController.
-        #
-        # @param doc [Object] document responding to #get_chapter(index)
-        # @param chapter_index [Integer]
-        # @param col_width [Integer]
-        # @param offset [Integer] wrapped-line offset
-        # @param display_height [Integer] lines per page
-        # @param pre_pages [Integer,nil] optional number of pages to prefetch; defaults from config
-        # @return [Array<String>] visible wrapped lines for the requested window
-        def fetch_window_and_prefetch(doc, chapter_index, col_width, offset, display_height,
-                                      pre_pages = nil)
-          return [] unless doc && display_height.to_i.positive?
-
-          chapter = doc.get_chapter(chapter_index)
-          return [] unless chapter
-
-          lines = chapter.lines || []
-          start_i = [offset.to_i, 0].max
-          length_i = display_height.to_i
-
-          visible = wrap_window(lines, chapter_index, col_width, start_i, length_i)
-
-          begin
-            pages = pre_pages
-            if pages.nil?
-              st = resolve(:state_store) if registered?(:state_store)
-              pages = begin
-                st.get(%i[config prefetch_pages]) if st.respond_to?(:get)
-              rescue StandardError
-                nil
-              end
-            end
-            pages = pages.nil? ? 20 : pages.to_i
-            pages = pages.clamp(0, 200)
-            window = pages * length_i
-            prefetch_start = [start_i - window, 0].max
-            prefetch_end   = start_i + window + (length_i - 1)
-            prefetch_len   = prefetch_end - prefetch_start + 1
-            enqueue_prefetch(chapter_index, col_width, prefetch_start, prefetch_len, lines)
-          rescue StandardError
-            # best-effort prefetch
+            slice = wrapped[start_i, length_i] || []
+            cache_put(key, [start_i, length_i], slice)
+            slice
           end
 
-          visible
-        end
+          def prefetch_windows(lines, chapter_index, width, start, length)
+            wrap_window(lines, chapter_index, width, start, length)
+          end
 
-        # Clear all cached wrapped lines
-        def clear_cache
-          @chapter_cache = Shoko::Core::Services::Pagination::Internal::ChapterCache.new
-          @window_cache.clear
-        end
+          # Wrap the visible window and prefetch ±N pages around it in the background.
+          # This centralizes the behavior that was previously embedded in ReaderController.
+          #
+          # @param doc [Object] document responding to #get_chapter(index)
+          # @param chapter_index [Integer]
+          # @param col_width [Integer]
+          # @param offset [Integer] wrapped-line offset
+          # @param display_height [Integer] lines per page
+          # @param pre_pages [Integer,nil] optional number of pages to prefetch; defaults from config
+          # @return [Array<String>] visible wrapped lines for the requested window
+          def fetch_window_and_prefetch(doc, chapter_index, col_width, offset, display_height,
+                                        pre_pages = nil)
+            return [] unless doc && display_height.to_i.positive?
+
+            chapter = doc.get_chapter(chapter_index)
+            return [] unless chapter
+
+            lines = chapter.lines || []
+            start_i = [offset.to_i, 0].max
+            length_i = display_height.to_i
+
+            visible = wrap_window(lines, chapter_index, col_width, start_i, length_i, document: doc)
+
+            begin
+              pages = pre_pages
+              pages = @config_reader&.prefetch_pages if pages.nil?
+              pages = pages.nil? ? 20 : pages.to_i
+              pages = pages.clamp(0, 200)
+              window = pages * length_i
+              prefetch_start = [start_i - window, 0].max
+              prefetch_end   = start_i + window + (length_i - 1)
+              prefetch_len   = prefetch_end - prefetch_start + 1
+              enqueue_prefetch(chapter_index, col_width, prefetch_start, prefetch_len, lines)
+            rescue Shoko::Error
+              # best-effort prefetch
+            end
 
-        # Clear cache entries for a given width
-        def clear_cache_for_width(width)
-          width_i = width.to_i
-          @chapter_cache.clear_cache_for_width(width_i)
-          @window_cache.delete_if do |key, _|
-            key.is_a?(Array) ? key[2] == width_i : key.to_s.end_with?("_#{width_i}")
+            visible
           end
-        end
 
-        protected
+          # Clear all cached wrapped lines
+          def clear_cache
+            @chapter_cache = build_chapter_cache
+            @window_cache.clear
+          end
 
-        def required_dependencies
-          []
-        end
+          # Clear cache entries for a given width
+          def clear_cache_for_width(width)
+            width_i = width.to_i
+            @chapter_cache.clear_cache_for_width(width_i)
+            @window_cache.delete_if do |key, _|
+              key.is_a?(Array) ? key[2] == width_i : key.to_s.end_with?("_#{width_i}")
+            end
+          end
 
-        private
+          private
 
-        # No-op private helpers retained for compatibility-free interface.
+          def build_chapter_cache
+            Shoko::Core::Services::Pagination::Internal::ChapterCache.new(
+              text_metrics: @text_metrics
+            )
+          end
 
-        def cache_put(key, subkey, value)
-          entry = @window_cache[key]
-          store = entry[:store]
-          order = entry[:order]
-          unless store.key?(subkey)
-            order << subkey
-            if order.length > WINDOW_CACHE_LIMIT
-              oldest = order.shift
-              store.delete(oldest)
+          def cache_put(key, subkey, value)
+            entry = @window_cache[key]
+            store = entry[:store]
+            order = entry[:order]
+            unless store.key?(subkey)
+              order << subkey
+              if order.length > WINDOW_CACHE_LIMIT
+                oldest = order.shift
+                store.delete(oldest)
+              end
             end
+            store[subkey] = value
           end
-          store[subkey] = value
-        end
 
-        def fetch_formatted_lines(chapter_index, width, offset, length)
-          return unless registered?(:formatting_service)
+          def cached_window_for(key, start_i, length_i)
+            store = @window_cache[key][:store]
+            exact = store[[start_i, length_i]]
+            return exact unless exact.nil?
+            return nil unless window_range_cache_enabled?
+
+            covered_window_slice(store, start_i, length_i)
+          end
 
-          document = begin
-            resolve(:document)
-          rescue StandardError
+          def covered_window_slice(store, start_i, length_i)
+            requested_end = start_i + length_i - 1
+            store.each do |(cached_start, cached_length), cached_values|
+              cached_end = cached_start + cached_length - 1
+              next if cached_start > start_i || cached_end < requested_end
+
+              offset = start_i - cached_start
+              return cached_values[offset, length_i] || []
+            end
             nil
           end
-          return unless document
 
-          formatting = resolve(:formatting_service)
-          lines = formatting.wrap_window(document, chapter_index, width, offset: offset, length: length)
-          return unless lines && !lines.empty?
+          def window_range_cache_enabled?
+            !@runtime_config.wrapping_window_range_cache_disabled?
+          end
 
-          lines.map { |line| line.respond_to?(:text) ? line.text : line }
-        rescue StandardError
-          nil
-        end
+          def fetch_formatted_lines(chapter_index, width, offset, length, document: nil)
+            document ||= current_document
+            return unless document
+
+            lines = @formatting_service.wrap_window(document, chapter_index, width, offset: offset, length: length)
+            return unless lines && !lines.empty?
 
-        def enqueue_prefetch(chapter_index, col_width, prefetch_start, prefetch_len, lines)
-          worker = background_worker
-          job = lambda do
-            prefetch_windows(lines, chapter_index, col_width, prefetch_start, prefetch_len)
+            lines.map { |line| line.is_a?(Shoko::Core::Models::DisplayLine) ? line.text : line }
+          rescue Shoko::Error
+            raise
           end
-          if worker
-            worker.submit(&job)
-          else
-            Thread.new do
-              job.call
-            rescue StandardError
-              # ignore background failures
-            end
+
+          def current_document
+            @reader_launch_state.preloaded_document
+          rescue Shoko::Error
+            raise
           end
-        rescue StandardError
-          # ignore background failures
-        end
 
-        def background_worker
-          return nil unless registered?(:background_worker)
+          def enqueue_prefetch(chapter_index, col_width, prefetch_start, prefetch_len, lines)
+            job = lambda do
+              prefetch_windows(lines, chapter_index, col_width, prefetch_start, prefetch_len)
+            end
+            @async_executor.submit(&job)
+          rescue Shoko::Error
+            # ignore background failures
+          end
 
-          resolve(:background_worker)
-        rescue StandardError
-          nil
-        end
         end
       end
     end

data/lib/shoko/adapters/output/instrumentation_service.rb

@@ -1,52 +1,87 @@
 # frozen_string_literal: true
 
-require_relative '../../core/services/base_service.rb'
+require_relative '../base_adapter'
+require_relative '../../core/ports/outbound/instrumentation'
 
 module Shoko
-  module Adapters::Output
+  module Adapters
+    module Output
       # Provides a single facade for performance monitoring and tracing so that
       # higher layers do not talk to infrastructure modules directly.
-      class InstrumentationService < BaseService
-        def initialize(dependencies)
-          super
-          @monitor = resolve_optional(:performance_monitor)
-          @tracer  = resolve_optional(:perf_tracer)
+      class InstrumentationService < Shoko::Adapters::BaseAdapter
+        include Shoko::Core::Ports::Outbound::Instrumentation
+
+        class NullMonitor
+          def time(_metric)
+            yield
+          end
+
+          def record_metric(_name, _value, _count = 1)
+            nil
+          end
+        end
+
+        class NullTracer
+          def measure(_metric)
+            yield
+          end
+
+          def annotate(_payload); end
+
+          def record(_metric, _value); end
+
+          def complete(**_payload); end
+
+          def cancel; end
+
+          def start_open(_path)
+            nil
+          end
+        end
+
+        # @param performance_monitor [Object, nil] Optional performance monitor
+        # @param perf_tracer [Object, nil] Optional performance tracer
+        # @param logger [Object, nil] Optional logger
+        def initialize(performance_monitor: nil, perf_tracer: nil, logger: nil)
+          super(logger: logger)
+          @monitor = performance_monitor || NullMonitor.new
+          @tracer = perf_tracer || NullTracer.new
+        end
+
+        def measure(metric, &)
+          raise ArgumentError, 'block required for #measure' unless block_given?
+
+          @tracer.measure(metric) { @monitor.time(metric, &) }
         end
 
         def time(metric, &)
-          raise ArgumentError, 'block required for #time' unless block_given?
-          return yield unless @monitor.respond_to?(:time)
+          measure(metric, &)
+        end
 
-          @monitor.time(metric, &)
+        def annotate(payload)
+          @tracer.annotate(payload)
         end
 
         def record_metric(name, value, count = 1)
-          @monitor&.record_metric(name, value, count)
+          @monitor.record_metric(name, value, count)
         end
 
         def record_trace(metric, value)
-          @tracer&.record(metric, value)
+          @tracer.record(metric, value)
         end
 
         def complete_trace(**payload)
-          @tracer&.complete(**payload)
+          @tracer.complete(**payload)
         end
 
         def cancel_trace
-          @tracer&.cancel
+          @tracer.cancel
         end
 
         def start_trace(path)
-          @tracer.respond_to?(:start_open) ? @tracer.start_open(path) : nil
-        end
-
-        private
-
-        def resolve_optional(name)
-          resolve(name)
-        rescue StandardError
-          nil
+          @tracer.start_open(path)
         end
       end
+    end
   end
 end

data/lib/shoko/adapters/output/kitty/display_capabilities.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/display_capabilities'
+require_relative 'kitty_graphics'
+
+module Shoko
+  module Adapters
+    module Output
+      module Kitty
+        # Adapter providing display capability checks for core ports.
+        class DisplayCapabilities
+          include Shoko::Core::Ports::Outbound::DisplayCapabilities
+
+          def kitty_images_enabled?(state_or_config)
+            KittyGraphics.enabled_for?(state_or_config)
+          end
+        end
+      end
+    end
+  end
+end