shoko 0.1.3 → 0.1.5

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

@@ -5,72 +5,110 @@ require 'json'
 require 'time'
 require_relative 'atomic_file_writer'
 require_relative 'config_paths'
-require_relative '../output/terminal/terminal_sanitizer.rb'
+require_relative '../../shared/text_sanitizer'
+require_relative '../../shared/errors'
 
 module Shoko
-  module Adapters::Storage
-    # Manages a list of recently opened files.
-    class RecentFiles
-      CONFIG_DIR = Adapters::Storage::ConfigPaths.config_root
-      RECENT_FILE = File.join(CONFIG_DIR, 'recent.json')
-      MAX_RECENT_FILES = 10
-
-      class << self
-        # Adds a file path to the top of the recent files list.
-        #
-        # @param path [String] The path to the file to add.
-        def add(path)
-          recent_files = load.reject { |file| file['path'] == path }
-
-          raw_label = File.basename(path, File.extname(path)).tr('_-', ' ')
-          label = Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(raw_label, preserve_newlines: false, preserve_tabs: false)
-
-          new_entry = {
-            'path' => path,
-            'name' => label,
-            'accessed' => Time.now.iso8601,
-          }
-
-          save([new_entry, *recent_files].first(MAX_RECENT_FILES))
-        end
+  module Adapters
+    module Storage
+      # Manages a list of recently opened files.
+      class RecentFiles
+        CONFIG_DIR = Adapters::Storage::ConfigPaths.config_root
+        RECENT_FILE = File.join(CONFIG_DIR, 'recent.json')
+        MAX_RECENT_FILES = 10
+
+        class << self
+          # Adds a file path to the top of the recent files list.
+          #
+          # @param path [String] The path to the file to add.
+          def add(path)
+            cleaned_path = path.to_s.strip
+            raise ArgumentError, 'path is required' if cleaned_path.empty?
+
+            recent_files = load.reject { |file| file['path'] == cleaned_path }
 
-        # Loads the list of recent files from disk.
-        #
-        # @return [Array<Hash>] An array of recent file entries.
-        def load
-          return [] unless File.exist?(RECENT_FILE)
+            raw_label = File.basename(cleaned_path, File.extname(cleaned_path)).tr('_-', ' ')
+            label = Shoko::Shared::TextSanitizer.sanitize(raw_label, preserve_newlines: false,
+                                                                     preserve_tabs: false)
 
-          entries = JSON.parse(File.read(RECENT_FILE))
-          Array(entries).map do |row|
-            next row unless row.is_a?(Hash)
+            new_entry = {
+              'path' => cleaned_path,
+              'name' => label,
+              'accessed' => Time.now.iso8601,
+            }
 
-            safe = row.dup
-            safe['name'] =
-              Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(safe['name'].to_s, preserve_newlines: false, preserve_tabs: false)
-            safe
+            save([new_entry, *recent_files].first(MAX_RECENT_FILES))
+          rescue StandardError => e
+            raise_storage_error('recent_files_add', RECENT_FILE, e)
           end
-        rescue JSON::ParserError, Errno::ENOENT
-          []
-        end
 
-        # Clears the recent files list by removing the recent file.
-        def clear
-          FileUtils.rm_f(RECENT_FILE)
-        rescue Errno::EACCES, Errno::ENOENT
-          # Ignore errors
-        end
+          # Loads the list of recent files from disk.
+          #
+          # @return [Array<Hash>] An array of recent file entries.
+          def load
+            return [] unless File.exist?(RECENT_FILE)
+
+            entries = JSON.parse(File.read(RECENT_FILE))
+            rows = validate_entries!(entries)
+            rows.map do |row|
+              next row unless row.is_a?(Hash)
+
+              safe = row.dup
+              safe['name'] =
+                Shoko::Shared::TextSanitizer.sanitize(safe['name'].to_s,
+                                                         preserve_newlines: false, preserve_tabs: false)
+              safe
+            end
+          rescue StandardError => e
+            raise_storage_error('recent_files_load', RECENT_FILE, e)
+          end
+
+          # Clears the recent files list by removing the recent file.
+          def clear
+            FileUtils.rm_f(RECENT_FILE)
+          rescue StandardError => e
+            raise_storage_error('recent_files_clear', RECENT_FILE, e)
+          end
 
