shoko 0.1.3 → 0.1.5

data/lib/{zip.rb → shoko/adapters/book_sources/archive/zip_reader.rb}

@@ -5,6 +5,7 @@
 #
 # Public API:
 #   Zip::File.open(path) { |zip| ... }
+#   zip.entries -> Array<Zip::Entry>
 #   zip.read(entry_path) -> String (binary)
 #   zip.find_entry(entry_path) -> entry or nil
 #   zip.close ; zip.closed?
@@ -269,21 +270,9 @@ module Zip
     attr_reader :max_entry_compressed, :max_entry_uncompressed, :max_total_uncompressed
 
     def initialize(max_entry_uncompressed:, max_entry_compressed:, max_total_uncompressed:)
-      @max_entry_uncompressed = LimitResolver.resolve(
-        max_entry_uncompressed,
-        env: 'SHOKO_ZIP_MAX_ENTRY_BYTES',
-        default: Limits::MAX_ENTRY_UNCOMPRESSED
-      )
-      @max_entry_compressed = LimitResolver.resolve(
-        max_entry_compressed,
-        env: 'SHOKO_ZIP_MAX_ENTRY_COMPRESSED_BYTES',
-        default: Limits::MAX_ENTRY_COMPRESSED
-      )
-      @max_total_uncompressed = LimitResolver.resolve(
-        max_total_uncompressed,
-        env: 'SHOKO_ZIP_MAX_TOTAL_BYTES',
-        default: Limits::MAX_TOTAL_UNCOMPRESSED
-      )
+      @max_entry_uncompressed = LimitResolver.resolve(max_entry_uncompressed, default: Limits::MAX_ENTRY_UNCOMPRESSED)
+      @max_entry_compressed = LimitResolver.resolve(max_entry_compressed, default: Limits::MAX_ENTRY_COMPRESSED)
+      @max_total_uncompressed = LimitResolver.resolve(max_total_uncompressed, default: Limits::MAX_TOTAL_UNCOMPRESSED)
       @total_uncompressed_bytes = 0
     end
 
@@ -351,34 +340,28 @@ module Zip
     end
   end
 
-  # Resolves limit values from arguments, environment, or defaults
+  # Resolves limit values from explicit arguments or defaults.
   class LimitResolver
-    def self.resolve(value, env:, default:)
-      new(value, env, default).resolve
+    def self.resolve(value, default:)
+      new(value, default).resolve
     end
 
-    def initialize(value, env, default)
+    def initialize(value, default)
       @value = value
-      @env = env
       @default = default
     end
 
     def resolve
-      candidate = value_or_env
-      parsed = parse_integer(candidate)
+      parsed = parse_integer(@value)
       valid_positive_or_default(parsed)
     end
 
     private
 
-    def value_or_env
-      @value || ENV.fetch(@env, nil)
-    end
-
     def parse_integer(candidate)
+      return nil if candidate.nil?
+
       Integer(candidate)
-    rescue StandardError
-      nil
     end
 
     def valid_positive_or_default(parsed)
@@ -479,8 +462,8 @@ module Zip
 
     def close_inflater(inflater)
       inflater&.close
-    rescue StandardError
-      nil
+    rescue Shoko::Error
+      raise
     end
 
     def decompress_all(inflater, entry, remaining_bytes)
@@ -657,7 +640,7 @@ module Zip
 
     def self.close_safely(zip_file)
       zip_file.close
-    rescue StandardError
+    rescue Shoko::Error
       # ignore close errors
     end
 
@@ -674,7 +657,7 @@ module Zip
       @io = @state.io
       @entries = @state.entries
       build_index!
-    rescue StandardError
+    rescue Shoko::Error
       close
       raise
     end
@@ -692,6 +675,10 @@ module Zip
       @entries[normalized_path]
     end
 
+    def entries
+      @entries.values
+    end
+
     def read(path)
       entry = find_entry_or_raise(path)
       validate_entry_readable(entry)
@@ -730,3 +717,30 @@ module Zip
     end
   end
 end
