shoko 0.1.3 → 0.1.5

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

@@ -4,163 +4,149 @@ require 'time'
 
 require_relative 'base_repository'
 require_relative 'storage/progress_file_store'
+require_relative '../../../core/ports/outbound/progress_repository'
+require_relative '../../../core/models/reading_progress'
 
 module Shoko
-  module Adapters::Storage::Repositories
-      # Repository for reading progress persistence, abstracting the underlying storage mechanism.
-      #
-      # This repository provides a clean domain interface for progress operations,
-      # hiding the file-based persistence details from domain services.
-      #
-      # @example Saving progress
-      #   repo = ProgressRepository.new(dependencies)
-      #   repo.save_for_book('/path/to/book.epub', chapter_index: 3, line_offset: 150)
-      #
-      # @example Loading progress
-      #   progress = repo.find_by_book_path('/path/to/book.epub')
-      class ProgressRepository < BaseRepository
-        # Progress data structure
-        ProgressData = Struct.new(:chapter_index, :line_offset, :timestamp, keyword_init: true) do
-          def to_h
-            {
-              chapter: chapter_index,
-              line_offset: line_offset,
-              timestamp: timestamp,
-            }
+  module Adapters
+    module Storage
+      module Repositories
+        # Repository for reading progress persistence, abstracting the underlying storage mechanism.
+        #
+        # This repository provides a clean domain interface for progress operations,
+        # hiding the file-based persistence details from domain services.
+        #
+        # @example Saving progress
+        #   repo = ProgressRepository.new(dependencies)
+        #   repo.save_for_book('/path/to/book.epub', chapter_index: 3, line_offset: 150)
+        #
+        # @example Loading progress
+        #   progress = repo.find_by_book_path('/path/to/book.epub')
+        class ProgressRepository < BaseRepository
+          include Shoko::Core::Ports::Outbound::ProgressRepository
+
+          def initialize(file_writer:, logger: nil)
+            super(logger: logger)
+            @storage = Storage::ProgressFileStore.new(file_writer: file_writer)
           end
 
