shoko 0.1.0

data/lib/shoko/application/use_cases/commands/conditional_navigation_commands.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative 'navigation_commands'
+require_relative 'sidebar_commands'
+
+module Shoko
+  module Application
+    module Commands
+      # Commands that route to different actions based on application state
+      class ConditionalNavigationCommand < BaseCommand
+        def initialize(primary_action, sidebar_action, name: nil, description: nil)
+          @primary_action = primary_action # Action when sidebar not visible
+          @sidebar_action = sidebar_action # Action when sidebar is visible
+          super(
+            name: name || "conditional_#{primary_action}",
+            description: description || "Conditional #{primary_action.to_s.tr('_', ' ')} navigation"
+          )
+        end
+
+        protected
+
+        def perform(context, params = {})
+          state = context.dependencies.resolve(:global_state)
+          sidebar_visible = state.get(%i[reader sidebar_visible])
+
+          if sidebar_visible
+            # Route to sidebar command
+            sidebar_command = SidebarCommand.new(@sidebar_action)
+            sidebar_command.execute(context, params)
+          else
+            # Route to navigation command
+            nav_command = NavigationCommand.new(@primary_action)
+            nav_command.execute(context, params)
+          end
+
+          sidebar_visible ? @sidebar_action : @primary_action
+        end
+
+        class << self
+          # Factory methods for common conditional navigation
+          def up_or_sidebar
+            new(:scroll_up, :up)
+          end
+
+          def down_or_sidebar
+            new(:scroll_down, :down)
+          end
+
+          def select_or_sidebar
+            new(:next_page, :select) # Enter key: next page normally, select in sidebar
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/commands/menu_commands.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+
+module Shoko
+  module Application
+    module Commands
+      # Menu commands for top-level and browse screens
+      class MenuCommand < BaseCommand
+        SETTINGS_ACTIONS = %i[
+          back_to_menu
+          toggle_view_mode
+          cycle_line_spacing
+          toggle_page_numbering_mode
+          toggle_page_numbers
+          toggle_highlight_quotes
+          toggle_kitty_images
+          wipe_cache
+        ].freeze
+        SETTINGS_MAX_INDEX = SETTINGS_ACTIONS.length - 1
+        private_constant :SETTINGS_ACTIONS, :SETTINGS_MAX_INDEX
+
+        def initialize(action)
+          @action = action
+          super(name: "menu_#{action}", description: "Menu action #{action}")
+        end
+
+        def can_execute?(context, _params = {})
+          context.respond_to?(:state) && (context.respond_to?(:dependencies) || true)
+        end
+
+        protected
+
+        def perform(context, _params = {})
+          state = context.state
+          mmc = context.respond_to?(:main_menu_component) ? context.main_menu_component : nil
+          can_switch = context.respond_to?(:switch_to_mode)
+          case @action
+          when :menu_up then update_menu_index(context, :selected, -1, 0, 5)
+          when :menu_down then update_menu_index(context, :selected, +1, 0, 5)
+          when :menu_select then context.handle_menu_selection if context.respond_to?(:handle_menu_selection)
+          when :menu_quit then context.cleanup_and_exit(0, '') if context.respond_to?(:cleanup_and_exit)
+          when :back_to_menu then switch_mode(context, :menu, can_switch)
+          when :browse_up then browse_nav(context, -1)
+          when :browse_down then browse_nav(context, +1)
+          when :browse_select then context.open_selected_book if context.respond_to?(:open_selected_book)
+          when :library_up then context.library_up if context.respond_to?(:library_up)
+          when :library_down then context.library_down if context.respond_to?(:library_down)
+          when :library_select then context.library_select if context.respond_to?(:library_select)
+          when :settings_up then update_menu_index(context, :settings_selected, -1, 0, SETTINGS_MAX_INDEX)
+          when :settings_down then update_menu_index(context, :settings_selected, +1, 0, SETTINGS_MAX_INDEX)
+          when :settings_select then perform_settings_select(context, can_switch)
+          when :toggle_view_mode then context.toggle_view_mode if context.respond_to?(:toggle_view_mode)
+          when :cycle_line_spacing then context.cycle_line_spacing if context.respond_to?(:cycle_line_spacing)
+          when :toggle_page_numbers then context.toggle_page_numbers if context.respond_to?(:toggle_page_numbers)
+          when :toggle_page_numbering_mode
+            context.toggle_page_numbering_mode if context.respond_to?(:toggle_page_numbering_mode)
+          when :toggle_highlight_quotes
+            context.toggle_highlight_quotes if context.respond_to?(:toggle_highlight_quotes)
+          when :toggle_kitty_images
+            context.toggle_kitty_images if context.respond_to?(:toggle_kitty_images)
+          when :wipe_cache then context.wipe_cache if context.respond_to?(:wipe_cache)
+          when :start_search
+            if context.respond_to?(:switch_to_search)
+              context.switch_to_search
+            else
+              # Fallback: set mode/search_active via actions
+              state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(mode: :search,
+                                                                                search_active: true))
+            end
+            current = (state.get(%i[menu search_query]) || '').to_s
+            state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(search_cursor: current.length))
+          when :exit_search
+            if context.respond_to?(:switch_to_browse)
+              context.switch_to_browse
+            else
+              state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(mode: :browse,
+                                                                                search_active: false))
+            end
+          # recent_* actions removed
+          # Annotations list (menu) actions
+          when :annotations_up
+            mmc&.annotations_screen&.navigate(:up)
+          when :annotations_down
+            mmc&.annotations_screen&.navigate(:down)
+          when :annotations_select
+            if mmc
+              screen = mmc.annotations_screen
+              ann = screen.current_annotation
+              path = screen.current_book_path
+              if ann && path
+                state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(
+                                 selected_annotation: ann,
+                                 selected_annotation_book: path
+                               ))
+                switch_mode(context, :annotation_detail, can_switch)
+              end
+            end
+          when :annotations_edit, :annotation_detail_edit
+            context.open_selected_annotation_for_edit if context.respond_to?(:open_selected_annotation_for_edit)
+          when :annotations_delete, :annotation_detail_delete
+            delete_selected_annotation_if_available(context, can_switch)
+          # Annotation detail actions
+          when :annotation_detail_open
+            context.open_selected_annotation if context.respond_to?(:open_selected_annotation)
+          when :annotation_detail_back
+            switch_mode(context, :annotations, can_switch)
+          else
+            :pass
+          end
+        end
+
+        private
+
+        def switch_mode(context, mode, can_switch)
+          context.switch_to_mode(mode) if can_switch
+        end
+
+        def delete_selected_annotation_if_available(context, can_switch)
+          return unless context.respond_to?(:delete_selected_annotation)
+
+          context.delete_selected_annotation
+          switch_mode(context, :annotations, can_switch)
+        end
+
+        def update_menu_index(context, field, delta, min_idx, max_idx)
+          state = context.state
+          current = state.get([:menu, field]) || 0
+          new_val = (current + delta).clamp(min_idx, max_idx)
+          state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(field => new_val))
+          new_val
+        end
+
+        def perform_settings_select(context, can_switch)
+          state = context.state
+          index = state.get(%i[menu settings_selected]) || 0
+          action = SETTINGS_ACTIONS[index]
+          return unless action
+
+          if action == :back_to_menu
+            switch_mode(context, :menu, can_switch)
+            return
+          end
+
+          context.public_send(action) if context.respond_to?(action)
+        end
+
+        def browse_nav(context, delta)
+          state = context.state
+          # Prefer component's filtered list length; fall back to public accessor
+          mmc = context.respond_to?(:main_menu_component) ? context.main_menu_component : nil
+          max_idx = if mmc.respond_to?(:browse_screen)
+                      cnt = mmc.browse_screen.filtered_count
+                      [(cnt || 0) - 1, 0].max
+                    else
+                      epubs = (context.respond_to?(:filtered_epubs) && context.filtered_epubs) || []
+                      [epubs.length - 1, 0].max
+                    end
+
+          current = state.get(%i[menu browse_selected]) || 0
+          new_val = (current + delta).clamp(0, max_idx)
+          state.dispatch(Shoko::Application::Actions::UpdateMenuAction.new(browse_selected: new_val))
+          new_val
+        end
+
+        # recent navigation removed
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/commands/navigation_commands.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+
+module Shoko
+  module Application
+    module Commands
+      # Navigation commands using proper domain services.
+      # Eliminates direct controller coupling and state manipulation.
+      class NavigationCommand < BaseCommand
+        def initialize(action, name: nil, description: nil)
+          @action = action
+          super(
+            name: name || "navigate_#{action}",
+            description: description || "Navigate #{humanize_action(action)}"
+          )
+        end
+
+        def validate_context(context)
+          super
+          return if context.respond_to?(:dependencies)
+
+          raise ValidationError.new('Context must provide dependencies', command_name: name)
+        end
+
+        def can_execute?(context, _params = {})
+          deps = context.dependencies
+          deps.registered?(:navigation_service) && deps.registered?(:state_store)
+        end
+
+        protected
+
+        def perform(context, _params = {})
+          deps = context.dependencies
+          navigation_service = deps.resolve(:navigation_service)
+          state_store = deps.resolve(:state_store)
+          current_chapter = current_chapter_from(state_store)
+
+          case @action
+          when :next_page
+            navigation_service.next_page
+          when :prev_page
+            navigation_service.prev_page
+          when :next_chapter
+            navigation_service.jump_to_chapter(current_chapter + 1)
+          when :prev_chapter
+            navigation_service.jump_to_chapter([current_chapter - 1, 0].max)
+          when :go_to_start
+            navigation_service.go_to_start
+          when :go_to_end
+            navigation_service.go_to_end
+          else
+            raise ExecutionError.new("Unknown navigation action: #{@action}", command_name: name)
+          end
+
+          @action
+        end
+
+        private
+
+        def humanize_action(action)
+          action.to_s.tr('_', ' ')
+        end
+
+        def current_chapter_from(state_store)
+          return 0 unless state_store.respond_to?(:current_state)
+
+          (state_store.current_state || {}).dig(:reader, :current_chapter) || 0
+        rescue StandardError
+          0
+        end
+      end
+
+      # Command that scrolls within the current chapter by a number of lines.
+      class ScrollCommand < BaseCommand
+        def initialize(direction, lines: 1, name: nil, description: nil)
+          @direction = direction
+          @lines = lines
+          super(
+            name: name || "scroll_#{direction}",
+            description: description || "Scroll #{direction} #{lines} line(s)"
+          )
+        end
+
+        def validate_parameters(params)
+          super
+
+          valid_directions = %i[up down]
+          unless valid_directions.include?(@direction)
+            raise ValidationError.new("Direction must be one of #{valid_directions}",
+                                      command_name: name)
+          end
+
+          return if @lines.is_a?(Integer) && @lines.positive?
+
+          raise ValidationError.new('Lines must be a positive integer', command_name: name)
+        end
+
+        protected
+
+        def perform(context, _params = {})
+          navigation_service = context.dependencies.resolve(:navigation_service)
+          navigation_service.scroll(@direction, @lines)
+
+          { direction: @direction, lines: @lines }
+        end
+      end
+
+      # Command that jumps to a specific chapter index.
+      class JumpToChapterCommand < BaseCommand
+        def initialize(chapter_index = nil, name: nil, description: nil)
+          @chapter_index = chapter_index
+          super(
+            name: name || 'jump_to_chapter',
+            description: description || 'Jump to specific chapter'
+          )
+        end
+
+        def validate_parameters(params)
+          super
+
+          # Chapter index can come from params or constructor
+          index = params[:chapter_index] || @chapter_index
+
+          return if index.is_a?(Integer) && index >= 0
+
+          raise ValidationError.new('Chapter index must be a non-negative integer',
+                                    command_name: name)
+        end
+
+        protected
+
+        def perform(context, params = {})
+          navigation_service = context.dependencies.resolve(:navigation_service)
+          index = params[:chapter_index] || @chapter_index
+
+          navigation_service.jump_to_chapter(index)
+
+          { chapter_index: index }
+        end
+      end
+
+      # Factory methods for common navigation commands
+      module NavigationCommandFactory
+        def self.next_page
+          NavigationCommand.new(:next_page)
+        end
+
+        def self.prev_page
+          NavigationCommand.new(:prev_page)
+        end
+
+        def self.next_chapter
+          NavigationCommand.new(:next_chapter)
+        end
+
+        def self.prev_chapter
+          NavigationCommand.new(:prev_chapter)
+        end
+
+        def self.go_to_start
+          NavigationCommand.new(:go_to_start)
+        end
+
+        def self.go_to_end
+          NavigationCommand.new(:go_to_end)
+        end
+
+        def self.scroll_up(lines = 1)
+          ScrollCommand.new(:up, lines: lines)
+        end
+
+        def self.scroll_down(lines = 1)
+          ScrollCommand.new(:down, lines: lines)
+        end
+
+        def self.jump_to_chapter(index)
+          JumpToChapterCommand.new(index)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/commands/reader_commands.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+
+module Shoko
+  module Application
+    module Commands
+      # Handles reader mode transitions (help) via domain command flow.
+      class ReaderModeCommand < BaseCommand
+        def initialize(action)
+          @action = action
+          super(name: "reader_mode_#{action}", description: "Reader mode action #{action}")
+        end
+
+        protected
+
+        def perform(context, _params = {})
+          ui_controller = resolve_ui_controller(context)
+          return :pass unless ui_controller
+
+          case @action
+          when :exit_help
+            ui_controller.switch_mode(:read)
+          else
+            raise ExecutionError.new("Unknown reader mode action: #{@action}", command_name: name)
+          end
+        end
+
+        private
+
+        def resolve_ui_controller(context)
+          if context.respond_to?(:dependencies)
+            begin
+              deps = context.dependencies
+              return deps.resolve(:ui_controller) if deps.respond_to?(:resolve)
+            rescue StandardError
+              # fall through
+            end
+          end
+
+          context.respond_to?(:ui_controller) ? context.ui_controller : nil
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/commands/sidebar_commands.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+
+module Shoko
+  module Application
+    module Commands
+      # Commands for sidebar navigation and interaction
+      class SidebarCommand < BaseCommand
+        def initialize(action, name: nil, description: nil)
+          @action = action
+          super(
+            name: name || "sidebar_#{action}",
+            description: description || "Sidebar #{action.to_s.tr('_', ' ')}"
+          )
+        end
+
+        protected
+
+        def perform(context, _params = {})
+          # Get UI controller through dependency injection
+          ui_controller = context.dependencies.resolve(:ui_controller)
+
+          case @action
+          when :up
+            ui_controller.sidebar_up
+          when :down
+            ui_controller.sidebar_down
+          when :select
+            ui_controller.sidebar_select
+          else
+            raise ExecutionError.new("Unknown sidebar action: #{@action}", command_name: name)
+          end
+
+          @action
+        end
+
+        class << self
+          # Factory methods for common sidebar commands
+          def up
+            new(:up)
+          end
+
+          def down
+            new(:down)
+          end
+
+          def select
+            new(:select)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/application/use_cases/settings_service.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative '../../core/services/base_service.rb'
+require_relative '../../adapters/storage/cache_paths'
+require_relative '../../adapters/storage/recent_files'
+require_relative '../state/actions/update_config_action.rb'
+require_relative '../selectors/config_selectors'
+
+module Shoko
+  module Application::UseCases
+      # Centralises configuration toggles and cache maintenance for menu settings flows.
+      class SettingsService < BaseService
+        WIPE_CACHE_MESSAGE = "All caches wiped. Use 'Find Book' to rescan"
+
+        def initialize(dependencies)
+          super
+          @state_store = resolve(:state_store)
+          @terminal_service = resolve(:terminal_service)
+          @wrapping_service = resolve(:wrapping_service) if registered?(:wrapping_service)
+          @recent_repository = Adapters::Storage::RecentFiles
+        end
+
+        # Toggle split/single view mode and persist the change.
+        def toggle_view_mode
+          current = Shoko::Application::Selectors::ConfigSelectors.view_mode(@state_store) || :split
+          new_mode = current == :split ? :single : :split
+          dispatch_config(view_mode: new_mode)
+          new_mode
+        end
+
+        # Toggle whether page numbers are displayed.
+        def toggle_page_numbers
+          current = Shoko::Application::Selectors::ConfigSelectors.show_page_numbers(@state_store)
+          dispatch_config(show_page_numbers: !current)
+        end
+
+        # Cycle through line spacing options (compact → normal → relaxed → ...).
+        def cycle_line_spacing
+          modes = Shoko::Core::Models::ReaderSettings::LINE_SPACING_VALUES
+          current = Shoko::Application::Selectors::ConfigSelectors.line_spacing(@state_store) || Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+          next_mode = modes[(modes.index(current) || 1) + 1] || modes.first
+          dispatch_config(line_spacing: next_mode)
+          next_mode
+        end
+
+        # Toggle quote highlighting preference.
+        def toggle_highlight_quotes
+          current = Shoko::Application::Selectors::ConfigSelectors.highlight_quotes(@state_store)
+          dispatch_config(highlight_quotes: !current)
+        end
+
+        def toggle_kitty_images
+          current = Shoko::Application::Selectors::ConfigSelectors.kitty_images(@state_store)
+          dispatch_config(kitty_images: !current)
+        end
+
+        # Toggle dynamic/absolute page numbering mode.
+        def toggle_page_numbering_mode
+          current = Shoko::Application::Selectors::ConfigSelectors.page_numbering_mode(@state_store) || :dynamic
+          next_mode = current == :absolute ? :dynamic : :absolute
+          dispatch_config(page_numbering_mode: next_mode)
+          next_mode
+        end
+
+        # Wipe cached EPUB data, recent file history, and wrapping caches.
+        # Returns the status message applied to the catalog.
+        def wipe_cache(catalog: nil)
+          Shoko::Adapters::BookSources::EPUBFinder.clear_cache
+          remove_epub_cache_on_disk
+          @recent_repository.clear
+          @wrapping_service&.clear_cache
+
+          target_catalog = catalog || resolve(:catalog_service)
+          if target_catalog
+            target_catalog.update_entries([])
+            target_catalog.scan_status = :idle
+            target_catalog.scan_message = WIPE_CACHE_MESSAGE
+          end
+
+          WIPE_CACHE_MESSAGE
+        end
+
+        private
+
+        def required_dependencies
+          %i[state_store terminal_service]
+        end
+
+        def dispatch_config(payload)
+          @state_store.dispatch(Shoko::Application::Actions::UpdateConfigAction.new(payload))
+          @state_store.save_config if @state_store.respond_to?(:save_config)
+        end
+
+        def remove_epub_cache_on_disk
+          cache_root = Adapters::Storage::CachePaths.cache_root
+          return unless cache_root && File.directory?(cache_root)
+
+          cache_real = safe_realpath(cache_root)
+          return unless cache_real
+
+          FileUtils.rm_rf(cache_real)
+        rescue StandardError
+          nil
+        end
+
+        def safe_realpath(path)
+          root_real = File.realpath(File.dirname(path))
+          cache_real = File.realpath(path)
+          return cache_real if cache_real.start_with?(root_real) && allowed_cache_dir?(File.basename(cache_real))
+
+          nil
+        rescue StandardError
+          allowed_cache_dir?(File.basename(path)) ? path : nil
+        end
+
+        def allowed_cache_dir?(name)
+          %w[shoko reader].include?(name)
+        end
+      end
+  end
+end