shoko 0.1.3 → 0.1.5

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_view_renderer'
-
-module Shoko
-  module Adapters::Output::Ui::Components
-    module Reading
-      # Renderer for help screen display
-      class HelpRenderer < BaseViewRenderer
-        HELP_LINES = [
-          '',
-          'Navigation Keys:',
-          '  j / ↓     Scroll down',
-          '  k / ↑     Scroll up',
-          '  l / →     Next page',
-          '  h / ←     Previous page',
-          '  SPACE     Next page',
-          '  n         Next chapter',
-          '  p         Previous chapter',
-          '  g         Go to beginning of chapter',
-          '  G         Go to end of chapter',
-          '',
-          'View Options:',
-          '  v         Toggle split/single view',
-          '  P         Toggle page numbering mode (Absolute/Dynamic)',
-          '  + / -     Adjust line spacing',
-          '',
-          'Features:',
-          '  t         Show Table of Contents',
-          '  b         Add a bookmark',
-          '  B         Show bookmarks',
-          '  A         Show annotations sidebar',
-          '  Ctrl+A    Toggle annotations overlay',
-          '',
-          'Other Keys:',
-          '  ?         Show/hide this help',
-          '  q         Quit to menu',
-          '  Q         Quit application',
-          '',
-          '',
-          'Press any key to return to reading...',
-        ].freeze
-
-        def render_with_context(surface, bounds, _context)
-          b_height = bounds.height
-          b_width  = bounds.width
-          start_row = [(b_height - HELP_LINES.size) / 2, 1].max
-
-          HELP_LINES.each_with_index do |line, idx|
-            row = start_row + idx
-            break if row >= b_height - 2
-
-            text_width = Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(line)
-            col = [(b_width - text_width) / 2, 1].max
-            surface.write(bounds, row, col,
-                          Shoko::Adapters::Output::Ui::Constants::UI::COLOR_TEXT_PRIMARY + line + Terminal::ANSI::RESET)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../../../core/models/content_block.rb'
-
-module Shoko
-  module Adapters::Output::Ui::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)
-        rescue StandardError
-          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
-        rescue StandardError
-          []
-        end
-
-        def in_ranges?(index, ranges)
-          idx = index.to_i
-          ranges.any? { |range| idx >= range.begin && idx < range.end }
-        rescue StandardError
-          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 = highlight_quotes ? match_ranges(text, Shoko::Adapters::Output::Ui::Constants::Highlighting::QUOTE_PATTERNS) : []
-          keyword_ranges = highlight_keywords ? match_ranges(text, Shoko::Adapters::Output::Ui::Constants::Highlighting::HIGHLIGHT_PATTERNS) : []
-          [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

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

@@ -1,262 +0,0 @@
-# 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

@@ -1,114 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-# 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