shoko 0.1.3 → 0.1.5

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

@@ -1,30 +1,33 @@
 # 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
+  module Application
+    module UseCases
       # Centralises configuration toggles and cache maintenance for menu settings flows.
-      class SettingsService < BaseService
+      class SettingsService
         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
+        def initialize(config_reader:, state_writer:, cache_manager:, dictionary_availability:,
+                       dictionary_storage:, data_cleanup:,
+                       wrapping_service: nil, recent_files_repository: nil, dictionary_service: nil,
+                       catalog_service: nil, config_storage: nil, logger: nil)
+          @config_reader = config_reader
+          @state_writer = state_writer
+          @cache_manager = cache_manager
+          @dictionary_availability = dictionary_availability
+          @dictionary_storage = dictionary_storage
+          @data_cleanup = data_cleanup
+          @wrapping_service = wrapping_service
+          @recent_repository = recent_files_repository
+          @dictionary_service = dictionary_service
+          @catalog_service_ref = catalog_service
+          @config_storage = config_storage
+          @logger = logger
         end
 
         # Toggle split/single view mode and persist the change.
         def toggle_view_mode
-          current = Shoko::Application::Selectors::ConfigSelectors.view_mode(@state_store) || :split
+          current = @config_reader.view_mode || :single
           new_mode = current == :split ? :single : :split
           dispatch_config(view_mode: new_mode)
           new_mode
@@ -32,14 +35,14 @@ module Shoko
 
         # Toggle whether page numbers are displayed.
         def toggle_page_numbers
-          current = Shoko::Application::Selectors::ConfigSelectors.show_page_numbers(@state_store)
+          current = @config_reader.show_page_numbers
           dispatch_config(show_page_numbers: !current)
         end
 
-        # Cycle through line spacing options (compact → normal → relaxed → ...).
+        # 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
+          current = @config_reader.line_spacing || 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
@@ -47,77 +50,192 @@ module Shoko
 
         # Toggle quote highlighting preference.
         def toggle_highlight_quotes
-          current = Shoko::Application::Selectors::ConfigSelectors.highlight_quotes(@state_store)
+          current = @config_reader.highlight_quotes
           dispatch_config(highlight_quotes: !current)
         end
 
+        def toggle_dictionary_backend
+          current = @config_reader.dictionary_backend
+          backend_name = current.to_s.downcase
+          auto_enabled = backend_name.empty? && dictionary_auto_available?
+          new_backend = case backend_name
+                        when 'sqlite'
+                          :disabled
+                        when 'disabled'
+                          :sqlite
+                        else
+                          auto_enabled ? :disabled : :sqlite
+                        end
+          dispatch_config(dictionary_backend: new_backend)
+          new_backend
+        end
+
+        def cycle_dictionary_pair
+          pairs = available_dictionary_pairs
+          source = @config_reader.dictionary_source_lang
+          target = @config_reader.dictionary_target_lang
+
+          auto = dictionary_auto_setting?(source)
+          indexed_pairs = pairs.map { |pair| [pair[:source], pair[:target]] }
+          current_index = auto ? -1 : indexed_pairs.index([source, target]) || -1
+          next_index = (current_index + 1) % (indexed_pairs.length + 1)
+
+          if next_index.zero?
+            dispatch_config(dictionary_source_lang: 'auto')
+            { source: 'auto', target: target }
+          else
+            next_pair = indexed_pairs[next_index - 1]
+            dispatch_config(dictionary_source_lang: next_pair[0], dictionary_target_lang: next_pair[1])
+            { source: next_pair[0], target: next_pair[1] }
+          end
+        end
+
         def toggle_kitty_images
-          current = Shoko::Application::Selectors::ConfigSelectors.kitty_images(@state_store)
+          current = @config_reader.kitty_images
           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
+          current = @config_reader.page_numbering_mode || :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.
+        # Wipe selected cached data and/or downloaded books.
         # 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
