shoko 0.1.0

data/lib/shoko/adapters/output/formatting/formatting_service/line_assembler/text_wrapper.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative '../../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Formatting
+      class FormattingService
+        class LineAssembler
+          # Wraps tokens into display lines (including inline image placeholders).
+          class TextWrapper
+            include Shoko::Core::Models
+
+            def initialize(width, image_builder:)
+              @width = width.to_i
+              @image_builder = image_builder
+            end
+
+            def wrap(tokens, metadata:, prefix: nil, continuation_prefix: nil)
+              return [] if tokens.empty?
+
+              first_prefix_tokens, continuation_tokens = prefix_tokens(prefix, continuation_prefix)
+              state = LineState.new(first_prefix_tokens, continuation_tokens)
+              wrapped = []
+
+              tokens.each do |token|
+                process_token(token, state, metadata, wrapped)
+              end
+
+              append_final_line(state, metadata, wrapped)
+              wrapped
+            end
+
+            private
+
+            def prefix_tokens(prefix, continuation_prefix)
+              first = Tokenizer.prefix_tokens(prefix)
+              continuation = continuation_prefix_value(prefix, continuation_prefix)
+              [first, Tokenizer.prefix_tokens(continuation)]
+            end
+
+            def continuation_prefix_value(prefix, continuation_prefix)
+              return continuation_prefix unless continuation_prefix.nil?
+
+              Tokenizer.prefix_indent(prefix)
+            end
+
+            def process_token(token, state, metadata, wrapped)
+              return append_inline_image(token[:inline_image], state, metadata, wrapped) if token[:image]
+              return append_newline(state, metadata, wrapped) if token[:newline]
+
+              append_text(token, state, metadata, wrapped)
+            end
+
+            def append_inline_image(inline, state, metadata, wrapped)
+              wrapped << finalize_line(state.tokens, metadata) unless state.tokens.empty?
+              wrapped.concat(@image_builder.inline_lines(inline, state.indent_cols))
+              state.reset_to_continuation!
+            end
+
+            def append_newline(state, metadata, wrapped)
+              wrapped << finalize_line(state.tokens, metadata)
+              state.reset_to_continuation!
+            end
+
+            def append_text(token, state, metadata, wrapped)
+              token_width = text_width(token[:text])
+              if wrap_needed?(state.width, token_width)
+                wrapped << finalize_line(state.tokens, metadata)
+                state.reset_to_continuation!
+                return if token[:text].strip.empty?
+              end
+
+              return if state.tokens.empty? && token[:text].strip.empty?
+
+              state.tokens << token
+              state.width += token_width
+            end
+
+            def append_final_line(state, metadata, wrapped)
+              wrapped << finalize_line(state.tokens, metadata) unless state.tokens.empty?
+            end
+
+            def wrap_needed?(current_width, token_width)
+              current_width.positive? && current_width + token_width > @width
+            end
+
+            def finalize_line(tokens, metadata)
+              DisplayLine.new(
+                text: line_text(tokens),
+                segments: merge_tokens_into_segments(tokens).reject { |seg| seg.text.empty? },
+                metadata: metadata
+              )
+            end
+
+            def line_text(tokens)
+              tokens.select { |token| token[:text] }.map { |token| token[:text] }.join.rstrip
+            end
+
+            def merge_tokens_into_segments(tokens)
+              merged = []
+              tokens.each do |token|
+                next unless token[:text]
+
+                styles = token[:styles] || {}
+                if merged.empty? || merged.last.styles != styles
+                  merged << TextSegment.new(text: token[:text], styles: styles)
+                else
+                  merged[-1] = TextSegment.new(text: merged[-1].text + token[:text], styles: styles)
+                end
+              end
+              merged
+            end
+
+            def text_width(text)
+              Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(text.to_s)
+            end
+
+            # Tracks the in-progress wrapped line while streaming tokens.
+            class LineState
+              attr_accessor :tokens, :width
+
+              def initialize(first_prefix_tokens, continuation_tokens)
+                @continuation_tokens = continuation_tokens
+                @tokens = first_prefix_tokens.dup
+                @width = visible_length(@tokens)
+              end
+
+              def indent_cols
+                visible_length(@continuation_tokens)
+              end
+
+              def reset_to_continuation!
+                @tokens = @continuation_tokens.dup
+                @width = visible_length(@tokens)
+              end
+
+              private
+
+              def visible_length(tokens)
+                tokens
+                  .select { |token| token[:text] }
+                  .sum { |token| Shoko::Adapters::Output::Terminal::TextMetrics.visible_length(token[:text]) }
+              end
+            end
+          end
+        end
+      end
+  end
+end

