shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/book_sources/{epub_finder.rb → book_finder.rb}

@@ -2,36 +2,48 @@
 
 require 'fileutils'
 require 'json'
-require 'set'
 require 'time'
 require 'timeout'
 
-require_relative 'epub_finder/scanner_context'
-require_relative 'epub_finder/directory_scanner'
-require_relative '../storage/atomic_file_writer.rb'
-require_relative '../storage/config_paths.rb'
-
+require_relative 'book_finder/scanner_context'
+require_relative 'book_finder/directory_scanner'
 module Shoko
-  module Adapters::BookSources
-    # EPUB file finder with robust error handling
-    class EPUBFinder
-      SCAN_TIMEOUT = 20
-      MAX_DEPTH = 3
-      MAX_FILES = 500
-      CACHE_DURATION = 86_400
-      CONFIG_DIR = Adapters::Storage::ConfigPaths.config_root
-      CACHE_FILE = File.join(CONFIG_DIR, 'epub_cache.json')
-      DEBUG_MODE = ARGV.include?('--debug') || ENV['DEBUG']
-      SKIP_DIRS = %w[
-        node_modules vendor cache tmp temp .git .svn
-        __pycache__ build dist bin obj debug release
-        .idea .vscode .atom .sublime library frameworks
-        applications system windows programdata appdata
-        .Trash .npm .gem .bundle .cargo .rustup .cache
-        .local .config backup backups old archive
-      ].freeze
-
-      class << self
+  module Adapters
+    module BookSources
+      # Book file finder with robust error handling
+      class BookFinder
+        SCAN_TIMEOUT = 30
+        MAX_DEPTH = 5
+        MAX_FILES = 2000
+        CACHE_DURATION = 86_400
+        SKIP_DIRS = %w[
+          node_modules vendor cache tmp temp .git .svn
+          __pycache__ build dist bin obj debug release
+          .idea .vscode .atom .sublime frameworks
+          applications system windows programdata appdata
+          .Trash .npm .gem .bundle .cargo .rustup .cache
+          .local .config
+        ].freeze
+
+        DEBUG_MODE = false
+
+        def initialize(cache_writer:, config_root:, logger: nil)
+          @cache_writer = cache_writer
+          @config_root = config_root
+          @logger = logger
+        end
+
+        def config_dir
+          root = @config_root.to_s
+          raise Shoko::ConfigurationError, 'BookFinder requires config_root' if root.empty?
+
+          root
+        end
+
+        def cache_file
+          File.join(config_dir, 'epub_cache.json')
+        end
+
         def scan_system(force_refresh: false)
           cache = load_cache
           return cache['files'] if !force_refresh && cache_valid?(cache)
@@ -40,9 +52,9 @@ module Shoko
         end
 
         def clear_cache
-          FileUtils.rm_f(CACHE_FILE)
-        rescue StandardError
-          nil
+          FileUtils.rm_f(cache_file)
+        rescue Shoko::Error
+          raise
         end
 
         private
@@ -66,9 +78,9 @@ module Shoko
           ts = timestamp.to_s.strip
           return true if ts.empty?
 
-          Time.now - Time.parse(ts) >= CACHE_DURATION
-        rescue StandardError
-          true
+          Time.now - Time.iso8601(ts) >= CACHE_DURATION
+        rescue ArgumentError => e
+          raise Shoko::FatalExternalInputError.new("Malformed cache timestamp: #{e.message}", source: :book_finder_cache)
         end
 
         def scan_with_timeout
@@ -76,7 +88,7 @@ module Shoko
           epubs = perform_scan_with_timeout
         rescue Timeout::Error
           handle_timeout_error(epubs)
-        rescue StandardError
+        rescue Shoko::Error
           epubs = cached_files_fallback
         ensure
           save_and_return_epubs(epubs)
@@ -109,7 +121,7 @@ module Shoko
             depth: 0
           )
 
-          scanner = DirectoryScanner.new(context)
+          scanner = DirectoryScanner.new(context, config_root: config_dir)
           scanner.scan_all_directories
 
           warn_debug "Found #{epubs.length} EPUB files"
@@ -117,12 +129,12 @@ module Shoko
         end
 
         def load_cache
-          return nil unless File.exist?(CACHE_FILE)
+          return nil unless File.exist?(cache_file)
 
