shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/storage/repositories/base_repository.rb

@@ -1,81 +1,86 @@
 # frozen_string_literal: true
 
 module Shoko
-  module Adapters::Storage::Repositories
-      # Base class for all repository implementations in the domain layer.
-      #
-      # Repositories provide an abstraction layer between domain services and
-      # infrastructure storage mechanisms, following the Repository pattern from
-      # Domain-Driven Design.
-      #
-      # All repositories should:
-      # - Provide domain-focused methods (not storage-focused)
-      # - Return domain objects or primitives
-      # - Handle storage-specific errors and convert to domain errors
-      # - Use dependency injection for storage implementations
-      #
-      # @example Implementing a repository
-      #   class MyRepository < BaseRepository
-      #     def find_by_id(id)
-      #       storage_result = @storage.find(id)
-      #       convert_to_domain_object(storage_result)
-      #     rescue Storage::NotFoundError => e
-      #       raise EntityNotFoundError, e.message
-      #     end
-      #   end
-      class BaseRepository
-        # Repository-specific errors
-        class RepositoryError < StandardError; end
-        class EntityNotFoundError < RepositoryError; end
-        class ValidationError < RepositoryError; end
-        class PersistenceError < RepositoryError; end
+  module Adapters
+    module Storage
+      module Repositories
+        # Base class for all repository implementations in the domain layer.
+        #
+        # Repositories provide an abstraction layer between domain services and
+        # infrastructure storage mechanisms, following the Repository pattern from
+        # Domain-Driven Design.
+        #
+        # All repositories should:
+        # - Provide domain-focused methods (not storage-focused)
+        # - Return domain objects or primitives
+        # - Handle storage-specific errors and convert to domain errors
+        # - Use dependency injection for storage implementations
+        #
+        # @example Implementing a repository
+        #   class MyRepository < BaseRepository
+        #     def find_by_id(id)
+        #       storage_result = @storage.find(id)
+        #       convert_to_domain_object(storage_result)
+        #       # Handle Storage::NotFoundError and map to EntityNotFoundError.
+        #     end
+        #   end
+        class BaseRepository
+          # Repository-specific errors
+          class RepositoryError < StandardError; end
+          class EntityNotFoundError < RepositoryError; end
+          class ValidationError < RepositoryError; end
+          class PersistenceError < RepositoryError; end
 
-        def initialize(dependencies)
-          @dependencies = dependencies
-          @logger = dependencies.resolve(:logger)
-          setup_repository_dependencies
-        end
+          def initialize(logger: nil)
+            @logger = logger
+          end
 
-        protected
+          protected
 
-        attr_reader :dependencies, :logger
+          attr_reader :logger
 
-        # Template method for subclasses to set up their specific dependencies
-        def setup_repository_dependencies
-          # Override in subclasses to resolve storage dependencies
-        end
+          # Helper to handle common storage errors
+          def handle_storage_error(error, context = nil)
+            msg = error.message
+            message = context ? "#{context}: #{msg}" : msg
+            logger&.error("Repository error - #{message}")
 
-        # Helper to handle common storage errors
-        def handle_storage_error(error, context = nil)
-          msg = error.message
-          message = context ? "#{context}: #{msg}" : msg
-          logger.error("Repository error - #{message}")
-
-          case error
-          when NoMethodError, ArgumentError
-            raise ValidationError, message
-          else
-            raise PersistenceError, message
+            case error
+            when ArgumentError
+              raise ValidationError, message
+            else
+              raise PersistenceError, message
+            end
           end
-        end
 
-        # Helper to validate required parameters
-        def validate_required_params(params, required_keys)
-          missing_keys = required_keys.select do |key|
-            val = params[key]
-            !params.key?(key) || val.nil? || (val.respond_to?(:empty?) && val.empty?)
+          # Helper to validate required parameters
+          def validate_required_params(params, required_keys)
+            missing_keys = required_keys.select do |key|
+              val = params[key]
+              !params.key?(key) || val.nil? || blank_value?(val)
+            end
+            return if missing_keys.empty?
+
+            raise ValidationError, "Missing required parameters: #{missing_keys.join(', ')}"
           end
-          return if missing_keys.empty?
 
-          raise ValidationError, "Missing required parameters: #{missing_keys.join(', ')}"
-        end
+          # Helper to ensure entity exists before operations
+          def ensure_entity_exists(entity, entity_name = 'Entity')
+            return if entity
 
