shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/storage/atomic_file_writer.rb

@@ -2,41 +2,69 @@
 
 require 'fileutils'
 require 'tempfile'
+require_relative '../../shared/errors'
 
 module Shoko
-  module Adapters::Storage
-    # Provides atomic, fsync-backed file writes to avoid partial/corrupt files.
-    class AtomicFileWriter
-      def self.write(path, data, binary: false)
-        write_using(path, binary:) do |io|
-          io.write(data)
+  module Adapters
+    module Storage
+      # Provides atomic, fsync-backed file writes to avoid partial/corrupt files.
+      class AtomicFileWriter
+        def self.write(path, data, binary: false)
+          write_using(path, binary:) do |io|
+            io.write(data)
+          end
+        end
+
+        def self.write_using(path, binary: false)
+          tempfile = nil
+          begin
+            dir = File.dirname(path)
+            FileUtils.mkdir_p(dir)
+            tempfile = Tempfile.new(['shoko', File.basename(path)], dir)
+            tempfile.binmode if binary
+            yield(tempfile)
+            tempfile.flush
+            tempfile.fsync
+            temp_path = tempfile.path
+            tempfile.close
+            File.rename(temp_path, path)
+          rescue StandardError => e
+            raise_storage_error('atomic_write', path, e)
+          ensure
+            cleanup_error = cleanup_tempfile(tempfile, path)
+            raise cleanup_error if cleanup_error && $!.nil?
+          end
         end
-      end
 
-      def self.write_using(path, binary: false)
-        dir = File.dirname(path)
-        FileUtils.mkdir_p(dir)
-        tempfile = Tempfile.new(['shoko', File.basename(path)], dir)
-        tempfile.binmode if binary
-        yield(tempfile)
-        tempfile.flush
-        tempfile.fsync
-        temp_path = tempfile.path
-        tempfile.close
-        File.rename(temp_path, path)
-      ensure
-        if tempfile
+        def self.cleanup_tempfile(tempfile, path)
+          return nil unless tempfile
+
           begin
             tempfile.close unless tempfile.closed?
-          rescue StandardError
-            # ignore cleanup errors
+          rescue StandardError => e
+            return storage_error('atomic_write_cleanup_close', path, e)
           end
+
           begin
             tempfile.unlink if tempfile.path && File.exist?(tempfile.path)
-          rescue StandardError
-            # ignore cleanup errors
+          rescue StandardError => e
+            return storage_error('atomic_write_cleanup_unlink', path, e)
           end
+
+          nil
+        end
+
+        def self.storage_error(operation, path, error)
+          return error if error.is_a?(Shoko::Error)
+
+          Shoko::StorageError.new(operation, path.to_s, error.message)
         end
+
+        def self.raise_storage_error(operation, path, error)
+          raise storage_error(operation, path, error)
+        end
+
+        private_class_method :cleanup_tempfile, :storage_error, :raise_storage_error
       end
     end
   end

data/lib/shoko/adapters/storage/background_worker.rb

@@ -1,62 +1,68 @@
 # frozen_string_literal: true
 
-require_relative '../monitoring/logger.rb'
+require_relative '../../core/ports/outbound/async_executor'
 
 module Shoko
-  module Adapters::Storage
-    # Single-thread worker with monitored queue and graceful shutdown semantics.
-    class BackgroundWorker
-      def initialize(name: 'shoko-worker')
-        @name = name
-        @queue = Queue.new
-        @shutdown = false
-        @mutex = Mutex.new
-        @thread = spawn_thread
-      end
+  module Adapters
+    module Storage
+      # Single-thread worker with monitored queue and graceful shutdown semantics.
+      class BackgroundWorker
+        include Shoko::Core::Ports::Outbound::AsyncExecutor
+        # @param name [String] Worker thread name
+        # @param logger [Core::Ports::Outbound::Logging] Logger adapter (required)
+        def initialize(logger:, name: 'shoko-worker')
+          @name = name
+          @logger = logger
+          @queue = Queue.new
+          @shutdown = false
+          @mutex = Mutex.new
+          @thread = spawn_thread
+        end
 