-          parse_cache_file(CACHE_FILE)
-        rescue StandardError => e
+          parse_cache_file(cache_file)
+        rescue Shoko::Error => e
           warn_debug "Cache load error: #{e.message}"
-          delete_cache_file(CACHE_FILE)
+          delete_cache_file(cache_file)
           nil
         end
 
@@ -134,26 +146,30 @@ module Shoko
 
         def delete_cache_file(path)
           File.delete(path)
-        rescue StandardError
-          nil
+        rescue Shoko::Error
+          raise
         end
 
         def save_cache(files)
-          FileUtils.mkdir_p(File.dirname(CACHE_FILE))
+          FileUtils.mkdir_p(File.dirname(cache_file))
           payload = JSON.pretty_generate({
                                            'timestamp' => Time.now.iso8601,
                                            'files' => files || [],
                                            'version' => VERSION,
                                          })
-          Adapters::Storage::AtomicFileWriter.write(CACHE_FILE, payload)
-        rescue StandardError => e
+          raise Shoko::ConfigurationError, 'BookFinder requires cache_writer' unless @cache_writer
+
+          @cache_writer.write(cache_file, payload)
+        rescue Shoko::Error => e
           warn_debug "Cache save error: #{e.message}"
         end
 
-        def debug? = !!DEBUG_MODE
-
         def warn_debug(msg)
-          warn msg if debug?
+          return unless DEBUG_MODE
+
+          @logger&.debug('book_finder.debug', message: msg)
+        rescue Shoko::Error
+          warn msg
         end
       end
     end

data/lib/shoko/adapters/book_sources/cache_import_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/folder_importer'
+require_relative '../../core/ports/outbound/document_loader'
+
+module Shoko
+  module Adapters
+    module BookSources
+      # Imports a document into cache through the existing document service pipeline.
+      class CacheImportAdapter
+        include Shoko::Core::Ports::Outbound::FolderImporter
+
+        def initialize(document_loader:)
+          unless document_loader.is_a?(Shoko::Core::Ports::Outbound::DocumentLoader)
+            raise ArgumentError, 'document_loader must implement Core::Ports::Outbound::DocumentLoader'
+          end
+
+          @document_loader = document_loader
+        end
+
+        def import(path)
+          document = @document_loader.load(path: path, progress_reporter: nil, background_worker: nil)
+          raise Shoko::MalformedBookInputError, "document import returned nil for #{path}" unless document
+
+          document.cached? ? :skipped : :imported
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/document_loader_adapter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/document_loader'
+require_relative '../../core/ports/outbound/reader_launch_state'
+require_relative '../../core/ports/outbound/runtime_config'
+require_relative '../../core/ports/outbound/line_wrapper'
+require_relative '../../core/ports/outbound/chapter_formatter'
+require_relative '../../core/ports/outbound/logging'
+require_relative '../../core/ports/outbound/book_cache_pipeline_factory'
+require_relative 'document_service'
+
+module Shoko
+  module Adapters
+    module BookSources
+      # Adapter that builds a document service and returns loaded documents.
+      class DocumentLoaderAdapter
+        include Shoko::Core::Ports::Outbound::DocumentLoader
+
+        def initialize(wrapping_service:, formatting_service:, reader_launch_state:, instrumentation:,
+                       runtime_config:, logger:, book_cache_pipeline_factory:)
+          unless wrapping_service.is_a?(Shoko::Core::Ports::Outbound::LineWrapper)
+            raise ArgumentError, 'wrapping_service must implement Core::Ports::Outbound::LineWrapper'
+          end
+          unless formatting_service.is_a?(Shoko::Core::Ports::Outbound::ChapterFormatter)
+            raise ArgumentError, 'formatting_service must implement Core::Ports::Outbound::ChapterFormatter'
+          end
+          unless reader_launch_state.is_a?(Shoko::Core::Ports::Outbound::ReaderLaunchState)
+            raise ArgumentError, 'reader_launch_state must implement Core::Ports::Outbound::ReaderLaunchState'
+          end
+          unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+            raise ArgumentError, 'runtime_config must implement Core::Ports::Outbound::RuntimeConfig'
+          end
+          unless logger.is_a?(Shoko::Core::Ports::Outbound::Logging)
+            raise ArgumentError, 'logger must implement Core::Ports::Outbound::Logging'
+          end
+          unless book_cache_pipeline_factory.is_a?(Shoko::Core::Ports::Outbound::BookCachePipelineFactory)
+            raise ArgumentError, 'book_cache_pipeline_factory must implement Core::Ports::Outbound::BookCachePipelineFactory'
+          end
+
+          @wrapping_service = wrapping_service
+          @formatting_service = formatting_service
+          @reader_launch_state = reader_launch_state
+          @instrumentation = instrumentation
+          @runtime_config = runtime_config
+          @logger = logger
+          @book_cache_pipeline_factory = book_cache_pipeline_factory
+        end
+
+        def load(path:, progress_reporter: nil, background_worker: nil)
+          worker = background_worker || @reader_launch_state.background_worker
+          book_cache_pipeline = @book_cache_pipeline_factory.build(
+            progress_reporter: progress_reporter,
+            runtime_config: @runtime_config,
+            logger: @logger
+          )
+
+          document_service = Shoko::Adapters::BookSources::DocumentService.new(
+            path,
+            @wrapping_service,
+            formatting_service: @formatting_service,
+            background_worker: worker,
+            progress_reporter: progress_reporter,
+            logger: @logger,
+            instrumentation: @instrumentation,
+            book_cache_pipeline: book_cache_pipeline
+          )
+          document_service.load_document
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/document_service.rb

