shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/ui/sessions/in_book_search_ui_session_adapter.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative '../../../shared/contracts/session_outcome'
+
+module Shoko
+  module Adapters
+    module Ui
+      module Sessions
+        # Adapter-owned lifecycle for in-book search popup component.
+        class InBookSearchUiSessionAdapter
+          RESCUABLE_ERRORS = [ArgumentError, TypeError, RuntimeError].freeze
+
+          def initialize(reader_state_reader:, state_writer:, ui_component_factory:, logger: nil)
+            @reader_state_reader = reader_state_reader
+            @state_writer = state_writer
+            @ui_component_factory = ui_component_factory
+            @logger = logger
+          end
+
+          def open(query: '', results: [], total_matches: 0)
+            popup = ensure_popup
+            return failure_outcome(:error, :in_book_search_popup_unavailable, 'In-book search popup unavailable') unless popup
+
+            popup.show(query: query, results: results, total_matches: total_matches)
+            @state_writer.update_reader(
+              in_book_search_popup: popup,
+              mode: :in_book_search,
+              popup_menu: nil
+            )
+            success_outcome(:opened, :in_book_search_opened)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.open', e)
+            failure_outcome(:error, :in_book_search_open_failed, e.message)
+          end
+
+          def close
+            popup = current_popup
+            popup.hide if popup
+            @state_writer.update_reader(
+              in_book_search_popup: nil,
+              mode: :read
+            )
+            success_outcome(:closed, :in_book_search_closed)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.close', e)
+            failure_outcome(:error, :in_book_search_close_failed, e.message)
+          end
+
+          def visible?
+            popup = current_popup
+            popup && popup.visible?
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.visible?', e)
+            false
+          end
+
+          def insert_char(char)
+            invoke_popup_action(
+              command: :insert_char,
+              method_name: :insert_char,
+              args: [char.to_s],
+              unavailable_code: :in_book_search_insert_char_unavailable
+            )
+          end
+
+          def backspace
+            invoke_popup_action(
+              command: :backspace,
+              method_name: :backspace,
+              unavailable_code: :in_book_search_backspace_unavailable
+            )
+          end
+
+          def confirm
+            invoke_popup_action(
+              command: :confirm,
+              method_name: :confirm,
+              unavailable_code: :in_book_search_confirm_unavailable
+            )
+          end
+
+          def cancel
+            invoke_popup_action(
+              command: :cancel,
+              method_name: :cancel,
+              unavailable_code: :in_book_search_cancel_unavailable
+            )
+          end
+
+          def scroll_up
+            invoke_scroll_action(:scroll_up, :scroll_up_action)
+          end
+
+          def scroll_down
+            invoke_scroll_action(:scroll_down, :scroll_down_action)
+          end
+
+          def update(query:, results:, total_matches:, results_query:)
+            popup = current_popup
+            return failure_outcome(:ignored, :in_book_search_update_unavailable, 'In-book search popup unavailable') unless popup
+
+            popup.update(
+              query: query,
+              results: results,
+              total_matches: total_matches,
+              results_query: results_query
+            )
+            success_outcome(:handled, :in_book_search_update_handled, payload: true)
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.update', e)
+            failure_outcome(:error, :in_book_search_update_failed, e.message)
+          end
+
+          private
+
+          def invoke_popup_action(command:, method_name:, args: [], unavailable_code:)
+            popup = current_popup
+            return failure_outcome(:ignored, unavailable_code, "#{method_name} unavailable for in-book search popup") unless popup
+
+            payload = invoke_popup_method(popup, method_name, *args)
+            success_outcome(:handled, "in_book_search_#{command}_handled".to_sym, payload: payload)
+          rescue *RESCUABLE_ERRORS => e
+            log_error("in_book_search.session.#{command}", e)
+            failure_outcome(:error, "in_book_search_#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_scroll_action(command, method_name)
+            popup = current_popup
+            return failure_outcome(:ignored, "in_book_search_#{command}_unavailable".to_sym, 'In-book search popup unavailable', payload: false) unless popup
+
+            payload = invoke_popup_method(popup, method_name)
+            if payload
+              success_outcome(:handled, "in_book_search_#{command}_handled".to_sym, payload: payload)
+            else
+              failure_outcome(:ignored, "in_book_search_#{command}_ignored".to_sym, 'In-book search scroll event was not handled', payload: false)
+            end
+          rescue *RESCUABLE_ERRORS => e
+            log_error("in_book_search.session.#{command}", e)
+            failure_outcome(:error, "in_book_search_#{command}_failed".to_sym, e.message)
+          end
+
+          def invoke_popup_method(popup, method_name, *args)
+            case method_name
+            when :insert_char then popup.insert_char(*args)
+            when :backspace then popup.backspace
+            when :confirm then popup.confirm
+            when :cancel then popup.cancel
+            when :scroll_up_action then popup.scroll_up_action
+            when :scroll_down_action then popup.scroll_down_action
+            else
+              raise ArgumentError, "Unsupported in-book-search popup method: #{method_name}"
+            end
+          end
+
+          def ensure_popup
+            current_popup || @ui_component_factory.in_book_search_popup
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.ensure_popup', e)
+            nil
+          end
+
+          def current_popup
+            @reader_state_reader.in_book_search_popup
+          rescue *RESCUABLE_ERRORS => e
+            log_error('in_book_search.session.current_popup', e)
+            nil
+          end
+
+          def success_outcome(status, code, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.success(status: status, code: code, payload: payload)
+          end
+
+          def failure_outcome(status, code, message, payload: nil)
+            Shoko::Shared::Contracts::SessionOutcome.failure(
+              status: status,
+              code: code,
+              message: message,
+              payload: payload
+            )
+          end
+
+          def log_error(event, error)
+            @logger&.error(event, error: error.class.name, message: error.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/view_models/reader_view_model.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Ui
+      module ViewModels
+        # Pure data structure for reader view rendering.
+        # Eliminates component coupling to controllers and services.
+        class ReaderViewModel
+          attr_reader :current_chapter, :total_chapters, :current_page, :total_pages,
+                      :chapter_title, :document_title, :view_mode, :sidebar_visible, :mode, :message,
+                      :bookmarks, :toc_entries, :content_lines, :page_info, :show_page_numbers,
+                      :page_numbering_mode, :line_spacing, :language
+
+          def initialize(
+            current_chapter: 0,
+            total_chapters: 0,
+            current_page: 0,
+            total_pages: 0,
+            chapter_title: '',
+            document_title: '',
+            view_mode: :single,
+            sidebar_visible: false,
+            mode: :read,
+            message: nil,
+            bookmarks: [],
+            toc_entries: [],
+            content_lines: [],
+            page_info: {},
+            show_page_numbers: true,
+            page_numbering_mode: :dynamic,
+            line_spacing: :normal,
+            language: 'en'
+          )
+            @current_chapter = current_chapter
+            @total_chapters = total_chapters
+            @current_page = current_page
+            @total_pages = total_pages
+            @chapter_title = chapter_title
+            @document_title = document_title
+            @view_mode = view_mode
+            @sidebar_visible = sidebar_visible
+            @mode = mode
+            @message = message
+            @bookmarks = bookmarks
+            @toc_entries = toc_entries
+            @content_lines = content_lines
+            @page_info = page_info
+            @show_page_numbers = show_page_numbers
+            @page_numbering_mode = page_numbering_mode
+            @line_spacing = line_spacing
+            @language = language
+            freeze
+          end
+
+          # Derived properties
+          def progress_percentage
+            return 0 if total_pages.zero?
+
+            ((current_page.to_f / total_pages) * 100).round(1)
+          end
+
+          def chapter_progress
+            return '0/0' if total_chapters.zero?
+
+            "#{current_chapter + 1}/#{total_chapters}"
+          end
+
+          def page_progress
+            return '0/0' if total_pages.zero?
+
+            "#{current_page + 1}/#{total_pages}"
+          end
+
+          def split_mode?
+            view_mode == :split
+          end
+
+          def single_mode?
+            view_mode == :single
+          end
+
+          def message?
+            !message.nil? && !message.empty?
+          end
+
+          def bookmarks?
+            !bookmarks.empty?
+          end
+
+          def toc?
+            !toc_entries.empty?
+          end
+
+          # Create new instance with updates
+          def with(**changes)
+            current_attributes = {
+              current_chapter: current_chapter,
+              total_chapters: total_chapters,
+              current_page: current_page,
+              total_pages: total_pages,
+              chapter_title: chapter_title,
+              document_title: document_title,
+              view_mode: view_mode,
+              sidebar_visible: sidebar_visible,
+              mode: mode,
+              message: message,
+              bookmarks: bookmarks,
+              toc_entries: toc_entries,
+              content_lines: content_lines,
+              page_info: page_info,
+              show_page_numbers: show_page_numbers,
+              page_numbering_mode: page_numbering_mode,
+              line_spacing: line_spacing,
+              language: language,
+            }
+
+            self.class.new(**current_attributes, **changes)
+          end
+        end
+
+        # View model for menu screens (main/browse/settings/annotations).
+        class MenuViewModel
+          attr_reader :mode, :selected_index, :items, :search_query, :search_active,
+                      :message, :title
+
+          def initialize(
+            mode: :main,
+            selected_index: 0,
+            items: [],
+            search_query: '',
+            search_active: false,
+            message: nil,
+            title: 'Shoko'
+          )
+            @mode = mode
+            @selected_index = selected_index
+            @items = items
+            @search_query = search_query
+            @search_active = search_active
+            @message = message
+            @title = title
+            freeze
+          end
+
+          def selected_item
+            items[selected_index]
+          end
+
+          def items?
+            !items.empty?
+          end
+
+          def message?
+            !message.nil? && !message.empty?
+          end
+
+          def searching?
+            search_active
+          end
+
+          def with(**changes)
+            current_attributes = {
+              mode: mode,
+              selected_index: selected_index,
+              items: items,
+              search_query: search_query,
+              search_active: search_active,
+              message: message,
+              title: title,
+            }
+
+            self.class.new(**current_attributes, **changes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/ui/view_models/reader_view_model_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'reader_view_model'
+
+module Shoko
+  module Adapters
+    module Ui
+      module ViewModels
+        # Builds ReaderViewModel from state reader ports and document, keeping controller lean.
+        class ReaderViewModelBuilder
+          def initialize(reader_state_reader:, config_reader:, doc:)
+            @reader_state_reader = reader_state_reader
+            @config_reader = config_reader
+            @doc = doc
+          end
+
+          def build(page_info)
+            ReaderViewModel.new(**attributes(page_info))
+          end
+
+          private
+
+          def attributes(page_info)
+            base_attributes.merge(page_info: page_info)
+          end
+
+          def base_attributes
+            {
+              current_chapter: @reader_state_reader.current_chapter,
+              total_chapters: total_chapter_count,
+              current_page: @reader_state_reader.current_page,
+              total_pages: @reader_state_reader.total_pages,
+              chapter_title: chapter_title(@reader_state_reader.current_chapter),
+              document_title: @doc&.title || '',
+              view_mode: @config_reader.view_mode || :single,
+              sidebar_visible: @reader_state_reader.sidebar_visible?,
+              mode: @reader_state_reader.mode,
+              message: @reader_state_reader.message,
+              bookmarks: @reader_state_reader.bookmarks || [],
+              toc_entries: doc_toc_entries,
+              show_page_numbers: @config_reader.show_page_numbers.nil? ? true : @config_reader.show_page_numbers,
+              page_numbering_mode: @config_reader.page_numbering_mode || :dynamic,
+              line_spacing: @config_reader.line_spacing || Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING,
+              language: @doc&.language || 'en',
+            }
+          end
+
+          def total_chapter_count
+            Array(@doc&.chapters).length
+          end
+
+          def chapter_title(index)
+            chapter = @doc&.get_chapter(index)
+            chapter&.title || ''
+          end
+
+          def doc_toc_entries
+            Array(@doc&.toc_entries)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/cli_progress_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    # Presents progress updates for CLI-only (pre-TUI) book loading.
+    class CLIProgressPresenter
+      MIN_PROGRESS_DELTA = 0.01
+
+      def initialize(renderer:)
+        @renderer = renderer
+        @last_message = nil
+        @last_progress = nil
+      end
+
+      def start(message: 'Preparing book...')
+        @last_message = message
+        @last_progress = 0.0
+        @renderer.render(message: @last_message, progress: @last_progress)
+      end
+
+      def update_status(message: nil, progress: nil)
+        updates = false
+
+        if message && message != @last_message
+          @last_message = message
+          updates = true
+        end
+
+        unless progress.nil?
+          normalized = progress.to_f.clamp(0.0, 1.0)
+          if @last_progress.nil? || (normalized - @last_progress).abs >= MIN_PROGRESS_DELTA
+            @last_progress = normalized
+            updates = true
+          end
+        end
+
+        return false unless updates
+
+        @renderer.render(message: @last_message, progress: @last_progress)
+        true
+      end
+
+      def finish
+        @renderer.clear
+      end
+    end
+  end
+end

data/lib/shoko/application/pending_jump_handler.rb

@@ -1,23 +1,42 @@
 # frozen_string_literal: true
 
-require_relative '../application/selectors/reader_selectors'
+require_relative '../core/ports/outbound/annotation_editor_launcher'
+require_relative '../core/ports/outbound/rendered_content_reader'
+require_relative '../core/models/pending_jump_payload'
+require_relative '../core/models/annotation_selection'
 
 module Shoko
   module Application
     # Applies a pending jump payload captured in state before reader starts.
     class PendingJumpHandler
-      def initialize(state, dependencies, ui_controller)
-        @state = state
-        @dependencies = dependencies
-        @ui_controller = ui_controller
+      def initialize(reader_state:, state_writer:, annotation_editor_launcher: nil, rendered_content_reader: nil,
+                     navigation_service: nil, selection_service: nil,
+                     coordinate_service: nil)
+        if annotation_editor_launcher &&
+           !annotation_editor_launcher.is_a?(Shoko::Core::Ports::Outbound::AnnotationEditorLauncher)
+          raise ArgumentError, 'annotation_editor_launcher must implement Core::Ports::Outbound::AnnotationEditorLauncher'
+        end
+        if rendered_content_reader &&
+           !rendered_content_reader.is_a?(Shoko::Core::Ports::Outbound::RenderedContentReader)
+          raise ArgumentError, 'rendered_content_reader must implement Core::Ports::Outbound::RenderedContentReader'
+        end
+
+        @reader_state = reader_state
+        @state_writer = state_writer
+        @annotation_editor_launcher = annotation_editor_launcher
+        @rendered_content_reader = rendered_content_reader
+        @navigation_service = navigation_service
+        @selection_service = selection_service
+        @coordinate_service = coordinate_service
       end
 
       def apply
-        payload = state.get(%i[reader pending_jump])
-        return unless payload
+        pending_jump = @reader_state.pending_jump
+        return unless pending_jump
 
-        apply_chapter_jump(payload)
-        apply_selection(payload)
+        payload = normalize_payload(pending_jump)
+        apply_chapter_jump(payload.chapter_index)
+        apply_selection(payload.selection_range)
         open_annotation_editor(payload)
       ensure
         clear_pending_jump
@@ -25,97 +44,62 @@ module Shoko
 
       private
 
-      attr_reader :state, :dependencies, :ui_controller
-
-      def apply_chapter_jump(payload)
-        chapter_index = payload[:chapter_index] || payload['chapter_index']
+      def apply_chapter_jump(chapter_index)
         return unless chapter_index
 
-        navigation = resolve_optional(:navigation_service)
-        navigation&.jump_to_chapter(chapter_index)
-      rescue StandardError
-        nil
+        @navigation_service&.jump_to_chapter(chapter_index)
       end
 
-      def apply_selection(payload)
-        range = payload[:selection_range] || payload['selection_range']
+      def apply_selection(range)
         return unless range
 
         normalized = normalize_selection(range)
         return unless normalized
 
-        state.dispatch(Shoko::Application::Actions::UpdateSelectionAction.new(normalized))
+        @state_writer.update_reader(selection: normalized)
       end
 
       def open_annotation_editor(payload)
-        return unless edit_requested?(payload)
+        return unless payload.edit == true
 
-        annotation = normalized_annotation(payload)
+        annotation = payload.annotation
         return unless annotation
 
-        ui_controller.open_annotation_editor_overlay(
-          text: annotation[:text],
-          range: annotation[:range],
-          chapter_index: annotation[:chapter_index],
-          annotation: annotation
+        return unless @annotation_editor_launcher
+        unless annotation.is_a?(Shoko::Core::Models::AnnotationSelection)
+          raise ArgumentError, 'pending_jump.annotation must be Core::Models::AnnotationSelection'
+        end
+
+        @annotation_editor_launcher.open_editor(
+          text: annotation.text,
+          range: annotation.range,
+          chapter_index: annotation.chapter_index,
+          annotation: annotation.to_annotation_h
         )
-      rescue StandardError
-        nil
       end
 
       def normalize_selection(range)
-        service = resolve_optional(:selection_service)
-        if service.respond_to?(:normalize_range)
-          normalized = service.normalize_range(state, range)
+        if @selection_service && @rendered_content_reader
+          normalized = @selection_service.normalize_range(
+            rendered_content_reader: @rendered_content_reader, selection_range: range
+          )
           return normalized if normalized
         end
 
-        coord = resolve_optional(:coordinate_service)
-        return range unless coord
+        return range unless @coordinate_service
 
-        rendered = Shoko::Application::Selectors::ReaderSelectors.rendered_lines(state)
-        coord.normalize_selection_range(range, rendered)
-      rescue StandardError
-        nil
+        rendered = @rendered_content_reader&.rendered_lines
+        @coordinate_service.normalize_selection_range(range, rendered)
       end
 
       def clear_pending_jump
-        state.dispatch(Shoko::Application::Actions::UpdateSelectionsAction.new(pending_jump: nil))
+        @state_writer.update_selections(pending_jump: nil)
       end
 
-      def resolve_optional(key)
-        return nil unless dependencies.respond_to?(:resolve)
-
-        dependencies.resolve(key)
-      rescue StandardError
-        nil
-      end
-
-      def truthy?(value)
-        return value unless value.is_a?(String)
-
-        !%w[false 0 no].include?(value.downcase)
-      end
-
-      def edit_requested?(payload)
-        truthy?(payload[:edit] || payload['edit'])
-      end
-
-      def normalized_annotation(payload)
-        raw = payload[:annotation] || payload['annotation']
-        return unless raw
-
-        {
-          id: value_from(raw, :id),
-          text: value_from(raw, :text),
-          note: value_from(raw, :note),
-          chapter_index: value_from(raw, :chapter_index),
-          range: value_from(raw, :range),
-        }
-      end
+      def normalize_payload(payload)
+        return payload if payload.is_a?(Shoko::Core::Models::PendingJumpPayload)
 
-      def value_from(hash, key)
-        hash[key] || hash[key.to_s]
+        Shoko::Core::Models::PendingJumpPayload.from_h(payload)
       end
     end
   end