-          def self.from_h(hash)
-            return nil unless hash
-
-            new(
-              chapter_index: hash['chapter'] || hash[:chapter],
-              line_offset: hash['line_offset'] || hash[:line_offset],
-              timestamp: hash['timestamp'] || hash[:timestamp]
+          # Save reading progress 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
+          # @return [Core::Models::ReadingProgress] The saved progress data
+          def save_for_book(book_path, chapter_index:, line_offset:)
+            validate_required_params(
+              { book_path: book_path, chapter_index: chapter_index, line_offset: line_offset },
+              %i[book_path chapter_index line_offset]
             )
-          end
-        end
-
-        def initialize(dependencies)
-          super
-          file_writer = dependencies.resolve(:file_writer)
-          @storage = Storage::ProgressFileStore.new(file_writer:)
-        end
 
-        # Save reading progress 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
-        # @return [ProgressData] The saved progress data
-        def save_for_book(book_path, chapter_index:, line_offset:)
-          validate_required_params(
-            { book_path: book_path, chapter_index: chapter_index, line_offset: line_offset },
-            %i[book_path chapter_index line_offset]
-          )
-
-          begin
-            @storage.save(book_path, chapter_index, line_offset)
-
-            # Return the progress data that was saved
-            ProgressData.new(
-              chapter_index: chapter_index,
-              line_offset: line_offset,
-              timestamp: Time.now.iso8601
-            )
-          rescue StandardError => e
-            handle_storage_error(e, "saving progress for #{book_path}")
+            begin
+              @storage.save(book_path, chapter_index, line_offset)
+
+              # Return the progress data that was saved
+              Shoko::Core::Models::ReadingProgress.new(
+                chapter_index: chapter_index,
+                line_offset: line_offset,
+                timestamp: Time.now.iso8601
+              )
+            rescue Shoko::Error => e
+              handle_storage_error(e, "saving progress for #{book_path}")
+            end
           end
-        end
 
-        # Find reading progress for a specific book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [ProgressData, nil] Progress data for the book, or nil if none exists
-        def find_by_book_path(book_path)
-          validate_required_params({ book_path: book_path }, [:book_path])
-
-          begin
-            progress_hash = @storage.load(book_path)
-            ProgressData.from_h(progress_hash)
-          rescue StandardError => e
-            handle_storage_error(e, "loading progress for #{book_path}")
+          # Find reading progress for a specific book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Core::Models::ReadingProgress, nil] Progress data for the book, or nil if none exists
+          def find_by_book_path(book_path)
+            validate_required_params({ book_path: book_path }, [:book_path])
+
+            begin
+              progress_hash = @storage.load(book_path)
+              Shoko::Core::Models::ReadingProgress.from_h(progress_hash)
+            rescue Shoko::Error => e
+              handle_storage_error(e, "loading progress for #{book_path}")
+            end
           end
-        end
 
-        # Find all reading progress across all books
-        #
-        # @return [Hash<String, ProgressData>] Hash mapping book paths to progress data
-        def find_all
-          all_progress = @storage.load_all
-          all_progress.transform_values { |progress_hash| ProgressData.from_h(progress_hash) }
-        rescue StandardError => e
-          handle_storage_error(e, 'loading all progress data')
-        end
+          # Find all reading progress across all books
+          #
+          # @return [Hash<String, Core::Models::ReadingProgress>] Hash mapping book paths to progress data
+          def find_all
+            all_progress = @storage.load_all
+            all_progress.transform_values { |progress_hash| Shoko::Core::Models::ReadingProgress.from_h(progress_hash) }
+          rescue Shoko::Error => e
+            handle_storage_error(e, 'loading all progress data')
+          end
 
-        # Check if progress exists for a book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Boolean] True if progress data exists for the book
-        def exists_for_book?(book_path)
-          !find_by_book_path(book_path).nil?
-        rescue StandardError => e
-          handle_storage_error(e, "checking progress existence for #{book_path}")
-        end
+          # Check if progress exists for a book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Boolean] True if progress data exists for the book
+          def exists_for_book?(book_path)
+            !find_by_book_path(book_path).nil?
+          rescue Shoko::Error => e
+            handle_storage_error(e, "checking progress existence for #{book_path}")
+          end
 
-        # Get the timestamp of the last progress update for a book
-        #
-        # @param book_path [String] Path to the EPUB file
-        # @return [Time, nil] Last update timestamp, or nil if no progress exists
-        def last_updated_at(book_path)
-          progress = find_by_book_path(book_path)
-          ts = progress&.timestamp
-          return nil unless ts
-
-          Time.parse(ts)
-        rescue StandardError => e
-          handle_storage_error(e, "getting last update time for #{book_path}")
-        end
+          # Get the timestamp of the last progress update for a book
+          #
+          # @param book_path [String] Path to the EPUB file
+          # @return [Time, nil] Last update timestamp, or nil if no progress exists
+          def last_updated_at(book_path)
+            progress = find_by_book_path(book_path)
+            ts = progress&.timestamp
+            return nil unless ts
+
+            Time.parse(ts)
+          rescue Shoko::Error => e
+            handle_storage_error(e, "getting last update time for #{book_path}")
+          end
 
-        # Get books ordered by most recently read
-        #
-        # @param limit [Integer, nil] Maximum number of books to return
-        # @return [Array<String>] Array of book paths ordered by recency
-        def recent_books(limit: nil)
-          all_progress = find_all
-          sorted_paths = all_progress.sort_by do |_path, progress|
-            ts = progress.timestamp
-            ts ? Time.parse(ts) : Time.at(0)
-          end.reverse.map(&:first)
-
-          limit ? sorted_paths.take(limit) : sorted_paths
-        rescue StandardError => e
-          handle_storage_error(e, 'getting recent books')
-        end
+          # Get books ordered by most recently read
+          #
+          # @param limit [Integer, nil] Maximum number of books to return
+          # @return [Array<String>] Array of book paths ordered by recency
+          def recent_books(limit: nil)
+            all_progress = find_all
+            sorted_paths = all_progress.sort_by do |_path, progress|
+              ts = progress.timestamp
+              ts ? Time.parse(ts) : Time.at(0)
+            end.reverse.map(&:first)
+
+            limit ? sorted_paths.take(limit) : sorted_paths
+          rescue Shoko::Error => e
+            handle_storage_error(e, 'getting recent books')
+          end
 
-        # Update progress only if the new position is further than current
-        #
-        # @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
-        # @return [ProgressData] The saved progress data
-        def save_if_further(book_path, chapter_index:, line_offset:)
-          current_progress = find_by_book_path(book_path)
-
-          should_save = if current_progress.nil?
-                          true
-                        else
-                          cur_ch = current_progress.chapter_index
-                          cur_off = current_progress.line_offset
-                          chapter_index > cur_ch ||
-                            (chapter_index == cur_ch && line_offset > cur_off)
-                        end
-
-          return save_for_book(book_path, chapter_index: chapter_index, line_offset: line_offset) if should_save
-
-          current_progress
-        rescue StandardError => e
-          handle_storage_error(e, "conditionally saving progress for #{book_path}")
+          # Update progress only if the new position is further than current
+          #
+          # @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
+          # @return [Core::Models::ReadingProgress] The saved progress data
+          def save_if_further(book_path, chapter_index:, line_offset:)
+            current_progress = find_by_book_path(book_path)
+
+            should_save = if current_progress.nil?
+                            true
+                          else
+                            cur_ch = current_progress.chapter_index
+                            cur_off = current_progress.line_offset
+                            chapter_index > cur_ch ||
+                              (chapter_index == cur_ch && line_offset > cur_off)
+                          end
+
+            return save_for_book(book_path, chapter_index: chapter_index, line_offset: line_offset) if should_save
+
+            current_progress
+          rescue Shoko::Error => e
+            handle_storage_error(e, "conditionally saving progress for #{book_path}")
+          end
         end
       end
+    end
   end
 end

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

@@ -1,128 +1,102 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'fileutils'
 require 'time'
-
-require_relative '../../../output/terminal/terminal_sanitizer.rb'
-require_relative 'file_store_utils'
-require_relative '../../config_paths'
-# Domain storage helpers should operate via injected services to avoid reaching into infrastructure.
+require 'securerandom'
+require_relative '../../../../shared/text_sanitizer'
+require_relative 'base_file_store'
 
 module Shoko
-  module Adapters::Storage::Repositories::Storage
-    # File-backed annotation storage under Domain.
-    # Persists annotations to ${XDG_CONFIG_HOME:-~/.config}/shoko/annotations.json
-    class AnnotationFileStore
-      FILE_NAME = 'annotations.json'
-
-      def initialize(file_writer:)
-        @file_writer = file_writer
-      end
-
-      def all
-        sanitize_all(load_all)
-      rescue StandardError
-        {}
-      end
-
-      def get(path)
-        sanitize_list(load_all[path.to_s] || []).dup
-      rescue StandardError
-        []
-      end
-
-      def add(path, text, note, range, chapter_index, page_meta = nil)
-        data = load_all
-        key = path.to_s
-        list = data[key] || []
-        now = Time.now
-        ann = {
-          'id' => now.to_f.to_s,
-          'text' => sanitize_body(text),
-          'note' => sanitize_body(note),
-          'range' => range,
-          'chapter_index' => chapter_index,
-          'created_at' => now.iso8601,
-        }
-        if page_meta.is_a?(Hash)
-          ann['page_current'] = page_meta[:current] || page_meta['current']
-          ann['page_total'] = page_meta[:total] || page_meta['total']
-          ann['page_mode'] = page_meta[:type] || page_meta['type']
-        end
-        list << ann
-        data[key] = list
-        save_all(data)
-        true
-      rescue StandardError
-        false
-      end
-
-      def update(path, id, note)
-        data = load_all
-        key = path.to_s
-        list = data[key] || []
-        ann = list.find { |a| a['id'] == id }
-        return false unless ann
-
-        ann['note'] = sanitize_body(note)
-        ann['updated_at'] = Time.now.iso8601
-        data[key] = list
-        save_all(data)
-        true
-      rescue StandardError
-        false
-      end
-
-      def delete(path, id)
-        data = load_all
-        key = path.to_s
-        list = data[key] || []
-        list.reject! { |a| a['id'] == id }
-        list.empty? ? data.delete(key) : data[key] = list
-        save_all(data)
-        true
-      rescue StandardError
-        false
-      end
-
-      private
-
-      attr_reader :file_writer
-
-      def load_all
-        FileStoreUtils.load_json_or_empty(file_path)
-      end
-
-      def sanitize_all(data)
-        return {} unless data.is_a?(Hash)
-
-        data.transform_values { |list| sanitize_list(list) }
-      end
-
-      def sanitize_list(list)
-        Array(list).map do |ann|
-          next ann unless ann.is_a?(Hash)
-
-          safe = ann.dup
-          safe['text'] = sanitize_body(safe['text'])
-          safe['note'] = sanitize_body(safe['note'])
-          safe
+  module Adapters
+    module Storage
+      module Repositories
+        module Storage
+          # File-backed annotation storage under Domain.
+          # Persists annotations to ${XDG_CONFIG_HOME:-~/.config}/shoko/annotations.json
+          class AnnotationFileStore < BaseFileStore
+            FILE_NAME = 'annotations.json'
+
+            def all
+              sanitize_all(load_all)
+            end
+
+            def get(path)
+              sanitize_list(load_all[path.to_s] || []).dup
+            end
+
+            def add(path, text, note, range, chapter_index, page_meta = nil)
+              data = load_all
+              key = path.to_s
+              list = data[key] || []
+              now = Time.now
+              ann = {
+                'id' => SecureRandom.uuid,
+                'text' => sanitize_body(text),
+                'note' => sanitize_body(note),
+                'range' => range,
+                'chapter_index' => chapter_index,
+                'created_at' => now.iso8601,
+              }
+              if page_meta.is_a?(Hash)
+                ann['page_current'] = page_meta[:current] || page_meta['current']
+                ann['page_total'] = page_meta[:total] || page_meta['total']
+                ann['page_mode'] = page_meta[:type] || page_meta['type']
+              end
+              list << ann
+              data[key] = list
+              save_all(data)
+              true
+            end
+
+            def update(path, id, note)
+              data = load_all
+              key = path.to_s
+              list = data[key] || []
+              ann = list.find { |a| a['id'] == id }
+              return false unless ann
+
+              ann['note'] = sanitize_body(note)
+              ann['updated_at'] = Time.now.iso8601
+              data[key] = list
+              save_all(data)
+              true
+            end
+
+            def delete(path, id)
+              data = load_all
+              key = path.to_s
+              list = data[key] || []
+              list.reject! { |a| a['id'] == id }
+              list.empty? ? data.delete(key) : data[key] = list
+              save_all(data)
+              true
+            end
+
+            private
+
+            def sanitize_all(data)
+              return {} unless data.is_a?(Hash)
+
+              data.transform_values { |list| sanitize_list(list) }
+            end
+
+            def sanitize_list(list)
+              Array(list).map do |ann|
+                next ann unless ann.is_a?(Hash)
+
+                safe = ann.dup
+                safe['text'] = sanitize_body(safe['text'])
+                safe['note'] = sanitize_body(safe['note'])
+                safe
+              end
+            end
+
+            def sanitize_body(text)
+              Shoko::Shared::TextSanitizer.sanitize(text.to_s, preserve_newlines: true,
+                                                               preserve_tabs: true)
+            end
+          end
         end
       end
-
-      def sanitize_body(text)
-        Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(text.to_s, preserve_newlines: true, preserve_tabs: true)
-      end
-
-      def save_all(data)
-        payload = JSON.pretty_generate(data)
-        file_writer.write(file_path, payload)
-      end
-
-      def file_path
-        Adapters::Storage::ConfigPaths.config_path(FILE_NAME)
-      end
     end
   end
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'file_store_utils'
+require_relative '../../config_paths'
+
+module Shoko
+  module Adapters
+    module Storage
+      module Repositories
+        module Storage
+          # Base class for file-backed JSON storage.
+          # Provides common file I/O operations for all file stores.
+          class BaseFileStore
+            def initialize(file_writer:)
+              @file_writer = file_writer
+            end
+
+            protected
+
+            attr_reader :file_writer
+
+            def load_all
+              FileStoreUtils.load_json_or_empty(file_path)
+            end
+
+            def save_all(data)
+              payload = JSON.pretty_generate(data)
+              file_writer.write(file_path, payload)
+            end
+
+            def file_path
+              Adapters::Storage::ConfigPaths.config_path(self.class::FILE_NAME)
+            end
+          end
+        end
+      end
+    end
+  end
+end