-        # Helper to ensure entity exists before operations
-        def ensure_entity_exists(entity, entity_name = 'Entity')
-          return if entity
+            raise EntityNotFoundError, "#{entity_name} not found"
+          end
 
-          raise EntityNotFoundError, "#{entity_name} not found"
+          def blank_value?(value)
+            case value
+            when String, Array, Hash
+              value.empty?
+            else
+              false
+            end
+          end
         end
       end
+    end
   end
 end

data/lib/shoko/adapters/storage/repositories/bookmark_repository.rb

@@ -1,132 +1,137 @@
 # frozen_string_literal: true
 
 require_relative 'base_repository'
-require_relative '../../../core/models/bookmark_data.rb'
+require_relative '../../../core/models/bookmark_data'
 require_relative 'storage/bookmark_file_store'
 
 module Shoko
-  module Adapters::Storage::Repositories
-      # Repository for bookmark persistence, abstracting the underlying storage mechanism.
-      #
-      # This repository provides a clean domain interface for bookmark operations,
-      # hiding the file-based persistence details from domain services.
-      #
-      # @example Adding a bookmark
-      #   repo = BookmarkRepository.new(dependencies)
-      #   repo.add_for_book('/path/to/book.epub', chapter: 2, line: 50, text: 'Important quote')
-      #
-      # @example Getting bookmarks for a book
-      #   bookmarks = repo.find_by_book_path('/path/to/book.epub')
-      class BookmarkRepository < BaseRepository
-        def initialize(dependencies)
-          super
-          file_writer = dependencies.resolve(:file_writer)
-          @storage = Storage::BookmarkFileStore.new(file_writer:)
-        end
-
-        # Add a bookmark for a specific book
+  module Adapters
+    module Storage
+      module Repositories
+        # Repository for bookmark persistence, abstracting the underlying storage mechanism.
+        #
+        # This repository provides a clean domain interface for bookmark operations,
+        # hiding the file-based persistence details from domain services.
         #
-        # @param book_path [String] Path to the EPUB file
-        # @param chapter_index [Integer] Chapter index (0-based)
-        # @param line_offset [Integer] Line offset within the chapter
-        # @param text_snippet [String] Text snippet for the bookmark
-        # @return [Models::Bookmark] The created bookmark
-        def add_for_book(book_path, chapter_index:, line_offset:, text_snippet:)
-          validate_required_params(
-            { book_path: book_path, chapter_index: chapter_index, line_offset: line_offset },
-            %i[book_path chapter_index line_offset]
-          )
+        # @example Adding a bookmark
+        #   repo = BookmarkRepository.new(dependencies)
+        #   repo.add_for_book('/path/to/book.epub', chapter: 2, line: 50, text: 'Important quote')
+        #
+        # @example Getting bookmarks for a book
+        #   bookmarks = repo.find_by_book_path('/path/to/book.epub')
+        class BookmarkRepository < BaseRepository
+          include Core::Ports::Outbound::BookmarkRepository
 
-          bookmark_data = Core::Models::BookmarkData.new(
-            path: book_path,
-            chapter: chapter_index,
-            line_offset: line_offset,
-            text: text_snippet || ''
-          )
+          def initialize(file_writer:, logger: nil)
+            super(logger: logger)
+            @storage = Storage::BookmarkFileStore.new(file_writer: file_writer)
+          end
 
-          begin
-            @storage.add(bookmark_data)
+          # Add a bookmark for a specific book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param chapter_index [Integer] Chapter index (0-based)
+          # @param line_offset [Integer] Line offset within the chapter
+          # @param text_snippet [String] Text snippet for the bookmark
+          # @return [Models::Bookmark] The created bookmark
+          def add_for_book(book_path, chapter_index:, line_offset:, text_snippet:)
+            validate_required_params(
+              { book_path: book_path, chapter_index: chapter_index, line_offset: line_offset },
+              %i[book_path chapter_index line_offset]
+            )
 
-            # Return the bookmark object that was created
-            bookmarks = find_by_book_path(book_path)
-            # Find the most recently added bookmark (by timestamp)
-            bookmarks.max_by(&:created_at)
-          rescue StandardError => e
-            handle_storage_error(e, "adding bookmark for #{book_path}")
+            bookmark_data = Core::Models::BookmarkData.new(
+              path: book_path,
+              chapter: chapter_index,
+              line_offset: line_offset,
+              text: text_snippet || ''
+            )
+
+            begin
+              @storage.add(bookmark_data)
+
+              # Return the bookmark object that was created
+              bookmarks = find_by_book_path(book_path)
+              # Find the most recently added bookmark (by timestamp)
+              bookmarks.max_by(&:created_at)
+            rescue Shoko::Error => e
+              handle_storage_error(e, "adding bookmark for #{book_path}")
+            end
           end
