shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/storage/cache/epub/serializer/serialize.rb

@@ -1,82 +1,85 @@
 # frozen_string_literal: true
 
 module Shoko
-  module Adapters::Storage
-    class EpubCache
-      # Serialization helpers for persisting cache payloads.
-      module Serializer
-        module_function
+  module Adapters
+    module Storage
+      class EpubCache
+        # Serialization helpers for persisting cache payloads.
+        module Serializer
+          module_function
 
-        def serialize(book_data, json: false)
-          {
-            book: serialize_book(book_data, json: json),
-            chapters: serialize_chapters(book_data.chapters, json: json),
-            resources: serialize_resources(book_data.resources),
-          }
-        end
-
-        def serialize_layouts(layouts_hash)
-          return {} unless layouts_hash.is_a?(Hash)
+          def serialize(book_data, json: false)
+            {
+              book: serialize_book(book_data, json: json),
+              chapters: serialize_chapters(book_data.chapters, json: json),
+              resources: serialize_resources(book_data.resources),
+            }
+          end
 
-          layouts_hash.transform_keys(&:to_s)
-        end
+          def serialize_layouts(layouts_hash)
+            return {} unless layouts_hash.is_a?(Hash)
 
-        def serialize_book(book, json: true)
-          {
-            payload_version: CACHE_VERSION, cache_version: CACHE_VERSION,
-            title: book.title, language: book.language,
-            authors_json: json_field(Array(book.authors), json),
-            metadata_json: json_field(book.metadata || {}, json),
-            opf_path: book.opf_path,
-            spine_json: json_field(Array(book.spine), json),
-            chapter_hrefs_json: json_field(Array(book.chapter_hrefs), json),
-            toc_json: json_field(serialized_toc(book), json),
-            container_path: book.container_path, container_xml: book.container_xml.to_s
-          }
-        end
+            layouts_hash.transform_keys(&:to_s)
+          end
 
-        def serialize_chapters(chapters, json: true)
-          Array(chapters).each_with_index.map do |chapter, idx|
-            metadata = chapter.metadata || {}
+          def serialize_book(book, json: true)
             {
-              position: idx,
-              number: chapter.number,
-              title: chapter.title,
-              metadata_json: json_field(metadata, json),
-              raw_content: chapter.raw_content,
+              payload_version: CACHE_VERSION, cache_version: CACHE_VERSION,
+              title: book.title, language: book.language,
+              authors_json: json_field(Array(book.authors), json),
+              metadata_json: json_field(book.metadata || {}, json),
+              opf_path: book.opf_path,
+              spine_json: json_field(Array(book.spine), json),
+              chapter_hrefs_json: json_field(Array(book.chapter_hrefs), json),
+              toc_json: json_field(serialized_toc(book), json),
+              container_path: book.container_path, container_xml: book.container_xml.to_s,
+              format_data_json: json_field(book.format_data || {}, json)
             }
           end
-        end
 
-        def serialize_resources(resources)
-          return [] unless resources
+          def serialize_chapters(chapters, json: true)
+            Array(chapters).each_with_index.map do |chapter, idx|
+              metadata = chapter.metadata || {}
+              {
+                position: idx,
+                number: chapter.number,
+                title: chapter.title,
+                metadata_json: json_field(metadata, json),
+                raw_content: chapter.raw_content,
+              }
+            end
+          end
 
-          resources.map do |path, data|
-            bytes = String(data).dup
-            bytes.force_encoding(Encoding::BINARY)
-            { path: path.to_s, data: bytes }
+          def serialize_resources(resources)
+            return [] unless resources
+
+            resources.map do |path, data|
+              bytes = String(data).dup
+              bytes.force_encoding(Encoding::BINARY)
+              { path: path.to_s, data: bytes }
+            end
           end
-        end
 