-        private
-
-        # Saves the list of recent files to disk.
-        #
-        # @param recent [Array<Hash>] The list of recent files to save.
-        def save(recent)
-          FileUtils.mkdir_p(File.dirname(RECENT_FILE))
-          payload = JSON.pretty_generate(recent)
-          Shoko::Adapters::Storage::AtomicFileWriter.write(RECENT_FILE, payload)
-        rescue StandardError
-          nil
+          private
+
+          # Saves the list of recent files to disk.
+          #
+          # @param recent [Array<Hash>] The list of recent files to save.
+          def save(recent)
+            FileUtils.mkdir_p(File.dirname(RECENT_FILE))
+            payload = JSON.pretty_generate(recent)
+            Shoko::Adapters::Storage::AtomicFileWriter.write(RECENT_FILE, payload)
+          rescue StandardError => e
+            raise_storage_error('recent_files_save', RECENT_FILE, e)
+          end
+
+          def validate_entries!(entries)
+            unless entries.is_a?(Array)
+              raise Shoko::StorageError.new('recent_files_load', RECENT_FILE, 'expected an array payload')
+            end
+
+            entries.each_with_index do |row, idx|
+              unless row.is_a?(Hash)
+                raise Shoko::StorageError.new('recent_files_load', RECENT_FILE, "entry #{idx} is not a hash")
+              end
+              unless row.key?('path') && row.key?('name') && row.key?('accessed')
+                raise Shoko::StorageError.new(
+                  'recent_files_load',
+                  RECENT_FILE,
+                  "entry #{idx} missing required keys"
+                )
+              end
+            end
+
+            entries
+          end
+
+          def raise_storage_error(operation, path, error)
+            raise error if error.is_a?(Shoko::Error)
+
+            raise Shoko::StorageError.new(operation, path.to_s, error.message)
+          end
         end
       end
     end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/recent_files_repository'
+require_relative 'recent_files'
+
+module Shoko
+  module Adapters
+    module Storage
+      # Adapter wrapper for recent files persistence.
+      class RecentFilesRepository
+        include Core::Ports::Outbound::RecentFilesRepository
+
+        def add(path)
+          RecentFiles.add(path)
+        end
+
+        def load
+          RecentFiles.load
+        end
+
+        def clear
+          RecentFiles.clear
+        end
+      end
+    end
+  end
+end

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

@@ -1,182 +1,170 @@
 # frozen_string_literal: true
 
+require 'set'
+
 require_relative 'base_repository'
 require_relative 'storage/annotation_file_store'
 
 module Shoko
-  module Adapters::Storage::Repositories
-      # Repository for annotation persistence, abstracting the underlying storage mechanism.
-      #
-      # This repository provides a clean domain interface for annotation operations,
-      # hiding the file-based persistence details from domain services.
-      #
-      # @example Adding an annotation
-      #   repo = AnnotationRepository.new(dependencies)
-      #   annotation = repo.add_for_book(
-      #     '/path/to/book.epub',
-      #     text: 'Selected text',
-      #     note: 'My note',
-      #     range: { start: 100, end: 120 },
-      #     chapter_index: 2
-      #   )
-      #
-      # @example Getting annotations for a book
-      #   annotations = repo.find_by_book_path('/path/to/book.epub')
-      class AnnotationRepository < BaseRepository
-        def initialize(dependencies)
-          super
-          file_writer = dependencies.resolve(:file_writer)
-          @storage = Storage::AnnotationFileStore.new(file_writer:)
-        end
-
-        # Add a new annotation for a specific book
+  module Adapters
+    module Storage
+      module Repositories
+        # Repository for annotation persistence, abstracting the underlying storage mechanism.
         #