-        end
 
-        # Find all bookmarks for a specific book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Array<Models::Bookmark>] Array of bookmarks for the book
-        def find_by_book_path(book_path)
-          validate_required_params({ book_path: book_path }, [:book_path])
+          # Find all bookmarks for a specific book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Array<Models::Bookmark>] Array of bookmarks for the book
+          def find_by_book_path(book_path)
+            validate_required_params({ book_path: book_path }, [:book_path])
 
-          begin
-            @storage.get(book_path) || []
-          rescue StandardError => e
-            handle_storage_error(e, "loading bookmarks for #{book_path}")
+            begin
+              @storage.get(book_path) || []
+            rescue Shoko::Error => e
+              handle_storage_error(e, "loading bookmarks for #{book_path}")
+            end
           end
-        end
 
-        # Delete a specific bookmark
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param bookmark [Models::Bookmark] The bookmark to delete
-        # @return [Boolean] True if deleted successfully
-        def delete_for_book(book_path, bookmark)
-          # Ensure entity existence takes precedence for clearer error semantics
-          ensure_entity_exists(bookmark, 'Bookmark')
-          validate_required_params({ book_path: book_path }, %i[book_path])
+          # Delete a specific bookmark
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param bookmark [Models::Bookmark] The bookmark to delete
+          # @return [Boolean] True if deleted successfully
+          def delete_for_book(book_path, bookmark)
+            # Ensure entity existence takes precedence for clearer error semantics
+            ensure_entity_exists(bookmark, 'Bookmark')
+            validate_required_params({ book_path: book_path }, %i[book_path])
 
-          begin
-            @storage.delete(book_path, bookmark)
-            true
-          rescue StandardError => e
-            handle_storage_error(e, "deleting bookmark for #{book_path}")
+            begin
+              @storage.delete(book_path, bookmark)
+              true
+            rescue Shoko::Error => e
+              handle_storage_error(e, "deleting bookmark for #{book_path}")
+            end
           end
-        end
 
-        # Check if a bookmark exists at the given position
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param chapter_index [Integer] Chapter index
-        # @param line_offset [Integer] Line offset within the chapter
-        # @return [Boolean] True if a bookmark exists at this position
-        def exists_at_position?(book_path, chapter_index, line_offset)
-          bookmarks = find_by_book_path(book_path)
-          bookmarks.any? do |bookmark|
-            bookmark.chapter_index == chapter_index && bookmark.line_offset == line_offset
+          # Check if a bookmark exists at the given position
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param chapter_index [Integer] Chapter index
+          # @param line_offset [Integer] Line offset within the chapter
+          # @return [Boolean] True if a bookmark exists at this position
+          def exists_at_position?(book_path, chapter_index, line_offset)
+            bookmarks = find_by_book_path(book_path)
+            bookmarks.any? do |bookmark|
+              bookmark.chapter_index == chapter_index && bookmark.line_offset == line_offset
+            end
+          rescue Shoko::Error => e
+            handle_storage_error(e, "checking bookmark existence for #{book_path}")
           end
-        rescue StandardError => e
-          handle_storage_error(e, "checking bookmark existence for #{book_path}")
-        end
 
-        # Get bookmark count for a book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Integer] Number of bookmarks for the book
-        def count_for_book(book_path)
-          find_by_book_path(book_path).size
-        rescue StandardError => e
-          handle_storage_error(e, "counting bookmarks for #{book_path}")
-        end
+          # Get bookmark count for a book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Integer] Number of bookmarks for the book
+          def count_for_book(book_path)
+            find_by_book_path(book_path).size
+          rescue Shoko::Error => e
+            handle_storage_error(e, "counting bookmarks for #{book_path}")
+          end
 