-        def serialize_toc_entry(entry)
-          {
-            title: value_for(entry, :title),
-            href: value_for(entry, :href),
-            level: value_for(entry, :level),
-            chapter_index: value_for(entry, :chapter_index),
-            navigable: value_for(entry, :navigable),
-          }
-        end
+          def serialize_toc_entry(entry)
+            {
+              title: value_for(entry, :title),
+              href: value_for(entry, :href),
+              level: value_for(entry, :level),
+              chapter_index: value_for(entry, :chapter_index),
+              navigable: value_for(entry, :navigable),
+            }
+          end
 
-        def json_field(value, json)
-          json ? JSON.generate(value) : value
-        end
-        private_class_method :json_field
+          def json_field(value, json)
+            json ? JSON.generate(value) : value
+          end
+          private_class_method :json_field
 
-        def serialized_toc(book)
-          Array(book.toc_entries).map { |entry| serialize_toc_entry(entry) }
+          def serialized_toc(book)
+            Array(book.toc_entries).map { |entry| serialize_toc_entry(entry) }
+          end
+          private_class_method :serialized_toc
         end
-        private_class_method :serialized_toc
       end
     end
   end

data/lib/shoko/adapters/storage/cache/epub/source_reference.rb

@@ -1,56 +1,58 @@
 # frozen_string_literal: true
 
 module Shoko
-  module Adapters::Storage
-    # Source resolution helpers for `EpubCache` (EPUB source vs `.cache` pointer file).
-    class EpubCache
-      private
-
-      def setup_source_reference
-        if self.class.cache_file?(@raw_path)
-          setup_source_reference_from_pointer
-        else
-          setup_source_reference_from_epub
+  module Adapters
+    module Storage
+      # Source resolution helpers for `EpubCache` (EPUB source vs `.cache` pointer file).
+      class EpubCache
+        private
+
+        def setup_source_reference
+          if self.class.cache_file?(@raw_path)
+            setup_source_reference_from_pointer
+          else
+            setup_source_reference_from_epub
+          end
         end
-      end
 
-      def setup_source_reference_from_pointer
-        @cache_path = @raw_path
-        @pointer_manager = CachePointerManager.new(@cache_path)
-        pointer = @pointer_manager.read
-        raise Shoko::CacheLoadError.new(@raw_path, 'invalid pointer file') unless pointer
+        def setup_source_reference_from_pointer
+          @cache_path = @raw_path
+          @pointer_manager = CachePointerManager.new(@cache_path)
+          pointer = @pointer_manager.read
+          raise Shoko::CacheLoadError.new(@raw_path, 'invalid pointer file') unless pointer
 
-        @source_type = :cache_pointer
-        @pointer_metadata = pointer
-        @source_sha = pointer['sha256']
-        @source_path = pointer['source_path']
-      end
+          @source_type = :cache_pointer
+          @pointer_metadata = pointer
+          @source_sha = pointer['sha256']
+          @source_path = pointer['source_path']
+        end
 
-      def setup_source_reference_from_epub
-        raise Shoko::FileNotFoundError, @raw_path unless File.file?(@raw_path)
+        def setup_source_reference_from_epub
+          raise Shoko::FileNotFoundError, @raw_path unless File.file?(@raw_path)
 
-        @source_type = :epub
-        @source_path = @raw_path
-        @source_sha = Digest::SHA256.file(@source_path).hexdigest
-        @cache_path = cache_path_for_source_sha
-        @pointer_manager = CachePointerManager.new(@cache_path)
-        @pointer_metadata = @pointer_manager.read
-      end
+          @source_type = :epub
+          @source_path = @raw_path
+          @source_sha = Digest::SHA256.file(@source_path).hexdigest
+          @cache_path = cache_path_for_source_sha
+          @pointer_manager = CachePointerManager.new(@cache_path)
+          @pointer_metadata = @pointer_manager.read
+        end
 
-      def cache_path_for_source_sha
-        cache_path = self.class.cache_path_for_sha(@source_sha, cache_root: @cache_root)
-        raise Shoko::CacheLoadError.new(@raw_path, 'invalid sha256 digest') unless cache_path
+        def cache_path_for_source_sha
+          cache_path = self.class.cache_path_for_sha(@source_sha, cache_root: @cache_root)
+          raise Shoko::CacheLoadError.new(@raw_path, 'invalid sha256 digest') unless cache_path
 
