shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/components/sidebar/tab_header_component.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '../base_component'
+require_relative '../../../../shared/terminal/text_metrics'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Modern bottom tab navigation for sidebar
+          class TabHeaderComponent < BaseComponent
+            include Adapters::Ui::Constants::Ui
+
+            RenderTarget = Struct.new(:surface, :bounds, keyword_init: true) do
+              def write(row, col, text)
+                surface.write(bounds, row, col, text)
+              end
+            end
+            private_constant :RenderTarget
+
+            TABS = %i[toc annotations bookmarks].freeze
+            TAB_INFO = {
+              toc: { label: 'Contents', icon: '◉', key: 'T' },
+              annotations: { label: 'Notes', icon: '◈', key: 'A' },
+              bookmarks: { label: 'Bookmarks', icon: '◆', key: 'B' },
+            }.freeze
+
+            def initialize(dependencies: nil)
+              super() # Call BaseComponent constructor with no services
+              @dependencies = dependencies
+              @reader_state_reader = nil
+            end
+
+            def do_render(surface, bounds)
+              target = RenderTarget.new(surface: surface, bounds: bounds)
+              draw_separator(target)
+              render_tab_navigation(target)
+            end
+
+            def tab_for_point(bounds, col, row)
+              return nil unless bounds
+
+              local_row = row.to_i - bounds.y + 1
+              local_col = col.to_i - bounds.x + 1
+              return nil unless local_row.between?(2, 3)
+              return nil unless local_col.between?(1, bounds.width)
+
+              tab_width = (bounds.width - 2) / TABS.length
+              return nil if tab_width <= 0
+
+              offset = local_col - 2
+              return nil if offset.negative?
+
+              max_tabs_width = tab_width * TABS.length
+              return nil if offset >= max_tabs_width
+
+              TABS[offset / tab_width]
+            end
+
+            # Internal context for rendering a single tab button.
+            TabButtonCtx = Struct.new(
+              :tab,
+              :x,
+              :width,
+              :active,
+              :icon,
+              :label,
+              :key,
+              :row_top,
+              :row_bottom,
+              keyword_init: true
+            )
+            private_constant :TabButtonCtx
+
+            private
+
+            def draw_separator(target)
+              width = target.bounds.width
+              line_width = [width - 1, 0].max
+              return if line_width.zero?
+
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              target.write(1, 1, "#{COLOR_TEXT_DIM}#{'─' * line_width}#{reset}")
+              junction_col = width
+              target.write(1, junction_col, "#{COLOR_TEXT_DIM}┤#{reset}") if junction_col.positive?
+            end
+
+            def render_tab_navigation(target)
+              tab_width = (target.bounds.width - 2) / TABS.length
+              row_top = 2
+              row_bottom = 3
+
+              active_tab = reader_state_reader&.sidebar_active_tab || :toc
+              TABS.each_with_index do |tab, index|
+                x_pos = 2 + (index * tab_width)
+                active = (active_tab == tab)
+                ctx = build_tab_button_ctx(tab, x_pos, tab_width, active, row_top: row_top, row_bottom: row_bottom)
+                render_tab_button(target, ctx)
+              end
+            end
+
+            def reader_state_reader
+              return @reader_state_reader if @reader_state_reader
+
+              @reader_state_reader = @dependencies&.reader_state_reader
+            end
+
+            def build_tab_button_ctx(tab, x_pos, width, active, row_top:, row_bottom:)
+              info = TAB_INFO.fetch(tab)
+              TabButtonCtx.new(
+                tab: tab,
+                x: x_pos,
+                width: width,
+                active: active,
+                icon: info[:icon],
+                label: info[:label],
+                key: info[:key],
+                row_top: row_top,
+                row_bottom: row_bottom
+              )
+            end
+
+            def render_tab_button(target, ctx)
+              ctx.active ? render_active(target, ctx) : render_inactive(target, ctx)
+            end
+
+            def render_active(target, ctx)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              icon_text = "#{COLOR_TEXT_ACCENT}#{ctx.icon}#{reset}"
+              label_text = "#{COLOR_TEXT_PRIMARY}#{ctx.label}#{reset}"
+
+              content = "#{ctx.icon} #{ctx.label}"
+              content_len = Shoko::Shared::Terminal::TextMetrics.visible_length(content)
+              padding = [(ctx.width - content_len) / 2, 0].max
+              padded_col = ctx.x + padding
+
+              target.write(ctx.row_top, padded_col, icon_text)
+              target.write(ctx.row_top, padded_col + 2, label_text)
+              render_active_indicator(target, ctx, content_len, reset)
+            end
+
+            def render_active_indicator(target, ctx, content_len, reset)
+              indicator_width = [content_len, ctx.width - 2].min
+              return if indicator_width <= 0
+
+              start = ctx.x + [(ctx.width - indicator_width) / 2, 0].max
+              line = "#{COLOR_TEXT_ACCENT}#{'▬' * indicator_width}#{reset}"
+              target.write(ctx.row_bottom, start, line)
+            end
+
+            def render_inactive(target, ctx)
+              reset = Shoko::Shared::Terminal::Ansi::RESET
+              icon_text = "#{COLOR_TEXT_DIM}#{ctx.icon}#{reset}"
+              key_hint = "#{COLOR_TEXT_DIM}[#{ctx.key}]#{reset}"
+
+              icon_padding = [(ctx.width - 1) / 2, 0].max
+              target.write(ctx.row_top, ctx.x + icon_padding, icon_text)
+
+              key_padding = [(ctx.width - 3) / 2, 0].max
+              target.write(ctx.row_bottom, ctx.x + key_padding, key_hint)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          SCROLLBAR_WIDTH = 1
+          RIGHT_MARGIN = 2
+
+          EntriesCache = Struct.new(:full, :visible, :visible_indices, keyword_init: true)
+          Metrics = Struct.new(:x, :y, :width, :height, keyword_init: true)
+          ViewportConfig = Struct.new(:start_y, :height, :max_width, keyword_init: true)
+          ItemConfig = Struct.new(
+            :item_entries, :entry, :index, :full_index, :selected_index, :max_width,
+            :full_entries, :collapsed_set, :filter_active, :wrap_cache, :text_metrics,
+            keyword_init: true
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Encapsulates TOC rendering context and state.
+          class RenderContext
+            include Adapters::Ui::Constants::Ui
+
+            attr_reader :surface, :bounds, :document, :wrap_cache, :sidebar_state_reader, :text_metrics
+
+            def initialize(surface, bounds, document, wrap_cache: nil, entries_cache: nil,
+                           sidebar_state_reader: nil, text_metrics:)
+              @surface = surface
+              @bounds = bounds
+              @document = document
+              @wrap_cache = wrap_cache || {}
+              @entries_cache = entries_cache
+              @sidebar_state_reader = sidebar_state_reader
+              @text_metrics = text_metrics
+            end
+
+            def entries
+              return @entries if @entries
+              return cached_entries if @entries_cache
+
+              @entries = EntriesCalculator.new(self).calculate
+            end
+
+            def selected_index
+              @selected_index ||= SelectedIndexCalculator.new(entries).calculate
+            end
+
+            def filter_active?
+              sidebar_state_reader&.sidebar_toc_filter_active?
+            end
+
+            def filter_text
+              sidebar_state_reader&.sidebar_toc_filter || ''
+            end
+
+            def collapsed_indices
+              raw = sidebar_state_reader&.sidebar_toc_collapsed
+              Array(raw).map(&:to_i)
+            end
+
+            def collapsed_set
+              @collapsed_set ||= Set.new(collapsed_indices)
+            end
+
+            def metrics
+              @metrics ||= calculate_metrics
+            end
+
+            def write(row, col, text)
+              surface.write(bounds, row, col, text)
+            end
+
+            def scroll_metrics
+              @scroll_metrics ||= EntriesScrollMetrics.new(self)
+            end
+
+            def entries_layout
+              @entries_layout ||= EntriesListLayout.new(self)
+            end
+
+            private
+
+            def cached_entries
+              @entries = EntriesCollection.new(
+                full: @entries_cache.full,
+                visible: @entries_cache.visible,
+                visible_indices: @entries_cache.visible_indices,
+                selected_full_index: selected_full_index_for(@entries_cache.full)
+              )
+            end
+
+            def selected_full_index_for(entries)
+              raw_index = sidebar_state_reader&.sidebar_toc_selected || 0
+              max_index = [entries.length - 1, 0].max
+              raw_index.to_i.clamp(0, max_index)
+            end
+
+            def calculate_metrics
+              Metrics.new(
+                x: 1,
+                y: 1,
+                width: bounds.width,
+                height: bounds.height
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../core/ports/outbound/reader_document'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Null object pattern for missing documents.
+          class NullDocument
+            include Shoko::Core::Ports::Outbound::ReaderDocument
+
+            EMPTY_ARRAY = [].freeze
+            EMPTY_HASH = {}.freeze
+
+            def self.wrap(document)
+              return document if document
+
+              new
+            end
+
+            def toc_entries
+              EMPTY_ARRAY
+            end
+
+            def chapters
+              EMPTY_ARRAY
+            end
+
+            def metadata
+              EMPTY_HASH
+            end
+
+            def title
+              nil
+            end
+
+            def chapter_count
+              0
+            end
+
+            def get_chapter(_index)
+              nil
+            end
+
+            def canonical_path
+              nil
+            end
+
+            def cached?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../core/services/toc_tree_service'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Collection of entries with selection state.
+          class EntriesCollection
+            attr_reader :full, :visible, :visible_indices, :selected_full_index
+
+            def initialize(full:, visible:, visible_indices:, selected_full_index:)
+              @full = full
+              @visible = visible
+              @visible_indices = visible_indices
+              @selected_full_index = selected_full_index
+            end
+
+            def empty?
+              visible.empty?
+            end
+
+            def count
+              full.length
+            end
+          end
+
+          # Calculates the selected index in visible list.
+          class SelectedIndexCalculator
+            def initialize(entries)
+              @entries = entries
+            end
+
+            def calculate
+              selected_entry = full_entries[selected_full_index]
+              find_visible_index(selected_entry)
+            end
+
+            private
+
+            def full_entries
+              @entries.full
+            end
+
+            def visible_entries
+              @entries.visible
+            end
+
+            def selected_full_index
+              @entries.selected_full_index
+            end
+
+            def find_visible_index(selected_entry)
+              return 0 unless selected_entry
+
+              visible_entries.index(selected_entry) || 0
+            end
+          end
+
+          # Calculates entries collection with filtering.
+          class EntriesCalculator
+            def initialize(context)
+              @context = context
+              @tree_service = Shoko::Core::Services::TocTreeService.instance
+            end
+
+            def calculate
+              full_entries = @tree_service.entries_for(@context.document)
+              visible_indices = @tree_service.visible_indices(
+                full_entries,
+                collapsed: @context.collapsed_indices,
+                filter_text: @context.filter_text,
+                filter_active: @context.filter_active?
+              )
+              visible = visible_indices.map { |idx| full_entries[idx] }.compact
+
+              EntriesCollection.new(
+                full: full_entries,
+                visible: visible,
+                visible_indices: visible_indices,
+                selected_full_index: calculate_selected_index(full_entries)
+              )
+            end
+
+            private
+
+            def calculate_selected_index(entries)
+              raw_index = @context.sidebar_state_reader&.sidebar_toc_selected || 0
+              max_index = [entries.length - 1, 0].max
+              raw_index.to_i.clamp(0, max_index)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Sidebar
+          # Calculates components of an entry (prefix, icon, title).
+          class EntryComponents
+            attr_reader :prefix, :icon, :title, :entry, :continuation_prefix
+
+            def initialize(item_entries, entry, index, full_entries:, full_index:, collapsed_set:, filter_active:, text_metrics:)
+              @entry = entry
+              @text_metrics = text_metrics
+              @prefix = TreeFormatter.prefix(item_entries, index, entry.level)
+              @icon = IconSelector.select(
+                full_entries,
+                entry,
+                full_index,
+                collapsed_set: collapsed_set,
+                filter_active: filter_active
+              )
+              @title = EntryTitleFormatter.format(entry)
+              @continuation_prefix = IndentCalculator.new(
+                item_entries,
+                index,
+                entry.level,
+                icon_present: icon_present?
+              ).build
+            end
+
+            def icon_present?
+              !@icon.empty?
+            end
+
+            def width_without_title
+              prefix_width + icon_width + spacer_width
+            end
+
+            private
+
+            def spacer_width
+              icon_present? ? 1 : 0
+            end
+
+            def prefix_width
+              @text_metrics.visible_length(@prefix)
+            end
+
+            def icon_width
+              @text_metrics.visible_length(@icon)
+            end
+          end
+
+          # Renders a single TOC entry.
+          class EntryRenderer
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(context, item)
+              @context = context
+              @item = item
+            end
+
+            def render
+              render_lines
+            end
+
+            private
+
+            def render_lines
+              formatter = EntryFormatter.new(@item)
+              lines = formatter.lines
+              start = @item.start_offset
+              visible = @item.visible_height
+              lines_to_render = lines.slice(start, visible) || []
+
+              lines_to_render.each_with_index do |line, offset|
+                y_pos = @item.screen_y + offset
+                write_gutter(y_pos)
+                write_content(y_pos, line)
+              end
+            end
+
+            def write_gutter(y_pos)
+              gutter = gutter_symbol + Shoko::Shared::Terminal::Ansi::RESET
+              @context.write(y_pos, @context.metrics.x, gutter)
+            end
+
+            def gutter_symbol
+              @item.selected? ? "#{COLOR_TEXT_ACCENT}│" : "#{COLOR_TEXT_DIM}│"
+            end
+
+            def write_content(y_pos, line)
+              @context.write(y_pos, @context.metrics.x + 2, line)
+            end
+          end
+
+          # Formats entry text with tree structure.
+          class EntryFormatter
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(item)
+              @item = item
+              @components = item.components
+            end
+
+            def lines
+              builder = EntryLineBuilder.new(@components, @item.wrapped_lines)
+              @item.selected? ? builder.build_selected : builder.build
+            end
+          end
+
+          # Builds multi-line entry strings.
+          class EntryLineBuilder
+            include Adapters::Ui::Constants::Ui
+
+            def initialize(components, wrapped_lines)
+              @components = components
+              @entry = components.entry
+              @wrapped_lines = wrapped_lines
+            end
+
+            def build
+              build_lines { |line, idx| format_line(line, idx) }
+            end
+
+            def build_selected
+              build_lines { |line, idx| format_selected_line(line, idx) }
+            end
+
+            private
+
+            def build_lines(&)
+              @wrapped_lines.map.with_index(&)
+            end
+
+            def format_line(line, idx)
+              idx.zero? ? format_first_line(line) : format_continuation_line(line)
+            end
+
+            def format_selected_line(line, idx)
+              plain = idx.zero? ? plain_first_line(line) : plain_continuation_line(line)
+              "#{Shoko::Shared::Terminal::Ansi::BG_GREY}#{Shoko::Shared::Terminal::Ansi::WHITE}#{plain}#{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+
+            def format_first_line(line)
+              parts = []
+              prefix = @components.prefix
+              parts << colorize(prefix, COLOR_TEXT_DIM) unless prefix.empty?
+
+              if @components.icon_present?
+                parts << colorize(@components.icon, EntryStyler.icon_color(@entry))
+                parts << ' '
+              end
+
+              parts << colorize(line, EntryStyler.title_color(@entry))
+              parts.join
+            end
+
+            def format_continuation_line(line)
+              prefix = @components.continuation_prefix
+              styled_prefix = prefix.empty? ? '' : colorize(prefix, COLOR_TEXT_DIM)
+              "#{styled_prefix}#{colorize(line, EntryStyler.title_color(@entry))}"
+            end
+
+            def plain_first_line(line)
+              spacer = @components.icon_present? ? ' ' : ''
+              "#{@components.prefix}#{@components.icon}#{spacer}#{line}"
+            end
+
+            def plain_continuation_line(line)
+              "#{@components.continuation_prefix}#{line}"
+            end
+
+            def colorize(text, color)
+              return text if text.empty? || color.nil?
+
+              "#{color}#{text}#{Shoko::Shared::Terminal::Ansi::RESET}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'document_model'
+require_relative 'entries_calculator'
+require_relative 'tree_formatting'
+require_relative 'entry_rendering'
+require_relative 'layout'
+require_relative 'scroll_metrics'
+require_relative 'context'
+require_relative 'renderers'