-        # Find bookmark at a specific position
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param chapter_index [Integer] Chapter index
-        # @param line_offset [Integer] Line offset within the chapter
-        # @return [Models::Bookmark, nil] The bookmark at this position, or nil
-        def find_at_position(book_path, chapter_index, line_offset)
-          bookmarks = find_by_book_path(book_path)
-          bookmarks.find do |bookmark|
-            bookmark.chapter_index == chapter_index && bookmark.line_offset == line_offset
+          # Find bookmark at a specific position
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param chapter_index [Integer] Chapter index
+          # @param line_offset [Integer] Line offset within the chapter
+          # @return [Models::Bookmark, nil] The bookmark at this position, or nil
+          def find_at_position(book_path, chapter_index, line_offset)
+            bookmarks = find_by_book_path(book_path)
+            bookmarks.find do |bookmark|
+              bookmark.chapter_index == chapter_index && bookmark.line_offset == line_offset
+            end
+          rescue Shoko::Error => e
+            handle_storage_error(e, "finding bookmark at position for #{book_path}")
           end
-        rescue StandardError => e
-          handle_storage_error(e, "finding bookmark at position for #{book_path}")
         end
       end
+    end
   end
 end

data/lib/shoko/adapters/storage/repositories/cached_library_repository.rb

@@ -7,123 +7,126 @@ require_relative '../cache_paths'
 require_relative '../json_cache_store'
 require_relative '../cache_pointer_manager'
 require_relative '../epub_cache'
-require_relative '../../output/terminal/terminal_sanitizer.rb'
+require_relative '../../../shared/text_sanitizer'
 
 module Shoko
-  module Adapters::Storage::Repositories
-      # Provides read-only access to cached library metadata on disk.
-      class CachedLibraryRepository
-        def initialize(cache_root: Adapters::Storage::CachePaths.cache_root, store: nil)
-          @cache_root = cache_root
-          @cache_store = store || Adapters::Storage::JsonCacheStore.new(cache_root:)
-        end
-
-        def list_entries
-          rows = fetch_manifest_rows
-          rows = fetch_rows if rows.empty?
-          return [] if rows.empty?
-
-          rows.filter_map { |row| build_entry_from_row(row) }
-        end
-
-        private
-
-        def fetch_rows
-          @cache_store.list_books
-        end
-
-        def fetch_manifest_rows
-          Adapters::Storage::JsonCacheStore.manifest_rows(@cache_root)
-        end
+  module Adapters
+    module Storage
+      module Repositories
+        # Provides read-only access to cached library metadata on disk.
+        class CachedLibraryRepository
+          def initialize(cache_root: Adapters::Storage::CachePaths.cache_root, store: nil, runtime_config: nil)
+            @cache_root = cache_root
+            @runtime_config = runtime_config
+            @cache_store = store || Adapters::Storage::JsonCacheStore.new(
+              cache_root: cache_root,
+              runtime_config: runtime_config
+            )
+          end
 
-        def build_entry_from_row(row)
-          sha = row.is_a?(Hash) ? (row['source_sha'] || row[:source_sha]) : nil
-          pointer_path = Adapters::Storage::EpubCache.cache_path_for_sha(sha, cache_root: @cache_root)
-          return nil unless pointer_path
+          def list_entries
+            rows = fetch_manifest_rows
+            rows = fetch_rows if rows.empty?
+            return [] if rows.empty?
 
-          ensure_pointer_file(row, pointer_path)
+            rows.filter_map { |row| build_entry_from_row(row) }
+          end
 
-          metadata = parse_json_object(row['metadata_json'])
-          authors = parse_json_array(row['authors_json']).map { |name| sanitize_display(name.to_s) }
+          private
 
-          {
-            title: sanitize_display(present_or_default(row['title'], 'Unknown')),
-            authors: authors.join(', '),
-            year: extract_year(metadata),
-            size_bytes: (row['cache_size_bytes'] || safe_file_size(pointer_path)).to_i,
-            open_path: pointer_path,
-            epub_path: row['source_path'].to_s,
-          }
-        end
+          def fetch_rows
+            @cache_store.list_books
+          end
 
-        def ensure_pointer_file(row, path)
-          return path if File.exist?(path) || row['source_sha'].to_s.empty?
+          def fetch_manifest_rows
+            Adapters::Storage::JsonCacheStore.manifest_rows(@cache_root, runtime_config: @runtime_config)
+          end
 