@@ -1,200 +1,164 @@
 # frozen_string_literal: true
 
-require_relative '../monitoring/performance_monitor.rb'
-require_relative 'epub_document'
+require_relative 'book_document'
 
 module Shoko
-  module Adapters::BookSources
-    # Document service for loading and accessing EPUB content.
-    # Provides clean interface to document operations without coupling to controllers.
-    class DocumentService
-      def initialize(epub_path, wrapping_service = nil, formatting_service: nil, background_worker: nil,
-                     progress_reporter: nil)
-        @epub_path = epub_path
-        @document = nil
-        @content_cache = {}
-        @wrapping_service = wrapping_service
-        @formatting_service = formatting_service
-        @background_worker = background_worker
-        @progress_reporter = progress_reporter
-      end
+  module Adapters
+    module BookSources
+      # Document service for loading and accessing ebook content.
+      # Provides clean interface to document operations without coupling to controllers.
+      class DocumentService
+        # @param book_path [String] Path to ebook file
+        # @param wrapping_service [Object, nil] Wrapping service
+        # @param formatting_service [Object, nil] Formatting service
+        # @param background_worker [Object, nil] Background worker
+        # @param progress_reporter [Object, nil] Progress reporter
+        # @param logger [Core::Ports::Outbound::Logging] Logger adapter (required)
+        def initialize(book_path, wrapping_service, logger:, formatting_service: nil, background_worker: nil,
+                       progress_reporter: nil, instrumentation: nil, book_cache_pipeline:)
+          raise ArgumentError, 'wrapping_service is required' if wrapping_service.nil?
+          raise ArgumentError, 'book_cache_pipeline is required' if book_cache_pipeline.nil?
+
+          @book_path = book_path
+          @document = nil
+          @content_cache = {}
+          @wrapping_service = wrapping_service
+          @formatting_service = formatting_service
+          @background_worker = background_worker
+          @progress_reporter = progress_reporter
+          @logger = logger
+          @instrumentation = instrumentation
+          @book_cache_pipeline = book_cache_pipeline
+        end
 
-      # Load the EPUB document
-      #
-      # @return [EPUBDocument] Loaded document
-      def load_document
-        @document ||= Adapters::Monitoring::PerformanceMonitor.time('import.document.load') do
-          EPUBDocument.new(@epub_path,
-                           formatting_service: @formatting_service,
-                           background_worker: @background_worker,
-                           progress_reporter: @progress_reporter)
+        # Load the ebook document
+        #
+        # @return [BookDocument] Loaded document
+        def load_document
+          @document ||= instrument('import.document.load') do
+            BookDocument.new(@book_path,
+                             formatting_service: @formatting_service,
+                             background_worker: @background_worker,
+                             progress_reporter: @progress_reporter,
+                             logger: @logger,
+                             instrumentation: @instrumentation,
+                             book_cache: @book_cache_pipeline)
+          end
+        rescue Shoko::BookParseError => e
+          @logger.error('Failed to load document', path: @book_path, error: e.message)
+          raise e
+        rescue Shoko::Error => e
+          @logger.error('Failed to load document', path: @book_path, error: e.message)
+          raise Shoko::BookParseError.new(e.message, @book_path)
         end