data/lib/shoko/adapters/output/formatting/formatting_service/line_assembler/tokenizer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Formatting
+      class FormattingService
+        class LineAssembler
+          # Turns styled text segments into a stream of wrapping tokens.
+          module Tokenizer
+            module_function
+
+            def tokenize(segments, image_rendering:, renderable_image_src:)
+              tokens = []
+
+              segments.to_a.each do |segment|
+                styles = segment.styles || {}
+                inline = styles[:inline_image] || styles['inline_image']
+                if image_rendering && inline_image_token?(inline, renderable_image_src)
+                  tokens << { image: true, inline_image: inline }
+                  next
+                end
+
+                tokens.concat(tokenize_text(segment.text.to_s, styles))
+              end
+
+              tokens
+            end
+
+            def prefix_indent(prefix)
+              return nil unless prefix
+
+              ' ' * prefix.to_s.length
+            end
+
+            def prefix_tokens(prefix)
+              return [] if prefix.nil? || prefix.empty?
+
+              [token_from_string(prefix, styles: { prefix: true })]
+            end
+
+            def tokenize_text(text, styles)
+              return [] if text.empty?
+
+              return split_token(text, styles) unless text.include?("\n")
+
+              tokenize_with_newlines(text, styles)
+            end
+
+            def tokenize_with_newlines(text, styles)
+              tokens = []
+              text.split(/(\n)/).each do |piece|
+                if piece == "\n"
+                  tokens << { newline: true }
+                elsif !piece.empty?
+                  tokens.concat(split_token(piece, styles))
+                end
+              end
+              tokens
+            end
+
+            def split_token(text, styles)
+              return [] if text.empty?
+
+              parts = text.scan(/\S+\s*/)
+              return [{ text: text, styles: styles.dup }] if parts.empty?
+
+              parts.map { |part| { text: part, styles: styles.dup } }
+            end
+
+            def token_from_string(text, styles:)
+              { text: text, styles: styles.dup }
+            end
+
+            def inline_image_token?(inline, renderable_image_src)
+              src = image_src(inline)
+              renderable_image_src.call(src)
+            rescue StandardError
+              false
+            end
+            private_class_method :inline_image_token?
+
+            def image_src(inline)
+              return nil unless inline.is_a?(Hash)
+
+              inline[:src] || inline['src']
+            end
+            private_class_method :image_src
+          end
+        end
+      end
+  end
+end