-          generated_at = begin
-            raw = row['generated_at']
-            raw ? Time.at(raw.to_f).utc.iso8601 : Time.now.utc.iso8601
-          rescue StandardError
-            Time.now.utc.iso8601
+          def build_entry_from_row(row)
+            sha = row.is_a?(Hash) ? (row['source_sha'] || row[:source_sha]) : nil
+            pointer_path = Adapters::Storage::EpubCache.cache_path_for_sha(sha, cache_root: @cache_root)
+            return nil unless pointer_path
+
+            ensure_pointer_file(row, pointer_path)
+
+            metadata = parse_json_object(row['metadata_json'])
+            authors = parse_json_array(row['authors_json']).map { |name| sanitize_display(name.to_s) }
+
+            source_path = row['source_path'].to_s
+            {
+              title: sanitize_display(present_or_default(row['title'], 'Unknown')),
+              authors: authors.join(', '),
+              year: extract_year(metadata),
+              size_bytes: (row['cache_size_bytes'] || safe_file_size(pointer_path)).to_i,
+              open_path: pointer_path,
+              book_path: source_path,
+              epub_path: source_path,
+            }
           end
 
-          metadata = {
-            'format' => Adapters::Storage::CachePointerManager::POINTER_FORMAT,
-            'version' => Adapters::Storage::CachePointerManager::POINTER_VERSION,
-            'sha256' => row['source_sha'],
-            'source_path' => row['source_path'],
-            'generated_at' => generated_at,
-            'engine' => Adapters::Storage::JsonCacheStore::ENGINE,
-          }
-
-          Adapters::Storage::CachePointerManager.new(path).write(metadata)
-          path
-        rescue StandardError
-          path
-        end
+          def ensure_pointer_file(row, path)
+            return path if File.exist?(path) || row['source_sha'].to_s.empty?
+
+            generated_at = begin
+              raw = row['generated_at']
+              raw ? Time.at(raw.to_f).utc.iso8601 : Time.now.utc.iso8601
+            rescue Shoko::Error
+              Time.now.utc.iso8601
+            end
+
+            metadata = {
+              'format' => Adapters::Storage::CachePointerManager::POINTER_FORMAT,
+              'version' => Adapters::Storage::CachePointerManager::POINTER_VERSION,
+              'sha256' => row['source_sha'],
+              'source_path' => row['source_path'],
+              'generated_at' => generated_at,
+              'engine' => Adapters::Storage::JsonCacheStore::ENGINE,
+            }
+
+            Adapters::Storage::CachePointerManager.new(path).write(metadata)
+            path
+          end
 
-        def parse_json_object(value)
-          return {} unless value
-          return value if value.is_a?(Hash)
+          def parse_json_object(value)
+            return {} unless value
+            return value if value.is_a?(Hash)
 
-          parsed = JSON.parse(value)
-          parsed.is_a?(Hash) ? parsed : {}
-        rescue JSON::ParserError, TypeError
-          {}
-        end
+            parsed = JSON.parse(value)
+            parsed.is_a?(Hash) ? parsed : {}
+          end
 
-        def parse_json_array(value)
-          return [] unless value
-          return value if value.is_a?(Array)
+          def parse_json_array(value)
+            return [] unless value
+            return value if value.is_a?(Array)
 
-          parsed = JSON.parse(value)
-          parsed.is_a?(Array) ? parsed : []
-        rescue JSON::ParserError, TypeError
-          []
-        end
+            parsed = JSON.parse(value)
+            parsed.is_a?(Array) ? parsed : []
+          end
 
-        def extract_year(metadata)
-          return '' unless metadata.respond_to?(:[])
+          def extract_year(metadata)
+            return '' unless metadata.is_a?(Hash)
 
-          year = metadata['year'] || metadata[:year]
-          year ? year.to_s : ''
-        end
+            year = metadata['year'] || metadata[:year]
+            year ? year.to_s : ''
+          end
 
-        def present_or_default(value, fallback)
-          str = value.to_s.strip
-          str.empty? ? fallback : value
-        end
+          def present_or_default(value, fallback)
+            str = value.to_s.strip
+            str.empty? ? fallback : value
+          end
 
-        def safe_file_size(path)
-          File.size(path)
-        rescue StandardError
-          0
-        end
+          def safe_file_size(path)
+            File.size(path)
+          end
 
-        def sanitize_display(text)
-          Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(text.to_s, preserve_newlines: false, preserve_tabs: false)
-        rescue StandardError
-          text.to_s
+          def sanitize_display(text)
+            Shoko::Shared::TextSanitizer.sanitize(text.to_s, preserve_newlines: false,
+                                                             preserve_tabs: false)
+          rescue Shoko::Error
+            text.to_s
+          end
         end
       end
+    end
   end
 end