-        # @param book_path [String] Path to the EPUB file
-        # @param text [String] The selected text being annotated
-        # @param note [String] The annotation note
-        # @param range [Hash] Text selection range with :start and :end
-        # @param chapter_index [Integer] Chapter index (0-based)
-        # @param page_meta [Hash, nil] Optional page metadata
-        # @return [Hash] The created annotation data
-        def add_for_book(book_path, text:, note:, range:, chapter_index:, page_meta: nil)
-          validate_required_params(
-            { book_path: book_path, text: text, note: note, range: range,
-              chapter_index: chapter_index },
-            %i[book_path text note range chapter_index]
-          )
-
-          begin
-            @storage.add(book_path, text, note, range, chapter_index, page_meta)
-
-            # Return the most recently created annotation
-            annotations = find_by_book_path(book_path)
-            annotations.max_by do |a|
-              Time.parse(a['created_at'] || a['updated_at'] || Time.now.iso8601)
-            end
-          rescue StandardError => e
-            handle_storage_error(e, "adding annotation for #{book_path}")
+        # This repository provides a clean domain interface for annotation operations,
+        # hiding the file-based persistence details from domain services.
+        #
+        # @example Adding an annotation
+        #   repo = AnnotationRepository.new(dependencies)
+        #   annotation = repo.add_for_book(
+        #     '/path/to/book.epub',
+        #     text: 'Selected text',
+        #     note: 'My note',
+        #     range: { start: 100, end: 120 },
+        #     chapter_index: 2
+        #   )
+        #
+        # @example Getting annotations for a book
+        #   annotations = repo.find_by_book_path('/path/to/book.epub')
+        class AnnotationRepository < BaseRepository
+          include Core::Ports::Outbound::AnnotationRepository
+
+          def initialize(file_writer:, logger: nil, storage: nil)
+            super(logger: logger)
+            @storage = storage || Storage::AnnotationFileStore.new(file_writer: file_writer)
           end
-        end
 
-        # Find all annotations for a specific book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Array<Hash>] Array of annotation hashes for the book
-        def find_by_book_path(book_path)
-          validate_required_params({ book_path: book_path }, [:book_path])
+          # Add a new annotation for a specific book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param text [String] The selected text being annotated
+          # @param note [String] The annotation note
+          # @param range [Hash] Text selection range with :start and :end
+          # @param chapter_index [Integer] Chapter index (0-based)
+          # @param page_meta [Hash, nil] Optional page metadata
+          # @return [Hash] The created annotation data
+          def add_for_book(book_path, text:, note:, range:, chapter_index:, page_meta: nil)
+            validate_required_params(
+              { book_path: book_path, text: text, note: note, range: range,
+                chapter_index: chapter_index },
+              %i[book_path text note range chapter_index]
+            )
+
+            existing_ids = Set.new(find_by_book_path(book_path).filter_map { |annotation| annotation['id'] })
+            persisted = @storage.add(book_path, text, note, range, chapter_index, page_meta)
+            raise PersistenceError, "adding annotation for #{book_path} failed" unless persisted
 
-          begin
+            annotations = find_by_book_path(book_path)
+            created = detect_created_annotation(existing_ids, annotations)
+            ensure_entity_exists(created, 'Annotation')
+            created
+          end
+
+          # Find all annotations for a specific book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Array<Hash>] Array of annotation hashes for the book
+          def find_by_book_path(book_path)
+            validate_required_params({ book_path: book_path }, [:book_path])
             @storage.get(book_path) || []
-          rescue StandardError => e
-            handle_storage_error(e, "loading annotations for #{book_path}")
           end
-        end
 
-        # Find all annotations across all books
-        #
-        # @return [Hash] Hash mapping book paths to annotation arrays
-        def find_all
-          @storage.all || {}
-        rescue StandardError => e
-          handle_storage_error(e, 'loading all annotations')
-        end
+          # Find all annotations across all books
+          #
+          # @return [Hash] Hash mapping book paths to annotation arrays
+          def find_all
+            @storage.all || {}
+          end
 
-        # Update an existing annotation's note
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param annotation_id [String] ID of the annotation to update
-        # @param note [String] New note content
-        # @return [Boolean] True if updated successfully
-        def update_note(book_path, annotation_id, note)
-          validate_required_params(
-            { book_path: book_path, annotation_id: annotation_id, note: note },
-            %i[book_path annotation_id note]
-          )
-
-          begin
-            @storage.update(book_path, annotation_id, note)
-            true
-          rescue StandardError => e
-            handle_storage_error(e, "updating annotation #{annotation_id} for #{book_path}")
+          # Update an existing annotation's note
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param annotation_id [String] ID of the annotation to update
+          # @param note [String] New note content
+          # @return [Boolean] True if updated successfully
+          def update_note(book_path, annotation_id, note)
+            validate_required_params(
+              { book_path: book_path, annotation_id: annotation_id, note: note },
+              %i[book_path annotation_id note]
+            )
+            @storage.update(book_path, annotation_id, note) == true
           end
-        end
 