-      def submit(&block)
-        raise ArgumentError, 'block required' unless block
+        def submit(&block)
+          raise ArgumentError, 'block required' unless block
 
-        @mutex.synchronize do
-          raise WorkerStoppedError, 'worker is shutting down' if @shutdown
+          @mutex.synchronize do
+            raise WorkerStoppedError, 'worker is shutting down' if @shutdown
 
-          @queue << block
+            @queue << block
+          end
         end
-      end
 
-      def shutdown(timeout: 2.0)
-        thread = nil
-        @mutex.synchronize do
-          return if @shutdown
+        def shutdown(timeout: 2.0)
+          thread = nil
+          @mutex.synchronize do
+            return if @shutdown
 
-          @shutdown = true
-          thread = @thread
-          @queue << nil if thread&.alive?
+            @shutdown = true
+            thread = @thread
+            @queue << nil if thread&.alive?
+          end
+          thread&.join(timeout)
+        ensure
+          @thread = nil
         end
-        thread&.join(timeout)
-      ensure
-        @thread = nil
-      end
 
-      class WorkerStoppedError < StandardError; end
+        class WorkerStoppedError < StandardError; end
 
-      private
+        private
 
-      def spawn_thread
-        Thread.new do
-          Thread.current.name = @name if Thread.current.respond_to?(:name=)
-          loop do
-            job = @queue.pop
-            break if job.nil? && @shutdown
+        def spawn_thread
+          Thread.new do
+            Thread.current.name = @name
+            loop do
+              job = @queue.pop
+              break if job.nil? && @shutdown
 
-            next unless job
+              next unless job
 
-            begin
-              job.call
-            rescue StandardError => e
-              Adapters::Monitoring::Logger.error('Background worker job failed',
-                                           worker: @name,
-                                           error: e.message)
+              begin
+                job.call
+              rescue Shoko::Error => e
+                @logger.error('Background worker job failed',
+                              worker: @name,
+                              error: e.message)
+              end
             end
           end
         end

