shoko 0.1.0

data/lib/shoko/adapters/output/ui/components/main_menu_component.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'layouts/vertical'
+require_relative 'screens/menu_screen_component'
+require_relative 'screens/browse_screen_component'
+require_relative 'screens/library_screen_component'
+require_relative 'screens/settings_screen_component'
+require_relative 'screens/download_books_screen_component'
+require_relative 'screens/annotations_screen_component'
+require_relative 'screens/annotation_edit_screen_component'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    # Root component for the main menu system
+    class MainMenuComponent < BaseComponent
+      def initialize(main_menu, dependencies)
+        super()
+        @main_menu = main_menu
+        @state = main_menu.state
+        @dependencies = dependencies
+        @catalog = @main_menu.catalog
+
+        setup_screen_components
+
+        # Initialize current screen
+        @current_screen = @screen_components[:menu]
+
+        # Observe mode changes to switch active component
+        @state.add_observer(self, %i[menu mode], %i[menu selected])
+      end
+
+      def state_changed(path, _old_value, new_value)
+        return unless path == %i[menu mode]
+
+        mapped = case new_value
+                 when :search then :browse
+                 when :download_search, :download then :download
+                 else new_value
+                 end
+        @current_screen = @screen_components[mapped] || @screen_components[:menu]
+      end
+
+      def do_render(surface, bounds)
+        current_screen&.render(surface, bounds)
+      end
+
+      def preferred_height(_available_height)
+        :fill
+      end
+
+      attr_reader :current_screen
+
+      # Delegate screen-specific methods
+      def browse_screen
+        @screen_components[:browse]
+      end
+
+      def library_screen
+        @screen_components[:library]
+      end
+
+      # recent screen removed
+
+      def settings_screen
+        @screen_components[:settings]
+      end
+
+      def download_books_screen
+        @screen_components[:download]
+      end
+
+      def annotations_screen
+        @screen_components[:annotations]
+      end
+
+      def annotation_detail_screen
+        @screen_components[:annotation_detail]
+      end
+
+      private
+
+      def setup_screen_components
+        @screen_components = {
+          menu: Screens::MenuScreenComponent.new(@state),
+          browse: Screens::BrowseScreenComponent.new(@catalog, @state),
+          library: Screens::LibraryScreenComponent.new(@state, @dependencies),
+          settings: Screens::SettingsScreenComponent.new(@state, @catalog),
+          download: Screens::DownloadBooksScreenComponent.new(@state),
+          annotations: Screens::AnnotationsScreenComponent.new(@state),
+          annotation_editor: Screens::AnnotationEditScreenComponent.new(@state, @dependencies),
+          annotation_detail: Screens::AnnotationDetailScreenComponent.new(@state),
+        }
+      end
+
+      public
+
+      def annotation_edit_screen
+        @screen_components[:annotation_editor]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../../rendering/models/rendering_context.rb'
+require_relative '../../../rendering/models/render_params.rb'
+require_relative '../../../terminal/text_metrics.rb'
+require_relative 'config_helpers'
+require_relative 'line_drawer'
+require_relative 'wrapped_lines_fetcher'
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Base class for all view renderers.
+      #
+      # Subclasses implement `render_with_context` and can use helpers for layout,
+      # wrapped line fetching, and line drawing.
+      class BaseViewRenderer < BaseComponent
+        def initialize(dependencies)
+          super()
+          @dependencies = dependencies
+          raise ArgumentError, 'Dependencies must be provided to BaseViewRenderer' unless @dependencies
+
+          @layout_service = @dependencies.resolve(:layout_service)
+          @wrapped_lines_fetcher = WrappedLinesFetcher.new(@dependencies)
+          @line_drawer = nil
+          @last_render_key = nil
+        end
+
+        # Standard ComponentInterface implementation
+        def do_render(surface, bounds)
+          context = create_rendering_context
+          return unless context
+
+          render_key = render_key_for(context, bounds)
+          record_geometry = rendered_lines_missing?(context.state) || render_key != @last_render_key
+          rendered_lines_buffer = record_geometry ? {} : nil
+          placed_kitty_images = {}
+          @line_drawer = LineDrawer.new(
+            dependencies: @dependencies,
+            rendered_lines_buffer: rendered_lines_buffer,
+            placed_kitty_images: placed_kitty_images,
+            record_geometry: record_geometry
+          )
+
+          render_with_context(surface, bounds, context)
+
+          if record_geometry
+            dispatch_rendered_lines(context.state, rendered_lines_buffer)
+            @last_render_key = render_key
+          end
+        ensure
+          @line_drawer = nil
+        end
+
+        # New rendering interface using context
+        def render_with_context(surface, bounds, context)
+          raise NotImplementedError, 'Subclasses must implement render_with_context method'
+        end
+
+        protected
+
+        def layout_metrics(width, height, view_mode)
+          @layout_service.calculate_metrics(width, height, view_mode)
+        end
+
+        def adjust_for_line_spacing(height, line_spacing = :normal)
+          @layout_service.adjust_for_line_spacing(height, line_spacing)
+        end
+
+        def calculate_center_start_row(content_height, lines_count, line_spacing)
+          @layout_service.calculate_center_start_row(content_height, lines_count, line_spacing)
+        end
+
+        # Compute common layout values for a given view mode.
+        # Returns `[col_width, content_height, spacing, displayable]`.
+        def compute_layout(bounds, view_mode, config)
+          col_width, content_height = layout_metrics(bounds.width, bounds.height, view_mode)
+          spacing = ConfigHelpers.line_spacing(config)
+          displayable = adjust_for_line_spacing(content_height, spacing)
+          [col_width, content_height, spacing, displayable]
+        end
+
+        # Draw a vertical divider between columns (shared helper)
+        def draw_divider(surface, bounds, divider_col, start_row = 3)
+          col = divider_col.to_i
+          return if col <= 0
+
+          (start_row..[bounds.height - 1, start_row + 1].max).each do |row|
+            surface.write(
+              bounds,
+              row,
+              col,
+              "#{Shoko::Adapters::Output::Ui::Constants::UI::BORDER_PRIMARY}│#{Terminal::ANSI::RESET}"
+            )
+          end
+        end
+
+        # Shared helpers for common renderer patterns
+        def center_start_col(total_width, col_width)
+          [(total_width - col_width) / 2, 1].max
+        end
+
+        def fetch_wrapped_lines(document:, chapter_index:, col_width:, offset:, length:)
+          @wrapped_lines_fetcher.fetch(
+            document: document,
+            chapter_index: chapter_index,
+            col_width: col_width,
+            offset: offset,
+            length: length
+          )
+        end
+
+        def fetch_wrapped_lines_with_offset(document:, chapter_index:, col_width:, offset:, length:)
+          @wrapped_lines_fetcher.fetch_with_offset(
+            document: document,
+            chapter_index: chapter_index,
+            col_width: col_width,
+            offset: offset,
+            length: length
+          )
+        end
+
+        def snap_offset_to_image_start(lines, offset)
+          @wrapped_lines_fetcher.snap_offset_to_image_start(lines, offset)
+        end
+
+        # Shared helper to draw a list of lines with spacing and clipping considerations.
+        def draw_lines(surface, bounds, lines, params)
+          drawer = line_drawer
+          ctx = params.context
+          spacing = ctx ? ConfigHelpers.line_spacing(ctx.config) : :normal
+          lines.each_with_index do |line, idx|
+            row = params.start_row + (spacing == :relaxed ? idx * 2 : idx)
+            break if row > bounds.height - 1
+
+            drawer.draw_line(surface: surface, bounds: bounds, line: line, row: row, col: params.col_start,
+                             width: params.col_width, context: ctx, column_id: params.column_id,
+                             line_offset: params.line_offset + idx, page_id: params.page_id)
+          end
+        end
+
+        private
+
+        def create_rendering_context
+          state = @dependencies.resolve(:global_state)
+          Adapters::Output::Rendering::Models::RenderingContext.new(
+            document: safe_resolve(:document),
+            page_calculator: safe_resolve(:page_calculator),
+            state: state,
+            config: state,
+            view_model: nil
+          )
+        end
+
+        def safe_resolve(name)
+          @dependencies.registered?(name) ? @dependencies.resolve(name) : nil
+        end
+
+        def dispatch_rendered_lines(state, rendered_lines)
+          state&.dispatch(Shoko::Application::Actions::UpdateRenderedLinesAction.new(rendered_lines))
+        rescue StandardError
+          nil
+        end
+
+        def render_key_for(context, bounds)
+          state = context.state
+          [
+            bounds.width,
+            bounds.height,
+            state.get(%i[reader current_chapter]),
+            state.get(%i[reader current_page_index]),
+            state.get(%i[reader left_page]),
+            state.get(%i[reader right_page]),
+            state.get(%i[reader single_page]),
+            context.view_mode,
+            context.page_numbering_mode,
+            Shoko::Application::Selectors::ConfigSelectors.line_spacing(state),
+            Shoko::Application::Selectors::ConfigSelectors.kitty_images(state),
+            context.document&.object_id
+          ]
+        end
+
+        def rendered_lines_missing?(state)
+          lines = Shoko::Application::Selectors::ReaderSelectors.rendered_lines(state)
+          !lines || lines.empty?
+        rescue StandardError
+          true
+        end
+
+        def line_drawer
+          return @line_drawer if @line_drawer
+
+          raise ArgumentError, 'LineDrawer not initialized (do_render not active)'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Output::Ui::Components
+    module Reading
+      # Shared helpers for resolving configuration values from the state store.
+      module ConfigHelpers
+        module_function
+
+        def config_store(config)
+          return config if config.respond_to?(:get)
+          return config.state if config.respond_to?(:state) && config.state.respond_to?(:get)
+
+          nil
+        end
+
+        def line_spacing(config)
+          store = config_store(config)
+          return Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING unless store
+
+          Shoko::Application::Selectors::ConfigSelectors.line_spacing(store) ||
+            Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+        rescue StandardError
+          Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+        end
+
+        def highlight_quotes?(store)
+          value = store&.get(%i[config highlight_quotes])
+          value.nil? || value
+        rescue StandardError
+          true
+        end
+
+        def highlight_keywords?(store)
+          !!store&.get(%i[config highlight_keywords])
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

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

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

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