shoko 0.1.3 → 0.1.5

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

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require_relative 'sidebar/toc_navigation'
+require_relative 'sidebar/anchor_resolver'
+require_relative 'sidebar/tab_state_orchestrator'
+require_relative 'sidebar/toc_facade'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        # Coordinates sidebar interactions while delegating focused logic to collaborators.
+        class SidebarController
+          Dependencies = Data.define(
+            :reader_state,
+            :config_reader,
+            :ui_state,
+            :sidebar_state,
+            :state_writer,
+            :document,
+            :navigation_service,
+            :bookmark_service,
+            :state_controller,
+            :ui_controller,
+            :notification_service,
+            :formatting_service,
+            :layout_service
+          ) do
+            REQUIRED_FIELDS = %i[
+              reader_state
+              config_reader
+              ui_state
+              sidebar_state
+              state_writer
+            ].freeze
+
+            def validate!
+              missing = []
+              missing << :reader_state if reader_state.nil?
+              missing << :config_reader if config_reader.nil?
+              missing << :ui_state if ui_state.nil?
+              missing << :sidebar_state if sidebar_state.nil?
+              missing << :state_writer if state_writer.nil?
+              return self if missing.empty?
+
+              raise ArgumentError, "Missing required sidebar controller dependencies: #{missing.join(', ')}"
+            end
+          end
+
+          include Sidebar::TocFacade
+
+          def initialize(deps:)
+            deps.validate!
+
+            @reader_state = deps.reader_state
+            @config_reader = deps.config_reader
+            @ui_state = deps.ui_state
+            @sidebar_state = deps.sidebar_state
+            @state_writer = deps.state_writer
+            @document = deps.document
+            @navigation_service = deps.navigation_service
+            @bookmark_service = deps.bookmark_service
+            @state_controller = deps.state_controller
+            @ui_controller = deps.ui_controller
+            @notification_service = deps.notification_service
+            @formatting_service = deps.formatting_service
+            @layout_service = deps.layout_service
+
+            @toc_navigation = Sidebar::TocNavigation.new
+            @anchor_resolver = Sidebar::AnchorResolver.new(
+              document_reader: -> { @document },
+              formatting_service: @formatting_service,
+              layout_service: @layout_service,
+              ui_state_reader: @ui_state,
+              config_reader: @config_reader,
+              sidebar_state_reader: @sidebar_state
+            )
+            @tab_state_orchestrator = Sidebar::TabStateOrchestrator.new(
+              config_reader: @config_reader,
+              reader_state_reader: @reader_state,
+              sidebar_state_reader: @sidebar_state,
+              state_writer: @state_writer,
+              toc_navigation: @toc_navigation,
+              document_reader: -> { @document },
+              ui_controller: @ui_controller,
+              notification_service: @notification_service
+            )
+          end
+
+          def open_toc
+            @tab_state_orchestrator.open_toc
+          end
+
+          def open_bookmarks
+            @tab_state_orchestrator.open_bookmarks
+          end
+
+          def open_annotations_tab
+            @tab_state_orchestrator.open_annotations_tab
+          end
+
+          def activate_sidebar_tab(tab)
+            @tab_state_orchestrator.activate_sidebar_tab(tab)
+          end
+
+          def handle_sidebar_toc_click(index)
+            return unless sidebar_visible?
+            return unless index.is_a?(Integer)
+
+            entries = toc_entries_for(@document)
+            return if entries.empty?
+            return unless index.between?(0, entries.length - 1)
+
+            collapsed = toc_collapsed_for(entries)
+            updates = { toc_selected: index }
+
+            if !toc_filter_active? && toc_entry_has_children?(entries, index)
+              collapsed = toggle_toc_collapsed(collapsed, index)
+              updates[:toc_collapsed] = collapsed
+              updates[:toc_selected] = ensure_visible_toc_selection(entries, collapsed, index)
+            end
+
+            @state_writer.update_sidebar(**updates)
+          end
+
+          def set_sidebar_toc_selected(index)
+            return unless sidebar_visible?
+
+            entries = toc_entries_for(@document)
+            return if entries.empty?
+
+            idx = index.to_i.clamp(0, entries.length - 1)
+            collapsed = toc_collapsed_for(entries)
+            idx = ensure_visible_toc_selection(entries, collapsed, idx)
+
+            updates = { toc_selected: idx }
+            updates[:toc_collapsed] = collapsed if collapsed != @sidebar_state.sidebar_toc_collapsed
+            @state_writer.update_sidebar(**updates)
+          end
+
+          # Sidebar navigation helpers
+          def sidebar_down
+            update_sidebar_selection(+1)
+          end
+
+          def sidebar_up
+            update_sidebar_selection(-1)
+          end
+
+          def sidebar_select
+            return unless sidebar_visible?
+
+            case @sidebar_state.sidebar_active_tab
+            when :toc then sidebar_select_toc
+            when :bookmarks then sidebar_select_bookmark
+            when :annotations then sidebar_select_annotation
+            end
+          end
+
+          def sidebar_toggle_toc
+            return unless sidebar_visible?
+            return unless @sidebar_state.sidebar_active_tab == :toc
+            return if toc_filter_active?
+
+            entries = toc_entries_for(@document)
+            return if entries.empty?
+
+            idx = (@sidebar_state.sidebar_toc_selected || 0).to_i
+            return unless idx.between?(0, entries.length - 1)
+            return unless toc_entry_has_children?(entries, idx)
+
+            collapsed = toc_collapsed_for(entries)
+            collapsed = toggle_toc_collapsed(collapsed, idx)
+            selected = ensure_visible_toc_selection(entries, collapsed, idx)
+
+            @state_writer.update_sidebar(
+              toc_collapsed: collapsed,
+              toc_selected: selected
+            )
+          end
+
+          def sidebar_visible?
+            @tab_state_orchestrator.sidebar_visible?
+          end
+
+          def close_sidebar_with_restore(tab)
+            @tab_state_orchestrator.close_sidebar_with_restore(tab)
+          end
+
+          private
+
+          def sidebar_select_toc
+            entries = toc_entries_for(@document)
+            selected_entry_index = (@sidebar_state.sidebar_toc_selected || 0).to_i
+            selected_entry_index = selected_entry_index.clamp(0, [entries.length - 1, 0].max)
+            selected_entry_index = ensure_visible_toc_selection(
+              entries,
+              toc_collapsed_for(entries),
+              selected_entry_index
+            )
+            entry = entries[selected_entry_index]
+            return unless entry
+
+            chapter_index = entry.chapter_index
+            return unless chapter_index
+
+            line_offset = line_offset_for_toc_entry(entry, chapter_index)
+            if line_offset
+              @state_controller.jump_to_chapter_offset(chapter_index, line_offset)
+            else
+              @navigation_service&.jump_to_chapter(chapter_index)
+            end
+            close_sidebar_with_restore(:toc)
+          end
+
+          def sidebar_select_bookmark
+            bookmarks = @reader_state.bookmarks || []
+            selected = (@sidebar_state.sidebar_bookmarks_selected || 0).to_i
+            selected = selected.clamp(0, [bookmarks.length - 1, 0].max)
+            bookmark = bookmarks[selected]
+            return unless bookmark
+
+            if @bookmark_service
+              @bookmark_service.jump_to_bookmark(bookmark)
+              @state_controller&.save_progress
+            end
+            close_sidebar_with_restore(:bookmarks)
+          end
+
+          def sidebar_select_annotation
+            annotations = @reader_state.annotations || []
+            selected = (@sidebar_state.sidebar_annotations_selected || 0).to_i
+            selected = selected.clamp(0, [annotations.length - 1, 0].max)
+            annotation = annotations[selected]
+            return unless annotation
+
+            @state_controller&.jump_to_annotation(annotation)
+            close_sidebar_with_restore(:annotations)
+          end
+
+          def update_sidebar_selection(delta)
+            return unless sidebar_visible?
+
+            case @sidebar_state.sidebar_active_tab
+            when :toc then update_toc_selection(delta)
+            when :annotations then update_list_selection(delta, :annotations, :sidebar_annotations_selected)
+            when :bookmarks then update_list_selection(delta, :bookmarks, :sidebar_bookmarks_selected)
+            end
+          end
+
+          def update_toc_selection(delta)
+            entries = toc_entries_for(@document)
+            raw_collapsed = @sidebar_state.sidebar_toc_collapsed
+            collapsed = toc_collapsed_for(entries, raw_collapsed)
+            indices = navigable_toc_entry_indices(entries, collapsed)
+
+            cur = (@sidebar_state.sidebar_toc_selected || indices.first || 0).to_i
+            cur = ensure_visible_toc_selection(entries, collapsed, cur)
+            target = find_toc_target(indices, cur, delta)
+
+            updates = { toc_selected: target }
+            updates[:toc_collapsed] = collapsed if raw_collapsed != collapsed
+            @state_writer.update_sidebar(**updates)
+          end
+
+          def find_toc_target(indices, current, delta)
+            @toc_navigation.target_index(indices, current, delta)
+          end
+
+          def update_list_selection(delta, list_key, state_key)
+            items = sidebar_list_items(list_key)
+            current = sidebar_list_selection(state_key)
+            max = [items.length - 1, 0].max
+            new_val = (current + delta).clamp(0, max)
+
+            action_key = state_key.to_s.sub('sidebar_', '').to_sym
+            @state_writer.update_sidebar(action_key => new_val)
+          end
+
+          def sidebar_list_items(list_key)
+            case list_key
+            when :annotations
+              @reader_state.annotations || []
+            when :bookmarks
+              @reader_state.bookmarks || []
+            else
+              []
+            end
+          end
+
+          def sidebar_list_selection(state_key)
+            case state_key
+            when :sidebar_annotations_selected
+              @sidebar_state.sidebar_annotations_selected || 0
+            when :sidebar_bookmarks_selected
+              @sidebar_state.sidebar_bookmarks_selected || 0
+            else
+              0
+            end
+          end
+
+          def line_offset_for_toc_entry(entry, chapter_index)
+            @anchor_resolver.line_offset_for_toc_entry(entry, chapter_index)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        # Handles all sidebar-related mouse interactions.
+        # Extracted from MouseableReader to reduce class size.
+        module SidebarMouseHandler
+          SCROLL_WHEEL_STEP = 1
+          SCROLL_WHEEL_COOLDOWN_SECONDS = 0.05
+
+          private
+
+          def handle_sidebar_mouse(event)
+            return false if @mouse_handler.selecting
+
+            ctx = sidebar_mouse_context(event)
+            return false unless ctx
+
+            return handle_sidebar_scroll_drag(event, ctx) if @sidebar_scroll_drag_active
+            return false unless within_sidebar_bounds?(ctx)
+
+            handle_sidebar_interaction(event, ctx)
+          end
+
+          def sidebar_mouse_context(event)
+            coords = @coordinate_service.mouse_to_terminal(event[:x], event[:y])
+            height, width = terminal_service.size
+            bounds = render_coordinator.sidebar_bounds(width, height)
+            component = render_coordinator.sidebar_component
+            return nil unless bounds && component
+
+            { coords: coords, bounds: bounds, component: component }
+          end
+
+          def within_sidebar_bounds?(ctx)
+            in_bounds = @coordinate_service.within_bounds?(
+              ctx[:coords][:x], ctx[:coords][:y], ctx[:bounds]
+            )
+            @mouse_handler.reset unless in_bounds
+            in_bounds
+          end
+
+          def handle_sidebar_interaction(event, ctx)
+            coords, bounds, component = ctx.values_at(:coords, :bounds, :component)
+
+            return true if handle_sidebar_wheel_if_applicable(event, coords, bounds, component)
+            return true if handle_sidebar_drag_start(event, coords, bounds, component)
+            return true if handle_sidebar_click(event, coords, bounds, component)
+
+            @mouse_handler.reset
+            true
+          end
+
+          def handle_sidebar_wheel_if_applicable(event, coords, bounds, component)
+            delta = mouse_wheel_delta(event[:button])
+            return false unless delta
+            return true unless sidebar_wheel_event_allowed?(delta)
+
+            handle_sidebar_wheel(delta, coords, bounds, component)
+          end
+
+          def handle_sidebar_drag_start(event, coords, bounds, component)
+            event[:button].zero? && !event[:released] &&
+              start_sidebar_scroll_drag(coords, bounds, component)
+          end
+
+          def handle_sidebar_click(event, coords, bounds, component)
+            return false unless event[:released] && event[:button].zero?
+
+            handle_sidebar_tab_click(coords, bounds, component) ||
+              handle_sidebar_toc_click(coords, bounds, component)
+          end
+
+          def handle_sidebar_tab_click(coords, bounds, component)
+            tab = component.tab_for_point(coords[:x], coords[:y], bounds)
+            return false unless tab
+
+            ui_controller.activate_sidebar_tab(tab)
+            draw_screen
+            @mouse_handler.reset
+            true
+          end
+
+          def handle_sidebar_toc_click(coords, bounds, component)
+            toc_item = component.toc_entry_at(coords[:x], coords[:y], bounds)
+            return false unless toc_item
+
+            ui_controller.handle_sidebar_toc_click(toc_item.full_index)
+            draw_screen
+            true
+          end
+
+          def mouse_wheel_delta(button)
+            case button
+            when 64 then -1
+            when 65 then 1
+            end
+          end
+
+          def handle_sidebar_wheel(delta, terminal_coords, sidebar_bounds, sidebar_component)
+            metrics = sidebar_component.toc_scroll_metrics(sidebar_bounds)
+            return false unless metrics&.row_in_track?(terminal_coords[:y])
+
+            indices = metrics.navigable_indices
+            return false if indices.empty?
+
+            target = wheel_scroll_target(metrics, indices, delta)
+            update_toc_selection(target)
+            true
+          end
+
+          def sidebar_wheel_event_allowed?(delta)
+            now = monotonic_time
+            last_time = @sidebar_wheel_last_applied_at
+            last_delta = @sidebar_wheel_last_applied_delta
+
+            if last_time && last_delta == delta &&
+               (now - last_time) < SCROLL_WHEEL_COOLDOWN_SECONDS
+              return false
+            end
+
+            @sidebar_wheel_last_applied_at = now
+            @sidebar_wheel_last_applied_delta = delta
+            true
+          end
+
+          def wheel_scroll_target(metrics, indices, delta)
+            current_pos = current_nav_position(metrics, indices)
+            step = SCROLL_WHEEL_STEP * delta
+            target_pos = (current_pos + step).clamp(0, indices.length - 1)
+            indices[target_pos]
+          end
+
+          def current_nav_position(metrics, indices)
+            current_full = metrics.selected_full_index || indices.first
+            pos = metrics.nav_position_for(current_full)
+
+            if pos.nil? && metrics.selected_visible_index
+              fallback = metrics.visible_indices[metrics.selected_visible_index]
+              pos = metrics.nav_position_for(fallback)
+            end
+
+            pos || 0
+          end
+
+          def update_toc_selection(index)
+            ui_controller.set_sidebar_toc_selected(index)
+            draw_screen
+            @mouse_handler.reset
+          end
+
+          def start_sidebar_scroll_drag(terminal_coords, sidebar_bounds, sidebar_component)
+            metrics = sidebar_component.toc_scroll_metrics(sidebar_bounds)
+            return false unless metrics
+            return false unless metrics.hit_scrollbar?(terminal_coords[:x], terminal_coords[:y])
+
+            @sidebar_scroll_drag_active = true
+            apply_sidebar_scroll_drag(metrics, terminal_coords[:y])
+            draw_screen
+            @mouse_handler.reset
+            true
+          end
+
+          def handle_sidebar_scroll_drag(event, ctx)
+            if event[:released]
+              @sidebar_scroll_drag_active = false
+              @mouse_handler.reset
+              return true
+            end
+
+            return true unless drag_motion?(event) || event[:button].zero?
+
+            metrics = ctx[:component].toc_scroll_metrics(ctx[:bounds])
+            return true unless metrics
+
+            apply_sidebar_scroll_drag(metrics, ctx[:coords][:y])
+            draw_screen
+            true
+          end
+
+          def drag_motion?(event)
+            event[:button].anybits?(32)
+          end
+
+          def apply_sidebar_scroll_drag(metrics, abs_row)
+            full_index = metrics.full_index_for_abs_row(abs_row)
+            return unless full_index
+
+            ui_controller.set_sidebar_toc_selected(full_index)
+          end
+
+          def monotonic_time
+            @clock_ref.monotonic_now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/state_controller/annotation_actions.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module StateControllerAnnotationActions
+          def refresh_annotations
+            annotations = []
+            begin
+              annotations = @annotation_service ? @annotation_service.list_for_book(@path) : []
+            rescue Shoko::Error => e
+              @logger&.error('Failed to refresh annotations', error: e.message, path: @path)
+            ensure
+              @state_writer.update_reader(annotations: annotations)
+            end
+          end
+
+          def jump_to_annotation(annotation)
+            normalized = normalize_annotation(annotation)
+            return unless normalized
+
+            chapter_index = normalized[:chapter_index]
+            range = normalized[:range]
+            @navigation_service&.jump_to_chapter(chapter_index) if chapter_index
+
+            if range
+              selection = normalize_selection_for_state(range)
+              @state_writer.update_reader(selection: selection) if selection
+            end
+
+            @state_writer.update_reader(mode: :read)
+          end
+
+          def jump_to_chapter_offset(chapter_index, line_offset)
+            return unless chapter_index
+
+            if @navigation_service
+              @navigation_service.jump_to_chapter(chapter_index)
+            else
+              @state_writer.update_reader(current_chapter: chapter_index)
+            end
+
+            offset = line_offset.to_i
+            stride = split_stride_for_state
+            payload = {
+              single_page: offset,
+              left_page: offset,
+              right_page: offset + stride,
+              current_page: offset,
+            }
+
+            if dynamic_page_numbering? && @page_calculator
+              page_index = @page_calculator.find_page_index(chapter_index, offset)
+              payload[:current_page_index] = page_index if page_index
+            end
+
+            @state_writer.update_page(**payload)
+            save_progress
+          end
+
+          def delete_annotation_by_id(annotation)
+            current_index = @sidebar_state.sidebar_annotations_selected || 0
+            normalized = normalize_annotation(annotation)
+            annotation_id = normalized[:id]
+
+            svc = @annotation_service
+            return current_index unless svc && annotation_id
+
+            svc.delete(@path, annotation_id)
+            annotations = svc.list_for_book(@path)
+            @state_writer.update_reader(annotations: annotations)
+
+            new_index = [current_index, annotations.length - 1].min
+            new_index = 0 if new_index.negative?
+            @state_writer.update_sidebar(
+              annotations_selected: new_index,
+              sidebar_annotations_selected: new_index
+            )
+            new_index
+          end
+
+          private
+
+          def normalize_selection_for_state(range)
+            return nil unless range
+
+            return range if anchor_range?(range)
+
+            coord = resolve_coordinate_service
+            return nil unless coord
+
+            rendered = @rendered_content_reader.rendered_lines
+            coord.normalize_selection_range(range, rendered)
+          end
+
+          def anchor_range?(range)
+            return false unless range.is_a?(Hash)
+
+            start_anchor = range[:start] || range['start']
+            start_anchor.is_a?(Hash) && (start_anchor.key?(:geometry_key) || start_anchor.key?('geometry_key'))
+          end
+
+          def resolve_coordinate_service
+            @coordinate_service
+          end
+
+          def normalize_annotation(annotation)
+            return {} 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