shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/input/controllers/selection_mouse_handler.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/models/selection_anchor'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        # Handles text selection and popup menu mouse interactions.
+        # Extracted from MouseableReader to reduce class size.
+        module SelectionMouseHandler
+          private
+
+          def handle_selection_end
+            update_state_selection(@mouse_handler.selection_range)
+            sel = @reader_state_reader.selection
+            return unless sel
+
+            @selected_text = extract_selected_text(sel)
+
+            unless @selected_text && !@selected_text.strip.empty?
+              @mouse_handler.reset
+              @state_writer.clear_selection
+            end
+          end
+
+          def handle_popup_context_click(event)
+            return false unless right_click_press?(event)
+
+            selection = @reader_state_reader.selection
+            return false unless selection
+
+            rendered = smh_rendered_content_reader&.rendered_lines
+            return false if rendered.nil? || rendered.empty?
+
+            click_anchor = @coordinate_service.anchor_from_point({ x: event[:x], y: event[:y] }, rendered, bias: :nearest)
+            return false unless click_anchor && anchor_within_selection?(click_anchor, selection, rendered)
+
+            selected_text = @selected_text || extract_selected_text(selection)
+            return false if selected_text.nil? || selected_text.strip.empty?
+
+            terminal_coords = @coordinate_service.mouse_to_terminal(event[:x], event[:y])
+            opened = show_popup_menu(anchor_position: terminal_coords)
+            @suppress_popup_release_once = true if opened
+            opened
+          end
+
+          def show_popup_menu(anchor_position: nil)
+            selection = @reader_state_reader.selection
+            return false unless selection
+
+            rendered = smh_rendered_content_reader&.rendered_lines
+            factory = smh_ui_component_factory
+            return false unless factory
+
+            popup_menu = factory.enhanced_popup_menu(
+              selection: selection,
+              coordinate_service: @coordinate_service,
+              popup_position_service: @popup_position_service,
+              clipboard_service: smh_clipboard_service,
+              rendered: rendered,
+              dictionary_enabled: dictionary_lookup_available?,
+              anchor_position: anchor_position
+            )
+            @state_writer.update_reader(popup_menu: popup_menu)
+            return false unless popup_menu&.visible
+
+            switch_mode(:popup_menu)
+            draw_screen
+            true
+          end
+
+          def right_click_press?(event)
+            button = event[:button].to_i
+            !event[:released] && (button & 0b11) == 2 && (button & 32).zero?
+          end
+
+          def anchor_within_selection?(anchor, selection, rendered)
+            normalized = @coordinate_service.normalize_selection_range(selection, rendered)
+            return false unless normalized
+
+            start_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized[:start])
+            end_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized[:end])
+            return false unless start_anchor && end_anchor
+
+            (start_anchor <=> anchor).to_i <= 0 && (anchor <=> end_anchor).to_i <= 0
+          end
+
+          def handle_popup_click(event)
+            terminal_coords = @coordinate_service.mouse_to_terminal(event[:x], event[:y])
+            popup_menu = @reader_state_reader.popup_menu
+            item = popup_menu.handle_click(terminal_coords[:x], terminal_coords[:y])
+
+            if item
+              handle_popup_action(item)
+            else
+              @state_writer.update_reader(popup_menu: nil)
+              @mouse_handler.reset
+              @state_writer.clear_selection
+            end
+            draw_screen
+          end
+
+          def handle_popup_hover(event)
+            terminal_coords = @coordinate_service.mouse_to_terminal(event[:x], event[:y])
+            popup_menu = @reader_state_reader.popup_menu
+            return unless popup_menu
+
+            result = popup_menu.handle_hover(terminal_coords[:x], terminal_coords[:y])
+            draw_screen if result && result[:type] == :selection_change
+          end
+
+          def extract_selected_text(range)
+            sel_svc = smh_selection_service
+            content_reader = smh_rendered_content_reader
+            return nil unless sel_svc && content_reader
+
+            rendered = content_reader.rendered_lines
+            sel_svc.extract_text(range, rendered)
+          end
+
+          def update_state_selection(mouse_range)
+            anchor_range = anchor_range_from_mouse(mouse_range)
+            if anchor_range
+              @state_writer.update_reader(selection: anchor_range)
+            else
+              @state_writer.clear_selection
+            end
+          end
+
+          def anchor_range_from_mouse(mouse_range)
+            return nil unless mouse_range
+
+            rendered = smh_rendered_content_reader&.rendered_lines
+            return nil if rendered.nil? || rendered.empty?
+
+            start_anchor = @coordinate_service.anchor_from_point(mouse_range[:start], rendered, bias: :leading)
+            end_anchor = @coordinate_service.anchor_from_point(mouse_range[:end], rendered, bias: :trailing)
+            return nil unless start_anchor && end_anchor
+
+            @coordinate_service.normalize_selection_range(
+              { start: start_anchor.to_h, end: end_anchor.to_h }, rendered
+            )
+          end
+
+          def copy_to_clipboard(text)
+            ui = smh_ui_controller
+            clip = smh_clipboard_service
+            return false unless clip
+
+            clip.copy_with_feedback(text) do |message|
+              ui&.set_message(message)
+            rescue Shoko::Error
+              # best-effort
+            end
+          rescue Shoko::ClipboardError => e
+            begin
+              ui&.set_message("Copy failed: #{e.message}")
+            rescue Shoko::Error
+              raise
+            end
+            false
+          end
+
+          def dictionary_lookup_available?
+            dict_avail = smh_dictionary_availability
+            return false unless dict_avail
+
+            return false unless dict_avail.sqlite3_available?
+
+            backend = @config_reader.dictionary_backend
+            backend_name = backend.to_s.downcase
+            return false if backend_name == 'disabled'
+            true
+          rescue Shoko::Error
+            raise
+          end
+
+          # Host class provides these dependencies as instance variables.
+          # Each method returns the corresponding dependency or nil.
+          def smh_selection_service
+            defined?(@selection_service) ? @selection_service : nil
+          end
+
+          def smh_rendered_content_reader
+            defined?(@rendered_content_reader) ? @rendered_content_reader : nil
+          end
+
+          def smh_render_registry
+            defined?(@render_registry) ? @render_registry : nil
+          end
+
+          def smh_ui_controller
+            defined?(@ui_controller_ref) ? @ui_controller_ref : nil
+          end
+
+          def smh_clipboard_service
+            defined?(@clipboard_service) ? @clipboard_service : nil
+          end
+
+          def smh_dictionary_availability
+            defined?(@dictionary_availability) ? @dictionary_availability : nil
+          end
+
+          def smh_ui_component_factory
+            defined?(@ui_component_factory) ? @ui_component_factory : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/sidebar/anchor_resolver.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require_relative '../../../../core/models/content_block'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Sidebar
+          # Resolves TOC href anchors into chapter line offsets.
+          class AnchorResolver
+            def initialize(document_reader:, formatting_service:, layout_service:, ui_state_reader:, config_reader:,
+                           sidebar_state_reader:)
+              @document_reader = document_reader
+              @formatting_service = formatting_service
+              @layout_service = layout_service
+              @ui_state_reader = ui_state_reader
+              @config_reader = config_reader
+              @sidebar_state_reader = sidebar_state_reader
+            end
+
+            def line_offset_for_toc_entry(entry, chapter_index)
+              anchor = anchor_from_href(entry&.href)
+              return nil if anchor.nil? || anchor.empty?
+
+              lines = wrapped_lines_for_anchor(chapter_index)
+              return nil if lines.nil? || lines.empty?
+
+              anchor_down = anchor.downcase
+              lines.each_with_index do |line, idx|
+                next unless line.is_a?(Shoko::Core::Models::DisplayLine)
+
+                anchors = line.metadata[:anchors] || line.metadata['anchors']
+                next unless anchors
+
+                anchors = Array(anchors).map(&:to_s)
+                return idx if anchors.include?(anchor)
+                return idx if anchors.any? { |value| value.casecmp?(anchor) }
+                return idx if anchors.any? { |value| value.downcase == anchor_down }
+              end
+              nil
+            rescue Shoko::Error
+              raise
+            end
+
+            def anchor_from_href(href)
+              return nil if href.nil?
+
+              fragment = href.to_s.split('#', 2)[1]
+              return nil if fragment.nil? || fragment.empty?
+
+              CGI.unescape(fragment.to_s).strip
+            rescue Shoko::Error
+              raise
+            end
+
+            private
+
+            def wrapped_lines_for_anchor(chapter_index)
+              return nil unless @formatting_service && @layout_service && document
+
+              width = (@ui_state_reader.terminal_width || 80).to_i
+              height = (@ui_state_reader.terminal_height || 24).to_i
+              view_mode = @config_reader.view_mode
+              line_spacing = @config_reader.line_spacing
+              effective_width = @layout_service.effective_content_width(
+                width,
+                sidebar_visible: @sidebar_state_reader.sidebar_visible?
+              )
+              col_width, content_height = @layout_service.calculate_metrics(effective_width, height, view_mode)
+              lines_per_page = @layout_service.adjust_for_line_spacing(content_height, line_spacing)
+
+              @formatting_service.wrap_all(document, chapter_index, col_width,
+                                           config: @config_reader, lines_per_page: lines_per_page)
+            rescue Shoko::Error
+              raise
+            end
+
+            def document
+              @document_reader.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/sidebar/tab_state_orchestrator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative '../support/message_notifier'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Sidebar
+          # Owns sidebar open/close/tab-switch orchestration and related state writes.
+          class TabStateOrchestrator
+            include Shoko::Adapters::Input::Controllers::Support::MessageNotifier
+
+            def initialize(config_reader:, reader_state_reader:, sidebar_state_reader:, state_writer:, toc_navigation:,
+                           document_reader:, ui_controller: nil, notification_service: nil)
+              @config_reader = config_reader
+              @reader_state_reader = reader_state_reader
+              @sidebar_state_reader = sidebar_state_reader
+              @state_writer = state_writer
+              @toc_navigation = toc_navigation
+              @document_reader = document_reader
+              @ui_controller = ui_controller
+              @notification_service = notification_service
+              raise ArgumentError, 'notification_service is required' if @notification_service.nil?
+            end
+
+            def open_toc
+              toggle_sidebar(:toc)
+            rescue Shoko::Error => e
+              set_message("TOC error: #{e.message}", 3)
+            end
+
+            def open_bookmarks
+              toggle_sidebar(:bookmarks)
+            end
+
+            def open_annotations_tab
+              toggle_sidebar(:annotations)
+            end
+
+            def activate_sidebar_tab(tab)
+              if sidebar_visible?
+                switch_sidebar_tab(tab)
+              else
+                open_sidebar_for(tab)
+              end
+            rescue Shoko::Error => e
+              set_message("Sidebar error: #{e.message}", 3)
+            end
+
+            def sidebar_visible?
+              @sidebar_state_reader.sidebar_visible?
+            end
+
+            def close_sidebar_with_restore(tab)
+              prev_mode = @sidebar_state_reader.sidebar_prev_view_mode
+              if prev_mode
+                @state_writer.update_config(view_mode: prev_mode)
+                @state_writer.update_selections(sidebar_prev_view_mode: nil)
+              end
+              @state_writer.update_sidebar(visible: false)
+              @state_writer.update_reader(mode: :read)
+              set_message("#{tab.to_s.capitalize} closed", 1) unless tab == :toc
+            end
+
+            private
+
+            def toggle_sidebar(tab)
+              close_annotations_overlay_via_ui_controller
+              if sidebar_visible?
+                return close_sidebar_with_restore(tab) if sidebar_open_for?(tab)
+
+                switch_sidebar_tab(tab)
+              else
+                open_sidebar_for(tab)
+              end
+            end
+
+            def sidebar_open_for?(tab)
+              @sidebar_state_reader.sidebar_visible? &&
+                @sidebar_state_reader.sidebar_active_tab == tab
+            end
+
+            def open_sidebar_for(tab)
+              @state_writer.update_selections(
+                sidebar_prev_view_mode: @config_reader.view_mode
+              )
+              @state_writer.update_config(view_mode: :single)
+
+              updates = { active_tab: tab, visible: true }
+              case tab
+              when :toc
+                entries = @toc_navigation.entries_for(document)
+                collapsed = @toc_navigation.collapsed_for(entries, @sidebar_state_reader.sidebar_toc_collapsed)
+                current_chapter = (@reader_state_reader.current_chapter || 0).to_i
+                selected = @toc_navigation.index_for_chapter(entries, current_chapter)
+                updates[:toc_collapsed] = collapsed
+                updates[:toc_selected] = @toc_navigation.ensure_visible_selection(entries, collapsed, selected)
+              when :annotations
+                updates[:annotations_selected] = @sidebar_state_reader.sidebar_annotations_selected || 0
+              when :bookmarks
+                updates[:bookmarks_selected] = @sidebar_state_reader.sidebar_bookmarks_selected || 0
+              end
+
+              @state_writer.update_sidebar(**updates)
+              @state_writer.update_reader(mode: :read)
+              set_message("#{tab.to_s.capitalize} opened", 1) unless tab == :toc
+            end
+
+            def switch_sidebar_tab(tab)
+              return unless sidebar_visible?
+
+              current_tab = @sidebar_state_reader.sidebar_active_tab
+              return if current_tab == tab
+
+              updates = { active_tab: tab }
+              case tab
+              when :toc
+                entries = @toc_navigation.entries_for(document)
+                collapsed = @toc_navigation.collapsed_for(entries, @sidebar_state_reader.sidebar_toc_collapsed)
+                selected = @sidebar_state_reader.sidebar_toc_selected
+                if selected.nil?
+                  current_chapter = (@reader_state_reader.current_chapter || 0).to_i
+                  selected = @toc_navigation.index_for_chapter(entries, current_chapter)
+                end
+                updates[:toc_collapsed] = collapsed
+                updates[:toc_selected] = @toc_navigation.ensure_visible_selection(entries, collapsed, selected)
+              when :annotations
+                updates[:annotations_selected] = @sidebar_state_reader.sidebar_annotations_selected || 0
+              when :bookmarks
+                updates[:bookmarks_selected] = @sidebar_state_reader.sidebar_bookmarks_selected || 0
+              end
+
+              @state_writer.update_sidebar(**updates)
+            end
+
+            def close_annotations_overlay_via_ui_controller
+              @ui_controller&.close_annotations_overlay
+            rescue Shoko::Error
+              raise
+            end
+
+            def document
+              @document_reader.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/sidebar/toc_facade.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Sidebar
+          # Shared TOC helper methods mixed into SidebarController.
+          module TocFacade
+            def toc_entries_for(doc)
+              @toc_navigation.entries_for(doc)
+            end
+
+            def toc_collapsed_for(entries, raw = nil)
+              raw = @sidebar_state.sidebar_toc_collapsed if raw.nil?
+              @toc_navigation.collapsed_for(entries, raw)
+            end
+
+            def toc_visible_indices(entries, collapsed)
+              @toc_navigation.visible_indices(
+                entries,
+                collapsed,
+                filter_text: toc_filter_text,
+                filter_active: toc_filter_active?
+              )
+            end
+
+            def toc_entry_has_children?(entries, index)
+              @toc_navigation.entry_has_children?(entries, index)
+            end
+
+            private
+
+            def toggle_toc_collapsed(collapsed, index)
+              @toc_navigation.toggle_collapsed(collapsed, index)
+            end
+
+            def ensure_visible_toc_selection(entries, collapsed, current)
+              @toc_navigation.ensure_visible_selection(
+                entries,
+                collapsed,
+                current,
+                filter_text: toc_filter_text,
+                filter_active: toc_filter_active?
+              )
+            end
+
+            def navigable_toc_entry_indices(entries, collapsed)
+              @toc_navigation.navigable_indices(
+                entries,
+                collapsed,
+                filter_text: toc_filter_text,
+                filter_active: toc_filter_active?
+              )
+            end
+
+            def toc_filter_active?
+              @sidebar_state.sidebar_toc_filter_active?
+            end
+
+            def toc_filter_text
+              return '' unless toc_filter_active?
+
+              @sidebar_state.sidebar_toc_filter.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/sidebar/toc_navigation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/services/toc_tree_service'
+
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Sidebar
+          # TOC tree navigation and collapse-state mechanics.
+          class TocNavigation
+            def initialize(tree_service: Core::Services::TocTreeService.instance)
+              @tree_service = tree_service
+            end
+
+            def entries_for(doc)
+              @tree_service.entries_for(doc)
+            end
+
+            def collapsed_for(entries, raw = nil)
+              entries = Array(entries)
+              return [] if entries.empty?
+              return @tree_service.default_collapsed(entries) if raw.nil?
+
+              @tree_service.normalize_collapsed(entries, raw)
+            end
+
+            def visible_indices(entries, collapsed, filter_text: '', filter_active: false)
+              @tree_service.visible_indices(
+                entries,
+                collapsed: collapsed,
+                filter_text: filter_text,
+                filter_active: filter_active
+              )
+            end
+
+            def entry_has_children?(entries, index)
+              @tree_service.entry_has_children?(entries, index)
+            end
+
+            def toggle_collapsed(collapsed, index)
+              @tree_service.toggle_collapsed(collapsed, index)
+            end
+
+            def ensure_visible_selection(entries, collapsed, current, filter_text: '', filter_active: false)
+              @tree_service.ensure_visible_selection(
+                entries,
+                collapsed,
+                current,
+                filter_text: filter_text,
+                filter_active: filter_active
+              )
+            end
+
+            def navigable_indices(entries, collapsed, filter_text: '', filter_active: false)
+              @tree_service.navigable_indices(
+                entries,
+                collapsed,
+                filter_text: filter_text,
+                filter_active: filter_active
+              )
+            end
+
+            def target_index(indices, current, delta)
+              @tree_service.target_index(indices, current, delta)
+            end
+
+            def index_for_chapter(entries, chapter_index)
+              @tree_service.index_for_chapter(entries, chapter_index)
+            end
+          end
+        end
+      end
+    end
+  end
+end