shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/reading/kitty_image_line_renderer.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require_relative '../../../terminal/text_metrics.rb'
+require_relative '../../../kitty/kitty_unicode_placeholders.rb'
+require_relative '../render_style'
+require_relative 'config_helpers'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Renders DisplayLine image metadata using Kitty graphics placeholders.
+      #
+      # This object is created per render frame and uses a per-frame dedupe cache to avoid
+      # repeated `prepare_virtual` calls for the same image placement.
+      class KittyImageLineRenderer
+        RenderRequest = Struct.new(:meta, :render_opts, :src, :cols, :rows, :col_offset, :line_index, :chapter_entry,
+                                   keyword_init: true)
+
+        def initialize(dependencies:, placed_kitty_images:)
+          @dependencies = dependencies
+          @placed_kitty_images = placed_kitty_images
+        end
+
+        def kitty_image_line?(line, config:)
+          meta = metadata_hash(line)
+          return false unless meta
+          return false unless enabled?(config)
+
+          render_opts = image_render_options(meta)
+          return false unless render_opts
+
+          !image_src(meta).to_s.strip.empty?
+        rescue StandardError
+          false
+        end
+
+        def render(line, context)
+          request = render_request_for(line)
+          return [nil, 0] unless request
+
+          placement_id = placement_id_for(render_opts: request.render_opts,
+                                          chapter_entry: request.chapter_entry,
+                                          src: request.src,
+                                          cols: request.cols,
+                                          rows: request.rows)
+          placeholder = placeholder_for_request(context, request, placement_id)
+          return [placeholder, request.col_offset] if placeholder
+
+          fallback_for(request.meta, request.cols, request.col_offset)
+        rescue StandardError
+          [nil, 0]
+        end
+
+        private
+
+        def render_request_for(line)
+          meta, render_opts = meta_and_render_options(line)
+          return nil unless meta && render_opts
+
+          src = src_for_request(meta)
+          return nil unless src
+
+          build_render_request(meta, render_opts, src)
+        end
+
+        def placeholder_for_request(context, request, placement_id)
+          prepared_id = prepared_id_for(context: context,
+                                        chapter_entry: request.chapter_entry,
+                                        src: request.src,
+                                        cols: request.cols,
+                                        rows: request.rows,
+                                        placement_id: placement_id)
+          return nil unless prepared_id
+
+          placeholder_for(prepared_id, placement_id, request.cols, request.line_index)
+        end
+
+        def metadata_hash(line)
+          return nil unless line.respond_to?(:metadata)
+
+          meta = line.metadata
+          meta.is_a?(Hash) ? meta : nil
+        end
+
+        def enabled?(config)
+          store = ConfigHelpers.config_store(config)
+          kitty_image_renderer&.enabled?(store)
+        rescue StandardError
+          false
+        end
+
+        def image_render_options(meta)
+          render_opts = meta[:image_render] || meta['image_render']
+          render_opts.is_a?(Hash) ? render_opts : nil
+        end
+
+        def image_src(meta)
+          image = meta[:image] || meta['image'] || {}
+          image[:src] || image['src']
+        end
+
+        def integer_or_zero(value)
+          value.to_i
+        rescue StandardError
+          0
+        end
+
+        def meta_and_render_options(line)
+          meta = metadata_hash(line)
+          return [nil, nil] unless meta
+
+          [meta, image_render_options(meta)]
+        end
+
+        def src_for_request(meta)
+          src = image_src(meta).to_s.strip
+          src.empty? ? nil : src
+        end
+
+        def build_render_request(meta, render_opts, src)
+          RenderRequest.new(
+            meta: meta,
+            render_opts: render_opts,
+            src: src,
+            cols: integer_or_zero(render_opts[:cols] || render_opts['cols']),
+            rows: integer_or_zero(render_opts[:rows] || render_opts['rows']),
+            col_offset: integer_or_zero(render_opts[:col_offset] || render_opts['col_offset']),
+            line_index: integer_or_zero(meta[:image_line_index] || meta['image_line_index']),
+            chapter_entry: meta[:chapter_source_path] || meta['chapter_source_path']
+          )
+        end
+
+        def placement_id_for(render_opts:, chapter_entry:, src:, cols:, rows:)
+          raw = integer_or_zero(render_opts[:placement_id] || render_opts['placement_id'])
+          return normalize_placement_id(raw) if raw.positive?
+
+          seed = placement_seed(chapter_entry, src, cols, rows)
+          normalize_placement_id(Digest::SHA1.digest(seed).unpack1('N'))
+        rescue StandardError
+          1
+        end
+
+        def placement_seed(chapter_entry, src, cols, rows)
+          core = core_src(src)
+          "#{chapter_entry}|#{core}|#{cols}|#{rows}"
+        end
+
+        def core_src(src)
+          src.to_s.split(/[?#]/, 2).first.to_s
+        rescue StandardError
+          src.to_s
+        end
+
+        def normalize_placement_id(raw)
+          value = raw.to_i & 0xFF_FF_FF
+          value.zero? ? 1 : value
+        rescue StandardError
+          1
+        end
+
+        def prepared_id_for(context:, chapter_entry:, src:, cols:, rows:, placement_id:)
+          dedupe = dedupe_key(chapter_entry:, src:, cols:, rows:, placement_id:)
+          prepared = cached_prepared_id(dedupe)
+          return prepared if prepared
+
+          prepared = prepare_virtual(context:, chapter_entry:, src:, cols:, rows:, placement_id:)
+          cache_prepared_id(dedupe, prepared)
+          prepared
+        end
+
+        def dedupe_key(chapter_entry:, src:, cols:, rows:, placement_id:)
+          core = core_src(src)
+          "#{chapter_entry}|#{core}|#{cols}|#{rows}|p=#{placement_id}"
+        rescue StandardError
+          nil
+        end
+
+        def cached_prepared_id(dedupe_key)
+          return nil unless dedupe_key && @placed_kitty_images.is_a?(Hash)
+
+          cached = @placed_kitty_images[dedupe_key]
+          return cached if cached.is_a?(Integer)
+
+          nil
+        end
+
+        def cache_prepared_id(dedupe_key, prepared_id)
+          return unless dedupe_key && @placed_kitty_images.is_a?(Hash)
+
+          @placed_kitty_images[dedupe_key] = prepared_id || false
+        rescue StandardError
+          nil
+        end
+
+        def prepare_virtual(context:, chapter_entry:, src:, cols:, rows:, placement_id:)
+          renderer = kitty_image_renderer
+          return nil unless renderer
+
+          renderer.prepare_virtual(
+            **prepare_virtual_args(
+              context: context,
+              chapter_entry: chapter_entry,
+              src: src,
+              cols: cols,
+              rows: rows,
+              placement_id: placement_id
+            )
+          )
+        rescue StandardError
+          nil
+        end
+
+        def prepare_virtual_args(context:, chapter_entry:, src:, cols:, rows:, placement_id:)
+          doc = context&.document
+          {
+            output: Terminal,
+            book_sha: doc.respond_to?(:cache_sha) ? doc.cache_sha : nil,
+            epub_path: doc.respond_to?(:canonical_path) ? doc.canonical_path : nil,
+            chapter_entry_path: chapter_entry,
+            src: src,
+            cols: cols,
+            rows: rows,
+            placement_id: placement_id,
+            z: -1,
+          }
+        end
+
+        def placeholder_for(prepared_id, placement_id, cols, line_index)
+          cols_i = cols.to_i
+          line_i = line_index.to_i
+          return nil unless cols_i.between?(1, 255) && line_i.between?(0, 255)
+
+          grid = (line_i << 8) | cols_i
+          Shoko::Adapters::Output::Kitty::KittyUnicodePlaceholders.line(
+            image_id: prepared_id,
+            placement_id: placement_id,
+            grid: grid
+          )
+        rescue StandardError
+          nil
+        end
+
+        def fallback_for(meta, cols, col_offset)
+          render_line = meta.key?(:image_render_line) ? meta[:image_render_line] : meta['image_render_line']
+          return ['', col_offset] unless render_line == true
+
+          plain = '[Image]'
+          clipped = cols.to_i.positive? ? Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(plain, cols.to_i) : plain
+          [Shoko::Adapters::Output::Ui::Components::RenderStyle.dim(clipped), col_offset]
+        end
+
+        def kitty_image_renderer
+          @kitty_image_renderer ||= @dependencies.resolve(:kitty_image_renderer)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/line_content_composer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../render_style'
+require_relative '../../../terminal/text_metrics.rb'
+require_relative 'inline_segment_highlighter'
+require_relative 'config_helpers'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Composes the plain and ANSI-styled text for a renderable line.
+      class LineContentComposer
+        def compose(line, width, config_store)
+          width_i = width.to_i
+          return ['', ''] if width_i <= 0
+
+          return compose_display_line(line, width_i, config_store) if display_line?(line)
+
+          compose_plain_line(line, width_i, config_store)
+        end
+
+        private
+
+        def display_line?(line)
+          line.respond_to?(:segments) && line.respond_to?(:text)
+        end
+
+        def compose_plain_line(line, width, store)
+          text = Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(line.to_s, width)
+          return [text, Shoko::Adapters::Output::Ui::Components::RenderStyle.primary(text)] unless store
+
+          text = highlight_keywords(text) if ConfigHelpers.highlight_keywords?(store)
+          text = highlight_quotes(text) if ConfigHelpers.highlight_quotes?(store)
+          [Shoko::Adapters::Output::Terminal::TextMetrics.strip_ansi(text), Shoko::Adapters::Output::Ui::Components::RenderStyle.primary(text)]
+        end
+
+        def compose_display_line(line, width, store)
+          highlight_quotes = ConfigHelpers.highlight_quotes?(store)
+          highlight_keywords = ConfigHelpers.highlight_keywords?(store)
+
+          metadata = display_line_metadata(line, highlight_quotes)
+          block_type = metadata[:block_type] || metadata['block_type']
+          segments = InlineSegmentHighlighter.apply(Array(line.segments),
+                                                    block_type: block_type,
+                                                    highlight_quotes: highlight_quotes,
+                                                    highlight_keywords: highlight_keywords)
+          build_from_segments(line, segments, width, metadata)
+        end
+
+        def display_line_metadata(line, highlight_quotes)
+          metadata = (line.metadata || {}).dup
+          metadata[:highlight_enabled] = highlight_quotes
+          metadata
+        end
+
+        def build_from_segments(line, segments, width, metadata)
+          plain = +''
+          styled = +''
+          remaining = width
+
+          segments.each do |segment|
+            break if remaining <= 0
+
+            chunk = segment_text_for_width(segment, remaining)
+            next if chunk.empty?
+
+            plain << chunk
+            styled << Shoko::Adapters::Output::Ui::Components::RenderStyle.styled_segment(chunk, segment.styles || {},
+                                                                          metadata: metadata)
+            remaining -= Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(chunk)
+          end
+
+          finalize_composed_line(line, width, plain, styled)
+        end
+
+        def segment_text_for_width(segment, remaining)
+          raw = segment&.text.to_s
+          return '' if raw.empty?
+
+          visible_len = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(raw)
+          return raw if visible_len <= remaining
+
+          Shoko::Adapters::Output::Terminal::TextMetrics.truncate_to(raw, remaining)
+        end
+
+        def finalize_composed_line(line, width, plain_builder, styled_builder)
+          if styled_builder.empty?
+            plain_text = plain_builder.empty? ? line.text.to_s[0, width] : plain_builder
+            return [plain_text, Shoko::Adapters::Output::Ui::Components::RenderStyle.primary(plain_text)]
+          end
+
+          plain_text = plain_builder.empty? ? line.text.to_s[0, width] : plain_builder
+          [plain_text, styled_builder]
+        end
+
+        def highlight_keywords(line)
+          accent = Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:accent)
+          base = Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:primary)
+          line.gsub(Shoko::Adapters::Output::Ui::Constants::Highlighting::HIGHLIGHT_PATTERNS) do |match|
+            accent + match + Terminal::ANSI::RESET + base
+          end
+        end
+
+        def highlight_quotes(line)
+          quote_color = Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:quote)
+          base = Shoko::Adapters::Output::Ui::Components::RenderStyle.color(:primary)
+          line.gsub(Shoko::Adapters::Output::Ui::Constants::Highlighting::QUOTE_PATTERNS) do |match|
+            quote_color + Terminal::ANSI::ITALIC + match + Terminal::ANSI::RESET + base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/line_drawer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/text_metrics.rb'
+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::Output::Ui::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
+          @content_composer = LineContentComposer.new
+          if @record_geometry
+            @geometry_builder = LineGeometryBuilder.new
+            @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 = context&.config
+          store = ConfigHelpers.config_store(config)
+
+          return if draw_kitty_line(surface: surface, bounds: bounds, line: line, row: row, col: col,
+                                    context: context, store: store)
+
+          _plain_text, styled_text = @content_composer.compose(line, width, store)
+          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:, store:)
+          return false unless @kitty_renderer.kitty_image_line?(line, config: store)
+
+          image_text, col_offset = @kitty_renderer.render(line, context)
+          return true unless image_text && !image_text.empty?
+
+          surface.write(bounds, row, col + col_offset.to_i, image_text)
+          true
+        rescue StandardError
+          false
+        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::Adapters::Output::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::Adapters::Output::Terminal::TextMetrics.truncate_to(
+            styled_text.to_s,
+            max_width,
+            start_column: start_column
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/ui/components/reading/line_geometry_builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/text_metrics.rb'
+require_relative '../../../rendering/models/line_geometry.rb'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Builds `Shoko::Adapters::Output::Rendering::Models::LineGeometry` objects for selection/highlighting.
+      class LineGeometryBuilder
+        def build(page_id:, column_id:, row:, col:, line_offset:, plain_text:, styled_text:)
+          cell_data = Shoko::Adapters::Output::Terminal::TextMetrics.cell_data_for(plain_text.to_s)
+          cells = cell_data.map { |cell| build_cell(cell) }
+
+          Shoko::Adapters::Output::Rendering::Models::LineGeometry.new(
+            page_id: page_id,
+            column_id: column_id,
+            row: row,
+            column_origin: col,
+            line_offset: line_offset,
+            plain_text: plain_text,
+            styled_text: styled_text,
+            cells: cells
+          )
+        end
+
+        private
+
+        def build_cell(cell)
+          Shoko::Adapters::Output::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

data/lib/shoko/adapters/output/ui/components/reading/rendered_lines_recorder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::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?
+          primary = ENV.fetch('SHOKO_DEBUG_GEOMETRY', '').to_s.strip
+          primary == '1'
+        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.resolve(:logger)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end