shoko 0.1.0

data/lib/shoko/application/infrastructure/state_store.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+begin
+  require 'json'
+rescue NameError => e
+  raise unless e.name == :Fragment
+
+  # Ensure JSON::Fragment exists for compatibility with JSON parsing in some environments.
+  module JSON
+    Fragment = Object unless const_defined?(:Fragment)
+  end
+  require 'json'
+end
+require_relative '../../adapters/storage/atomic_file_writer.rb'
+require_relative '../../adapters/storage/config_paths.rb'
+require_relative '../../adapters/output/kitty/kitty_graphics'
+
+module Shoko
+  module Application::Infrastructure
+    # Immutable state store with event-driven updates.
+    # Single source of truth for application state with validation.
+    class StateStore
+      attr_reader :event_bus
+
+      SYMBOL_KEYS = %i[view_mode line_spacing page_numbering_mode theme].freeze
+      LINE_SPACING_ALIASES = {
+        tight: :compact,
+        wide: :relaxed,
+      }.freeze
+      private_constant :SYMBOL_KEYS, :LINE_SPACING_ALIASES
+
+      # Configuration file management (used by persistence + specs).
+      def self.config_dir
+        Shoko::Adapters::Storage::ConfigPaths.config_root
+      end
+
+      def self.config_file
+        File.join(config_dir, 'config.json')
+      end
+
+      def initialize(event_bus = EventBus.new)
+        @event_bus = event_bus
+        @state = build_initial_state
+        @mutex = Mutex.new
+      end
+
+      # Cheap, read-only reference to the current state (no deep copy).
+      # Callers must not mutate the returned object.
+      def peek
+        @mutex.synchronize { @state }
+      end
+
+      # Get current state snapshot (immutable)
+      #
+      # @return [Hash] Current state
+      def current_state
+        @mutex.synchronize { deep_dup(@state, true) }
+      end
+
+      # Get value at specific path
+      #
+      # @param path [Array<Symbol>] Path to value
+      # @return [Object] Value at path
+      def get(path)
+        @mutex.synchronize do
+          path.reduce(@state) { |state, key| state&.dig(key) }
+        end
+      end
+
+      # Update state and emit events
+      #
+      # @param updates [Hash] Hash of path => value updates
+      def update(updates)
+        @mutex.synchronize do
+          old_state = @state
+          new_state = apply_updates(old_state, updates)
+
+          return if old_state == new_state
+
+          @state = new_state
+          emit_change_events(old_state, new_state, updates)
+        end
+      end
+
+      # Update single path
+      #
+      # @param path [Array<Symbol>] Path to update
+      # @param value [Object] New value
+      def set(path, value)
+        update({ path => value })
+      end
+
+      # Reset to initial state
+      def reset!
+        @mutex.synchronize do
+          old_state = @state
+          @state = build_initial_state
+          @event_bus.emit_event(:state_reset, { old_state: old_state, new_state: @state })
+        end
+      end
+
+      # Validate state transition (override in subclasses)
+      #
+      # @param old_state [Hash] Previous state
+      # @param new_state [Hash] Proposed new state
+      # @param updates [Hash] Applied updates
+      # @return [Boolean] Whether transition is valid
+      def valid_transition?(_old_state, _new_state, _updates)
+        true # Base implementation allows all transitions
+      end
+
+      # Convenience methods for compatibility with legacy callers
+      def terminal_size_changed?(width, height)
+        last_width = get(%i[reader last_width])
+        last_height = get(%i[reader last_height])
+        width != last_width || height != last_height
+      end
+
+      def update_terminal_size(width, height)
+        update({
+                 %i[reader last_width] => width,
+                 %i[reader last_height] => height,
+                 %i[ui terminal_width] => width,
+                 %i[ui terminal_height] => height,
+               })
+      end
+
+      def apply_terminal_dimensions(width, height)
+        return unless width && height
+
+        update_terminal_size(width, height)
+      end
+
+      # State snapshot for persistence
+      def reader_snapshot
+        {
+          current_chapter: get(%i[reader current_chapter]),
+          page_offset: get(%i[reader single_page]),
+          mode: get(%i[reader mode]).to_s,
+          timestamp: Time.now.iso8601,
+        }
+      end
+
+      # Restore reader state from snapshot
+      def restore_reader_from(snapshot)
+        update({
+                 %i[reader current_chapter] => snapshot['current_chapter'] || 0,
+                 %i[reader single_page] => snapshot['page_offset'] || 0,
+                 %i[reader left_page] => snapshot['page_offset'] || 0,
+                 %i[reader mode] => (snapshot['mode'] || 'read').to_sym,
+               })
+      end
+
+      # Configuration persistence methods
+      def save_config
+        ensure_config_dir
+        write_config_file
+      rescue StandardError
+        # Ignore save errors
+      end
+
+      def config_to_h
+        get([:config])
+      end
+
+      # Dispatch Application::Actions to update state explicitly
+      def dispatch(action)
+        return unless action.respond_to?(:apply)
+
+        action.apply(self)
+      end
+
+      private
+
+      def build_initial_state
+        {
+          reader: {
+            # Position state
+            current_chapter: 0,
+            left_page: 0,
+            right_page: 0,
+            single_page: 0,
+            current_page_index: 0,
+
+            # Mode and UI state
+            mode: :read,
+            selection: nil,
+            message: nil,
+            running: true,
+
+            # Lists and selections
+            bookmarks: [],
+            annotations: [],
+
+            # Pagination state
+            page_map: [],
+            total_pages: 0,
+            pages_per_chapter: [],
+
+            # Terminal sizing
+            last_width: 0,
+            last_height: 0,
+            page_offset: 0,
+
+            # Dynamic pagination
+            dynamic_page_map: nil,
+            dynamic_total_pages: 0,
+            dynamic_chapter_starts: [],
+            last_dynamic_width: 0,
+            last_dynamic_height: 0,
+
+            # UI state
+            rendered_lines: {},
+            popup_menu: nil,
+            annotations_overlay: nil,
+            annotation_editor_overlay: nil,
+
+            # Sidebar state
+            sidebar_visible: false,
+            sidebar_active_tab: :toc,
+            sidebar_toc_selected: 0,
+            sidebar_annotations_selected: 0,
+            sidebar_bookmarks_selected: 0,
+            sidebar_toc_filter: nil,
+            sidebar_toc_filter_active: false,
+            sidebar_toc_collapsed: nil,
+          },
+
+          menu: {
+            selected: 0,
+            mode: :menu,
+            browse_selected: 0,
+            settings_selected: 1,
+            search_query: '',
+            search_cursor: 0,
+            search_active: false,
+            download_query: '',
+            download_cursor: 0,
+            download_selected: 0,
+            download_results: [],
+            download_count: 0,
+            download_next: nil,
+            download_prev: nil,
+            download_status: :idle,
+            download_message: '',
+            download_progress: 0.0,
+          },
+
+          config: {
+            view_mode: :split,
+            line_spacing: :compact,
+            page_numbering_mode: :dynamic,
+            theme: :dark,
+            show_page_numbers: true,
+            highlight_quotes: true,
+            highlight_keywords: false,
+            prefetch_pages: 20,
+            kitty_images: Shoko::Adapters::Output::Kitty::KittyGraphics.supported?,
+          },
+
+          ui: {
+            terminal_width: 80,
+            terminal_height: 24,
+          },
+        }
+      end
+
+      def apply_updates(state, updates)
+        # Copy only the branches we need to touch instead of duplicating the entire tree.
+        clones = {}.compare_by_identity
+        new_root = duplicate_node(state, clones)
+
+        updates.each do |path, value|
+          validate_update(path, value)
+          keys = Array(path)
+          target = new_root
+          keys[0...-1].each do |key|
+            existing = target[key]
+            duplicated = duplicate_node(existing, clones)
+            duplicated = {} if duplicated.nil?
+            target[key] = duplicated
+            target = duplicated
+          end
+          target[keys.last] = value
+        end
+
+        new_root
+      end
+
+      def validate_update(path, value)
+        # Add validation logic here
+        path_array = Array(path)
+
+        case path_array
+        when %i[reader current_chapter]
+          raise ArgumentError, 'current_chapter must be non-negative' if value.negative?
+        when %i[config view_mode]
+          raise ArgumentError, 'invalid view_mode' unless %i[single split].include?(value)
+        when %i[config kitty_images]
+          raise ArgumentError, 'kitty_images must be boolean' unless [true, false].include?(value)
+        when %i[ui terminal_width], %i[ui terminal_height]
+          raise ArgumentError, 'terminal dimensions must be positive' if value <= 0
+        end
+      end
+
+      def set_nested(hash, path, value)
+        *keys, last_key = path
+
+        if keys.empty?
+          hash[last_key] = value
+        else
+          # Create mutable path to target
+          target = hash
+          keys.each do |key|
+            target[key] = {} unless target.key?(key)
+            target = target[key]
+          end
+          target[last_key] = value
+        end
+      end
+
+      def duplicate_node(node, clones)
+        return node unless node.is_a?(Hash)
+        return clones[node] if clones.key?(node)
+
+        duped = node.dup
+        clones[node] = duped
+        duped
+      rescue StandardError
+        node
+      end
+
+      def deep_dup(obj, freeze_result = false)
+        case obj
+        when Hash
+          result = obj.transform_values { |v| deep_dup(v, freeze_result) }
+          freeze_result ? result.freeze : result
+        when Array
+          result = obj.map { |v| deep_dup(v, freeze_result) }
+          freeze_result ? result.freeze : result
+        else
+          begin
+            obj.dup
+          rescue StandardError
+            obj
+          end
+        end
+      end
+
+      def emit_change_events(old_state, new_state, updates)
+        updates.each do |path, new_value|
+          arr_path = Array(path)
+          old_value = get_nested_value(old_state, arr_path)
+          next if old_value == new_value
+
+          @event_bus.emit_event(:state_changed, {
+                                  path: arr_path,
+                                  old_value: old_value,
+                                  new_value: new_value,
+                                  full_state: new_state,
+                                })
+        end
+      end
+
+      def get_nested_value(hash, path)
+        path.reduce(hash) { |h, key| h&.dig(key) }
+      end
+
+      def ensure_config_dir
+        FileUtils.mkdir_p(self.class.config_dir)
+      rescue StandardError
+        nil
+      end
+
+      def write_config_file
+        payload = JSON.pretty_generate(config_to_h)
+        Shoko::Adapters::Storage::AtomicFileWriter.write(self.class.config_file, payload)
+      rescue StandardError
+        nil
+      end
+
+      # Load config from file on initialization
+      def load_config_from_file
+        config_file = self.class.config_file
+        return unless File.exist?(config_file)
+
+        data = parse_config_file(config_file)
+        apply_config_data(data) if data
+      rescue StandardError
+        # Use defaults on error
+      end
+
+      def parse_config_file(path)
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue StandardError
+        nil
+      end
+
+      def apply_config_data(data)
+        config_updates = {}
+        data.each do |key, value|
+          next unless get([:config]).key?(key)
+
+          value = value.to_sym if SYMBOL_KEYS.include?(key)
+          value = LINE_SPACING_ALIASES.fetch(value, value) if key == :line_spacing
+          config_updates[[:config, key]] = value
+        end
+        update(config_updates) unless config_updates.empty?
+      end
+    end
+  end
+end