-        cache_path
-      end
+          cache_path
+        end
 
-      def ensure_sha!
-        return if @source_sha
+        def ensure_sha!
+          return if @source_sha
 
-        if @source_type == :epub
-          @source_sha = Digest::SHA256.file(@source_path).hexdigest
-        elsif @pointer_metadata
-          @source_sha = @pointer_metadata['sha256']
+          if @source_type == :epub
+            @source_sha = Digest::SHA256.file(@source_path).hexdigest
+          elsif @pointer_metadata
+            @source_sha = @pointer_metadata['sha256']
+          end
         end
       end
     end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/cache_availability'
+require_relative '../../shared/source_fingerprint'
+require_relative 'cache_paths'
+require_relative 'json_cache_store'
+require_relative 'cache_pointer_manager'
+require_relative 'epub_cache'
+
+module Shoko
+  module Adapters
+    module Storage
+      # Adapter for checking if a cache entry exists for a given source path.
+      class CacheAvailabilityAdapter
+        include Core::Ports::Outbound::CacheAvailability
+
+        def initialize(cache_root: CachePaths.cache_root, store: nil, logger: nil, runtime_config: nil)
+          @cache_root = cache_root
+          @runtime_config = runtime_config
+          @store = store || JsonCacheStore.new(
+            cache_root: cache_root,
+            logger: logger,
+            runtime_config: runtime_config
+          )
+        end
+
+        def cache_available?(path)
+          source_path = path.to_s
+          return false if source_path.empty?
+          return false unless File.file?(source_path)
+
+          if Adapters::Storage::EpubCache.cache_file?(source_path)
+            pointer = CachePointerManager.new(source_path).read
+            sha = pointer && pointer['sha256']
+            return false if sha.to_s.strip.empty?
+
+            payload_path = File.join(@cache_root, "#{sha.downcase}.json")
+            return File.file?(payload_path)
+          end
+
+          rows = JsonCacheStore.manifest_rows(@cache_root, runtime_config: @runtime_config)
+          return false if rows.empty?
+
+          fingerprint = Shoko::Shared::SourceFingerprint.compute(source_path).to_s
+          fingerprint = nil if fingerprint.empty?
+          source_mtime = File.mtime(source_path).utc
+          source_size = File.size(source_path)
+
+          rows.any? do |row|
+            row = normalize_row(row)
+            next false unless row
+
+            next false unless row[:source_path] == source_path
+            next false unless mtime_match?(row[:source_mtime], source_mtime)
+            next false unless size_match?(row[:source_size_bytes], source_size)
+            next false if row[:source_fingerprint] && fingerprint && row[:source_fingerprint] != fingerprint
+
+            sha = row[:source_sha]
+            next false if sha.to_s.strip.empty?
+
+            payload_path = File.join(@cache_root, "#{sha.downcase}.json")
+            File.file?(payload_path)
+          end
+        rescue Shoko::Error
+          raise
+        end
+
+        private
+
+        def normalize_row(row)
+          return nil unless row.is_a?(Hash)
+
+          {
+            source_path: row['source_path'].to_s,
+            source_mtime: row['source_mtime'],
+            source_size_bytes: row['source_size_bytes'],
+            source_fingerprint: normalize_fingerprint(row['source_fingerprint']),
+            source_sha: row['source_sha'].to_s,
+          }
+        end
+
+        def normalize_fingerprint(value)
+          str = value.to_s.strip
+          str.empty? ? nil : str
+        end
+
+        def mtime_match?(raw, source_mtime)
+          return true unless raw
+
+          (raw.to_f - source_mtime.to_f).abs <= 1.0
+        rescue Shoko::Error
+          raise
+        end
+
+        def size_match?(raw, source_size)
+          return true unless raw
+
+          raw.to_i == source_size.to_i
+        rescue Shoko::Error
+          raise
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/cache_manager'
+
+module Shoko
+  module Adapters
+    module Storage
+      # Adapter implementing the CacheManager port.
+      # Dependencies injected to avoid coupling to sibling adapters.
+      class CacheManagerAdapter
+        include Core::Ports::Outbound::CacheManager
+
+        def initialize(epub_cache_clearer:, cache_path_provider:)
+          @epub_cache_clearer = epub_cache_clearer
+          @cache_path_provider = cache_path_provider
+        end
+
+        def clear_epub_cache
+          @epub_cache_clearer.call
+        end
+
+        def cache_root
+          @cache_path_provider.cache_root
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,22 @@
 # frozen_string_literal: true
 
 module Shoko