+
+module Shoko
+  module Adapters
+    module BookSources
+      module Archive
+        # Adapter-owned archive facade used by book-source importers/loaders.
+        module ZipReader
+          module_function
+
+          def open(path, runtime_config: nil, &block)
+            Zip::File.open(path, **zip_limit_kwargs(runtime_config), &block)
+          end
+
+          def zip_limit_kwargs(runtime_config)
+            return {} unless runtime_config
+
+            {
+              max_entry_uncompressed_bytes: runtime_config.zip_max_entry_uncompressed_bytes,
+              max_entry_compressed_bytes: runtime_config.zip_max_entry_compressed_bytes,
+              max_total_uncompressed_bytes: runtime_config.zip_max_total_uncompressed_bytes
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/book_document.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative '../../shared/text_sanitizer'
+require_relative '../../shared/errors'
+require_relative '../../core/models/chapter'
+require_relative '../../core/models/toc_entry'
+require_relative '../../core/ports/outbound/reader_document'
+
+module Shoko
+  module Adapters
+    module BookSources
+      # Represents an ebook document backed by the cache pipeline.
+      # The document always operates on in-memory chapter objects; no temporary
+      # extraction to disk is required.  Supports any format registered with
+      # {FormatRegistry}.
+      class BookDocument
+        include Shoko::Core::Ports::Outbound::ReaderDocument
+
+        attr_reader :title, :chapters, :language, :source_path,
+                    :cache_path, :cache_sha, :toc_entries, :metadata, :resources
+
+        # @param path [String] Path to EPUB file
+        # @param formatting_service [Object, nil] Formatting service
+        # @param background_worker [Object, nil] Background worker
+        # @param progress_reporter [Object, nil] Progress reporter
+        # @param logger [Core::Ports::Outbound::Logging] Logger adapter (required)
+        # @param instrumentation [Core::Ports::Outbound::Instrumentation, nil] Instrumentation service
+        def initialize(path, logger:, formatting_service: nil, background_worker: nil, progress_reporter: nil,
+                       instrumentation: nil, book_cache:)
+          @open_path = File.expand_path(path)
+          @formatting_service = formatting_service
+          @background_worker = background_worker
+          @progress_reporter = progress_reporter
+          @logger = logger
+          @instrumentation = instrumentation
+          raise ArgumentError, 'book_cache is required' if book_cache.nil?
+          @book_cache = book_cache
+
+          @title = fallback_title(@open_path)
+          @language = 'en_US'
+          @chapters = []
+          @toc_entries = []
+          @metadata = {}
+          @resources = {}
+          @cache_path = nil
+          @source_path = @open_path
+          @loaded_from_cache = false
+
+          load_via_pipeline!
+        rescue Shoko::Error => e
+          @logger.error('BookDocument initialization failed', path: @open_path, error: e.message)
+          raise Shoko::BookParseError.new(e.message, @open_path)
+        end
+
+        def chapter_count
+          @chapters.size
+        end
+
+        def get_chapter(index)
+          return nil unless index.is_a?(Integer) && index >= 0 && index < @chapters.length
+
+          chapter = @chapters[index]
+          return nil unless chapter
+
+          ensure_formatted_chapter(chapter, index)
+          chapter.lines ||= []
+          chapter
+        end
+
+        def cached?
+          @loaded_from_cache
+        end
+
+        def canonical_path
+          @source_path || @open_path
+        end
+
+        # Backwards compatibility for components that previously expected a cache
+        # directory. Returns the directory containing the `.cache` file.
+        def cache_dir
+          return nil unless @cache_path
+
+          File.dirname(@cache_path)
+        end
+
+        private
+
+        def load_via_pipeline!
+          result = instrument('import.pipeline') do
+            instrument('cache.pipeline') do
+              @book_cache.load(@open_path, formatting_service: @formatting_service)
+            end
+          end
+
+          apply_pipeline_result(result)
+        end
+
+        def apply_pipeline_result(result)
+          book = result.book
+          @instrumentation&.annotate(
+            cache_hit: result.loaded_from_cache,
+            chapters: Array(book&.chapters).size,
+            book: result.source_path || @open_path
+          )
+          @cache_path = result.cache_path
+          @cache_sha = derive_cache_sha(@cache_path)
+          @source_path = result.source_path || @open_path
+          @loaded_from_cache = result.loaded_from_cache
+
+          @title = present_or_fallback(book.title, fallback_title(@source_path))
+          @language = book.language || @language
+          @metadata = book.metadata || {}
+          @chapters = Array(book.chapters).dup
+          @toc_entries = Array(book.toc_entries).dup
+          @resources = (book.resources || {}).dup
+
+          ensure_chapters_exist
+        end
+
+        def derive_cache_sha(path)
+          return nil unless path && !path.to_s.empty?
+
+          File.basename(path.to_s, File.extname(path.to_s))
+        rescue Shoko::Error
+          raise
+        end
+
+        def present_or_fallback(value, fallback)
+          str = value.to_s.strip
+          str.empty? ? fallback : value
+        end
+
+        def ensure_chapters_exist
+          return unless @chapters.empty?
+
+          raise Shoko::BookParseError.new('book contains no chapters', @open_path)
+        end
+
+        def ensure_formatted_chapter(chapter, index)
+          return unless @formatting_service && chapter
+
+          chapter_index = index.to_i
+          return if chapter.blocks && !chapter.blocks.empty?
+
+          # Always format synchronously so rendering/pagination receives structured lines immediately.
+          format_chapter_sync(chapter_index, chapter, raise_on_error: true)
+        end
+
+        def fallback_title(path)
+          raw = File.basename(path, File.extname(path)).tr('_', ' ')
+          Shoko::Shared::TextSanitizer.sanitize(raw, preserve_newlines: false,
+                                                     preserve_tabs: false)
+        end
+
+        def instrument(label, &)
+          if @instrumentation
+            @instrumentation.measure(label, &)
+          else
+            yield
+          end
+        end
+
+        def format_chapter_sync(index, chapter, raise_on_error:)
+          instrument('formatting.ensure') do
+            @formatting_service.ensure_formatted!(self, index, chapter)
+          end
+        rescue Shoko::FormattingError => e
+          @logger.error('Formatting error', error: e.message, chapter: index + 1)
+          raise if raise_on_error
+        rescue Shoko::Error => e
+          @logger.debug('Formatting service failed', error: e.message, chapter: index + 1)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/book_file_probe.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../core/book_formats/format_registry'
+
+module Shoko
+  module Adapters
+    module BookSources
+      # Adapter-side probe for filesystem book eligibility checks.
+      class BookFileProbe
+        def initialize(format_registry: Shoko::Core::BookFormats::FormatRegistry)
+          @format_registry = format_registry
+        end
+
+        def book_file?(path)
+          @format_registry.supported_extension?(path) &&
+            File.readable?(path) &&
+            File.size(path).positive?
+        rescue Shoko::Error
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/book_finder/directory_scanner.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../../shared/text_sanitizer'
+require_relative '../../../core/book_formats/format_registry'
+require_relative '../book_file_probe'
+
+module Shoko
+  module Adapters
+    module BookSources
+      class BookFinder
+        # Scans directories to locate EPUB files
+        class DirectoryScanner
+          def initialize(context, config_root:, book_file_probe: nil)
+            @context = context
+            @config_root = config_root
+            @book_file_probe = book_file_probe || Shoko::Adapters::BookSources::BookFileProbe.new
+          end
+
+          def scan_all_directories
+            all_dirs = build_directory_list
+            warn_debug "Scanning directories: #{all_dirs.join(', ')}"
+
+            all_dirs.each do |dir|
+              break if @context.epubs.length >= BookFinder::MAX_FILES
+
+              warn_debug "Scanning: #{dir}"
+              scan_directory(dir)
+            end
+          end
+
+          private
+
+          def build_directory_list
+            directories = configured_directories + default_directories
+            directories.uniq.select { |dir| safe_directory_exists?(dir) }
+          end
+
+          def default_directories
+            [
+              File.join(@config_root, 'downloads'),
+              '~/Books',
+              '~/Bücher', # German books directory
+              '~/Documents/Books'
+            ].map { |dir| File.expand_path(dir) }
+          end
+
+          def configured_directories
+            raw = ENV.fetch('SHOKO_BOOK_SCAN_DIRS', '').to_s
+            return [] if raw.strip.empty?
+
+            raw
+              .split(File::PATH_SEPARATOR)
+              .map(&:strip)
+              .reject(&:empty?)
+              .map { |dir| File.expand_path(dir) }
+          end
+
+          def safe_directory_exists?(dir)
+            Dir.exist?(dir)
+          rescue Shoko::Error
+            raise
+          end
+
+          def scan_directory(dir)
+            return unless @context.can_scan?(dir, BookFinder::MAX_DEPTH, BookFinder::MAX_FILES)
+
+            @context.mark_visited(dir)
+            process_entries(dir)
+          rescue Errno::EACCES, Errno::ENOENT, Errno::EPERM
+            # Skip directories we can't access
+          rescue Shoko::Error => e
+            warn_debug "Error scanning #{dir}: #{e.message}"
+          end
+          protected :scan_directory
+
+          def process_entries(dir)
+            Dir.entries(dir).each do |entry|
+              next if entry.start_with?('.')
+
+              path = File.join(dir, entry)
+              next if @context.visited_paths.include?(path)
+
+              process_path(path)
+            end
+          end
+
+          def process_path(path)
+            if File.directory?(path)
+              process_directory(path)
+            elsif ebook_file?(path)
+              add_book(path)
+            end
+          rescue Shoko::Error
+            # Skip items we can't process
+          end
+
+          def process_directory(path)
+            return if skip_directory?(path)
+
+            DirectoryScanner.new(
+              @context.with_deeper_depth,
+              config_root: @config_root,
+              book_file_probe: @book_file_probe
+            ).scan_directory(path)
+          end
+
+          def skip_directory?(path)
+            base = File.basename(path).downcase
+            BookFinder::SKIP_DIRS.map(&:downcase).include?(base)
+          end
+
+          def ebook_file?(path)
+            @book_file_probe.book_file?(path)
+          end
+
+          def add_book(path)
+            raw_name = strip_ebook_extension(path).gsub(/[_-]/, ' ')
+            display_name = Shoko::Shared::TextSanitizer.sanitize(raw_name,
+                                                                    preserve_newlines: false, preserve_tabs: false)
+
+            @context.epubs << {
+              'path' => path,
+              'name' => display_name,
+              'size' => File.size(path),
+              'modified' => File.mtime(path).iso8601,
+              'dir' => File.dirname(path),
+            }
+          end
+
+          def strip_ebook_extension(path)
+            basename = File.basename(path)
+            # Try compound extensions first (e.g. '.fb2.zip')
+            Shoko::Core::BookFormats::FormatRegistry.supported_extensions
+                                                         .sort_by { |ext| -ext.length }
+                                                         .each do |ext|
+                                                           return basename[0..-(ext.length + 1)] if basename.downcase.end_with?(ext)
+            end
+            File.basename(path, File.extname(path))
+          end
+
+          def debug? = BookFinder::DEBUG_MODE
+
+          def warn_debug(msg)
+            warn msg if debug?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/book_finder/scanner_context.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    module BookSources
+      class BookFinder
+        # Context for directory scanning operations
+        ScannerContext = Struct.new(:epubs, :visited_paths, :depth, keyword_init: true) do
+          def can_scan?(dir, max_depth, max_files)
+            depth <= max_depth &&
+              epubs.length < max_files &&
+              !visited_paths.include?(dir)
+          end
+
+          def mark_visited(dir)
+            visited_paths.add(dir)
+          end
+
+          def with_deeper_depth
+            self.class.new(
+              epubs: epubs,
+              visited_paths: visited_paths,
+              depth: depth + 1
+            )
+          end
+        end
+      end
+    end
+  end
+end