+        def wipe_cache(catalog: nil, cached: nil, downloads: nil, nuke: nil,
+                       annotations: nil, bookmarks: nil, progress: nil, config_file: nil)
+          cached = cached.nil? ? true : !!cached
+          downloads = !!downloads
+          nuke = !!nuke
+          dictionary = false
+          annotations = !!annotations
+          bookmarks = !!bookmarks
+          progress = !!progress
+          config_file = !!config_file
+
+          if nuke
+            cached = true
+            downloads = true
+            dictionary = true
+            annotations = true
+            bookmarks = true
+            progress = true
+            config_file = true
+          end
 
-          target_catalog = catalog || resolve(:catalog_service)
+          wipe_cached_data if cached
+          remove_downloads_on_disk if downloads
+          remove_dictionary_databases if dictionary
+          remove_user_data_files(annotations: annotations, bookmarks: bookmarks,
+                                 progress: progress, config_file: config_file)
+
+          target_catalog = catalog || @catalog_service_ref
           if target_catalog
-            target_catalog.update_entries([])
-            target_catalog.scan_status = :idle
-            target_catalog.scan_message = WIPE_CACHE_MESSAGE
+            target_catalog.reset_after_wipe(
+              message: wipe_cache_message(cached: cached, downloads: downloads, nuke: nuke,
+                                          annotations: annotations, bookmarks: bookmarks,
+                                          progress: progress, config_file: config_file)
+            )
           end
 
-          WIPE_CACHE_MESSAGE
+          wipe_cache_message(cached: cached, downloads: downloads, nuke: nuke,
+                             annotations: annotations, bookmarks: bookmarks,
+                             progress: progress, config_file: config_file)
         end
 
         private
 
-        def required_dependencies
-          %i[state_store terminal_service]
+        def dispatch_config(**payload)
+          @state_writer.update_config(**payload)
+        end
+
+        def available_dictionary_pairs
+          pairs = @dictionary_service&.available_language_pairs || []
+          pairs.filter_map do |pair|
+            normalized = normalize_language_pair(pair)
+            source = normalized[:source].to_s.strip
+            target = normalized[:target].to_s.strip
+            next if source.empty? || target.empty?
+
+            { source: source, target: target }
+          end.uniq.sort_by { |pair| [pair[:source].to_s, pair[:target].to_s] }
+        end
+
+        def dictionary_auto_setting?(value)
+          return true if value.nil?
+
+          str = value.to_s.strip
+          str.empty? || str.casecmp('auto').zero?
         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)
+        def dictionary_auto_available?
+          return false unless @dictionary_availability&.sqlite3_available?
+
+          @dictionary_storage&.databases_present?(@config_reader.dictionary_path)
         end
 
         def remove_epub_cache_on_disk
-          cache_root = Adapters::Storage::CachePaths.cache_root
-          return unless cache_root && File.directory?(cache_root)
+          @data_cleanup&.remove_cache_root(@cache_manager.cache_root)
+        end
+
+        def remove_downloads_on_disk
+          @data_cleanup&.remove_downloads_root(configured_config_root)
+        end
+
+        def remove_dictionary_databases
+          @dictionary_storage&.remove_databases_path(@config_reader.dictionary_path)
+        end
+
+        def wipe_cached_data
+          @cache_manager.clear_epub_cache
+          remove_epub_cache_on_disk
+          @recent_repository&.clear
+          @wrapping_service&.clear_cache
+        end
+
+        def wipe_cache_message(cached:, downloads:, nuke:, annotations:, bookmarks:, progress:, config_file:)
+          return "All data wiped. Use 'Find Book' to rescan" if nuke
 
-          cache_real = safe_realpath(cache_root)
-          return unless cache_real
+          data = annotations || bookmarks || progress || config_file
+          return "Caches + downloads + data wiped. Use 'Find Book' to rescan" if cached && downloads && data
+          return "Caches + downloads wiped. Use 'Find Book' to rescan" if cached && downloads
+          return "Caches + data wiped. Use 'Find Book' to rescan" if cached && data
+          return "Downloads + data wiped. Use 'Find Book' to rescan" if downloads && data
+          return WIPE_CACHE_MESSAGE if cached
+          return "Downloads deleted. Use 'Find Book' to rescan" if downloads
+          return 'User data wiped.' if data
 