data/lib/shoko/application/main_menu/menu_progress_presenter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    module MainMenu
+      # Encapsulates loading-state updates while a book is preprocessed.
+      class MenuProgressPresenter
+        MIN_PROGRESS_DELTA = 0.01
+
+      def initialize(state)
+        @state = state
+        @last_message = nil
+        @last_progress = nil
+      end
+
+      def show(path:, index:, mode:)
+        @last_message = 'Preparing book...'
+        @last_progress = 0.0
+        dispatch(
+          loading_active: true,
+          loading_path: path,
+          loading_progress: 0.0,
+          loading_index: index,
+          loading_mode: mode,
+          loading_message: @last_message
+        )
+      end
+
+      def update(done:, total:)
+        progress = Shoko::Core::Services::ProgressHelper.ratio(done, total)
+        update_status(progress: progress)
+      end
+
+      def update_message(message)
+        update_status(message: message)
+      end
+
+      def set_progress(progress)
+        update_status(progress: progress)
+      end
+
+      def update_status(message: nil, progress: nil)
+        updates = {}
+
+        if message && message != @last_message
+          updates[:loading_message] = message
+          @last_message = message
+        end
+
+        unless progress.nil?
+          normalized = progress.to_f.clamp(0.0, 1.0)
+          if @last_progress.nil? || (normalized - @last_progress).abs >= MIN_PROGRESS_DELTA
+            updates[:loading_progress] = normalized
+            @last_progress = normalized
+          end
+        end
+
+        dispatch(updates) unless updates.empty?
+        !updates.empty?
+      end
+
+      def clear
+        @last_message = nil
+        @last_progress = nil
+        dispatch(
+          loading_active: false,
+          loading_path: nil,
+          loading_progress: nil,
+          loading_index: nil,
+          loading_mode: nil,
+          loading_message: nil
+        )
+      end
+
+      private
+
+        def dispatch(payload)
+          @state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(payload))
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/pending_jump_handler.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../application/selectors/reader_selectors'
+
+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
+      end
+
+      def apply
+        payload = state.get(%i[reader pending_jump])
+        return unless payload
+
+        apply_chapter_jump(payload)
+        apply_selection(payload)
+        open_annotation_editor(payload)
+      ensure
+        clear_pending_jump
+      end
+
+      private
+
+      attr_reader :state, :dependencies, :ui_controller
+
+      def apply_chapter_jump(payload)
+        chapter_index = payload[:chapter_index] || payload['chapter_index']
+        return unless chapter_index
+
+        navigation = resolve_optional(:navigation_service)
+        navigation&.jump_to_chapter(chapter_index)
+      rescue StandardError
+        nil
+      end
+
+      def apply_selection(payload)
+        range = payload[:selection_range] || payload['selection_range']
+        return unless range
+
+        normalized = normalize_selection(range)
+        return unless normalized
+
+        state.dispatch(Shoko::Application::Actions::UpdateSelectionAction.new(normalized))
+      end
+
+      def open_annotation_editor(payload)
+        return unless edit_requested?(payload)
+
+        annotation = normalized_annotation(payload)
+        return unless annotation
+
+        ui_controller.open_annotation_editor_overlay(
+          text: annotation[:text],
+          range: annotation[:range],
+          chapter_index: annotation[:chapter_index],
+          annotation: annotation
+        )
+      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)
+          return normalized if normalized
+        end
+
+        coord = resolve_optional(:coordinate_service)
+        return range unless coord
+
+        rendered = Shoko::Application::Selectors::ReaderSelectors.rendered_lines(state)
+        coord.normalize_selection_range(range, rendered)
+      rescue StandardError
+        nil
+      end
+
+      def clear_pending_jump
+        state.dispatch(Shoko::Application::Actions::UpdateSelectionsAction.new(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 value_from(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+    end
+  end
+end

data/lib/shoko/application/reader_lifecycle.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Application
+    # Manages reader startup and shutdown concerns (terminal setup, background worker).
+    class ReaderLifecycle
+      def initialize(controller, dependencies:, terminal_service:)
+        @controller = controller
+        @dependencies = dependencies
+        @terminal_service = terminal_service
+        @background_worker = nil
+      end
+
+      def ensure_background_worker(name: 'reader-background')
+        @background_worker ||= resolve_existing(:background_worker)
+        return @background_worker if @background_worker
+
+        factory = resolve_optional(:background_worker_factory)
+        return nil unless factory.respond_to?(:call)
+
+        @background_worker = factory.call(name: name)
+        @dependencies.register(:background_worker, @background_worker) if @background_worker
+        @background_worker
+      rescue StandardError
+        nil
+      end
+
+      attr_reader :background_worker
+
+      def run
+        ensure_background_worker
+        @terminal_service.setup
+        @controller.mark_metrics_start!
+        Shoko::Application::ReaderStartupOrchestrator.new(@dependencies).start(@controller)
+        @controller.main_loop
+      ensure
+        shutdown_background_worker
+        @terminal_service.cleanup
+      end
+
+      def shutdown_background_worker
+        @background_worker&.shutdown
+      ensure
+        @background_worker = nil
+        @dependencies.register(:background_worker, nil)
+      end
+
+      private
+
+      def resolve_existing(name)
+        return nil unless @dependencies.respond_to?(:registered?) && @dependencies.registered?(name)
+
+        @dependencies.resolve(name)
+      rescue StandardError
+        nil
+      end
+
+      def resolve_optional(name)
+        @dependencies.resolve(name)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end