data/lib/shoko/adapters/storage/background_worker_builder_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/background_worker_builder'
+require_relative '../../core/ports/outbound/logging'
+require_relative 'background_worker'
+
+module Shoko
+  module Adapters
+    module Storage
+      # Adapter that constructs background worker instances for runtime workflows.
+      class BackgroundWorkerBuilderAdapter
+        include Shoko::Core::Ports::Outbound::BackgroundWorkerBuilder
+
+        def build(name:, logger:)
+          unless logger.nil? || logger.is_a?(Shoko::Core::Ports::Outbound::Logging)
+            raise ArgumentError, 'logger must implement Core::Ports::Outbound::Logging when provided'
+          end
+
+          Shoko::Adapters::Storage::BackgroundWorker.new(name: name, logger: logger)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/cache_integrity_checker.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Validates cached payload completeness.
+        class CacheIntegrityChecker
+          def initialize(cache:, payload:)
+            @cache = cache
+            @payload = payload
+          end
+
+          def incomplete?
+            chapters = Array(book&.chapters)
+            return true if chapters.empty? || chapters.any?(&:nil?)
+
+            !@cache.chapters_complete?(chapters.length, generation: chapters_generation)
+          end
+
+          private
+
+          def book
+            @payload&.book
+          end
+
+          def chapters_generation
+            book&.chapters_generation
+          end
+        end
+
+        private_constant :CacheIntegrityChecker
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/cache_session.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative '../../support/lifecycle_helpers'
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Handles cache loading/rebuilding for a specific cache instance.
+        class CacheSession
+          include Shoko::Adapters::Support::LifecycleHelpers
+
+          def initialize(cache:, formatting_service:, importer_class:, load_callback:, progress_reporter: nil,
+                         runtime_config: nil, logger: nil)
+            @cache = cache
+            @formatting_service = formatting_service
+            @importer_class = importer_class
+            @load_callback = load_callback
+            @progress_reporter = progress_reporter
+            @runtime_config = runtime_config
+            @logger = logger
+          end
+
+          def load
+            cache_file = @cache.cache_file?
+            report('Loading cached book...') if cache_file
+            result = result_from_initial_payload
+            return result if result
+
+            raise Shoko::CacheLoadError.new(@cache.cache_path, 'cached payload unavailable') if cache_file
+
+            import_and_result
+          end
+
+          def fast_load
+            report('Loading cached book...')
+            payload, cache_status = payload_from_cache
+            context = PayloadContext.new(payload: payload, cache_status: cache_status)
+            result_from_payload_or_nil(context)
+          end
+
+          private
+
+          def initial_payload
+            return @cache.read_cache(strict: true) if @cache.cache_file?
+
+            payload_from_source
+          end
+
+          def payload_from_cache
+            payload = @cache.read_cache(strict: true)
+            raise Shoko::CacheLoadError.new(@cache.cache_path, 'cached payload unavailable') unless payload
+
+            cache_status = CacheStatus.hit(payload)
+            [payload, cache_status]
+          end
+
+          def payload_from_source
+            @cache.load_for_source(strict: true)
+          end
+
+          def result_from_initial_payload
+            payload = initial_payload
+            payload && result_from_payload(
+              PayloadContext.new(payload: payload, cache_status: CacheStatus.hit(payload))
+            )
+          end
+
+          def result_from_payload(context)
+            payload = rebuild_if_incomplete(context)
+            result_for(payload, loaded_from_cache: context.cache_status.loaded_from_cache?)
+          end
+
+          def result_from_payload_or_nil(context)
+            context.payload && begin
+              payload = rebuild_if_incomplete(context)
+              payload && result_for(payload, loaded_from_cache: context.cache_status.loaded_from_cache?)
+            end
+          end
+
+          def rebuild_if_incomplete(context)
+            payload = context.payload
+            return payload unless context.cache_status.loaded_from_cache?
+
+            checker = CacheIntegrityChecker.new(cache: @cache, payload: payload)
+            return payload unless checker.incomplete?
+
+            raise Shoko::CacheLoadError.new(@cache.cache_path, 'cached payload is incomplete')
+          end
+
+          def result_for(payload, loaded_from_cache:)
+            book = payload.book
+            cache_path = @cache.cache_path
+            source_path = payload.source_path || @cache.source_path
+            Result.new(
+              book: book,
+              cache_path: cache_path,
+              source_path: source_path,
+              loaded_from_cache: loaded_from_cache,
+              payload: payload
+            )
+          end
+
+          def import_and_result
+            context = PayloadContext.new(payload: rebuild_cache, cache_status: CacheStatus.miss)
+            result_from_payload(context)
+          end
+
+          def rebuild_cache
+            resolved_class = resolve_importer_class
+            importer = resolved_class.new(**importer_init_kwargs(resolved_class))
+            book_data = importer.import(@cache.source_path)
+            report('Creating JSON cache...', progress: 0.0)
+            cache_write_ok = @cache.write_book!(book_data)
+            raise Shoko::CacheLoadError.new(@cache.cache_path, 'cache write failed') unless cache_write_ok
+            report('Finalizing cache...', progress: 1.0)
+            payload = payload_from_source
+            return payload if payload
+
+            raise Shoko::CacheLoadError.new(@cache.cache_path, 'cache payload unavailable after write')
+          end
+
+          def resolve_importer_class
+            source = @cache.source_path.to_s
+            from_registry = Shoko::Core::BookFormats::FormatRegistry.importer_for(source)
+            from_registry || @importer_class
+          end
+
+          def importer_init_kwargs(importer_class)
+            kwargs = {
+              formatting_service: @formatting_service,
+              progress_reporter: @progress_reporter
+            }
+            return kwargs unless importer_supports_keyword?(importer_class, :runtime_config)
+
+            kwargs[:runtime_config] = @runtime_config
+            kwargs
+          end
+
+          def importer_supports_keyword?(importer_class, keyword)
+            parameters = importer_class.instance_method(:initialize).parameters
+            parameters.any? { |kind, name| (kind == :key || kind == :keyreq) && name == keyword }
+          end
+        end
+
+        private_constant :CacheSession
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/cache_status.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Tracks whether a payload originated from cache.
+        class CacheStatus
+          def self.hit(cache_marker)
+            new(cache_marker)
+          end
+
+          def self.miss
+            new(nil)
+          end
+
+          def initialize(cache_marker)
+            @cache_marker = cache_marker
+          end
+
+          def mark_rebuilt
+            @cache_marker = nil
+          end
+
+          def loaded_from_cache?
+            !!@cache_marker
+          end
+        end
+
+        private_constant :CacheStatus
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/fingerprint_filter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Filters manifest rows by source fingerprint, keeping untagged rows.
+        class FingerprintFilter
+          def initialize(source_path)
+            @source_path = source_path
+            @fingerprint = nil
+            @fingerprint_blank = false
+          end
+
+          def call(rows)
+            matches = rows.select { |row| include_row?(row) }
+            [matches, applied?, blank?]
+          end
+
+          private
+
+          def include_row?(row)
+            value = row.fingerprint_value
+            return true unless value
+
+            ensure_fingerprint
+            return false if @fingerprint_blank
+
+            value == @fingerprint
+          end
+
+          def ensure_fingerprint
+            return if @fingerprint
+
+            @fingerprint = Shoko::Shared::SourceFingerprint.compute(@source_path).to_s
+            @fingerprint_blank = @fingerprint.empty?
+          end
+
+          def applied?
+            !!@fingerprint
+          end
+
+          def blank?
+            @fingerprint_blank
+          end
+        end
+
+        private_constant :FingerprintFilter
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/load_error_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Raises standardized load errors for pipeline failures.
+        class LoadErrorHandler
+          def initialize(path, logger: nil)
+            @path = path
+            @logger = logger
+          end
+
+          def call(error)
+            message = error.message
+            @logger&.error('Book cache pipeline failed', path: @path, error: message)
+            raise Shoko::BookParseError.new(message, @path)
+          end
+        end
+
+        private_constant :LoadErrorHandler
+      end
+    end
+  end
+end

