shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/components/sidebar/toc/renderers/header_renderer.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Renders header with title and entry count.
+          class HeaderRenderer
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(context)
+              @context = context
+            end
+
+            def render
+              writer = HeaderWriter.new(@context)
+              writer.write_title(title_content)
+              writer.write_subtitle(subtitle_content) if should_show_subtitle?
+              writer.write_divider
+
+              @context.metrics.y + 2
+            end
+
+            private
+
+            def title_content
+              TitleExtractor.new(@context.document, @context.text_metrics).extract
+            end
+
+            def subtitle_content
+              SubtitleFormatter.new(@context.entries.count, @context.text_metrics).format
+            end
+
+            def should_show_subtitle?
+              subtitle_width = @context.text_metrics.visible_length(subtitle_content.plain)
+              @context.metrics.width > subtitle_width + 2
+            end
+          end
+
+          # Extracts and formats title from document.
+          class TitleExtractor
+            DEFAULT_TITLE = 'CONTENTS'
+
+            def initialize(document, text_metrics)
+              @document = NullDocument.wrap(document)
+              @text_metrics = text_metrics
+            end
+
+            def extract
+              title = extract_title_text
+              return default_content if title.empty?
+
+              TitleContent.new(title.strip.upcase, @text_metrics)
+            end
+
+            private
+
+            def default_content
+              @default_content ||= TitleContent.new(DEFAULT_TITLE, @text_metrics)
+            end
+
+            def extract_title_text
+              metadata_title = @document.metadata.fetch(:title, nil)
+              metadata_title || @document.title || ''
+            end
+          end
+
+          # Represents styled title content.
+          class TitleContent
+            include Adapters::Ui::Constants::Ui
+
+            attr_reader :plain
+
+            def initialize(plain_text, text_metrics)
+              @plain = plain_text
+              @text_metrics = text_metrics
+            end
+
+            def styled
+              "#{Shoko::Shared::Terminal::Ansi::BOLD}#{COLOR_TEXT_ACCENT}#{@plain}#{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+
+            def width
+              @text_metrics.visible_length(@plain)
+            end
+          end
+
+          # Formats subtitle with entry count.
+          class SubtitleFormatter
+            def initialize(count, text_metrics)
+              @count = count
+              @text_metrics = text_metrics
+            end
+
+            def format
+              SubtitleContent.new("#{@count} entries", @text_metrics)
+            end
+          end
+
+          # Represents styled subtitle content.
+          class SubtitleContent
+            include Adapters::Ui::Constants::Ui
+
+            attr_reader :plain
+
+            def initialize(plain_text, text_metrics)
+              @plain = plain_text
+              @text_metrics = text_metrics
+            end
+
+            def styled
+              "#{COLOR_TEXT_DIM}#{@plain}#{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+
+            def width
+              @text_metrics.visible_length(@plain)
+            end
+          end
+
+          # Writes header components to surface.
+          class HeaderWriter
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(context)
+              @context = context
+              @metrics = context.metrics
+              @last_title_width = 0
+            end
+
+            def write_title(title_content)
+              @context.write(y_pos, x_pos + 1, title_content.styled)
+              @last_title_width = title_content.width
+            end
+
+            def write_subtitle(subtitle_content)
+              col = calculate_subtitle_column(subtitle_content)
+              @context.write(y_pos, col, subtitle_content.styled)
+            end
+
+            def write_divider
+              width = [@metrics.width - 2, 0].max
+              divider = "#{COLOR_TEXT_DIM}#{'─' * width}#{Shoko::Shared::Terminal::Ansi::RESET}"
+              @context.write(y_pos + 1, x_pos + 1, divider)
+              write_right_junction
+            end
+
+            private
+
+            def calculate_subtitle_column(subtitle_content)
+              min_col = x_pos + 1 + @last_title_width + 2
+              right_col = x_pos + @metrics.width - subtitle_content.width - 1
+              [right_col, min_col].max
+            end
+
+            def y_pos
+              @metrics.y
+            end
+
+            def x_pos
+              @metrics.x
+            end
+
+            def write_right_junction
+              junction_col = x_pos + @metrics.width - 1
+              return if junction_col < x_pos
+
+              glyph = "#{COLOR_TEXT_DIM}┤#{Shoko::Shared::Terminal::Ansi::RESET}"
+              @context.write(y_pos + 1, junction_col, glyph)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/sidebar/toc/renderers/scrollbar_renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Renders a scrollbar at the right edge of the TOC content area.
+          class ScrollbarRenderer
+            include Adapters::Ui::Constants::Ui
+
+            TRACK_CHAR = '░'
+            THUMB_CHAR = '█'
+
+            def initialize(context)
+              @context = context
+            end
+
+            def render
+              metrics = @context.scroll_metrics
+              return unless metrics.scrollable?
+
+              draw_track(metrics)
+              draw_thumb(metrics)
+            end
+
+            private
+
+            def draw_track(metrics)
+              track_end = metrics.track_start_y + metrics.track_height - 1
+              line = "#{COLOR_TEXT_DIM}#{TRACK_CHAR * SCROLLBAR_WIDTH}#{Shoko::Shared::Terminal::Ansi::RESET}"
+              metrics.track_start_y.upto(track_end) do |row|
+                @context.write(row, metrics.scrollbar_start_col, line)
+              end
+            end
+
+            def draw_thumb(metrics)
+              return unless metrics.thumb_height.positive?
+
+              thumb_end = metrics.thumb_start_y + metrics.thumb_height - 1
+              line = "#{COLOR_TEXT_ACCENT}#{THUMB_CHAR * SCROLLBAR_WIDTH}#{Shoko::Shared::Terminal::Ansi::RESET}"
+              metrics.thumb_start_y.upto(thumb_end) do |row|
+                @context.write(row, metrics.scrollbar_start_col, line)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/sidebar/toc/renderers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'renderers/component_orchestrator'
+require_relative 'renderers/empty_state_renderer'
+require_relative 'renderers/header_renderer'
+require_relative 'renderers/filter_input_renderer'
+require_relative 'renderers/entries_list_renderer'
+require_relative 'renderers/scrollbar_renderer'

