shoko 0.1.3 → 0.1.5

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/models/content_block'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Applies inline quote/keyword highlighting to a list of TextSegment objects.
+          #
+          # This is used for DisplayLine rendering where segments already carry style metadata.
+          module InlineSegmentHighlighter
+            module_function
+
+            def apply(segments, block_type:, highlight_quotes:, highlight_keywords:)
+              return segments unless highlightable?(segments, block_type, highlight_quotes, highlight_keywords)
+
+              text = segments_text(segments)
+              return segments if text.empty?
+
+              quote_ranges, keyword_ranges = build_ranges(text, highlight_quotes, highlight_keywords)
+              return segments if quote_ranges.empty? && keyword_ranges.empty?
+
+              applicator = RangeApplicator.new(text: text, quote_ranges: quote_ranges, keyword_ranges: keyword_ranges)
+              applicator.apply_to_segments(segments)
+            end
+
+            def match_ranges(text, pattern)
+              ranges = []
+              text.to_enum(:scan, pattern).each do
+                match = Regexp.last_match
+                next unless match
+
+                start_index = match.begin(0)
+                end_index = match.end(0)
+                ranges << (start_index...end_index) if end_index > start_index
+              end
+              ranges
+            end
+
+            def in_ranges?(index, ranges)
+              return false if ranges.empty?
+
+              idx = index.to_i
+              lo = 0
+              hi = ranges.length - 1
+              while lo <= hi
+                mid = (lo + hi) / 2
+                range = ranges[mid]
+                return true if idx >= range.begin && idx < range.end
+
+                idx < range.begin ? hi = mid - 1 : lo = mid + 1
+              end
+              false
+            end
+
+            def segments_text(segments)
+              segments.map { |segment| segment&.text.to_s }.join
+            end
+
+            private
+
+            def highlightable?(segments, block_type, highlight_quotes, highlight_keywords)
+              return false unless highlight_quotes || highlight_keywords
+              return false if segments.empty?
+
+              block_type != :code
+            end
+
+            def build_ranges(text, highlight_quotes, highlight_keywords)
+              quote_ranges = if highlight_quotes
+                               match_ranges(text,
+                                            Shoko::Adapters::Ui::Constants::Highlighting::QUOTE_PATTERNS)
+                             else
+                               []
+                             end
+              keyword_ranges = if highlight_keywords
+                                 match_ranges(text,
+                                              Shoko::Adapters::Ui::Constants::Highlighting::HIGHLIGHT_PATTERNS)
+                               else
+                                 []
+                               end
+              [quote_ranges, keyword_ranges]
+            end
+
+            module_function :highlightable?, :build_ranges
+            private_class_method :highlightable?, :build_ranges
+
+            # Applies computed range boundaries to segments and emits new TextSegment objects.
+            class RangeApplicator
+              def initialize(text:, quote_ranges:, keyword_ranges:)
+                @text = text
+                @quote_ranges = quote_ranges
+                @keyword_ranges = keyword_ranges
+              end
+
+              def apply_to_segments(segments)
+                output = []
+                offset = 0
+
+                segments.each do |segment|
+                  seg_text = segment.text.to_s
+                  seg_start = offset
+                  seg_end = seg_start + seg_text.length
+                  offset = seg_end
+                  next if seg_text.empty?
+
+                  base_styles = segment.styles || {}
+                  boundaries = boundaries_for_segment(seg_start, seg_end, base_styles)
+                  output.concat(segment_pieces(boundaries, base_styles))
+                end
+
+                output
+              end
+
+              private
+
+              attr_reader :text, :quote_ranges, :keyword_ranges
+
+              def boundaries_for_segment(seg_start, seg_end, base_styles)
+                boundaries = [seg_start, seg_end]
+                return boundaries if base_styles[:code]
+
+                (quote_ranges + keyword_ranges).each do |range|
+                  add_boundary(boundaries, range.begin, seg_start, seg_end)
+                  add_boundary(boundaries, range.end, seg_start, seg_end)
+                end
+
+                boundaries.sort.uniq
+              end
+
+              def add_boundary(boundaries, value, seg_start, seg_end)
+                boundaries << value if value > seg_start && value < seg_end
+              end
+
+              def segment_pieces(boundaries, base_styles)
+                boundaries.each_cons(2).filter_map do |start_index, end_index|
+                  next if start_index >= end_index
+
+                  piece = text[start_index...end_index].to_s
+                  next if piece.empty?
+
+                  styles = styles_for_piece(base_styles, start_index)
+                  Shoko::Core::Models::TextSegment.new(text: piece, styles: styles)
+                end
+              end
+
+              def styles_for_piece(base_styles, index)
+                return base_styles if base_styles[:code]
+
+                styles = base_styles
+                styles = styles.merge(quote: true) if InlineSegmentHighlighter.in_ranges?(index, quote_ranges)
+                styles = styles.merge(accent: true) if InlineSegmentHighlighter.in_ranges?(index, keyword_ranges)
+                styles
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../../../../shared/terminal/kitty_unicode_placeholders'
+require_relative '../../components/render_style'
+require_relative 'config_helpers'
+
+module Shoko
+  module Adapters
+    module Ui
+      module 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 Shoko::Error
+              raise
+            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)
+            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)
+              meta = line.metadata
+              meta.is_a?(Hash) ? meta : nil
+            end
+
+            def enabled?(config)
+              !!config.kitty_images
+            rescue Shoko::Error
+              raise
+            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
+            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'))
+            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 Shoko::Error
+              src.to_s
+            end
+
+            def normalize_placement_id(raw)
+              value = raw.to_i & 0xFF_FF_FF
+              value.zero? ? 1 : value
+            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 Shoko::Error
+              raise
+            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 Shoko::Error
+              raise
+            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
+                )
+              )
+            end
+
+            def prepare_virtual_args(context:, chapter_entry:, src:, cols:, rows:, placement_id:)
+              doc = context&.document
+              {
+                output: Terminal,
+                book_sha: doc&.cache_sha,
+                epub_path: doc&.canonical_path,
+                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::Shared::Terminal::KittyUnicodePlaceholders.line(
+                image_id: prepared_id,
+                placement_id: placement_id,
+                grid: grid
+              )
+            rescue Shoko::Error
+              raise
+            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 = if cols.to_i.positive?
+                          Shoko::Shared::Terminal::TextMetrics.truncate_to(plain,
+                                                                                     cols.to_i)
+                        else
+                          plain
+                        end
+              [Shoko::Adapters::Ui::Components::RenderStyle.dim(clipped), col_offset]
+            end
+
+            def kitty_image_renderer
+              @kitty_image_renderer ||= @dependencies.kitty_image_renderer
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require_relative '../../components/render_style'
+require_relative '../../../../core/models/content_block'
+require_relative '../../../../core/models/block_type'
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../../../../core/ports/outbound/runtime_config'
+require_relative 'inline_segment_highlighter'
+require_relative 'config_helpers'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Reading
+          # Composes the plain and ANSI-styled text for a renderable line.
+          class LineContentComposer
+            COMPOSE_CACHE_LIMIT = 20_000
+            COMPOSE_CACHE_KEY = :shoko_line_content_compose_cache
+            COMPOSE_CACHE_ORDER_KEY = :shoko_line_content_compose_cache_order
+            COMPOSE_CACHE_ENABLED_KEY = :shoko_line_content_compose_cache_enabled
+            RUNTIME_CONFIG_KEY = :shoko_line_content_compose_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_compose_cache(enabled:)
+                previous = Thread.current[COMPOSE_CACHE_ENABLED_KEY]
+                Thread.current[COMPOSE_CACHE_ENABLED_KEY] = enabled ? true : false
+                yield
+              ensure
+                Thread.current[COMPOSE_CACHE_ENABLED_KEY] = previous
+              end
+
+              def compose_cache_enabled?
+                override = Thread.current[COMPOSE_CACHE_ENABLED_KEY]
+                return override unless override.nil?
+
+                !runtime_config.line_content_compose_cache_disabled?
+              end
+
+              def clear_compose_cache
+                Thread.current[COMPOSE_CACHE_KEY] = {}
+                Thread.current[COMPOSE_CACHE_ORDER_KEY] = []
+              end
+
+              def runtime_config
+                config = Thread.current[RUNTIME_CONFIG_KEY]
+                return config if config
+
+                raise Shoko::ConfigurationError, 'LineContentComposer 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
+            end
+
+            def compose(line, width, config_store)
+              with_runtime_config do
+                width_i = width.to_i
+                return ['', ''] if width_i <= 0
+
+                highlight_quotes = ConfigHelpers.highlight_quotes?(config_store)
+                highlight_keywords = ConfigHelpers.highlight_keywords?(config_store)
+                cache_key = compose_cache_key(line, width_i, highlight_quotes, highlight_keywords)
+                cached = fetch_cached_compose(cache_key)
+                return cached unless cached.nil?
+
+                result = if display_line?(line)
+                           compose_display_line(
+                             line,
+                             width_i,
+                             highlight_quotes: highlight_quotes,
+                             highlight_keywords: highlight_keywords
+                           )
+                         else
+                           compose_plain_line(
+                             line,
+                             width_i,
+                             highlight_quotes: highlight_quotes,
+                             highlight_keywords: highlight_keywords
+                           )
+                         end
+
+                cache_compose_result(cache_key, result)
+              end
+            end
+
+            private
+
+            def with_runtime_config(&)
+              return yield unless @runtime_config
+
+              self.class.with_runtime_config(config: @runtime_config, &)
+            end
+
+            def display_line?(line)
+              line.is_a?(Shoko::Core::Models::DisplayLine)
+            end
+
+            def compose_plain_line(line, width, highlight_quotes:, highlight_keywords:)
+              text = Shoko::Shared::Terminal::TextMetrics.truncate_to(line.to_s, width)
+              text = highlight_keywords(text) if highlight_keywords
+              text = highlight_quotes(text) if highlight_quotes
+              [Shoko::Shared::Terminal::TextMetrics.strip_ansi(text), Shoko::Adapters::Ui::Components::RenderStyle.primary(text)]
+            end
+
+            def compose_display_line(line, width, highlight_quotes:, highlight_keywords:)
+              metadata = display_line_metadata(line, highlight_quotes)
+              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
+              block_type = canonical_block_type(metadata)
+              metadata.delete('block_type')
+              metadata[:block_type] = block_type if block_type
+              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::Ui::Components::RenderStyle.styled_segment(chunk, segment.styles || {},
+                                                                                              metadata: metadata)
+                remaining -= Shoko::Shared::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::Shared::Terminal::TextMetrics.visible_length(raw)
+              return raw if visible_len <= remaining
+
+              Shoko::Shared::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::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 compose_cache_key(line, width, highlight_quotes, highlight_keywords)
+              return nil unless self.class.compose_cache_enabled?
+
+              palette_id = Shoko::Adapters::Ui::Components::RenderStyle.palette.object_id
+              if display_line?(line)
+                metadata = line.metadata || {}
+                block_type = canonical_block_type(metadata)
+                text = line.text.to_s
+                [:display_line, line.object_id, line.segments.object_id, text.hash, text.bytesize,
+                 block_type, width, highlight_quotes, highlight_keywords, palette_id]
+              else
+                text = line.to_s
+                [:plain_line, text.hash, text.bytesize, width, highlight_quotes, highlight_keywords, palette_id]
+              end
+            rescue Shoko::Error
+              raise
+            end
+
+            def fetch_cached_compose(key)
+              return nil unless key && self.class.compose_cache_enabled?
+
+              compose_cache_store[key]
+            end
+
+            def cache_compose_result(key, result)
+              return result unless key && self.class.compose_cache_enabled?
+
+              plain, styled = result
+              frozen_result = [plain.to_s.freeze, styled.to_s.freeze].freeze
+              store = compose_cache_store
+              order = compose_cache_order
+              unless store.key?(key)
+                order << key
+                if order.length > COMPOSE_CACHE_LIMIT
+                  oldest = order.shift
+                  store.delete(oldest)
+                end
+              end
+              store[key] = frozen_result
+              frozen_result
+            end
+
+            def compose_cache_store
+              Thread.current[COMPOSE_CACHE_KEY] ||= {}
+            end
+
+            def compose_cache_order
+              Thread.current[COMPOSE_CACHE_ORDER_KEY] ||= []
+            end
+
+            def highlight_keywords(line)
+              accent = Shoko::Adapters::Ui::Components::RenderStyle.color(:accent)
+              base = Shoko::Adapters::Ui::Components::RenderStyle.color(:primary)
+              line.gsub(Shoko::Adapters::Ui::Constants::Highlighting::HIGHLIGHT_PATTERNS) do |match|
+                accent + match + Shoko::Shared::Terminal::Ansi::RESET + base
+              end
+            end
+
+            def highlight_quotes(line)
+              quote_color = Shoko::Adapters::Ui::Components::RenderStyle.color(:quote)
+              base = Shoko::Adapters::Ui::Components::RenderStyle.color(:primary)
+              line.gsub(Shoko::Adapters::Ui::Constants::Highlighting::QUOTE_PATTERNS) do |match|
+                quote_color + Shoko::Shared::Terminal::Ansi::ITALIC + match + Shoko::Shared::Terminal::Ansi::RESET + base
+              end
+            end
+
+            def canonical_block_type(metadata)
+              raw = metadata[:block_type] || metadata['block_type']
+              Shoko::Core::Models::BlockType.canonical(raw) || raw
+            end
+          end
+        end
+      end
+    end
+  end
+end