-          FileUtils.rm_rf(cache_real)
-        rescue StandardError
-          nil
+          'Nothing selected to wipe'
         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))
+        def remove_user_data_files(annotations:, bookmarks:, progress:, config_file:)
+          @data_cleanup&.remove_user_data_files(
+            config_root: configured_config_root,
+            annotations: annotations,
+            bookmarks: bookmarks,
+            progress: progress,
+            config_file: config_file
+          )
+        end
 
-          nil
-        rescue StandardError
-          allowed_cache_dir?(File.basename(path)) ? path : nil
+        def configured_config_root
+          @config_storage&.config_dir
         end
 
-        def allowed_cache_dir?(name)
-          %w[shoko reader].include?(name)
+        def normalize_language_pair(pair)
+          unless pair.is_a?(Hash)
+            raise ArgumentError, "dictionary language pair must be a Hash, got #{pair.class}"
+          end
+
+          pair.each_with_object({}) do |(key, value), acc|
+            normalized_key = key.is_a?(String) ? key.to_sym : key
+            acc[normalized_key] = value
+          end
         end
       end
+    end
   end
 end

data/lib/shoko/application/workflows/cli/folder_import_workflow.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/folder_scanner'
+require_relative '../../../core/ports/outbound/folder_importer'
+require_relative '../../../core/ports/outbound/clock'
+require_relative '../../../core/ports/outbound/path_ops'
+
+module Shoko
+  module Application
+    module Workflows
+      module Cli
+        # Coordinates directory discovery and batch cache imports for CLI usage.
+        class FolderImportWorkflow
+          GROUP_ORDER = %i[epub pdf fb2 kindle rtf].freeze
+
+          DocumentCandidate = Shoko::Core::Ports::Outbound::FolderScanner::Entry
+          DiscoveryReport = Data.define(:directory_path, :documents, :counts_by_group, :total_count)
+          ImportFailure = Data.define(:path, :error_class, :error_message)
+          ImportReport = Data.define(:total_count, :imported_count, :skipped_count, :failed_count, :failures,
+                                     :elapsed_seconds)
+
+          def initialize(scanner:, importer:, clock:, path_ops:, logger: nil)
+            unless scanner.is_a?(Shoko::Core::Ports::Outbound::FolderScanner)
+              raise ArgumentError, 'scanner must implement Core::Ports::Outbound::FolderScanner'
+            end
+            unless importer.is_a?(Shoko::Core::Ports::Outbound::FolderImporter)
+              raise ArgumentError, 'importer must implement Core::Ports::Outbound::FolderImporter'
+            end
+            unless clock.is_a?(Shoko::Core::Ports::Outbound::Clock)
+              raise ArgumentError, 'clock must implement Core::Ports::Outbound::Clock'
+            end
+            unless path_ops.is_a?(Shoko::Core::Ports::Outbound::PathOps)
+              raise ArgumentError, 'path_ops must implement Core::Ports::Outbound::PathOps'
+            end
+
+            @scanner = scanner
+            @importer = importer
+            @clock = clock
+            @path_ops = path_ops
+            @logger = logger
+          end
+
+          def discover(directory_path, recursive: true, skip_hidden: true)
+            root = @path_ops.expand_path(directory_path.to_s)
+            raw_documents = Array(@scanner.scan(root, recursive: recursive, skip_hidden: skip_hidden))
+            documents = raw_documents.map { |entry| normalize_candidate(entry) }
+                                   .sort_by { |entry| entry.path.to_s.downcase }
+
+            counts = default_counts
+            documents.each do |document|
+              group = normalize_group(document.format_group)
+              counts[group] ||= 0
+              counts[group] += 1
+            end
+
+            DiscoveryReport.new(
+              directory_path: root,
+              documents: documents,
+              counts_by_group: counts,
+              total_count: documents.length
+            )
+          end
+
+          def import(documents)
+            selected = Array(documents).map { |entry| normalize_candidate(entry) }
+            total = selected.length
+            imported_count = 0
+            skipped_count = 0
+            started_at = monotonic_now
+
+            selected.each_with_index do |document, index|
+              path = document.path
+
+              status = normalize_import_status(@importer.import(path))
+              if status == :skipped
+                skipped_count += 1
+              else
+                imported_count += 1
+              end
+              yield(done: index + 1, total: total, path: path, status: status) if block_given?
+            end
+
+            ImportReport.new(
+              total_count: total,
+              imported_count: imported_count,
+              skipped_count: skipped_count,
+              failed_count: 0,
+              failures: [],
+              elapsed_seconds: monotonic_now - started_at
+            )
+          end
+
+          private
+
+          def normalize_candidate(entry)
+            unless entry.is_a?(DocumentCandidate)
+              raise ArgumentError, "Expected #{DocumentCandidate}, got #{entry.class}"
+            end
+
+            path = entry.path
+            if path.to_s.strip.empty?
+              raise ArgumentError, 'candidate path cannot be blank'
+            end
+
+            extension = normalize_extension(entry.format_extension, path)
+            group = normalize_group(entry.format_group || group_for_extension(extension))
+
+            DocumentCandidate.new(
+              path: path,
+              format_group: group,
+              format_extension: extension || ''
+            )
+          end
+
+          def group_for_extension(extension)
+            case extension.to_s.downcase
+            when '.epub' then :epub
+            when '.pdf' then :pdf
+            when '.fb2', '.fb2.zip' then :fb2
+            when '.mobi', '.azw', '.azw3' then :kindle
+            when '.rtf' then :rtf
+            else
+              nil
+            end
+          end
+
+          def normalize_group(group)
+            value = group.to_s.strip.downcase
+            return :unknown if value.empty?
+
+            value.tr('-', '_').to_sym
+          end
+
+          def normalize_extension(extension, path)
+            value = extension.to_s.strip.downcase
+            return value unless value.empty?
+
+            basename = @path_ops.basename(path.to_s).downcase
+            return '.fb2.zip' if basename.end_with?('.fb2.zip')
+
+            @path_ops.extname(path.to_s).downcase
+          end
+
+          def normalize_import_status(result)
+            case result
+            when :imported, :skipped
+              result
+            else
+              raise ArgumentError, "Invalid folder import status: #{result.inspect}"
+            end
+          end
+
+          def default_counts
+            GROUP_ORDER.each_with_object({}) { |group, acc| acc[group] = 0 }
+          end
+
+          def monotonic_now
+            @clock.monotonic_now.to_f
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/menu_mode_switcher'
+require_relative '../../../core/ports/outbound/annotation_selection_reader'
+require_relative '../../../core/ports/outbound/annotation_view_refresher'
+require_relative '../../../core/ports/outbound/reader_runner'
+require_relative '../../../core/ports/outbound/menu_workflow_state_reader'
+require_relative '../../../core/ports/outbound/menu_workflow_state_writer'
+require_relative '../../../core/models/annotation_selection'
+require_relative '../../../core/models/pending_jump_payload'
+
+module Shoko
+  module Application
+    module Workflows
+      module Menu
+        class AnnotationWorkflow
+          def initialize(mode_switcher:, menu_state_reader:, menu_state_writer:, state_writer:, annotation_service:,
+                         logger:, selected_annotation_reader:, annotations_view_refresher:, reader_runner:)
+            unless mode_switcher.is_a?(Shoko::Core::Ports::Outbound::MenuModeSwitcher)
+              raise ArgumentError, 'mode_switcher must implement Core::Ports::Outbound::MenuModeSwitcher'
+            end
+            unless selected_annotation_reader.is_a?(Shoko::Core::Ports::Outbound::AnnotationSelectionReader)
+              raise ArgumentError, 'selected_annotation_reader must implement Core::Ports::Outbound::AnnotationSelectionReader'
+            end
+            unless annotations_view_refresher.is_a?(Shoko::Core::Ports::Outbound::AnnotationViewRefresher)
+              raise ArgumentError, 'annotations_view_refresher must implement Core::Ports::Outbound::AnnotationViewRefresher'
+            end
+            unless reader_runner.is_a?(Shoko::Core::Ports::Outbound::ReaderRunner)
+              raise ArgumentError, 'reader_runner must implement Core::Ports::Outbound::ReaderRunner'
+            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 menu_state_writer.is_a?(Shoko::Core::Ports::Outbound::MenuWorkflowStateWriter)
+              raise ArgumentError, 'menu_state_writer must implement Core::Ports::Outbound::MenuWorkflowStateWriter'
+            end
+            raise ArgumentError, 'annotation_service is required' if annotation_service.nil?
+
+            @mode_switcher = mode_switcher
+            @menu_state_reader = menu_state_reader
+            @menu_state_writer = menu_state_writer
+            @state_writer = state_writer
+            @annotation_service = annotation_service
+            @logger = logger
+            @selected_annotation_reader = selected_annotation_reader
+            @annotations_view_refresher = annotations_view_refresher
+            @reader_runner = reader_runner
+          end
+
+          def open_selected_annotation
+            selection = selected_annotation
+            return unless selection
+
+            @state_writer.update_reader_meta(book_path: selection.book_path)
+            pending_payload = Shoko::Core::Models::PendingJumpPayload.new(
+              chapter_index: selection.chapter_index,
+              selection_range: selection.range,
+              annotation: selection,
+              edit: false
+            )
+            @state_writer.update_selections(pending_jump: pending_payload)
+
+            @reader_runner.run_reader(selection.book_path)
+          end
+
+          def open_selected_annotation_for_edit
+            selection = selected_annotation
+            return unless selection
+
+            note_text = selection.note.to_s
+            @menu_state_writer.set_annotation_state(
+              selected_annotation: selection.to_annotation_h,
+              selected_annotation_book: selection.book_path,
+              annotation_edit_text: note_text,
+              annotation_edit_cursor: note_text.length
+            )
+            @mode_switcher.switch_mode(:annotation_editor)
+          end
+
+          def delete_selected_annotation
+            selection = selected_annotation
+            return unless selection
+
+            ann_id = selection.id
+            return unless ann_id
+
+            @annotation_service.delete(selection.book_path, ann_id)
+            @menu_state_writer.set_annotation_state(annotations_all: @annotation_service.list_all)
+
+            @annotations_view_refresher.refresh_annotations_view
+          end
+
+          def save_current_annotation_edit
+            context = current_annotation_edit_context
+            return unless context
+
+            @annotation_service.update(context[:path], context[:id], context[:text])
+            @menu_state_writer.set_annotation_state(annotations_all: @annotation_service.list_all)
+
+            @mode_switcher.switch_mode(:annotations)
+            @annotations_view_refresher.refresh_annotations_view
+          end
+
+          private
+
+          def selected_annotation
+            @selected_annotation_reader.selected_annotation
+          end
+
+          def current_annotation_edit_context
+            annotation = @menu_state_reader.selected_annotation_record || {}
+            path = @menu_state_reader.selected_annotation_book_path
+            text = @menu_state_reader.annotation_editor_text
+            return unless path
+            unless annotation.is_a?(Hash)
+              raise ArgumentError, "selected_annotation_record must be Hash, got #{annotation.class}"
+            end
+
+            ann_id = if annotation.key?(:id)
+                       annotation[:id]
+                     elsif annotation.key?('id')
+                       raise ArgumentError, 'selected_annotation_record must use symbol keys'
+                     end
+            return unless ann_id
+
+            { path: path, id: ann_id, text: text }
+          end
+        end
+      end
+    end
+  end
+end