-      rescue StandardError => e
-        Adapters::Monitoring::Logger.error('Failed to load document', path: @epub_path, error: e.message)
-        create_error_document(e.message)
-      end
 
-      # Get chapter by index
-      #
-      # @param index [Integer] Chapter index
-      # @return [Chapter] Chapter object or nil
-      def chapter_at(index)
-        return nil unless @document
+        # Get chapter by index
+        #
+        # @param index [Integer] Chapter index
+        # @return [Chapter] Chapter object or nil
+        def chapter_at(index)
+          return nil unless @document
 
-        @document.get_chapter(index)
-      end
-
-      # Get table of contents
-      #
-      # @return [Array<Hash>] Array of TOC entries
-      def get_table_of_contents
-        return [] unless @document
-
-        @document.chapters.map.with_index do |chapter, index|
-          {
-            index: index,
-            title: chapter.title || "Chapter #{index + 1}",
-            level: 0, # Could be enhanced to support nested TOC
-          }
+          @document.get_chapter(index)
         end
-      end
 
-      # Get content for specific page
-      #
-      # @param chapter_index [Integer] Chapter index
-      # @param page_offset [Integer] Page offset within chapter
-      # @param lines_per_page [Integer] Number of lines per page
-      # @return [Array<String>] Array of content lines
-      def get_page_content(chapter_index, page_offset, lines_per_page = 20)
-        cache_key = "#{chapter_index}_#{page_offset}_#{lines_per_page}"
-        cached_fetch(cache_key, default: []) do
-          with_chapter(chapter_index, default: []) do |chapter|
-            lines = chapter.lines || []
-            start_line = page_offset * lines_per_page
-            end_line = start_line + lines_per_page - 1
-            lines[start_line..end_line] || []
+        # Get content for specific page
+        #
+        # @param chapter_index [Integer] Chapter index
+        # @param page_offset [Integer] Page offset within chapter
+        # @param lines_per_page [Integer] Number of lines per page
+        # @return [Array<String>] Array of content lines
+        def get_page_content(chapter_index, page_offset, lines_per_page = 20)
+          cache_key = "#{chapter_index}_#{page_offset}_#{lines_per_page}"
+          cached_fetch(cache_key, default: []) do
+            with_chapter(chapter_index, default: []) do |chapter|
+              lines = chapter.lines || []
+              start_line = page_offset * lines_per_page
+              end_line = start_line + lines_per_page - 1
+              lines[start_line..end_line] || []
+            end
           end
         end
-      end
 
-      # Get wrapped content for specific page
-      #
-      # @param chapter_index [Integer] Chapter index
-      # @param page_offset [Integer] Page offset within chapter
-      # @param column_width [Integer] Column width for wrapping
-      # @param lines_per_page [Integer] Number of lines per page
-      # @return [Array<String>] Array of wrapped content lines
-      def get_wrapped_page_content(chapter_index, page_offset, column_width, lines_per_page = 20)
-        cache_key = "wrapped_#{chapter_index}_#{page_offset}_#{column_width}_#{lines_per_page}"
-        cached_fetch(cache_key, default: []) do
-          with_chapter(chapter_index, default: []) do |chapter|
-            lines = chapter.lines || []
-            wrapped_lines = wrap_lines(chapter_index, lines, column_width)
-            start_line = page_offset * lines_per_page
-            end_line = start_line + lines_per_page - 1
-            wrapped_lines[start_line..end_line] || []
+        # Get wrapped content for specific page
+        #
+        # @param chapter_index [Integer] Chapter index
+        # @param page_offset [Integer] Page offset within chapter
+        # @param column_width [Integer] Column width for wrapping
+        # @param lines_per_page [Integer] Number of lines per page
+        # @return [Array<String>] Array of wrapped content lines
+        def get_wrapped_page_content(chapter_index, page_offset, column_width, lines_per_page = 20)
+          cache_key = "wrapped_#{chapter_index}_#{page_offset}_#{column_width}_#{lines_per_page}"
+          cached_fetch(cache_key, default: []) do
+            with_chapter(chapter_index, default: []) do |chapter|
+              lines = chapter.lines || []
+              wrapped_lines = wrap_lines(chapter_index, lines, column_width)
+              start_line = page_offset * lines_per_page
+              end_line = start_line + lines_per_page - 1
+              wrapped_lines[start_line..end_line] || []
+            end
           end
         end