data/lib/shoko/adapters/storage/book_cache_pipeline/manifest_row.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module Storage
+      class BookCachePipeline
+        # Wraps manifest row hashes with typed accessors.
+        class ManifestRow
+          def self.from(row)
+            return nil unless row.is_a?(Hash)
+
+            new(row)
+          end
+
+          def initialize(row)
+            source_path, source_mtime, source_size, source_fingerprint, updated_at, source_sha =
+              row.values_at(
+                'source_path',
+                'source_mtime',
+                'source_size_bytes',
+                'source_fingerprint',
+                'updated_at',
+                'source_sha'
+              )
+            fingerprint_value = source_fingerprint.to_s.strip
+            fingerprint_value = nil if fingerprint_value.empty?
+
+            @data = {
+              source_path: source_path.to_s,
+              source_mtime: source_mtime,
+              source_size_bytes: source_size,
+              source_fingerprint: fingerprint_value,
+              updated_at: updated_at.to_f,
+              source_sha: source_sha.to_s.strip,
+            }
+          end
+
+          def path_match?(source_path)
+            @data[:source_path] == source_path
+          end
+
+          def mtime_match?(source_mtime)
+            raw_mtime = @data[:source_mtime]
+            return false unless raw_mtime
+
+            (raw_mtime.to_f - source_mtime.to_f).abs <= 1.0
+          end
+
+          def size_match?(source_size_bytes)
+            raw_size = @data[:source_size_bytes]
+            return true unless raw_size
+
+            raw_size.to_i == source_size_bytes.to_i
+          end
+
+          def fingerprint_value
+            @data[:source_fingerprint]
+          end
+
+          def updated_at
+            @data[:updated_at]
+          end
+
+          def source_sha
+            sha = @data[:source_sha]
+            sha.empty? ? nil : sha
+          end
+        end
+
+        private_constant :ManifestRow
+      end
+    end
+  end
+end