data/lib/shoko/adapters/output/formatting/formatting_service/line_assembler.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/models/content_block.rb'
+require_relative '../../terminal/text_metrics.rb'
+
+module Shoko
+  module Adapters::Output::Formatting
+      class FormattingService
+        # Helper responsible for converting semantic blocks into display-ready
+        # lines, preserving inline styles and metadata.
+        class LineAssembler
+          include Shoko::Core::Models
+
+          def initialize(width, chapter_index: nil, chapter_source_path: nil, rendering_mode: nil,
+                         image_rendering: false, max_image_rows: nil)
+            @width = [width.to_i, 10].max
+            @chapter_index = chapter_index
+            @chapter_source_path = chapter_source_path
+            @image_rendering = if rendering_mode
+                                 rendering_mode == :images
+                               else
+                                 image_rendering ? true : false
+                               end
+            @image_builder = ImageBuilder.new(
+              width: @width,
+              chapter_index: chapter_index,
+              chapter_source_path: chapter_source_path,
+              max_image_rows: max_image_rows
+            )
+            @text_wrapper = TextWrapper.new(@width, image_builder: @image_builder)
+          end
+
+          def build(blocks)
+            blocks.to_a.each_with_index.with_object([]) do |(block, index), lines|
+              lines.concat(lines_for_block(block, index: index))
+              lines << blank_line if blank_line_after?(block, blocks, index)
+            end
+          end
+
+          private
+
+          def metadata_for(block)
+            base = (block.metadata || {}).merge(block_type: block.type)
+            base[:chapter_index] = @chapter_index if @chapter_index
+            base[:chapter_source_path] = @chapter_source_path if @chapter_source_path
+            base
+          end
+
+          def lines_for_block(block, index:)
+            return preformatted_lines(block) if preformatted?(block)
+            return [separator_line] if block.type == :separator
+            return [blank_line] if block.type == :break
+            return image_block_lines(block, index) if block.type == :image && renderable_image_block?(block)
+
+            wrapped_block_lines(block)
+          end
+
+          def preformatted?(block)
+            %i[code table].include?(block.type)
+          end
+
+          def blank_line_after?(block, blocks, index)
+            return false if index >= blocks.length - 1
+            return true if force_blank_line_after?(block)
+
+            blocks[index + 1]&.type != :list_item
+          end
+
+          def force_blank_line_after?(block)
+            block.type == :image || preformatted?(block)
+          end
+
+          def renderable_image_block?(block)
+            @image_rendering && @image_builder.renderable_block_image?(block)
+          end
+
+          def image_block_lines(block, index)
+            @image_builder.block_lines(block, block_index: index, base_metadata: metadata_for(block))
+          end
+
+          def wrapped_block_lines(block)
+            metadata, prefix, continuation_prefix = wrapped_block_options(block)
+            tokens = Tokenizer.tokenize(
+              block.segments,
+              image_rendering: @image_rendering,
+              renderable_image_src: @image_builder.method(:renderable_image_src?)
+            )
+            @text_wrapper.wrap(tokens, metadata: metadata, prefix: prefix, continuation_prefix: continuation_prefix)
+          end
+
+          def wrapped_block_options(block)
+            metadata = metadata_for(block)
+
+            case block.type
+            when :heading
+              [metadata, '', '']
+            when :list_item
+              list_item_options(block, metadata)
+            when :quote
+              [metadata.merge(block_type: :quote), '│ ', '│ ']
+            else
+              [metadata, nil, nil]
+            end
+          end
+
+          def list_item_options(block, metadata)
+            indent = '  ' * [block.level.to_i - 1, 0].max
+            marker = (block.metadata && block.metadata[:marker]) || '•'
+            first_prefix = "#{indent}#{marker} "
+            continuation_prefix = indent + (' ' * (marker.to_s.length + 1))
+            [metadata.merge(list: true), first_prefix, continuation_prefix]
+          end
+
+          def preformatted_lines(block)
+            text = block.segments.to_a.map(&:text).join
+            style = (block.segments.first&.styles || {}).merge(code: true)
+
+            text.split(/\r?\n/).map do |row|
+              plain = row.rstrip
+              DisplayLine.new(
+                text: plain,
+                segments: [TextSegment.new(text: plain, styles: style)],
+                metadata: metadata_for(block)
+              )
+            end
+          end
+
+          def separator_line
+            bar = '─' * [@width, 40].min
+            segment = TextSegment.new(text: bar, styles: { separator: true })
+            DisplayLine.new(text: bar, segments: [segment], metadata: { block_type: :separator })
+          end
+
+          def blank_line
+            DisplayLine.new(text: '', segments: [], metadata: { spacer: true })
+          end
+        end
+      end
+  end
+end
+
+require_relative 'line_assembler/image_builder'
+require_relative 'line_assembler/text_wrapper'
+require_relative 'line_assembler/tokenizer'

