shoko 0.1.3 → 0.1.5

data/lib/shoko/application/workflows/menu/reader_launch/document_preparation.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative 'contracts'
+require_relative '../../../../core/ports/outbound/document_loader'
+require_relative '../../../../core/ports/outbound/background_worker_builder'
+require_relative '../../../../core/ports/outbound/reader_launch_state'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        module ReaderLaunch
+          # Handles document loading, worker warmup, and session document state.
+          class DocumentPreparation
+            include Contracts::DocumentPreparation
+
+            Dependencies = Data.define(
+              :document_loader,
+              :reader_launch_state,
+              :state_writer,
+              :background_worker_builder,
+              :logger
+            ) do
+              def validate!
+                missing = []
+                missing << :document_loader if document_loader.nil?
+                missing << :reader_launch_state if reader_launch_state.nil?
+                missing << :state_writer if state_writer.nil?
+                missing << :background_worker_builder if background_worker_builder.nil?
+                unless missing.empty?
+                  raise ArgumentError, "Missing document preparation dependencies: #{missing.join(', ')}"
+                end
+
+                unless document_loader.is_a?(Shoko::Core::Ports::Outbound::DocumentLoader)
+                  raise ArgumentError, 'document_loader must implement Core::Ports::Outbound::DocumentLoader'
+                end
+                unless background_worker_builder.is_a?(Shoko::Core::Ports::Outbound::BackgroundWorkerBuilder)
+                  raise ArgumentError, 'background_worker_builder must implement Core::Ports::Outbound::BackgroundWorkerBuilder'
+                end
+                unless reader_launch_state.is_a?(Shoko::Core::Ports::Outbound::ReaderLaunchState)
+                  raise ArgumentError, 'reader_launch_state must implement Core::Ports::Outbound::ReaderLaunchState'
+                end
+
+                self
+              end
+            end
+
+            def initialize(deps:)
+              dependencies = deps.validate!
+              @document_loader = dependencies.document_loader
+              @reader_launch_state = dependencies.reader_launch_state
+              @state_writer = dependencies.state_writer
+              @background_worker_builder = dependencies.background_worker_builder
+              @logger = dependencies.logger
+            end
+
+            def document
+              @reader_launch_state.preloaded_document
+            end
+
+            def current_background_worker
+              @reader_launch_state.background_worker
+            end
+
+            def ensure_background_worker(name:)
+              return if current_background_worker
+
+              worker = build_background_worker(name: name)
+              @reader_launch_state.set_background_worker(worker)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @logger&.debug('menu.document_preparation.ensure_background_worker_failed',
+                             error: e.class.name, message: e.message)
+              raise Shoko::StateUpdateError, "Failed to initialize reader background worker: #{e.message}"
+            end
+
+            def register_document(document)
+              @reader_launch_state.set_preloaded_document(document)
+            end
+
+            def clear_document!
+              @reader_launch_state.clear_preloaded_document
+            end
+
+            def update_total_chapters(document)
+              total = document&.chapter_count || 0
+              @state_writer.update_pagination_state(total_chapters: total)
+            end
+
+            def load_document_for(path, progress_reporter:, path_resolution:)
+              resolved_path = resolve_source_path(path, path_resolution)
+              @document_loader.load(
+                path: resolved_path,
+                progress_reporter: progress_reporter,
+                background_worker: current_background_worker
+              )
+            end
+
+            def ensure_reader_document_for(path:, path_resolution:, on_error:)
+              target_path = path_resolution.canonical_path(path)
+              existing = document
+              return true if path_resolution.document_matches?(existing, target_path)
+
+              loaded = load_document_for(target_path, progress_reporter: nil, path_resolution: path_resolution)
+              register_document(loaded)
+              update_total_chapters(loaded)
+              true
+            # resilient-boundary
+            rescue Shoko::Error => e
+              on_error&.call(path, e)
+              false
+            end
+
+            private
+
+            def resolve_source_path(path, path_resolution)
+              return path unless path_resolution.cache_pointer?(path)
+
+              payload = path_resolution.cache_payload(path, strict: false)
+              resolved = payload&.source_path
+              resolved && !resolved.to_s.empty? ? resolved : path
+            end
+
+            def build_background_worker(name:)
+              @background_worker_builder.build(logger: @logger, name: name)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @logger&.debug('menu.document_preparation.build_background_worker_failed',
+                             error: e.class.name, message: e.message)
+              raise Shoko::StateUpdateError, "Unable to build reader background worker: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/workflows/menu/reader_launch/path_resolution.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'contracts'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        module ReaderLaunch
+          # Resolves and validates reader/menu file paths.
+          class PathResolution
+            include Contracts::PathResolution
+
+            Dependencies = Data.define(:cache_pointer_resolver, :document_path_resolver, :file_probe, :logger) do
+              def validate!
+                raise ArgumentError, 'cache_pointer_resolver is required' if cache_pointer_resolver.nil?
+                raise ArgumentError, 'document_path_resolver is required' if document_path_resolver.nil?
+                raise ArgumentError, 'file_probe is required' if file_probe.nil?
+
+                self
+              end
+            end
+
+            def initialize(deps:)
+              dependencies = deps.validate!
+              @cache_pointer_resolver = dependencies.cache_pointer_resolver
+              @document_path_resolver = dependencies.document_path_resolver
+              @file_probe = dependencies.file_probe
+              @logger = dependencies.logger
+            end
+
+            def canonical_path(path)
+              @document_path_resolver.canonical_reader_path(path) || path
+            end
+
+            def canonical_recent_path(path)
+              @document_path_resolver.resolve_source_path(path)
+            end
+
+            def document_matches?(document, target_path)
+              @document_path_resolver.document_matches_path?(document, target_path)
+            end
+
+            def file_exists?(path)
+              @file_probe.exist?(path)
+            end
+
+            def file_regular?(path)
+              @file_probe.file?(path)
+            end
+
+            def cache_pointer?(path)
+              @cache_pointer_resolver.cache_pointer?(path)
+            end
+
+            def cache_payload(path, strict:)
+              @cache_pointer_resolver.read_cache(path, strict: strict)
+            end
+
+            def valid_cache_path?(path)
+              return false unless path && file_regular?(path)
+              return false unless cache_pointer?(path)
+
+              !!cache_payload(path, strict: true)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @logger&.debug('menu.path_resolution.valid_cache_path_failed',
+                             path: path, error: e.class.name, message: e.message)
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/workflows/menu/reader_launch/progress_orchestration.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative 'contracts'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        module ReaderLaunch
+          # Manages progress overlay, throttled redraws, and pagination build flow.
+          class ProgressOrchestration
+            include Contracts::ProgressOrchestration
+
+            Dependencies = Data.define(
+              :menu_state_reader,
+              :menu_runtime,
+              :progress_presenters,
+              :null_presenter,
+              :pagination_orchestrator,
+              :page_calculator,
+              :config_reader,
+              :reader_state_reader,
+              :sidebar_state_reader,
+              :state_writer,
+              :pagination_cache_preloader,
+              :runtime_config,
+              :ui_state_reader,
+              :clock,
+              :logger
+            ) do
+              REQUIRED_FIELDS = %i[
+                menu_state_reader
+                menu_runtime
+                progress_presenters
+                null_presenter
+                pagination_orchestrator
+                ui_state_reader
+                clock
+              ].freeze
+
+              def validate!
+                values = to_h
+                missing = REQUIRED_FIELDS.select { |field| values[field].nil? }
+                return self if missing.empty?
+
+                raise ArgumentError, "Missing progress orchestration dependencies: #{missing.join(', ')}"
+              end
+            end
+
+            def initialize(deps:)
+              dependencies = deps.validate!
+              @menu_state_reader = dependencies.menu_state_reader
+              @menu_runtime = dependencies.menu_runtime
+              @progress_presenters = dependencies.progress_presenters
+              @null_presenter = dependencies.null_presenter
+              @pagination_orchestrator = dependencies.pagination_orchestrator
+              @page_calculator = dependencies.page_calculator
+              @config_reader = dependencies.config_reader
+              @reader_state_reader = dependencies.reader_state_reader
+              @sidebar_state_reader = dependencies.sidebar_state_reader
+              @state_writer = dependencies.state_writer
+              @pagination_cache_preloader = dependencies.pagination_cache_preloader
+              @runtime_config = dependencies.runtime_config
+              @ui_state_reader = dependencies.ui_state_reader
+              @clock = dependencies.clock
+              @logger = dependencies.logger
+            end
+
+            def load_and_open_with_progress(path:, prepare_reader_launch:, run_reader:)
+              return launch_without_overlay(path, prepare_reader_launch: prepare_reader_launch, run_reader: run_reader) if skip_progress_overlay?
+
+              launch_with_overlay(path, prepare_reader_launch: prepare_reader_launch, run_reader: run_reader)
+            end
+
+            def prepare_reader_launch(path:, load_document:, register_document:, update_total_chapters:, presenter:)
+              width, height = terminal_dimensions
+              progress_reporter = progress_reporter_for(presenter)
+              document = load_document.call(path, progress_reporter)
+
+              register_document.call(document)
+              update_total_chapters.call(document)
+
+              if document_cached?(document)
+                preload_cached_pagination(document, width:, height:)
+                return path
+              end
+
+              build_pagination(document, width, height, presenter)
+              nil
+            end
+
+            def preload_cached_pagination(document, width:, height:)
+              return unless @pagination_cache_preloader
+
+              @pagination_cache_preloader.preload(document, width:, height:)
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @logger&.debug('menu.progress_orchestration.cached_pagination_preload_failed',
+                             error: e.class.name, message: e.message)
+              nil
+            end
+
+            private
+
+            def launch_without_overlay(path, prepare_reader_launch:, run_reader:)
+              @active_presenter = @null_presenter
+              target_path = prepare_reader_launch.call(path, @active_presenter)
+              run_reader.call(target_path || path)
+            ensure
+              @active_presenter = nil
+            end
+
+            def launch_with_overlay(path, prepare_reader_launch:, run_reader:)
+              index = @menu_state_reader.selected_library_index || 0
+              mode = @menu_state_reader.current_menu_mode
+              @active_presenter = @progress_presenters.build
+              @active_presenter.show(path: path, index: index, mode: mode)
+
+              target_path = nil
+              begin
+                target_path = prepare_reader_launch.call(path, @active_presenter)
+              ensure
+                @active_presenter.clear
+              end
+
+              run_reader.call(target_path || path)
+            ensure
+              @active_presenter = nil
+            end
+
+            def skip_progress_overlay?
+              return @runtime_config.skip_progress_overlay? if @runtime_config
+
+              false
+            end
+
+            def document_cached?(document)
+              document.cached?
+            end
+
+            def build_pagination(document, width, height, presenter)
+              calculator = @page_calculator
+              return unless calculator
+              return unless width && height
+
+              session = @pagination_orchestrator.session(
+                doc: document,
+                page_calculator: calculator,
+                dimensions: [width, height],
+                config_reader: @config_reader,
+                reader_state_reader: @reader_state_reader,
+                pagination_state_writer: @state_writer,
+                ui_loading_writer: @state_writer,
+                sidebar_state_reader: @sidebar_state_reader
+              )
+              return unless session
+
+              presenter.update_message('Calculating pages...')
+              @menu_runtime.draw_screen
+
+              session.build_full_map! do |done, total|
+                presenter.update(done: done, total: total)
+                @menu_runtime.draw_screen
+              end
+              presenter.update(done: 1, total: 1)
+            end
+
+            def progress_reporter_for(presenter)
+              Class.new do
+                def initialize(presenter:, clock:, menu_runtime:)
+                  @presenter = presenter
+                  @clock = clock
+                  @menu_runtime = menu_runtime
+                  @last_update = nil
+                end
+
+                def update_status(message: nil, progress: nil)
+                  changed = @presenter.update_status(message: message, progress: progress)
+                  return unless changed
+
+                  now = @clock.monotonic_now
+                  if @last_update.nil? || (now - @last_update) >= 0.05
+                    @menu_runtime.draw_screen
+                    @last_update = now
+                  end
+                end
+              end
+              .new(presenter: presenter, clock: @clock, menu_runtime: @menu_runtime)
+            end
+
+            def terminal_dimensions
+              width = @ui_state_reader&.terminal_width.to_i
+              height = @ui_state_reader&.terminal_height.to_i
+              width = 80 if width <= 0
+              height = 24 if height <= 0
+              [width, height]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/workflows/menu/reader_launch/runtime_execution.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'contracts'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        module ReaderLaunch
+          # Executes menu->reader transition and lifecycle state updates.
+          class RuntimeExecution
+            include Contracts::RuntimeExecution
+
+            Dependencies = Data.define(
+              :menu_state_reader,
+              :state_writer,
+              :reader_launch_state,
+              :menu_launch_state,
+              :recent_files_repository,
+              :catalog,
+              :menu_runtime,
+              :path_resolution,
+              :logger
+            ) do
+              def validate!
+                missing = %i[
+                  menu_state_reader
+                state_writer
+                reader_launch_state
+                menu_launch_state
+                catalog
+                menu_runtime
+                path_resolution
+                ].select { |field| to_h[field].nil? }
+                return self if missing.empty?
+
+                raise ArgumentError, "Missing runtime execution dependencies: #{missing.join(', ')}"
+              end
+            end
+
+            def initialize(deps:)
+              dependencies = deps.validate!
+              @menu_state_reader = dependencies.menu_state_reader
+              @state_writer = dependencies.state_writer
+              @reader_launch_state = dependencies.reader_launch_state
+              @menu_launch_state = dependencies.menu_launch_state
+              @recent_files_repository = dependencies.recent_files_repository
+              @catalog = dependencies.catalog
+              @menu_runtime = dependencies.menu_runtime
+              @path_resolution = dependencies.path_resolution
+              @logger = dependencies.logger
+            end
+
+            def run_reader(path:, ensure_reader_document_for:)
+              prior_mode = @menu_state_reader.current_menu_mode
+              reader_path = @path_resolution.canonical_path(path)
+
+              return unless ensure_reader_document_for.call(reader_path)
+
+              recent_path = @path_resolution.canonical_recent_path(reader_path)
+              @recent_files_repository&.add(recent_path) if recent_path
+
+              @logger&.debug('menu.run_reader.dispatch_running', path: reader_path, running: true)
+              @state_writer.update_reader_meta(book_path: reader_path, running: true)
+              @state_writer.update_reader(mode: :read)
+
+              @menu_launch_state.set_last_opened_path(reader_path)
+              @menu_runtime.run_reader(
+                path: reader_path,
+                preloaded_document: @reader_launch_state.preloaded_document,
+                background_worker: @reader_launch_state.background_worker
+              )
+            # resilient-boundary
+            rescue Shoko::Error => e
+              @logger&.error('menu.run_reader.exception', error: e.class.name, message: e.message)
+              raise
+            ensure
+              @logger&.debug('menu.run_reader.ensure', prior_mode: prior_mode)
+              @reader_launch_state.clear_preloaded_document
+              @reader_launch_state.clear_background_worker
+              @menu_runtime.switch_mode(prior_mode || :browse)
+            end
+
+            def file_not_found
+              @catalog.update_scan_state(status: :error, message: 'File not found')
+            end
+
+            def handle_reader_error(path, error)
+              @logger&.error('Failed to open book', error: error.message, path: path)
+              @catalog.update_scan_state(
+                status: :error,
+                message: "Failed: #{error.class}: #{error.message[0, 60]}"
+              )
+
+              @logger&.debug(
+                'Reader error backtrace',
+                path: path,
+                backtrace: Array(error.backtrace).join("\n")
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/workflows/menu/reader_launch_service.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/menu_book_selection'
+require_relative '../../../core/ports/outbound/menu_workflow_state_reader'
+require_relative '../../../core/models/menu_book'
+require_relative 'reader_launch/contracts'
+require_relative 'reader_launch/path_resolution'
+require_relative 'reader_launch/document_preparation'
+require_relative 'reader_launch/runtime_execution'
+require_relative 'reader_launch/progress_orchestration'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        class ReaderLaunchService
+          Dependencies = Data.define(
+            :menu_state_reader,
+            :book_selection,
+            :path_resolution,
+            :document_preparation,
+            :runtime_execution,
+            :progress_orchestration
+          ) do
+            REQUIRED_FIELDS = %i[
+              menu_state_reader
+              book_selection
+              path_resolution
+              document_preparation
+              runtime_execution
+              progress_orchestration
+            ].freeze
+
+            def validate!
+              values = to_h
+              missing = REQUIRED_FIELDS.select { |field| values[field].nil? }
+              unless missing.empty?
+                raise ArgumentError, "Missing required reader launch dependencies: #{missing.join(', ')}"
+              end
+
+              unless menu_state_reader.is_a?(Shoko::Core::Ports::Outbound::MenuWorkflowStateReader)
+                raise ArgumentError, 'menu_state_reader must implement Core::Ports::Outbound::MenuWorkflowStateReader'
+              end
+              unless book_selection.is_a?(Shoko::Core::Ports::Outbound::MenuBookSelection)
+                raise ArgumentError, 'book_selection must implement Core::Ports::Outbound::MenuBookSelection'
+              end
+              unless path_resolution.is_a?(Shoko::Application::Workflows::Menu::ReaderLaunch::Contracts::PathResolution)
+                raise ArgumentError, 'path_resolution must implement ReaderLaunch::Contracts::PathResolution'
+              end
+              unless document_preparation.is_a?(Shoko::Application::Workflows::Menu::ReaderLaunch::Contracts::DocumentPreparation)
+                raise ArgumentError, 'document_preparation must implement ReaderLaunch::Contracts::DocumentPreparation'
+              end
+              unless runtime_execution.is_a?(Shoko::Application::Workflows::Menu::ReaderLaunch::Contracts::RuntimeExecution)
+                raise ArgumentError, 'runtime_execution must implement ReaderLaunch::Contracts::RuntimeExecution'
+              end
+              unless progress_orchestration.is_a?(Shoko::Application::Workflows::Menu::ReaderLaunch::Contracts::ProgressOrchestration)
+                raise ArgumentError, 'progress_orchestration must implement ReaderLaunch::Contracts::ProgressOrchestration'
+              end
+
+              self
+            end
+          end
+
+          def initialize(deps:)
+            deps.validate!
+            @menu_state_reader = deps.menu_state_reader
+            @book_selection = deps.book_selection
+            @path_resolution = deps.path_resolution
+            @document_preparation = deps.document_preparation
+            @runtime_execution = deps.runtime_execution
+            @progress_orchestration = deps.progress_orchestration
+          end
+
+          def open_selected_book
+            book = @book_selection.selected_book
+
+            return unless book
+            unless book.is_a?(Shoko::Core::Models::MenuBook)
+              raise ArgumentError, "book_selection must return Core::Models::MenuBook, got #{book.class}"
+            end
+
+            path = book.path
+            if path && @path_resolution.file_exists?(path)
+              load_and_open_with_progress(path)
+            else
+              file_not_found
+            end
+          end
+
+          def open_book(path)
+            return file_not_found unless @path_resolution.file_exists?(path)
+
+            load_and_open_with_progress(path)
+          # resilient-boundary
+          rescue Shoko::Error => e
+            handle_reader_error(path, e)
+            raise
+          end
+
+          def run_reader(path)
+            @runtime_execution.run_reader(
+              path: path,
+              ensure_reader_document_for: ->(candidate_path) { ensure_reader_document_for(candidate_path) }
+            )
+          end
+
+          def load_and_open_with_progress(path)
+            @progress_orchestration.load_and_open_with_progress(
+              path: path,
+              prepare_reader_launch: method(:prepare_reader_launch),
+              run_reader: method(:run_reader)
+            )
+          # resilient-boundary
+          rescue Shoko::Error => e
+            handle_reader_error(path, e)
+            raise
+          end
+
+          def file_not_found
+            @runtime_execution.file_not_found
+          end
+
+          def handle_reader_error(path, error)
+            @runtime_execution.handle_reader_error(path, error)
+          end
+
+          def valid_cache_path?(path)
+            @path_resolution.valid_cache_path?(path)
+          end
+
+          def ensure_reader_document_for(path)
+            @document_preparation.ensure_reader_document_for(
+              path: path,
+              path_resolution: @path_resolution,
+              on_error: method(:handle_reader_error)
+            )
+          end
+
+          private
+
+          def prepare_reader_launch(path, presenter)
+            @document_preparation.ensure_background_worker(name: 'document-preload')
+            @progress_orchestration.prepare_reader_launch(
+              path: path,
+              load_document: lambda do |load_path, progress_reporter|
+                @document_preparation.load_document_for(
+                  load_path,
+                  progress_reporter: progress_reporter,
+                  path_resolution: @path_resolution
+                )
+              end,
+              register_document: ->(document) { @document_preparation.register_document(document) },
+              update_total_chapters: ->(document) { @document_preparation.update_total_chapters(document) },
+              presenter: presenter
+            )
+          end
+        end
+      end
+    end
+  end
+end