data/lib/shoko/adapters/ui/components/sidebar/toc/scroll_metrics.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Computes scroll metrics for TOC entries within the content viewport.
+          class EntriesScrollMetrics
+            attr_reader :track_start_y, :track_height, :thumb_start_y, :thumb_height, :total_items,
+                        :total_height, :viewport_height, :viewport_start, :max_start,
+                        :scrollbar_start_col, :scrollbar_end_col, :visible_indices,
+                        :selected_full_index, :selected_visible_index, :navigable_indices
+
+            def initialize(context)
+              @context = context
+              @layout = context.entries_layout
+              @visible_entries = context.entries.visible
+              @visible_indices = context.entries.visible_indices
+              @total_items = @visible_entries.length
+              @total_height = @layout.total_height
+              @viewport_height = @layout.available_height
+              @scrollbar_end_col = context.metrics.width
+              @scrollbar_start_col = [@scrollbar_end_col - SCROLLBAR_WIDTH + 1, 1].max
+              @track_start_y = @layout.content_start_y
+              @track_height = @layout.available_height
+              @max_start = [@total_height - @viewport_height, 0].max
+              @selected_visible_index = context.selected_index
+              @selected_full_index = context.entries.selected_full_index
+              @viewport_start = calculate_viewport_start
+              @thumb_height = calculate_thumb_height
+              @thumb_start_y = calculate_thumb_start
+              @navigable_indices = build_navigable_indices
+              @nav_positions = build_nav_positions
+            end
+
+            def scrollable?
+              @track_height.positive? && @total_height.positive?
+            end
+
+            def absolute_scrollbar_start_col
+              @context.bounds.x + @scrollbar_start_col - 1
+            end
+
+            def absolute_scrollbar_end_col
+              @context.bounds.x + @scrollbar_end_col - 1
+            end
+
+            def absolute_track_start_y
+              @context.bounds.y + @track_start_y - 1
+            end
+
+            def absolute_track_end_y
+              absolute_track_start_y + @track_height - 1
+            end
+
+            def absolute_thumb_start_y
+              @context.bounds.y + @thumb_start_y - 1
+            end
+
+            def hit_scrollbar?(abs_col, abs_row)
+              return false unless scrollable?
+
+              abs_col.between?(absolute_scrollbar_start_col, absolute_scrollbar_end_col) &&
+                abs_row.between?(absolute_track_start_y, absolute_track_end_y)
+            end
+
+            def row_in_track?(abs_row)
+              return false unless scrollable?
+
+              abs_row.between?(absolute_track_start_y, absolute_track_end_y)
+            end
+
+            def hit_thumb?(abs_col, abs_row)
+              return false unless hit_scrollbar?(abs_col, abs_row)
+              return false unless @thumb_height.positive?
+
+              abs_row.between?(absolute_thumb_start_y, absolute_thumb_start_y + @thumb_height - 1)
+            end
+
+            def full_index_for_abs_row(abs_row)
+              full_index_for_row(abs_row - @context.bounds.y + 1)
+            end
+
+            def full_index_for_row(local_row)
+              return nil unless scrollable?
+              return nil if @visible_indices.empty?
+              return @visible_indices.first if @max_start <= 0 || @track_height <= 1
+
+              clamped = [local_row - @track_start_y, 0].max
+              clamped = [clamped, @track_height - 1].min
+              ratio = clamped.to_f / (@track_height - 1)
+              viewport_start = (ratio * @max_start).round
+              target_line = viewport_start + (@viewport_height / 2.0)
+              target_index = @layout.line_index.entry_index_for_line(target_line) || 0
+              @visible_indices[target_index]
+            end
+
+            def nav_position_for(full_index)
+              @nav_positions[full_index]
+            end
+
+            private
+
+            def calculate_viewport_start
+              return 0 if @total_height <= @viewport_height || @viewport_height <= 0
+
+              selected_index = @selected_visible_index.to_i.clamp(0, @visible_entries.length - 1)
+              selected_offset = @layout.line_index.offset_for(selected_index)
+              selected_height = @layout.line_index.height_for(selected_index)
+              selected_center = selected_offset + (selected_height / 2.0)
+
+              raw = selected_center - (@viewport_height / 2.0)
+              raw = [raw, 0].max
+              [raw.round, @max_start].min
+            end
+
+            def calculate_thumb_height
+              return 0 unless scrollable?
+              return @track_height if @max_start <= 0
+
+              height = (@viewport_height.to_f / @total_height) * @track_height
+              [height.round, 1].max
+            end
+
+            def calculate_thumb_start
+              return @track_start_y unless scrollable?
+              return @track_start_y if @max_start <= 0 || @track_height <= @thumb_height
+
+              offset = ((@viewport_start.to_f / @max_start) * (@track_height - @thumb_height)).round
+              @track_start_y + offset
+            end
+
+            def build_navigable_indices
+              navigable = []
+              @visible_entries.each_with_index do |entry, idx|
+                navigable << @visible_indices[idx] if entry&.chapter_index
+              end
+              navigable.empty? ? @visible_indices.dup : navigable
+            end
+
+            def build_nav_positions
+              positions = {}
+              @navigable_indices.each_with_index { |idx, pos| positions[idx] = pos }
+              positions
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/sidebar/toc/tree_formatting.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../core/services/toc_tree_service'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Formats entry titles.
+          module EntryTitleFormatter
+            def self.format(entry)
+              text = entry.title || 'Untitled'
+              entry.level.zero? ? text.upcase : text
+            end
+          end
+
+          # Formats tree structure prefix for entries.
+          class TreeFormatter
+            def self.prefix(item_entries, index, level)
+              return '' if level <= 0
+
+              PrefixBuilder.new(item_entries, index, level).build
+            end
+
+            def self.continuation_prefix(item_entries, index, level)
+              return '' if level <= 0
+
+              ContinuationPrefixBuilder.new(item_entries, index, level).build
+            end
+          end
+
+          # Calculates indentation for wrapped lines.
+          class IndentCalculator
+            def initialize(item_entries, index, level, icon_present:)
+              @item_entries = item_entries
+              @index = index
+              @level = level
+              @icon_present = icon_present
+            end
+
+            def build
+              prefix = TreeFormatter.continuation_prefix(@item_entries, @index, @level)
+              prefix + (@icon_present ? '  ' : '')
+            end
+          end
+
+          # Builds continuation prefix from segments.
+          class ContinuationPrefixBuilder
+            def initialize(item_entries, index, level)
+              @item_entries = item_entries
+              @index = index
+              @level = level
+            end
+
+            def build
+              (1..@level).map { |depth| segment_for_depth(depth) }.join
+            end
+
+            private
+
+            def segment_for_depth(depth)
+              TreeAnalyzer.ancestor_continues?(@item_entries, @index, depth) ? '│ ' : '  '
+            end
+          end
+
+          # Builds tree prefix from segments.
+          class PrefixBuilder
+            def initialize(item_entries, index, level)
+              @item_entries = item_entries
+              @index = index
+              @level = level
+            end
+
+            def build
+              (1..@level).map { |depth| segment_for_depth(depth) }.join
+            end
+
+            private
+
+            def segment_for_depth(depth)
+              TreeSegment.new(@item_entries, @index, depth, @level).format
+            end
+          end
+
+          # Represents a single tree segment.
+          class TreeSegment
+            def initialize(item_entries, index, depth, current_level)
+              @item_entries = item_entries
+              @index = index
+              @depth = depth
+              @current_level = current_level
+            end
+
+            def format
+              at_current_level? ? branch_segment : continuation_segment
+            end
+
+            private
+
+            def at_current_level?
+              @depth == @current_level
+            end
+
+            def branch_segment
+              TreeAnalyzer.last_child?(@item_entries, @index) ? '└─' : '├─'
+            end
+
+            def continuation_segment
+              TreeAnalyzer.ancestor_continues?(@item_entries, @index, @depth) ? '│ ' : '  '
+            end
+          end
+
+          # Analyzes tree structure relationships.
+          class TreeAnalyzer
+            def self.last_child?(item_entries, index)
+              analyzer = SiblingAnalyzer.new(item_entries, index)
+              analyzer.last_child?
+            end
+
+            def self.ancestor_continues?(item_entries, index, depth)
+              analyzer = AncestorContinuationAnalyzer.new(item_entries, index, depth)
+              analyzer.continues?
+            end
+          end
+
+          # Analyzes sibling relationships.
+          class SiblingAnalyzer
+            def initialize(item_entries, index)
+              @item_entries = item_entries
+              @index = index
+              @current_level = item_entries[index].level
+            end
+
+            def last_child?
+              (@index + 1).upto(@item_entries.length - 1) do |next_index|
+                next_level = @item_entries[next_index].level
+                return false if next_level == @current_level
+                return true if next_level < @current_level
+              end
+
+              true
+            end
+          end
+
+          # Analyzes ancestor continuation.
+          class AncestorContinuationAnalyzer
+            def initialize(item_entries, index, depth)
+              @item_entries = item_entries
+              @index = index
+              @depth = depth
+            end
+
+            def continues?
+              (@index + 1).upto(@item_entries.length - 1) do |next_index|
+                next_level = @item_entries[next_index].level
+                return true if next_level == @depth
+                return false if next_level < @depth
+              end
+
+              false
+            end
+          end
+
+          # Selects appropriate icon for entry.
+          class IconSelector
+            def self.select(full_entries, _entry, full_index, collapsed_set:, filter_active:)
+              tree_service = Shoko::Core::Services::TocTreeService.instance
+              return ' ' unless tree_service.entry_has_children?(full_entries, full_index)
+
+              collapsed = !filter_active && collapsed_set.include?(full_index)
+              collapsed ? '▶' : '▼'
+            end
+          end
+
+          # Provides styling colors for entries.
+          class EntryStyler
+            include Adapters::Ui::Constants::Ui
+
+            def self.icon_color(entry)
+              ICON_COLORS[entry.level] || COLOR_TEXT_DIM
+            end
+
+            def self.title_color(entry)
+              TITLE_COLORS[entry.level] || COLOR_TEXT_SECONDARY
+            end
+
+            ICON_COLORS = {
+              0 => COLOR_TEXT_ACCENT,
+              1 => COLOR_TEXT_SECONDARY,
+            }.freeze
+
+            TITLE_COLORS = {
+              0 => "#{Shoko::Shared::Terminal::Ansi::BOLD}#{COLOR_TEXT_PRIMARY}",
+              1 => COLOR_TEXT_PRIMARY,
+            }.freeze
+          end
+        end
+      end
+    end
+  end
+end