shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/input/controllers/menu/actions/dictionary_actions.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../shared/menu_definitions'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+            module Actions
+              module Dictionary
+              def open_dictionary_settings(_key = nil)
+                reset_dictionary_state
+                @menu_state_writer.update_menu(mode: :dictionary, dictionary_selected: 0)
+                input_controller.activate(:dictionary)
+                state_controller.fetch_dictionary_catalog
+              end
+
+              def dictionary_up(_key = nil)
+                update_dictionary_selection(-1)
+              end
+
+              def dictionary_down(_key = nil)
+                update_dictionary_selection(1)
+              end
+
+              def dictionary_select(_key = nil)
+                index = (@menu_state_reader.dictionary_selected || 0).to_i
+                action_count = dictionary_action_count
+
+                if index < action_count
+                  handle_dictionary_action(index)
+                else
+                  entry = selected_dictionary_entry
+                  state_controller.download_dictionary(entry) if entry
+                end
+              end
+
+              def dictionary_start_search(_key = nil)
+                query = @menu_state_reader.dictionary_query.to_s
+                @menu_state_writer.update_menu(mode: :dictionary_search, dictionary_cursor: query.length)
+                input_controller.activate(:dictionary_search)
+              end
+
+              def dictionary_back(_key = nil)
+                @menu_state_writer.update_menu(mode: :settings)
+                input_controller.activate(:settings)
+              end
+
+              def dictionary_exit_search(_key = nil)
+                @menu_state_writer.update_menu(mode: :dictionary)
+                input_controller.activate(:dictionary)
+              end
+
+              def dictionary_submit_search(_key = nil)
+                @menu_state_writer.update_menu(mode: :dictionary, dictionary_selected: 0)
+                input_controller.activate(:dictionary)
+              end
+
+              def dictionary_refresh(_key = nil)
+                state_controller.fetch_dictionary_catalog
+              end
+
+            private
+
+              def update_dictionary_selection(delta)
+                max_index = [dictionary_item_count - 1, 0].max
+                current = (@menu_state_reader.dictionary_selected || 0).to_i
+                new_val = (current + delta).clamp(0, max_index)
+                @menu_state_writer.update_menu(dictionary_selected: new_val)
+              end
+
+              def dictionary_item_count
+                dictionary_action_count + dictionary_filtered_results.length
+              end
+
+              def dictionary_action_count
+                Shoko::Shared::MenuDefinitions.dictionary_action_items.length
+              end
+
+              def dictionary_filtered_results
+                query = @menu_state_reader.dictionary_query.to_s.downcase
+                results = Array(@menu_state_reader.dictionary_results)
+                return results if query.empty?
+
+                results.select do |item|
+                  name = item[:name].to_s.downcase
+                  pair = "#{item[:source]}-#{item[:target]}".downcase
+                  name.include?(query) || pair.include?(query)
+                end
+              end
+
+              def selected_dictionary_entry
+                index = (@menu_state_reader.dictionary_selected || 0).to_i
+                list_index = index - dictionary_action_count
+                return nil if list_index.negative?
+
+                dictionary_filtered_results[list_index]
+              end
+
+              def handle_dictionary_action(index)
+                item = Shoko::Shared::MenuDefinitions.dictionary_action_item(index)
+                action = item&.action
+                return if action.nil?
+
+                case action
+                when :dictionary_back then dictionary_back
+                when :toggle_dictionary_backend then toggle_dictionary_backend
+                when :cycle_dictionary_pair then cycle_dictionary_pair
+                when :dictionary_refresh then dictionary_refresh
+                else
+                  raise ArgumentError, "Unsupported dictionary action: #{action}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/actions/download_actions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+            module Actions
+              module Download
+              def open_download_screen(_key = nil)
+                reset_download_state
+                @menu_state_writer.update_menu(mode: :download)
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def download_start_search(_key = nil)
+                query = @menu_state_reader.download_query.to_s
+                @menu_state_writer.update_menu(mode: :download_search, download_cursor: query.length)
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def download_exit_search(_key = nil)
+                @menu_state_writer.update_menu(mode: :download)
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def download_submit_search(_key = nil)
+                query = @menu_state_reader.download_query.to_s
+                state_controller.search_downloads(query: query)
+                download_exit_search
+              end
+
+              def download_refresh(_key = nil)
+                query = @menu_state_reader.download_query.to_s
+                state_controller.search_downloads(query: query)
+              end
+
+              def download_next_page(_key = nil)
+                next_url = @menu_state_reader.download_next
+                return unless next_url
+
+                query = @menu_state_reader.download_query.to_s
+                state_controller.search_downloads(query: query, page_url: next_url)
+              end
+
+              def download_prev_page(_key = nil)
+                prev_url = @menu_state_reader.download_prev
+                return unless prev_url
+
+                query = @menu_state_reader.download_query.to_s
+                state_controller.search_downloads(query: query, page_url: prev_url)
+              end
+
+              def download_up(_key = nil)
+                update_download_selection(-1)
+              end
+
+              def download_down(_key = nil)
+                update_download_selection(1)
+              end
+
+              def download_confirm(_key = nil)
+                book = selected_download_book
+                return unless book
+
+                state_controller.download_book(book)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/actions/lifecycle_actions.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          module Actions
+            module Lifecycle
+              def run
+                @terminal_service.setup
+                @catalog.load_cached
+                epubs = @catalog.entries || []
+                @filtered_epubs = epubs
+                @main_menu_component.browse_screen.filtered_epubs = epubs
+                @catalog.start_scan(force: true) if epubs.empty?
+
+                main_loop
+              rescue Interrupt
+                cleanup_and_exit(0, "\nGoodbye!")
+              rescue Shoko::FatalExternalInputError => e
+                log_fatal_external_input(e)
+                cleanup_and_exit(2, "Fatal external input error: #{e.message}", e)
+              # resilient-boundary
+              rescue Shoko::Error => e
+                cleanup_and_exit(1, "Error: #{e.message}", e)
+              ensure
+                begin
+                  @terminal_service.force_cleanup
+                # resilient-boundary
+                rescue Shoko::Error => e
+                  @logger_ref&.debug('menu.run.ensure_terminal_cleanup_failed',
+                                     error: e.class.name,
+                                     message: e.message)
+                end
+                @catalog.cleanup
+              end
+
+              def cleanup_and_exit(code, message, error = nil)
+                cleanup_terminal
+
+                log_exit(message, error)
+                @process_control&.terminate(code)
+              end
+
+              def main_loop
+                draw_screen
+                loop do
+                  process_scan_results_if_available
+                  handle_user_input
+                  draw_screen
+                end
+              end
+
+              def handle_user_input
+                keys = read_input_keys(timeout: annotation_editor_active? ? blink_poll_interval : nil)
+                input_controller.handle_keys(keys)
+              end
+
+              def read_input_keys(timeout: nil)
+                @terminal_service.read_keys_blocking(limit: 10, timeout: timeout)
+              end
+
+              def process_scan_results_if_available
+                return unless (epubs = @catalog.process_results)
+
+                @filtered_epubs = epubs
+                @main_menu_component.browse_screen.filtered_epubs = epubs
+                @main_menu_component.library_screen.invalidate_cache!
+              end
+
+              def draw_screen
+                notification_service&.tick
+                @frame_coordinator.with_frame do |surface, bounds, _w, _h|
+                  @render_pipeline.render_component(surface, bounds, @main_menu_component)
+                end
+              end
+
+              def annotation_editor_active?
+                @menu_state_reader.mode == :annotation_editor
+              rescue Shoko::FatalExternalInputError
+                raise
+              # resilient-boundary
+              rescue Shoko::Error => e
+                @logger_ref&.debug('menu.annotation_editor_active_check_failed',
+                                   error: e.class.name,
+                                   message: e.message)
+                false
+              end
+
+              def blink_poll_interval
+                0.1
+              end
+
+            private
+
+              def cleanup_terminal
+                terminal = terminal_service
+                return unless terminal
+
+                cleanup_error = nil
+                begin
+                  terminal.cleanup
+                # resilient-boundary
+                rescue Shoko::Error => e
+                  cleanup_error = e
+                  @logger_ref&.error('Menu terminal cleanup failed', error: e.message)
+                ensure
+                  force_cleanup_if_needed(terminal, cleanup_error)
+                end
+              end
+
+              def force_cleanup_if_needed(terminal, cleanup_error)
+                remaining_depth = terminal.session_depth || 0
+                needs_force = cleanup_error || remaining_depth.positive?
+                return unless needs_force
+
+                terminal.force_cleanup
+              # resilient-boundary
+              rescue Shoko::Error => e
+                @logger_ref&.error('Menu terminal force cleanup failed', error: e.message)
+              end
+
+              def log_exit(message, error)
+                @logger_ref&.info('Exiting menu', message: message, status: error ? 'error' : 'ok')
+                return unless error
+
+                @logger_ref&.error('Menu exit error', error: error.message, backtrace: Array(error.backtrace))
+              end
+
+              def log_fatal_external_input(error)
+                @logger_ref&.error(
+                  fatal_event_id_for(error),
+                  error: error.class.name,
+                  message: error.message
+                )
+              end
+
+              def fatal_event_id_for(error)
+                case error
+                when Shoko::MalformedBookInputError
+                  'fatal.external_input.book'
+                when Shoko::MalformedMetadataInputError
+                  'fatal.external_input.metadata'
+                when Shoko::MalformedDictionaryInputError
+                  'fatal.external_input.dictionary'
+                else
+                  'fatal.external_input.unknown'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/actions/navigation_actions.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../shared/menu_definitions'
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+            module Actions
+              module Navigation
+              def handle_menu_selection(_key = nil)
+                item = Shoko::Shared::MenuDefinitions.main_menu_item((@menu_state_reader.selected || 0).to_i)
+                case item&.action
+                when :switch_to_browse then switch_to_browse
+                when :switch_to_library then switch_to_mode(:library)
+                when :switch_to_annotations then switch_to_mode(:annotations)
+                when :open_download then open_download_screen
+                when :switch_to_settings then switch_to_mode(:settings)
+                when :quit then cleanup_and_exit(0, '')
+                end
+              end
+
+              def handle_navigation(direction, _key = nil)
+                current = @menu_state_reader.selected
+                max_val = Shoko::Shared::MenuDefinitions.main_menu_items.length - 1
+
+                new_selected = case direction
+                               when :up then [current - 1, 0].max
+                               when :down then [current + 1, max_val].min
+                               else current
+                               end
+                @menu_state_writer.update_menu(selected: new_selected)
+              end
+
+              def switch_to_browse(_key = nil)
+                @menu_state_writer.update_menu(mode: :browse, search_active: false)
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def switch_to_search(_key = nil)
+                @menu_state_writer.update_menu(mode: :search, search_active: true)
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def switch_to_mode(mode)
+                payload = { mode: mode, browse_selected: 0 }
+                payload[:settings_selected] = 1 if mode == :settings
+                payload[:library_details_open] = false if mode == :library
+                @menu_state_writer.update_menu(payload)
+                preload_annotations if mode == :annotations
+                input_controller.activate(@menu_state_reader.mode)
+              end
+
+              def refresh_scan(force: true)
+                state_controller.refresh_scan(force: force)
+              end
+
+              def library_up(_key = nil)
+                current = @menu_state_reader.browse_selected || 0
+                @menu_state_writer.update_menu(browse_selected: (current - 1).clamp(0, current))
+              end
+
+              def library_down(_key = nil)
+                items = main_menu_component.library_screen.items
+                max_index = [items.length - 1, 0].max
+                current = @menu_state_reader.browse_selected || 0
+                @menu_state_writer.update_menu(browse_selected: (current + 1).clamp(0, max_index))
+              end
+
+              def library_select(_key = nil)
+                item = selected_library_item
+                return unless item
+
+                target_path = resolve_library_path(item)
+                return state_controller.file_not_found unless target_path
+
+                state_controller.run_reader(target_path)
+              end
+
+              def library_toggle_details(_key = nil)
+                current = !!@menu_state_reader.library_details_open?
+                @menu_state_writer.update_menu(library_details_open: !current)
+              end
+
+              def open_selected_book(_key = nil)
+                state_controller.open_selected_book
+              end
+
+              # Annotation helpers (public so dispatcher can invoke explicitly)
+              def open_selected_annotation(_key = nil)
+                state_controller.open_selected_annotation
+              end
+
+              def open_selected_annotation_for_edit(_key = nil)
+                state_controller.open_selected_annotation_for_edit
+              end
+
+              def annotations_up(_key = nil)
+                @main_menu_component&.annotations_screen&.navigate(:up)
+              end
+
+              def annotations_down(_key = nil)
+                @main_menu_component&.annotations_screen&.navigate(:down)
+              end
+
+              def annotations_select(_key = nil)
+                context = selected_annotation_for_workflow
+                annotation = context[:annotation]
+                book_path = context[:book_path]
+                return unless annotation && book_path
+
+                @menu_state_writer.update_menu(selected_annotation: annotation, selected_annotation_book: book_path)
+                switch_to_mode(:annotation_detail)
+              end
+
+              def delete_selected_annotation(_key = nil)
+                state_controller.delete_selected_annotation
+              end
+
+              def browse_items_count
+                @main_menu_component.browse_screen.filtered_count
+              end
+
+              def save_current_annotation_edit(_key = nil)
+                state_controller.save_current_annotation_edit
+              end
+
+              # Current editor component exposed for annotation editor command routing.
+              def current_editor_component
+                return nil unless @menu_state_reader.mode == :annotation_editor
+
+                @main_menu_component.annotation_edit_screen
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/input/controllers/menu/actions/settings_actions.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Input
+      module Controllers
+        module Menu
+          module Actions
+            module Settings
+              # Settings are handled directly via dispatcher bindings
+              def toggle_view_mode(_key = nil)
+                settings_service.toggle_view_mode
+              end
+
+              def toggle_page_numbers(_key = nil)
+                settings_service.toggle_page_numbers
+              end
+
+              def cycle_line_spacing(_key = nil)
+                settings_service.cycle_line_spacing
+              end
+
+              def toggle_highlight_quotes(_key = nil)
+                settings_service.toggle_highlight_quotes
+              end
+
+              def toggle_dictionary_backend(_key = nil)
+                settings_service.toggle_dictionary_backend
+              end
+
+              def cycle_dictionary_pair(_key = nil)
+                settings_service.cycle_dictionary_pair
+              end
+
+              def toggle_kitty_images(_key = nil)
+                settings_service.toggle_kitty_images
+              end
+
+              def toggle_page_numbering_mode(_key = nil)
+                settings_service.toggle_page_numbering_mode
+              end
+
+              def wipe_cache(_key = nil)
+                message = settings_service.wipe_cache(
+                  catalog: @catalog,
+                  cached: @menu_state_reader.wipe_cache_cached? || nil,
+                  downloads: @menu_state_reader.wipe_cache_downloads? || nil,
+                  nuke: @menu_state_reader.wipe_cache_nuke? || nil,
+                  annotations: @menu_state_reader.wipe_cache_annotations? || nil,
+                  bookmarks: @menu_state_reader.wipe_cache_bookmarks? || nil,
+                  progress: @menu_state_reader.wipe_cache_progress? || nil,
+                  config_file: @menu_state_reader.wipe_cache_config? || nil
+                )
+                @filtered_epubs = []
+                message
+              end
+
+              def toggle_wipe_cache_cached(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_cached, default: true)
+              end
+
+              def toggle_wipe_cache_downloads(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_downloads, default: false)
+              end
+
+              def toggle_wipe_cache_annotations(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_annotations, default: false)
+              end
+
+              def toggle_wipe_cache_bookmarks(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_bookmarks, default: false)
+              end
+
+              def toggle_wipe_cache_progress(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_progress, default: false)
+              end
+
+              def toggle_wipe_cache_config(_key = nil)
+                toggle_wipe_cache_flag(:wipe_cache_config, default: false)
+              end
+
+              def toggle_wipe_cache_nuke(_key = nil)
+                current = @menu_state_reader.wipe_cache_nuke?
+                new_value = !current
+
+                payload = { wipe_cache_nuke: new_value }
+                if new_value
+                  payload[:wipe_cache_cached] = true
+                  payload[:wipe_cache_downloads] = true
+                  payload[:wipe_cache_annotations] = true
+                  payload[:wipe_cache_bookmarks] = true
+                  payload[:wipe_cache_progress] = true
+                  payload[:wipe_cache_config] = true
+                end
+
+                @menu_state_writer.update_menu(payload)
+              end
+
+            private
+
+              def toggle_wipe_cache_flag(key, default:)
+                current = read_wipe_cache_flag(key, default: default)
+                new_val = !current
+
+                payload = { key => new_val }
+                payload[:wipe_cache_nuke] = false if !new_val && @menu_state_reader.wipe_cache_nuke?
+
+                @menu_state_writer.update_menu(payload)
+              end
+
+              def read_wipe_cache_flag(key, default:)
+                case key
+                when :wipe_cache_cached then @menu_state_reader.wipe_cache_cached?
+                when :wipe_cache_downloads then @menu_state_reader.wipe_cache_downloads?
+                when :wipe_cache_annotations then @menu_state_reader.wipe_cache_annotations?
+                when :wipe_cache_bookmarks then @menu_state_reader.wipe_cache_bookmarks?
+                when :wipe_cache_progress then @menu_state_reader.wipe_cache_progress?
+                when :wipe_cache_config then @menu_state_reader.wipe_cache_config?
+                else default
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end