data/lib/shoko/adapters/output/formatting/formatting_service/plain_lines_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Formatting
+      class FormattingService
+        # Builds plain text fallback lines from parsed content blocks.
+        module PlainLinesBuilder
+          module_function
+
+          def build(blocks)
+            lines = []
+            blocks.to_a.each { |block| append_lines_for_block(lines, block) }
+            trim_trailing_blank_lines(lines)
+          end
+
+          def append_lines_for_block(lines, block)
+            case block.type
+            when :heading, :paragraph, :image
+              append_text_with_blank_line(lines, block.text)
+            when :list_item
+              lines << list_item_plain_text(block)
+            when :quote
+              append_text_with_blank_line(lines, "> #{block.text}")
+            when :code, :table
+              append_preformatted_lines(lines, block.text)
+            when :separator
+              lines << ('╌' * 40)
+            end
+          end
+
+          def list_item_plain_text(block)
+            indent = '  ' * [block.level.to_i - 1, 0].max
+            marker = (block.metadata && block.metadata[:marker]) || '•'
+            "#{indent}#{marker} #{block.text}"
+          end
+
+          def append_text_with_blank_line(lines, text)
+            lines << text
+            lines << ''
+          end
+
+          def append_preformatted_lines(lines, text)
+            text.to_s.split(/\r?\n/).each { |row| lines << row.rstrip }
+            lines << ''
+          end
+
+          def trim_trailing_blank_lines(lines)
+            lines.pop while lines.last&.strip&.empty?
+            lines
+          end
+        end
+      end
+  end
+end

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

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require_relative '../../../core/services/base_service.rb'
+require_relative '../../../core/models/content_block.rb'
+require_relative '../terminal/text_metrics.rb'
+require_relative '../kitty/kitty_graphics.rb'
+
+module Shoko
+  module Adapters::Output::Formatting
+      # Responsible for transforming chapter XHTML into semantic blocks and
+      # producing display-ready wrapped lines (with style metadata) for renderers.
+      class FormattingService < BaseService
+        # Cached chapter formatting results.
+        FormattedChapter = Struct.new(:blocks, :plain_lines, :checksum, keyword_init: true)
+        private_constant :FormattedChapter
+
+        def initialize(dependencies = nil)
+          super
+          @chapter_cache = {}
+          @wrapped_cache = Hash.new { |h, k| h[k] = {} }
+          @parser_factory = begin
+            resolve(:xhtml_parser_factory)
+          rescue StandardError
+            nil
+          end
+          @logger = begin
+            resolve(:logger)
+          rescue StandardError
+            nil
+          end
+        end
+
+        # Ensure the provided chapter has semantic blocks + plain lines.
+        #
+        # @param document [EPUBDocument]
+        # @param chapter_index [Integer]
+        # @param chapter [Core::Models::Chapter]
+        def ensure_formatted!(document, chapter_index, chapter)
+          ensure_formatted_core(document, chapter_index, chapter)
+        rescue Shoko::FormattingError
+          raise
+        rescue StandardError => e
+          @logger&.error('Formatting service failed', error: e.message)
+          nil
+        end
+
+        # Retrieve wrapped, display-ready lines for a chapter window.
+        # Returns an array of Core::Models::DisplayLine, falling back to plain
+        # strings when formatting is unavailable.
+        #
+        # @param document [EPUBDocument]
+        # @param chapter_index [Integer]
+        # @param width [Integer]
+        # @param offset [Integer]
+        # @param length [Integer]
+        # @param config [Object,nil] state store-like object responding to #get
+        # @param lines_per_page [Integer,nil] optional page height hint for image sizing
+        # @return [Array<Core::Models::DisplayLine,String>]
+        def wrap_window(document, chapter_index, width, offset:, length:, config: nil, lines_per_page: nil)
+          width_i = width.to_i
+          length_i = length.to_i
+          offset_i = offset.to_i
+          return [] if width_i <= 0 || length_i <= 0
+
+          chapter = document&.get_chapter(chapter_index)
+          return [] unless chapter
+
+          formatted = ensure_formatted!(document, chapter_index, chapter)
+          return plain_window(chapter, offset: offset_i, length: length_i) unless formatted
+
+          chapter_source_path = chapter_source_path_for(chapter)
+          wrapped = wrapped_lines_for(document, chapter_index, formatted, width_i,
+                                      chapter_source_path: chapter_source_path, config: config,
+                                      lines_per_page: lines_per_page)
+          window_slice(wrapped, offset: offset_i, length: length_i)
+        end
+
+        # Retrieve all wrapped lines for a chapter at the provided width.
+        #
+        # @return [Array<Core::Models::DisplayLine>]
+        def wrap_all(document, chapter_index, width, config: nil, lines_per_page: nil)
+          return [] if width.to_i <= 0
+
+          chapter = document&.get_chapter(chapter_index)
+          return [] unless chapter
+
+          formatted = ensure_formatted!(document, chapter_index, chapter)
+          return chapter.lines || [] unless formatted
+
+          chapter_source_path = chapter_source_path_for(chapter)
+          wrapped_lines_for(document, chapter_index, formatted, width.to_i,
+                            chapter_source_path: chapter_source_path, config: config,
+                            lines_per_page: lines_per_page)
+        end
+
+        private
+
+        def wrapped_lines_for(document, chapter_index, formatted, width, chapter_source_path:, config:,
+                              lines_per_page: nil)
+          width_key = width.to_i
+          cache_key = chapter_cache_key(document, chapter_index)
+          variant = wrap_variant(config)
+          max_image_rows = max_image_rows_for(lines_per_page)
+          composite_key = wrapped_composite_key(width_key, variant, max_image_rows)
+          cache_for_chapter = @wrapped_cache[cache_key]
+          cache_for_chapter[composite_key] ||= build_wrapped_lines(
+            formatted.blocks,
+            width: width_key,
+            chapter_index: chapter_index,
+            chapter_source_path: chapter_source_path,
+            rendering_mode: rendering_mode_for(variant),
+            max_image_rows: max_image_rows
+          )
+        end
+
+        def checksum_for(content)
+          Digest::SHA1.hexdigest(content.to_s)
+        end
+
+        def apply_formatted_to_chapter(chapter, formatted)
+          chapter.blocks = formatted.blocks if chapter.respond_to?(:blocks=)
+          return unless chapter.respond_to?(:lines=) && (chapter.lines.nil? || chapter.lines.empty?)
+
+          chapter.lines = formatted.plain_lines
+        end
+
+        def chapter_cache_key(document, chapter_index)
+          source = document.respond_to?(:canonical_path) ? document.canonical_path : document.object_id
+          "#{source}:#{chapter_index}"
+        end
+
+        def build_parser(raw)
+          return nil unless @parser_factory.respond_to?(:call)
+
+          @parser_factory.call(raw)
+        rescue StandardError
+          nil
+        end
+
+        def build_plain_lines(blocks)
+          PlainLinesBuilder.build(blocks)
+        end
+
+        def chapter_source_path_for(chapter)
+          metadata = chapter.respond_to?(:metadata) ? chapter.metadata : nil
+          return nil unless metadata
+
+          metadata[:source_path] || metadata['source_path'] || metadata[:href] || metadata['href']
+        rescue StandardError
+          nil
+        end
+
+        def wrap_variant(config)
+          Shoko::Adapters::Output::Kitty::KittyGraphics.enabled_for?(config) ? 'img' : 'txt'
+        rescue StandardError
+          'txt'
+        end
+
+        def raw_content_for(chapter)
+          chapter.respond_to?(:raw_content) ? chapter.raw_content : nil
+        end
+
+        def formatted_chapter_from_blocks(blocks, checksum)
+          FormattedChapter.new(
+            blocks: blocks,
+            plain_lines: build_plain_lines(blocks),
+            checksum: checksum
+          )
+        end
+
+        def plain_window(chapter, offset:, length:)
+          (chapter.lines || [])[offset, length] || []
+        end
+
+        def window_slice(lines, offset:, length:)
+          (lines || [])[offset, length] || []
+        end
+
+        def max_image_rows_for(lines_per_page)
+          rows = lines_per_page.to_i
+          rows.positive? ? rows : nil
+        end
+
+        def wrapped_composite_key(width_key, variant, max_image_rows)
+          return "#{width_key}|#{variant}" unless variant == 'img' && max_image_rows
+
+          "#{width_key}|#{variant}|#{max_image_rows}"
+        end
+
+        def rendering_mode_for(variant)
+          variant == 'img' ? :images : :text
+        end
+
+        def build_wrapped_lines(blocks, width:, chapter_index:, chapter_source_path:, rendering_mode:, max_image_rows:)
+          LineAssembler.new(
+            width,
+            chapter_index: chapter_index,
+            chapter_source_path: chapter_source_path,
+            rendering_mode: rendering_mode,
+            max_image_rows: max_image_rows
+          ).build(blocks)
+        end
+
+        def ensure_formatted_core(document, chapter_index, chapter)
+          return nil unless chapter
+
+          raw = raw_content_for(chapter)
+          cache_key = chapter_cache_key(document, chapter_index)
+          cached = @chapter_cache[cache_key]
+          checksum = checksum_for(raw)
+          return cached if cache_hit?(cached, checksum, chapter)
+          return cached if raw.nil?
+
+          formatted = build_formatted_from_raw(raw, checksum)
+          return cached unless formatted
+
+          store_formatted_chapter(cache_key, formatted, chapter)
+        end
+
+        def cache_hit?(cached, checksum, chapter)
+          return false unless cached && cached.checksum == checksum
+
+          apply_formatted_to_chapter(chapter, cached)
+          true
+        end
+
+        def build_formatted_from_raw(raw, checksum)
+          parser = build_parser(raw)
+          return nil unless parser
+
+          formatted_chapter_from_blocks(parser.parse, checksum)
+        end
+
+        def store_formatted_chapter(cache_key, formatted, chapter)
+          @chapter_cache[cache_key] = formatted
+          @wrapped_cache.delete(cache_key)
+          apply_formatted_to_chapter(chapter, formatted)
+          formatted
+        end
+      end
+  end
+end
+
+require_relative 'formatting_service/line_assembler'
+require_relative 'formatting_service/plain_lines_builder'