-  module Adapters::Storage
-    # Cache path helpers (XDG-compatible) for on-disk Shoko artifacts.
-    module CachePaths
-      module_function
+  module Adapters
+    module Storage
+      # Cache path helpers (XDG-compatible) for on-disk Shoko artifacts.
+      module CachePaths
+        module_function
 
-      # Root directory for Shoko cache: ${XDG_CACHE_HOME:-~/.cache}/shoko
-      def cache_root
-        env_home = ENV.fetch('XDG_CACHE_HOME', nil)
-        cache_root = if env_home && !env_home.empty?
-                       env_home
-                     else
-                       File.join(Dir.home, '.cache')
-                     end
-        File.join(cache_root, 'shoko')
+        # Root directory for Shoko cache: ${XDG_CACHE_HOME:-~/.cache}/shoko
+        def cache_root
+          env_home = ENV.fetch('XDG_CACHE_HOME', nil)
+          cache_root = if env_home && !env_home.empty?
+                         env_home
+                       else
+                         File.join(Dir.home, '.cache')
+                       end
+          File.join(cache_root, 'shoko')
+        end
       end
     end
   end

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

@@ -3,57 +3,59 @@
 require 'json'
 
 require_relative 'atomic_file_writer'
-require_relative '../monitoring/logger.rb'
 
 module Shoko
-  module Adapters::Storage
-    # Manages pointer files that reference serialized cache payloads on disk.
-    class CachePointerManager
-      POINTER_FORMAT = 'shoko-cache'
-      LEGACY_POINTER_FORMATS = ['reader-cache', 'reader-marshal-cache'].freeze
-      POINTER_VERSION = 2
-      POINTER_KEYS    = %w[format version sha256 source_path generated_at engine].freeze
-      SUPPORTED_FORMATS = [POINTER_FORMAT, *LEGACY_POINTER_FORMATS].freeze
-      SUPPORTED_ENGINES = %w[json marshal].freeze
-      SHA256_HEX_PATTERN = /\A[0-9a-f]{64}\z/i
-
-      def initialize(path)
-        @path = path
-      end
+  module Adapters
+    module Storage
+      # Manages pointer files that reference serialized cache payloads on disk.
+      class CachePointerManager
+        POINTER_FORMAT = 'shoko-cache'
+        LEGACY_POINTER_FORMATS = %w[reader-cache reader-marshal-cache].freeze
+        POINTER_VERSION = 2
+        POINTER_KEYS    = %w[format version sha256 source_path generated_at engine].freeze
+        SUPPORTED_FORMATS = [POINTER_FORMAT, *LEGACY_POINTER_FORMATS].freeze
+        SUPPORTED_ENGINES = %w[json marshal].freeze
+        SHA256_HEX_PATTERN = /\A[0-9a-f]{64}\z/i
+
+        def initialize(path, logger: nil)
+          @path = path
+          @logger = logger
+        end
 
-      attr_reader :path
+        attr_reader :path
 
-      def read
-        return nil unless File.exist?(path)
+        def read
+          return nil unless File.exist?(path)
 
-        content = File.read(path)
-        return nil if content.nil? || content.empty?
+          content = File.read(path)
+          return nil if content.nil? || content.empty?
 
-        data = JSON.parse(content)
-        return nil unless valid_pointer?(data)
+          data = JSON.parse(content)
+          return nil unless valid_pointer?(data)
 