-        # Delete a specific annotation
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param annotation_id [String] ID of the annotation to delete
-        # @return [Boolean] True if deleted successfully
-        def delete_by_id(book_path, annotation_id)
-          validate_required_params(
-            { book_path: book_path, annotation_id: annotation_id },
-            %i[book_path annotation_id]
-          )
-
-          begin
-            @storage.delete(book_path, annotation_id)
-            true
-          rescue StandardError => e
-            handle_storage_error(e, "deleting annotation #{annotation_id} for #{book_path}")
+          # Delete a specific annotation
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param annotation_id [String] ID of the annotation to delete
+          # @return [Boolean] True if deleted successfully
+          def delete_by_id(book_path, annotation_id)
+            validate_required_params(
+              { book_path: book_path, annotation_id: annotation_id },
+              %i[book_path annotation_id]
+            )
+            @storage.delete(book_path, annotation_id) == true
           end
-        end
 
-        # Find a specific annotation by ID
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param annotation_id [String] ID of the annotation to find
-        # @return [Hash, nil] The annotation hash, or nil if not found
-        def find_by_id(book_path, annotation_id)
-          annotations = find_by_book_path(book_path)
-          annotations.find { |a| a['id'] == annotation_id }
-        rescue StandardError => e
-          handle_storage_error(e, "finding annotation #{annotation_id} for #{book_path}")
-        end
+          # Find a specific annotation by ID
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param annotation_id [String] ID of the annotation to find
+          # @return [Hash, nil] The annotation hash, or nil if not found
+          def find_by_id(book_path, annotation_id)
+            annotations = find_by_book_path(book_path)
+            annotations.find { |a| a['id'] == annotation_id }
+          end
 
-        # Get annotation count for a book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Integer] Number of annotations for the book
-        def count_for_book(book_path)
-          find_by_book_path(book_path).size
-        rescue StandardError => e
-          handle_storage_error(e, "counting annotations for #{book_path}")
-        end
+          # Get annotation count for a book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Integer] Number of annotations for the book
+          def count_for_book(book_path)
+            find_by_book_path(book_path).length
+          end
 
-        # Find annotations by chapter
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param chapter_index [Integer] Chapter index to filter by
-        # @return [Array<Hash>] Annotations in the specified chapter
-        def find_by_chapter(book_path, chapter_index)
-          annotations = find_by_book_path(book_path)
-          annotations.select { |a| a['chapter_index'] == chapter_index }
-        rescue StandardError => e
-          handle_storage_error(e, "finding annotations by chapter for #{book_path}")
-        end
+          # Find annotations by chapter
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param chapter_index [Integer] Chapter index to filter by
+          # @return [Array<Hash>] Annotations in the specified chapter
+          def find_by_chapter(book_path, chapter_index)
+            annotations = find_by_book_path(book_path)
+            annotations.select { |a| a['chapter_index'] == chapter_index }
+          end
 
-        # Check if any annotations exist at a text range
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @param chapter_index [Integer] Chapter index
-        # @param range [Hash] Text range with :start and :end
-        # @return [Boolean] True if annotations exist in this range
-        def exists_in_range?(book_path, chapter_index, range)
-          annotations = find_by_chapter(book_path, chapter_index)
-          annotations.any? do |annotation|
-            annotation_range = annotation['range']
-            next false unless annotation_range
-
-            # Check for overlap
-            annotation_start = annotation_range['start'] || annotation_range[:start]
-            annotation_end = annotation_range['end'] || annotation_range[:end]
-            range_start = range['start'] || range[:start]
-            range_end = range['end'] || range[:end]
-
-            annotation_start < range_end && range_start < annotation_end
+          # Check if any annotations exist at a text range
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @param chapter_index [Integer] Chapter index
+          # @param range [Hash] Text range with :start and :end
+          # @return [Boolean] True if annotations exist in this range
+          def exists_in_range?(book_path, chapter_index, range)
+            annotations = find_by_chapter(book_path, chapter_index)
+            annotations.any? do |annotation|
+              annotation_range = annotation['range']
+              next false unless annotation_range
+
+              # Check for overlap
+              annotation_start = annotation_range['start'] || annotation_range[:start]
+              annotation_end = annotation_range['end'] || annotation_range[:end]
+              range_start = range['start'] || range[:start]
+              range_end = range['end'] || range[:end]
+
+              annotation_start < range_end && range_start < annotation_end
+            end
+          end
+
+          private
+
+          def detect_created_annotation(existing_ids, annotations)
+            annotations.reverse_each do |annotation|
+              id = annotation['id']
+              return annotation if id && !existing_ids.include?(id)
+            end
+
+            annotations.last
           end
-        rescue StandardError => e
-          handle_storage_error(e, "checking annotation range for #{book_path}")
         end
       end
+    end
   end
 end