-      end
 
-      # Get total wrapped lines for chapter
-      #
-      # @param chapter_index [Integer] Chapter index
-      # @param column_width [Integer] Column width for wrapping
-      # @return [Integer] Total wrapped lines
-      def get_chapter_wrapped_line_count(chapter_index, column_width)
-        cache_key = "line_count_#{chapter_index}_#{column_width}"
-        cached_fetch(cache_key, default: 0) do
-          with_chapter(chapter_index, default: 0) do |chapter|
-            lines = chapter.lines || []
-            wrapped_lines = wrap_lines(chapter_index, lines, column_width)
-            wrapped_lines.size
+        # Get total wrapped lines for chapter
+        #
+        # @param chapter_index [Integer] Chapter index
+        # @param column_width [Integer] Column width for wrapping
+        # @return [Integer] Total wrapped lines
+        def get_chapter_wrapped_line_count(chapter_index, column_width)
+          cache_key = "line_count_#{chapter_index}_#{column_width}"
+          cached_fetch(cache_key, default: 0) do
+            with_chapter(chapter_index, default: 0) do |chapter|
+              lines = chapter.lines || []
+              wrapped_lines = wrap_lines(chapter_index, lines, column_width)
+              wrapped_lines.size
+            end
           end
         end
-      end
-
-      # Clear content cache
-      def clear_cache
-        @content_cache.clear
-      end
-
-      # Clear cache for specific width
-      #
-      # @param width [Integer] Column width
-      def clear_cache_for_width(width)
-        @content_cache.delete_if { |key, _| key.include?("_#{width}_") }
-      end
-
-      private
-
-      def create_error_document(error_message)
-        # Create a simple document with error information
-        ErrorDocument.new(error_message)
-      end
-
-      def wrap_lines(chapter_index, lines, column_width)
-        return lines if column_width <= 0
-        return @wrapping_service.wrap_lines(lines, chapter_index, column_width) if @wrapping_service
 
-        # Minimal fallback for tests/dev without DI
-        lines
-      end
-
-      def cached_fetch(key, default: nil)
-        return @content_cache[key] if @content_cache.key?(key)
-
-        value = yield
-        value = default if value.nil?
-        @content_cache[key] = value
-        value
-      end
+        # Clear content cache
+        def clear_cache
+          @content_cache.clear
+        end
 
-      def with_chapter(index, default: nil)
-        chapter = chapter_at(index)
-        return default unless chapter
+        # Clear cache for specific width
+        #
+        # @param width [Integer] Column width
+        def clear_cache_for_width(width)
+          @content_cache.delete_if { |key, _| key.include?("_#{width}_") }
+        end
 
-        yield chapter
-      end
-    end
+        private
 
-    # Simple error document for when EPUB loading fails
-    class ErrorDocument
-      attr_reader :error_message
+        def wrap_lines(chapter_index, lines, column_width)
+          return lines if column_width <= 0
+          @wrapping_service.wrap_lines(lines, chapter_index, column_width, document: @document)
+        end
 
-      def initialize(error_message)
-        @error_message = error_message
-      end
+        def cached_fetch(key, default: nil)
+          return @content_cache[key] if @content_cache.key?(key)
 
-      def chapter_count
-        1
-      end
+          value = yield
+          value = default if value.nil?
+          @content_cache[key] = value
+          value
+        end
 
-      def get_chapter(index)
-        return nil unless index.zero?
+        def with_chapter(index, default: nil)
+          chapter = chapter_at(index)
+          return default unless chapter
 
-        ErrorChapter.new(@error_message)
-      end
+          yield chapter
+        end
 
-      def chapters
-        [get_chapter(0)]
-      end
-    end
+        def instrument(label, &)
+          if @instrumentation
+            @instrumentation.measure(label, &)
+          else
+            yield
+          end
+        end
 
-    # Simple error chapter
-    class ErrorChapter
-      attr_reader :title, :lines
-
-      def initialize(error_message)
-        @title = 'Error Loading Book'
-        @lines = [
-          'Failed to load the EPUB file:',
-          '',
-          error_message,
-          '',
-          'Please check that the file exists and is a valid EPUB.',
-          '',
-          "Press 'q' to return to the main menu.",
-        ]
       end
     end
   end