-        data
-      rescue JSON::ParserError
-        nil
-      end
+          data
+        rescue JSON::ParserError
+          raise
+        end
 
-      def write(data)
-        AtomicFileWriter.write_using(path) do |io|
-          io.write(JSON.generate(data))
+        def write(data)
+          AtomicFileWriter.write_using(path) do |io|
+            io.write(JSON.generate(data))
+          end
+        rescue Shoko::Error => e
+          @logger&.debug('CachePointerManager: write failed', path:, error: e.message)
+          false
         end
-      rescue StandardError => e
-        Shoko::Adapters::Monitoring::Logger.debug('CachePointerManager: write failed', path:, error: e.message)
-        false
-      end
 
-      private
+        private
 
-      def valid_pointer?(data)
-        POINTER_KEYS.all? { |key| data.key?(key) } &&
-          SUPPORTED_FORMATS.include?(data['format'].to_s) &&
-          SUPPORTED_ENGINES.include?(data['engine'].to_s) &&
-          data['version'].to_i == POINTER_VERSION &&
-          data['sha256'].to_s.match?(SHA256_HEX_PATTERN)
+        def valid_pointer?(data)
+          POINTER_KEYS.all? { |key| data.key?(key) } &&
+            SUPPORTED_FORMATS.include?(data['format'].to_s) &&
+            SUPPORTED_ENGINES.include?(data['engine'].to_s) &&
+            data['version'].to_i == POINTER_VERSION &&
+            data['sha256'].to_s.match?(SHA256_HEX_PATTERN)
+        end
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/cache_pointer_resolver'
+require_relative 'epub_cache'
+require_relative 'cache_pointer_manager'
+
+module Shoko
+  module Adapters
+    module Storage
+      # Adapter for resolving EPUB cache pointer files.
+      class CachePointerResolver
+        include Core::Ports::Outbound::CachePointerResolver
+        SourcePathPayload = Struct.new(:source_path)
+
+        def cache_pointer?(path)
+          EpubCache.cache_file?(path)
+        end
+
+        def read_cache(path, strict: false)
+          payload = EpubCache.new(path).read_cache(strict: strict)
+          return payload if payload
+          return nil if strict
+
+          pointer = CachePointerManager.new(path).read
+          source_path = pointer && pointer['source_path'].to_s.strip
+          return nil if source_path.nil? || source_path.empty?
+
+          SourcePathPayload.new(source_path)
+        rescue Shoko::Error
+          raise
+        end
+      end
+    end
+  end
+end

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

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
 module Shoko
-  module Adapters::Storage
-    # Resolves XDG-aware configuration paths for Shoko.
-    module ConfigPaths
-      module_function
+  module Adapters
+    module Storage
+      # Resolves XDG-aware configuration paths for Shoko.
+      module ConfigPaths
+        module_function
 
-      # Root directory for Shoko config: ${XDG_CONFIG_HOME:-~/.config}/shoko
-      def config_root
-        env_home = ENV.fetch('XDG_CONFIG_HOME', nil)
-        config_root = if env_home && !env_home.empty?
-                        env_home
-                      else
-                        File.join(Dir.home, '.config')
-                      end
-        File.join(config_root, 'shoko')
-      end
+        # Root directory for Shoko config: ${XDG_CONFIG_HOME:-~/.config}/shoko
+        def config_root
+          env_home = ENV.fetch('XDG_CONFIG_HOME', nil)
+          config_root = if env_home && !env_home.empty?
+                          env_home
+                        else
+                          File.join(Dir.home, '.config')
+                        end
+          File.join(config_root, 'shoko')
+        end
 
-      # Downloaded books directory under config root.
-      def downloads_root
-        File.join(config_root, 'downloads')
-      end
+        # Downloaded books directory under config root.
+        def downloads_root
+          File.join(config_root, 'downloads')
+        end
 
-      def config_path(*segments)
-        File.join(config_root, *segments)
+        def config_path(*segments)
+          File.join(config_root, *segments)
+        end
       end
     end
   end