shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/rendering/line/line_drawer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative 'config_helpers'
+require_relative 'kitty_image_line_renderer'
+require_relative 'line_content_composer'
+require_relative 'line_geometry_builder'
+require_relative 'rendered_lines_recorder'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Draws a single line into a Surface and records its geometry.
+          class LineDrawer
+            def initialize(dependencies:, rendered_lines_buffer:, placed_kitty_images:, record_geometry: true)
+              @dependencies = dependencies
+              @record_geometry = record_geometry
+              runtime_config = @dependencies&.runtime_config
+              @content_composer = LineContentComposer.new(runtime_config: runtime_config)
+              if @record_geometry
+                @geometry_builder = LineGeometryBuilder.new(runtime_config: runtime_config)
+                @recorder = RenderedLinesRecorder.new(buffer: rendered_lines_buffer, dependencies: dependencies)
+              end
+              @kitty_renderer = KittyImageLineRenderer.new(dependencies: dependencies,
+                                                           placed_kitty_images: placed_kitty_images)
+            end
+
+            def draw_line(surface:, bounds:, line:, row:, col:, width:, context:, column_id:, line_offset:, page_id:)
+              config_reader = resolve_config_reader(context)
+
+              return if draw_kitty_line(surface: surface, bounds: bounds, line: line, row: row, col: col,
+                                        context: context, config_reader: config_reader)
+
+              _plain_text, styled_text = @content_composer.compose(line, width, config_reader)
+              abs_row, abs_col = absolute_cell(bounds, row, col)
+              clipped_styled, clipped_plain = clip_to_bounds(styled_text, width, bounds, abs_col)
+
+              if @record_geometry
+                geometry = @geometry_builder.build(page_id: page_id, column_id: column_id, row: abs_row, col: abs_col,
+                                                   line_offset: line_offset, plain_text: clipped_plain,
+                                                   styled_text: clipped_styled)
+                @recorder.record(geometry)
+              end
+              surface.write(bounds, row, col, clipped_styled)
+            end
+
+            private
+
+            def draw_kitty_line(surface:, bounds:, line:, row:, col:, context:, config_reader:)
+              return false unless @kitty_renderer.kitty_image_line?(line, config: config_reader)
+
+              image_text, col_offset = @kitty_renderer.render(line, context)
+              return false if image_text.nil?
+              return true if image_text.empty?
+
+              surface.write(bounds, row, col + col_offset.to_i, image_text)
+              true
+            rescue Shoko::Error
+              raise
+            end
+
+            def resolve_config_reader(context)
+              context&.config_reader
+            end
+
+            def absolute_cell(bounds, row, col)
+              [bounds.y + row - 1, bounds.x + col - 1]
+            end
+
+            def clip_to_bounds(styled_text, width, bounds, abs_col)
+              max_width = [width.to_i, bounds.right - abs_col + 1].min
+              max_width = 0 if max_width.negative?
+              start_column = [abs_col - 1, 0].max
+
+              clipped_styled = clipped_styled_text(styled_text, max_width, start_column)
+              clipped_plain = Shoko::Shared::Terminal::TextMetrics.strip_ansi(clipped_styled)
+              [clipped_styled, clipped_plain]
+            end
+
+            def clipped_styled_text(styled_text, max_width, start_column)
+              return '' unless max_width.positive?
+
+              Shoko::Shared::Terminal::TextMetrics.truncate_to(
+                styled_text.to_s,
+                max_width,
+                start_column: start_column
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/rendering/line/line_geometry_builder.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../models/line_geometry'
+require_relative '../../../../core/ports/outbound/runtime_config'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Builds `Shoko::Adapters::Ui::Rendering::Models::LineGeometry` objects for selection/highlighting.
+          class LineGeometryBuilder
+            CELL_CACHE_LIMIT = 2_000
+            CELL_CACHEABLE_BYTES = 256
+            CELL_CACHE_ENABLED_KEY = :shoko_line_geometry_cell_cache_enabled
+            RUNTIME_CONFIG_KEY = :shoko_line_geometry_runtime_config
+
+            class << self
+              def with_runtime_config(config:)
+                previous = Thread.current[RUNTIME_CONFIG_KEY]
+                Thread.current[RUNTIME_CONFIG_KEY] = config if config
+                yield
+              ensure
+                Thread.current[RUNTIME_CONFIG_KEY] = previous
+              end
+
+              def with_cell_cache(enabled:)
+                previous = Thread.current[CELL_CACHE_ENABLED_KEY]
+                Thread.current[CELL_CACHE_ENABLED_KEY] = enabled ? true : false
+                yield
+              ensure
+                Thread.current[CELL_CACHE_ENABLED_KEY] = previous
+              end
+
+              def cell_cache_enabled?
+                override = Thread.current[CELL_CACHE_ENABLED_KEY]
+                return override unless override.nil?
+
+                !runtime_config.line_geometry_cell_cache_disabled?
+              end
+
+              def runtime_config
+                config = Thread.current[RUNTIME_CONFIG_KEY]
+                return config if config
+
+                raise Shoko::ConfigurationError, 'LineGeometryBuilder runtime_config is not configured'
+              end
+            end
+
+            def initialize(runtime_config:)
+              unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+                raise ArgumentError, 'runtime_config must implement Core::Ports::Outbound::RuntimeConfig'
+              end
+
+              @runtime_config = runtime_config
+              @cell_cache = {}
+              @cell_cache_order = []
+            end
+
+            def build(page_id:, column_id:, row:, col:, line_offset:, plain_text:, styled_text:)
+              with_runtime_config do
+                plain = plain_text.to_s
+                cells = cells_for_plain_text(plain)
+
+                Shoko::Adapters::Ui::Rendering::Models::LineGeometry.new(
+                  page_id: page_id,
+                  column_id: column_id,
+                  row: row,
+                  column_origin: col,
+                  line_offset: line_offset,
+                  plain_text: plain,
+                  styled_text: styled_text,
+                  cells: cells
+                )
+              end
+            end
+
+            private
+
+            def with_runtime_config(&)
+              return yield unless @runtime_config
+
+              self.class.with_runtime_config(config: @runtime_config, &)
+            end
+
+            def cells_for_plain_text(plain)
+              return build_cells(plain) unless cacheable_plain_text?(plain)
+              return build_cells(plain) unless self.class.cell_cache_enabled?
+
+              cached = @cell_cache[plain]
+              return cached if cached
+
+              built = build_cells(plain).each(&:freeze).freeze
+              store_cached_cells(plain, built)
+              built
+            end
+
+            def cacheable_plain_text?(plain)
+              plain.bytesize <= CELL_CACHEABLE_BYTES
+            end
+
+            def store_cached_cells(plain, cells)
+              key = plain.frozen? ? plain : plain.dup.freeze
+              @cell_cache_order.delete(key)
+              @cell_cache_order << key
+              @cell_cache[key] = cells
+              while @cell_cache_order.length > CELL_CACHE_LIMIT
+                oldest = @cell_cache_order.shift
+                @cell_cache.delete(oldest)
+              end
+            end
+
+            def build_cells(plain)
+              cell_data = Shoko::Shared::Terminal::TextMetrics.cell_data_for(plain)
+              cell_data.map { |cell| build_cell(cell) }
+            end
+
+            def build_cell(cell)
+              Shoko::Adapters::Ui::Rendering::Models::LineCell.new(
+                cluster: cell[:cluster],
+                char_start: cell[:char_start],
+                char_end: cell[:char_end],
+                display_width: cell[:display_width],
+                screen_x: cell[:screen_x]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/rendering/line/render_dependencies.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Typed dependencies shared by reading renderers and helpers.
+          RenderDependencies = Data.define(
+            :layout_service,
+            :layout_metrics,
+            :render_state_writer,
+            :config_reader,
+            :reader_state_reader,
+            :rendered_content_reader,
+            :logger,
+            :observer_registry,
+            :reader_launch_state,
+            :document,
+            :page_calculator,
+            :formatting_service,
+            :wrapping_service,
+            :kitty_image_renderer,
+            :runtime_config
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/rendering/line/rendered_lines_recorder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/ports/outbound/runtime_config'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Records per-line geometry into the state buffer so selection/overlays can
+          # use the exact rendered layout.
+          class RenderedLinesRecorder
+            def initialize(buffer:, dependencies:)
+              @buffer = buffer
+              @dependencies = dependencies
+            end
+
+            def record(geometry)
+              return unless @buffer.is_a?(Hash)
+              return if skip_geometry?(geometry)
+
+              width = geometry.visible_width
+              @buffer[geometry.key] = entry_for(geometry, width)
+
+              dump_geometry(geometry) if geometry_debug_enabled?
+            end
+
+            private
+
+            def skip_geometry?(geometry)
+              width = geometry.visible_width
+              width <= 0 && geometry.plain_text.to_s.empty?
+            end
+
+            def entry_for(geometry, width)
+              end_col = geometry.column_origin + width - 1
+              {
+                row: geometry.row,
+                col: geometry.column_origin,
+                col_end: end_col,
+                text: geometry.plain_text,
+                width: width,
+                geometry: geometry,
+              }
+            end
+
+            def geometry_debug_enabled?
+              runtime_config = @dependencies&.runtime_config
+              unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+                raise ArgumentError, 'reader rendering dependencies must provide runtime_config'
+              end
+              runtime_config&.debug_geometry_enabled? == true
+            rescue Shoko::Error
+              raise
+            end
+
+            def dump_geometry(geometry)
+              payload = geometry.to_h
+              logger = resolve_logger
+              return logger.debug('geometry.line', payload) if logger
+
+              warn("[geometry] #{payload}")
+            end
+
+            def resolve_logger
+              @dependencies&.logger
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/rendering/line/wrapped_lines_fetcher.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/models/content_block'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Fetches wrapped lines from the document using the formatting and wrapping services.
+          #
+          # Also applies the "image block offset snap" behavior so paging doesn't land in the
+          # middle of a Kitty image placeholder block (which can cause disappearing images).
+          class WrappedLinesFetcher
+            def initialize(dependencies)
+              @dependencies = dependencies
+            end
+
+            def fetch(document:, chapter_index:, col_width:, offset:, length:)
+              chapter = document&.get_chapter(chapter_index)
+              return [] unless chapter
+
+              lines = fetch_via_formatting_service(document: document, chapter_index: chapter_index, col_width: col_width,
+                                                   offset: offset, length: length)
+              return lines unless lines.empty?
+
+              lines = fetch_via_wrapping_service(document: document, chapter: chapter, chapter_index: chapter_index,
+                                                 col_width: col_width,
+                                                 offset: offset, length: length)
+              return lines unless lines.empty?
+
+              fallback_lines(chapter, offset, length)
+            end
+
+            def fetch_with_offset(document:, chapter_index:, col_width:, offset:, length:)
+              offset_i = offset.to_i
+              lines = fetch(document: document, chapter_index: chapter_index, col_width: col_width, offset: offset_i,
+                            length: length)
+              snapped = snap_offset_to_image_start(lines, offset_i)
+              return [lines, offset_i] if snapped == offset_i
+
+              [fetch(document: document, chapter_index: chapter_index, col_width: col_width, offset: snapped,
+                     length: length), snapped]
+            end
+
+            def snap_offset_to_image_start(lines, offset)
+              offset_i = offset.to_i
+              return offset_i if offset_i <= 0
+
+              meta = image_block_metadata(lines)
+              return offset_i unless meta
+
+              idx = image_line_index(meta)
+              return offset_i unless idx
+
+              snapped_offset(offset_i, idx)
+            rescue Shoko::Error
+              offset.to_i
+            end
+
+            private
+
+            def fetch_via_formatting_service(document:, chapter_index:, col_width:, offset:, length:)
+              formatting_service = @dependencies&.formatting_service
+              return [] unless formatting_service
+              config = @dependencies.config_reader
+
+              Array(
+                formatting_service.wrap_window(
+                  document,
+                  chapter_index,
+                  col_width,
+                  offset: offset,
+                  length: length,
+                  config: config,
+                  lines_per_page: length
+                )
+              )
+            end
+
+            def fetch_via_wrapping_service(document:, chapter:, chapter_index:, col_width:, offset:, length:)
+              wrapping = @dependencies&.wrapping_service
+              return [] unless wrapping
+              wrapping.wrap_window(
+                chapter.lines || [],
+                chapter_index,
+                col_width,
+                offset,
+                length,
+                document: document
+              ) || []
+            end
+
+            def fallback_lines(chapter, offset, length)
+              (chapter.lines || [])[offset, length] || []
+            end
+
+            def first_line_metadata(lines)
+              first = Array(lines).first
+              return nil unless first.is_a?(Shoko::Core::Models::DisplayLine)
+
+              meta = first.metadata
+              meta.is_a?(Hash) ? meta : nil
+            end
+
+            def image_render_hash?(meta)
+              return false unless meta.is_a?(Hash)
+
+              render = meta[:image_render] || meta['image_render']
+              render.is_a?(Hash)
+            end
+
+            def image_block_metadata(lines)
+              meta = first_line_metadata(lines)
+              return nil unless image_render_hash?(meta)
+              return nil if image_render_line?(meta)
+
+              meta
+            end
+
+            def image_render_line?(meta)
+              value = meta.key?(:image_render_line) ? meta[:image_render_line] : meta['image_render_line']
+              value == true
+            end
+
+            def image_line_index(meta)
+              value = meta.key?(:image_line_index) ? meta[:image_line_index] : meta['image_line_index']
+              value&.to_i
+            end
+
+            def snapped_offset(offset, index)
+              snapped = offset.to_i - index.to_i
+              snapped.negative? ? 0 : snapped
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/{output → ui}/rendering/models/line_geometry.rb

@@ -2,7 +2,7 @@
 
 module Shoko
   module Adapters
-    module Output
+    module Ui
       module Rendering
         module Models
           # Represents a single rendered cell (grapheme cluster) within a line box.
@@ -12,9 +12,9 @@ module Shoko
             end
           end
 
-    # Represents the geometry for a rendered line on screen. Holds the plain
-    # text, ANSI-styled text, and per-cell breakdown so selections/tooltips can
-    # share the same layout information as the renderer.
+          # Represents the geometry for a rendered line on screen. Holds the plain
+          # text, ANSI-styled text, and per-cell breakdown so selections/tooltips can
+          # share the same layout information as the renderer.
           class LineGeometry
             attr_reader :page_id, :column_id, :row, :column_origin, :line_offset,
                         :plain_text, :styled_text, :cells

data/lib/shoko/adapters/{output → ui}/rendering/models/page_rendering_context.rb

@@ -2,7 +2,7 @@
 
 module Shoko
   module Adapters
-    module Output
+    module Ui
       module Rendering
         module Models
           PageRenderingContext = Struct.new(

data/lib/shoko/adapters/{output → ui}/rendering/models/render_params.rb

@@ -2,7 +2,7 @@
 
 module Shoko
   module Adapters
-    module Output
+    module Ui
       module Rendering
         module Models
           # Parameter object to reduce long parameter lists in renderers.

data/lib/shoko/adapters/ui/rendering/models/rendering_context.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Rendering
+        module Models
+          # Context object for rendering operations.
+          # Replaces direct controller dependency in renderers with structured data access.
+          class RenderingContext
+            attr_reader :document, :page_calculator, :view_model,
+                        :config_reader, :reader_state_reader
+
+            def initialize(document:, page_calculator: nil,
+                           config_reader: nil, reader_state_reader: nil,
+                           view_model: nil)
+              @document = document
+              @page_calculator = page_calculator
+              @view_model = view_model
+              @config_reader = config_reader
+              @reader_state_reader = reader_state_reader
+              freeze
+            end
+
+            # Convenience methods for common rendering needs
+            def current_chapter
+              chapter_index = @reader_state_reader&.current_chapter || 0
+              @document&.get_chapter(chapter_index)
+            end
+
+            def current_page_index
+              @reader_state_reader&.current_page_index || 0
+            end
+
+            def view_mode
+              @config_reader&.view_mode || :single
+            end
+
+            def page_numbering_mode
+              @config_reader&.page_numbering_mode || :dynamic
+            end
+
+            # Dynamic mode page data access
+            def get_page_data(index, width: nil, height: nil, sidebar_visible: nil)
+              return nil unless @page_calculator && page_numbering_mode == :dynamic
+
+              @page_calculator.get_page(
+                index,
+                width: width,
+                height: height,
+                sidebar_visible: sidebar_visible
+              )
+            end
+
+            def total_pages
+              if @page_calculator && page_numbering_mode == :dynamic
+                @page_calculator.total_pages
+              else
+                @reader_state_reader&.total_pages || 0
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end