shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/components/annotations_overlay_component.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'ui/box_drawer'
+require_relative 'ui/overlay_layout'
+require_relative 'annotations_overlay/list_renderer'
+require_relative '../../../shared/key_definitions'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # Centered overlay listing annotations above the reading surface.
+        class AnnotationsOverlayComponent < BaseComponent
+          include Adapters::Ui::Constants::Ui
+          include Ui::BoxDrawer
+
+          def initialize(state, dependencies: nil)
+            super()
+            @state = state
+            @dependencies = dependencies
+            @reader_state_reader = nil
+            @visible = true
+            @selected_index = (reader_state_reader&.sidebar_annotations_selected || 0).to_i
+            @overlay_sizing = Ui::OverlaySizing.new(
+              width_ratio: 0.6,
+              width_padding: 8,
+              min_width: 48,
+              height_ratio: 0.5,
+              height_padding: 6,
+              min_height: 12
+            )
+          end
+
+          def visible?
+            @visible
+          end
+
+          def hide
+            @visible = false
+          end
+
+          def selected_index=(index)
+            @selected_index = index.to_i
+          end
+
+          def handle_key(key)
+            entries = annotations
+            return { type: :close } if close_when_empty?(entries, key)
+
+            navigation_action(key) || selection_action(key) || close_action(key)
+          end
+
+          def current_annotation
+            entries = annotations
+            entries.empty? ? nil : entries[@selected_index]
+          end
+
+          def scroll_up
+            move_selection(-1)
+          end
+
+          def scroll_down
+            move_selection(1)
+          end
+
+          def cancel
+            { type: :close }
+          end
+
+          def render(surface, bounds)
+            do_render(surface, bounds)
+          end
+
+          def do_render(surface, bounds)
+            return unless @visible
+
+            entries = annotations
+            layout = overlay_layout(bounds)
+
+            layout.fill_background(surface, bounds, background: POPUP_BG_DEFAULT)
+            draw_box(surface, bounds, layout.origin_y, layout.origin_x, layout.height, layout.width, label: 'Annotations')
+            render_context = AnnotationsOverlay::ListRenderer::RenderContext.new(
+              surface: surface,
+              bounds: bounds,
+              layout: layout,
+              entries: entries,
+              selected_index: @selected_index
+            )
+            list_renderer.render(render_context)
+            draw_footer(surface, bounds, layout)
+          end
+
+          private
+
+          def annotations
+            @annotations = (reader_state_reader&.annotations || []).map { |ann| symbolize_keys(ann) }
+            clamp_selection!
+            @annotations
+          end
+
+          def reader_state_reader
+            return @reader_state_reader if @reader_state_reader
+
+            @reader_state_reader = @dependencies&.reader_state_reader || @state
+          end
+
+          def clamp_selection!
+            count = @annotations.length
+            @selected_index = if count.zero?
+                                0
+                              else
+                                @selected_index.clamp(0, count - 1)
+                              end
+          end
+
+          def move_selection(delta)
+            entries = annotations
+            return if entries.empty?
+
+            new_index = (@selected_index + delta).clamp(0, entries.length - 1)
+            return if new_index == @selected_index
+
+            @selected_index = new_index
+            { type: :selection_change, index: @selected_index }
+          end
+
+          def draw_footer(surface, bounds, layout)
+            hint = "#{COLOR_TEXT_DIM}Use ↑/↓ to navigate • Enter to open#{Shoko::Shared::Terminal::Ansi::RESET}"
+            surface.write(bounds, layout.origin_y + layout.height - 2, layout.origin_x + 2, hint)
+          end
+
+          def calculate_width(total_width)
+            @overlay_sizing.width_for(total_width)
+          end
+
+          def calculate_height(total_height)
+            @overlay_sizing.height_for(total_height)
+          end
+
+          def up_key?(key)
+            Shared::KeyDefinitions::NAVIGATION[:up].include?(key)
+          end
+
+          def down_key?(key)
+            Shared::KeyDefinitions::NAVIGATION[:down].include?(key)
+          end
+
+          def confirm_key?(key)
+            Shared::KeyDefinitions::ACTIONS[:confirm].include?(key)
+          end
+
+          def cancel_key?(key)
+            Shared::KeyDefinitions::ACTIONS[:cancel].include?(key)
+          end
+
+          def edit_key?(key)
+            %w[e E].include?(key)
+          end
+
+          def delete_key?(key)
+            key == 'd'
+          end
+
+          def close_when_empty?(entries, key)
+            entries.empty? && cancel_key?(key)
+          end
+
+          def navigation_action(key)
+            return move_selection(-1) if up_key?(key)
+
+            move_selection(1) if down_key?(key)
+          end
+
+          def selection_action(key)
+            annotation = current_annotation
+            return nil unless annotation
+
+            return { type: :open, annotation: annotation } if confirm_key?(key)
+            return { type: :edit, annotation: annotation } if edit_key?(key)
+
+            { type: :delete, annotation: annotation } if delete_key?(key)
+          end
+
+          def close_action(key)
+            { type: :close } if cancel_key?(key)
+          end
+
+          def overlay_layout(bounds)
+            width = calculate_width(bounds.width)
+            height = calculate_height(bounds.height)
+            Ui::OverlayLayout.centered(bounds, width: width, height: height)
+          end
+
+          def list_renderer
+            @list_renderer ||= AnnotationsOverlay::ListRenderer.new
+          end
+
+          def symbolize_keys(annotation)
+            return annotation unless annotation.is_a?(Hash)
+
+            annotation.transform_keys do |key|
+              key.is_a?(String) ? key.to_sym : key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/base_component.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # Base class for all UI components.
+        # Provides lifecycle management, rendering contract, and observer support.
+        class BaseComponent
+          attr_reader :dependencies
+
+          def initialize(dependencies = nil)
+            @dependencies = dependencies
+            @initialized = false
+            @needs_update = true
+          end
+
+          # Render this component into the given surface within bounds
+          # @param surface [Surface] terminal surface wrapper
+          # @param bounds [Rect] local bounds for this component
+          def render(surface, bounds)
+            ensure_mounted
+
+            # Always render for now to debug display issues
+            do_render(surface, bounds)
+            mark_updated
+          end
+
+          # Override this method in subclasses for actual rendering logic
+          def do_render(surface, bounds)
+            # to be implemented by subclasses
+          end
+
+          # Handle input key for this component
+          # Return :handled or :pass_through
+          def handle_input(_key)
+            :pass_through
+          end
+
+          # Component height calculation contract
+          # @param available_height [Integer] Total height available from parent
+          # @return [Integer, :flexible, :fill] Height requirement:
+          #   - Integer: Fixed height in rows
+          #   - :flexible: Use as much space as needed, up to available
+          #   - :fill: Take all remaining space after fixed components
+          def preferred_height(_available_height)
+            :flexible
+          end
+
+          # Component width calculation contract
+          # @param available_width [Integer] Total width available from parent
+          # @return [Integer, :flexible] Width requirement
+          def preferred_width(_available_width)
+            :flexible
+          end
+
+          # Component lifecycle methods
+
+          # Called once when component is first initialized with a parent
+          def mount
+            ensure_mounted
+          end
+
+          # Called when component is removed from the component tree
+          def unmount
+            ensure_unmounted
+          end
+
+          # Mark component as needing a re-render
+          def invalidate
+            @needs_update = true
+          end
+
+          # Check if component needs to be re-rendered
+          def needs_update?
+            @needs_update
+          end
+
+          # Mark component as updated (called automatically after render)
+          def mark_updated
+            @needs_update = false
+          end
+
+          # Override in subclasses for mount logic
+          def on_mount
+            # no-op by default
+          end
+
+          # Override in subclasses for cleanup logic
+          def on_unmount
+            # no-op by default
+          end
+
+          # Observer pattern support for state changes
+          def state_changed(_path, _old_value, _new_value)
+            invalidate
+          end
+
+          private
+
+          def ensure_mounted
+            return if @initialized
+
+            on_mount
+            @initialized = true
+          end
+
+          def ensure_unmounted
+            return unless @initialized
+
+            on_unmount
+            @initialized = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/content_component.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+require_relative 'surface'
+require_relative '../rendering/views/view_renderer_factory'
+require_relative '../rendering/views/help_renderer'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        # ContentComponent coordinates the main reading content area.
+        # It switches between help and the active view renderer based on state.
+        class ContentComponent < BaseComponent
+          def initialize(controller:, render_dependencies:)
+            super(render_dependencies)
+            @controller = controller
+            @render_dependencies = render_dependencies
+            @view_renderer = nil
+            @help_renderer = Reading::HelpRenderer.new(@render_dependencies)
+
+            observer_registry = @render_dependencies.observer_registry
+            # Observe core fields that affect content rendering via ObserverRegistry
+            observer_registry.add_observer(self, %i[reader current_chapter], %i[reader left_page], %i[reader right_page],
+                                           %i[reader single_page], %i[reader current_page_index], %i[reader mode],
+                                           %i[config view_mode])
+          end
+
+          # Observer callback triggered by ObserverStateStore
+          def state_changed(path, old_value, new_value)
+            # Reset renderer for mode changes or view mode changes
+            @view_renderer = nil if [%i[reader mode], %i[config view_mode]].include?(path)
+
+            # Call parent invalidate to properly trigger re-rendering
+            super
+          end
+
+          # Fill remaining space after fixed components
+          def preferred_height(_available_height)
+            :fill
+          end
+
+          def do_render(surface, bounds)
+            case reader_state_reader&.mode
+            when :help
+              @help_renderer.render(surface, bounds)
+            else
+              view_renderer.render(surface, bounds)
+            end
+          end
+
+          private
+
+          def view_renderer
+            return @view_renderer if @view_renderer
+
+            @view_renderer = Reading::ViewRendererFactory.create(@render_dependencies)
+          end
+
+          def reader_state_reader
+            @render_dependencies.reader_state_reader
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/components/dictionary/entry_formatter.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative '../../../../shared/terminal/text_metrics'
+require_relative '../ui/text_utils'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Components
+        module Dictionary
+          # Formats dictionary entries for TUI display.
+          # Uses bold, italic, and subtle styling for clean visual hierarchy.
+          class EntryFormatter
+            include Adapters::Ui::Constants::Ui
+
+            # ANSI style codes (not colors, just styles)
+            BOLD = "\e[1m"
+            DIM = "\e[2m"
+            ITALIC = "\e[3m"
+            RESET_STYLE = "\e[22;23;24m" # Reset bold, italic, underline only (not colors/bg)
+
+            LANG_NAMES = {
+              'en' => 'English',
+              'de' => 'German',
+              'ru' => 'Russian',
+              'zh' => 'Chinese',
+              'fr' => 'French',
+              'es' => 'Spanish',
+              'it' => 'Italian',
+              'pt' => 'Portuguese',
+              'ja' => 'Japanese',
+              'ko' => 'Korean',
+            }.freeze
+
+            def initialize(width:, background: nil, color_mode: :dark)
+              @width = width
+              @content_width = [width - 2, 10].max
+              @bg = background || ''
+              @color_mode = color_mode
+            end
+
+            def format_result(result, entry_index: nil)
+              @target_lang = result.target_lang
+              return format_unavailable(result) if result.search_mode == :unavailable
+              return format_error(result) if result.search_mode == :error
+              return format_not_found(result.query) if result.empty?
+
+              lines = []
+              lines.concat(format_header(result))
+
+              entries = select_entries(result, entry_index)
+              entries.each_with_index do |entry, idx|
+                lines.concat(format_entry(entry))
+                lines << '' unless idx == entries.length - 1
+              end
+
+              lines.concat(format_footer(result, entry_index: entry_index))
+              lines
+            end
+
+            def format_entry(entry)
+              lines = []
+
+              # Main word - bold and accented
+              lines << "#{BOLD}#{accent}#{entry.word}#{RESET_STYLE}"
+
+              # Part of speech / grammatical info - italic, only if clean
+              if entry.lexentry && !entry.lexentry.empty? && clean_lexentry?(entry.lexentry)
+                lines << "#{DIM}#{ITALIC}#{format_lexentry(entry.lexentry)}#{RESET_STYLE}"
+              end
+
+              lines << ''
+
+              # Definitions/senses
+              lines.concat(format_senses(entry.senses))
+
+              # Translations with label
+              lines.concat(format_translations(entry.translations))
+
+              lines
+            end
+
+            def format_fuzzy_results(matches, query)
+              return format_not_found(query) if matches.empty?
+
+              lines = []
+              lines << "#{DIM}Similar to#{RESET_STYLE} #{BOLD}#{query}#{RESET_STYLE}"
+              lines << ''
+
+              matches.first(8).each_with_index do |match, idx|
+                pct = (match.similarity * 100).round
+                lines << "  #{DIM}#{idx + 1}.#{RESET_STYLE} #{accent}#{match.word}#{RESET_STYLE} #{DIM}#{pct}%#{RESET_STYLE}"
+              end
+
+              lines
+            end
+
+            private
+
+            def format_header(result)
+              src = result.source_lang&.upcase || '?'
+              tgt = result.target_lang&.upcase || '?'
+              ["#{DIM}#{src} → #{tgt}#{RESET_STYLE}", '']
+            end
+
+            def format_footer(result, entry_index: nil)
+              return [] unless entry_index && result.entry_count > 1
+
+              ['', "#{DIM}#{entry_index + 1} of #{result.entry_count}#{RESET_STYLE}"]
+            end
+
+            def format_lexentry(lexentry)
+              # Clean up ugly database IDs like "eng/revolutionary__Noun__1"
+              cleaned = lexentry.to_s
+                                .gsub(%r{^[a-z]{2,3}/}, '')  # Remove language prefix
+                                .gsub(/__\d+$/, '')          # Remove trailing numbers
+                                .gsub('__', ' · ')           # Replace __ with dot
+                                .tr('_', ' ')
+              cleaned.split(' · ').map(&:capitalize).join(' · ')
+            end
+
+            def clean_lexentry?(lexentry)
+              return false if lexentry.to_s.strip.empty?
+              return false if lexentry.to_s.length > 50
+
+              true
+            end
+
+            def format_senses(senses)
+              return [] if senses.empty?
+
+              lines = []
+              senses.first(4).each_with_index do |sense, idx|
+                wrapped = word_wrap(sense, @content_width - 4)
+                wrapped.each_with_index do |line, line_idx|
+                  lines << if line_idx.zero?
+                             "#{DIM}#{idx + 1}.#{RESET_STYLE} #{line}"
+                           else
+                             "   #{line}"
+                           end
+                end
+              end
+              lines
+            end
+
+            def format_translations(translations)
+              return [] if translations.empty?
+
+              lines = ['']
+
+              # Add translation label based on target language
+              lang_name = LANG_NAMES[@target_lang&.downcase] || @target_lang&.capitalize || 'Translation'
+              lines << "#{DIM}#{lang_name}:#{RESET_STYLE}"
+
+              translations.first(4).each do |trans|
+                wrapped = word_wrap(trans, @content_width - 4)
+                wrapped.each_with_index do |line, idx|
+                  lines << if idx.zero?
+                             "  #{accent}→#{RESET_STYLE} #{line}"
+                           else
+                             "    #{line}"
+                           end
+                end
+              end
+              lines
+            end
+
+            def format_not_found(query)
+              [
+                "No results for #{BOLD}#{query}#{RESET_STYLE}",
+                '',
+                "#{DIM}Try different spelling or press f for fuzzy search#{RESET_STYLE}",
+              ]
+            end
+
+            def format_unavailable(result)
+              [
+                'Dictionary unavailable',
+                '',
+                "#{DIM}#{result.source_lang}-#{result.target_lang} not installed#{RESET_STYLE}",
+              ]
+            end
+
+            def format_error(result)
+              msg = result.error_message
+              msg = nil if msg.to_s.strip.empty?
+              [
+                'Lookup failed',
+                '',
+                "#{DIM}#{msg || 'Please try again'}#{RESET_STYLE}",
+              ]
+            end
+
+            def select_entries(result, entry_index)
+              entries = result.entries
+              return entries unless entry_index && !entries.empty?
+
+              index = entry_index % entries.length
+              entry = entries[index]
+              entry ? [entry] : []
+            end
+
+            def word_wrap(text, width)
+              return [text] if text.length <= width
+
+              text.split.each_with_object([]) do |word, lines|
+                if lines.empty? || (lines.last.length + word.length + 1) > width
+                  lines << word
+                else
+                  lines[-1] = "#{lines.last} #{word}"
+                end
+              end
+            end
+
+            def accent
+              # Use darker colors for light mode for better contrast
+              if @color_mode == :light
+                "\e[34m" # Blue - good contrast on light bg
+              else
+                begin
+                  RenderStyle.color(:accent)
+                rescue Shoko::Error
+                  "\e[96m"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end