shoko 0.1.3 → 0.1.5

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

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require_relative '../../core/services/base_service.rb'
-require_relative '../storage/config_paths'
+require_relative '../base_adapter'
 
 module Shoko
-  module Adapters::BookSources
+  module Adapters
+    module BookSources
       # Coordinates Gutendex search + download to the local library.
-      class DownloadService < BaseService
+      class DownloadService < Shoko::Adapters::BaseAdapter
         class DownloadError < StandardError; end
 
+        # @param gutendex_client [Object] Client for Gutendex API
+        # @param logger [Object, nil] Optional logger
+        def initialize(gutendex_client:, downloads_root: nil, logger: nil)
+          super(logger: logger)
+          @client = gutendex_client
+          @downloads_root = downloads_root
+        end
+
         def search(query:, page_url: nil)
-          payload = client.search(query: query, page_url: page_url)
+          payload = @client.search(query: query, page_url: page_url)
           {
             count: payload['count'].to_i,
             next: payload['next'],
@@ -29,24 +37,16 @@ module Shoko
           dest_path = File.join(dest_dir, filename_for(book))
           return { path: dest_path, existing: true } if File.exist?(dest_path)
 
-          client.download(url, dest_path) { |done, total| yield(done, total) if block_given? }
+          @client.download(url, dest_path) { |done, total| yield(done, total) if block_given? }
           { path: dest_path, existing: false }
         end
 
-        protected
-
-        def required_dependencies
-          [:gutendex_client]
-        end
-
         private
 
-        def client
-          @client ||= resolve(:gutendex_client)
-        end
-
         def downloads_root
-          Adapters::Storage::ConfigPaths.downloads_root
+          raise Shoko::ConfigurationError, 'DownloadService requires downloads_root: to be provided' unless @downloads_root
+
+          @downloads_root
         end
 
         def normalize_books(items)
@@ -64,7 +64,7 @@ module Shoko
 
         def pick_download_url(book)
           formats = value_for(book, :formats, 'formats', {})
-          return nil unless formats.respond_to?(:each)
+          return nil unless formats.is_a?(Hash)
 
           keys = formats.keys.map(&:to_s)
           epub_key = keys.find { |k| k.start_with?('application/epub+zip') } ||
@@ -84,12 +84,13 @@ module Shoko
         end
 
         def value_for(book, key_sym, key_str, default)
-          return book[key_sym] if book.respond_to?(:key?) && book.key?(key_sym)
-          return book[key_str] if book.respond_to?(:key?) && book.key?(key_str)
+          return default unless book.is_a?(Hash)
+          return book[key_sym] if book.key?(key_sym)
+          return book[key_str] if book.key?(key_str)
 
           default
         end
-
       end
+    end
   end
 end

data/lib/shoko/adapters/book_sources/epub/epub_importer.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+require_relative '../../../shared/errors'
+require_relative '../../../shared/text_sanitizer'
+require_relative '../archive/zip_reader'
+require_relative '../../../core/book_formats/epub/html_processor'
+require_relative '../../../core/book_formats/epub/rexml_safe_parser'
+require_relative '../../../core/book_formats/epub/opf_processor'
+require_relative '../../../core/book_formats/epub/xml_text_normalizer'
+require_relative '../../../core/models/book_data'
+require_relative '../../../core/models/chapter'
+require_relative '../../../core/models/toc_entry'
+require_relative '../../support/lifecycle_helpers'
+module Shoko
+  module Adapters
+    module BookSources
+      module Epub
+        # Imports an EPUB archive into an in-memory representation that can be
+        # serialized using {EpubCache}. Responsible for extracting metadata,
+        # chapters, and table-of-contents entries in a consistent schema.
+        #
+        # Binary resources (images, stylesheets, etc.) are intentionally not extracted
+        # by default since the reader currently renders image placeholders and does
+        # not consume the raw bytes. Optional consumers (e.g. Kitty image rendering)
+        # should load resources on-demand.
+        class EpubImporter
+          include Shoko::Adapters::Support::LifecycleHelpers
+
+          DEFAULT_LANGUAGE = 'en_US'
+          CONTAINER_PATH   = 'META-INF/container.xml'
+
+          def initialize(formatting_service: nil, extract_resources: false, progress_reporter: nil, instrumentation: nil,
+                         runtime_config: nil,
+                         archive_reader: Shoko::Adapters::BookSources::Archive::ZipReader)
+            @formatting_service = formatting_service
+            @extract_resources = !!extract_resources
+            @progress_reporter = progress_reporter
+            @instrumentation = instrumentation
+            @runtime_config = runtime_config
+            @archive_reader = archive_reader
+          end
+
+          def import(epub_path)
+            @epub_path = File.expand_path(epub_path)
+            raise Shoko::FileNotFoundError, epub_path unless File.file?(@epub_path)
+
+            report('Opening EPUB archive...', progress: 0.0)
+            @archive_reader.open(@epub_path, runtime_config: @runtime_config) do |zip|
+              report('Reading container.xml...', progress: 0.0)
+              container_xml = read_container(zip)
+              report('Locating OPF package...', progress: 0.0)
+              opf_path = locate_opf_path(zip, container_xml)
+              report('Parsing OPF metadata...', progress: 0.0)
+              processor = Core::BookFormats::Epub::OPFProcessor.new(opf_path, zip: zip,
+                                                                              instrumentation: @instrumentation)
+
+              metadata = processor.extract_metadata
+              report('Building manifest...', progress: 0.0)
+              manifest = processor.build_manifest_map
+              report('Reading navigation data...', progress: 0.0)
+              chapter_titles = processor.extract_chapter_titles(manifest)
+
+              chapters_data = build_chapters(zip, opf_path, processor, manifest, chapter_titles)
+              chapters      = chapters_data[:chapters]
+              chapter_hrefs = chapters_data[:hrefs]
+              spine         = chapters_data[:spine]
+
+              report('Building table of contents...', progress: 0.0)
+              toc_entries = build_toc_entries(chapters, processor.toc_entries, chapter_hrefs, opf_path)
+              report('Extracting resources...', progress: 0.0) if @extract_resources
+              resources = @extract_resources ? extract_resources(zip, opf_path, manifest) : {}
+
+              Core::Models::BookData.new(
+                title: metadata[:title] || fallback_title(@epub_path),
+                language: metadata[:language] || DEFAULT_LANGUAGE,
+                authors: Array(metadata[:authors]).map(&:to_s),
+                chapters: chapters,
+                toc_entries: toc_entries,
+                opf_path: opf_path,
+                spine: spine,
+                chapter_hrefs: chapter_hrefs,
+                resources: resources,
+                metadata: metadata,
+                container_path: CONTAINER_PATH,
+                container_xml: container_xml
+              )
+            end
+          rescue Zip::Error, REXML::ParseException => e
+            raise Shoko::BookParseError.new(e.message, epub_path)
+          end
+
+          private
+
+          def read_container(zip)
+            instrument('epub.read_container') do
+              normalize_text(zip.read(CONTAINER_PATH))
+            end
+          rescue Zip::Error
+            raise Shoko::BookParseError.new('Missing META-INF/container.xml', @epub_path)
+          end
+
+          def locate_opf_path(zip, container_xml)
+            instrument('epub.locate_opf') do
+              doc = Core::BookFormats::Epub::REXMLSafeParser.parse(container_xml)
+              elems = doc.elements
+              rootfile = elems['//rootfile'] || elems['//container:rootfile']
+              candidate = rootfile&.attributes&.[]('full-path')
+              return candidate if candidate && zip.find_entry(candidate)
+            end
+
+            if (match = container_xml.to_s.match(/full-path=["']([^"']+)["']/i))
+              candidate = match[1]
+              return candidate if zip.find_entry(candidate)
+            end
+
+            raise Shoko::BookParseError.new('Unable to locate OPF file', @epub_path)
+          rescue REXML::ParseException => e
+            raise Shoko::BookParseError.new("Invalid container.xml: #{e.message}", @epub_path)
+          end
+
+          def build_chapters(zip, opf_path, processor, manifest, chapter_titles)
+            chapters = []
+            hrefs    = []
+            spine    = []
+
+            items = []
+            processor.process_spine(manifest, chapter_titles) { |item| items << item }
+            total = items.length
+
+            if total.positive?
+              report("Extracting HTML (0/#{total})...", progress: 0.0)
+            else
+              report('Extracting HTML...', progress: 0.0)
+            end
+
+            items.each_with_index do |item, index|
+              report(
+                "Extracting HTML (#{index + 1}/#{total})...",
+                progress: ratio(index + 1, total)
+              )
+              raw = read_text_entry(zip, item.file_path)
+              resolved_href = resolve_href(opf_path, item.href)
+              chapter = Core::Models::Chapter.new(
+                number: item.number.to_s,
+                title: extract_chapter_title(raw, item.number, item.title),
+                lines: nil,
+                metadata: { source_path: item.file_path, href: resolved_href },
+                blocks: nil,
+                raw_content: raw
+              )
+
+              chapters << chapter
+              hrefs << resolved_href
+              spine << item.file_path
+            end
+
+            { chapters:, hrefs:, spine: }
+          end
+
+          def build_toc_entries(chapters, toc_entries, chapter_hrefs, opf_path)
+            href_to_index = {}
+            chapter_hrefs.each_with_index do |href, idx|
+              href_to_index[href] = idx if href
+            end
+
+            Array(toc_entries).map do |entry|
+              title = entry[:title]
+              href  = entry[:href]
+              level = entry[:level].to_i
+
+              target = resolve_toc_target(opf_path, entry)
+              chapter_index = href_to_index[target]
+              if chapter_index && (chapter = chapters[chapter_index]) && chapter.title.to_s.strip.empty?
+                chapter.title = title
+              end
+
+              Core::Models::TOCEntry.new(
+                title: title,
+                href: href,
+                level: level,
+                chapter_index: chapter_index,
+                navigable: !chapter_index.nil?
+              )
+            end
+          end
+
+          def resolve_toc_target(opf_path, entry)
+            return nil unless entry
+
+            return entry[:target].to_s if entry.is_a?(Hash) && entry[:target]
+
+            href = entry.is_a?(Hash) ? entry[:href] : nil
+            return nil unless href
+
+            core = href.to_s.split('#', 2).first.to_s
+            return nil if core.empty?
+
+            source_path = entry.is_a?(Hash) ? entry[:source_path] : nil
+            base_path = (source_path || opf_path).to_s
+            base_dir = File.dirname(base_path)
+            File.expand_path(File.join('/', base_dir, core), '/').sub(%r{^/}, '')
+          end
+
+          def extract_resources(zip, opf_path, manifest)
+            resources = {}
+
+            manifest.each_value do |href|
+              rel = href.to_s
+              next if rel.empty?
+
+              path = resolve_href(opf_path, rel)
+              next unless zip.find_entry(path)
+
+              resources[path] = read_binary_entry(zip, path)
+            end
+            resources
+          end
+
+          def read_text_entry(zip, path)
+            instrument('epub.read_text_entry') do
+              content = zip.read(path)
+              normalize_text(content)
+            end
+          end
+
+          def read_binary_entry(zip, path)
+            instrument('epub.read_binary_entry') do
+              data = zip.read(path)
+              data.force_encoding(Encoding::BINARY)
+            end
+          end
+
+          def normalize_text(content)
+            Core::BookFormats::Epub::XmlTextNormalizer.normalize(content)
+          end
+
+          def resolve_href(opf_path, href)
+            return nil unless href
+
+            base = File.dirname(opf_path)
+            root = File.expand_path(File.join('/', base, href), '/')
+            root.sub(%r{^/}, '')
+          end
+
+          def extract_chapter_title(raw_content, number, hinted_title)
+            hinted = hinted_title.to_s.strip
+            return hinted unless hinted.empty?
+
+            Core::BookFormats::Epub::HTMLProcessor.extract_title(raw_content) || "Chapter #{number}"
+          end
+
+          def fallback_title(path)
+            fallback_title_from_path(path)
+          end
+
+          def ratio(done, total)
+            denom = [total.to_f, 1.0].max
+            done.to_f / denom
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/book_sources/epub/epub_resource_loader.rb

@@ -1,136 +1,147 @@
 # frozen_string_literal: true
 
 require 'digest'
-require 'zip'
-
-require_relative '../../storage/atomic_file_writer.rb'
-require_relative '../../storage/cache_paths.rb'
-require_relative '../../monitoring/logger.rb'
+require_relative '../archive/zip_reader'
 
 module Shoko
-  module Adapters::BookSources::Epub
-    # Loads resources (typically images) from an EPUB on-demand and optionally
-    # persists them as per-book blobs under the cache root.
-    class EpubResourceLoader
-      SHA256_HEX_PATTERN = /\A[0-9a-f]{64}\z/i
-
-      def initialize(cache_root: CachePaths.cache_root)
-        @cache_root = cache_root
-      end
-
-      # Fetch an entry from the per-book blob cache or from the EPUB archive.
-      #
-      # @param book_sha [String,nil] 64-char hex digest identifying the book cache directory
-      # @param epub_path [String] filesystem path to the EPUB
-      # @param entry_path [String] path inside the EPUB zip
-      # @param cache_key [String,nil] logical cache key (defaults to entry_path)
-      # @return [String,nil] binary bytes
-      def fetch(book_sha:, epub_path:, entry_path:, persist: true, cache_key: nil)
-        return nil if entry_path.to_s.empty?
-
-        normalized_sha = normalize_sha(book_sha)
-        key = (cache_key || entry_path).to_s
-        return nil if key.empty?
-
-        cached = normalized_sha ? read_blob(normalized_sha, key) : nil
-        return cached if cached
-
-        bytes = read_from_zip(epub_path, entry_path)
-        return nil unless bytes
-
-        write_blob(normalized_sha, key, bytes) if persist && normalized_sha
-        bytes
-      end
-
-      def store(book_sha:, entry_path:, bytes:)
-        normalized_sha = normalize_sha(book_sha)
-        return false unless normalized_sha
-        return false if entry_path.to_s.empty?
-
-        write_blob(normalized_sha, entry_path, bytes)
-        true
-      rescue StandardError
-        false
-      end
-
-      # Resolve a resource href relative to a chapter (zip entry) path.
-      #
-      # @param chapter_entry_path [String] zip entry path of the chapter
-      # @param href [String] href/src value from XHTML
-      # @return [String,nil] normalized zip entry path
-      def self.resolve_chapter_relative(chapter_entry_path, href)
-        return nil unless chapter_entry_path && href
-
-        core = href.to_s.split(/[?#]/, 2).first.to_s
-        return nil if core.empty?
-        return nil if core.match?(/\A[a-z][a-z0-9+.-]*:/i) # data:, http:, etc.
-
-        normalized = if core.start_with?('/')
-                       core.sub(%r{\A/+}, '')
-                     else
-                       base = File.dirname(chapter_entry_path.to_s)
-                       File.expand_path(File.join('/', base, core), '/').sub(%r{^/}, '')
-                     end
-
-        normalized.empty? ? nil : normalized
-      rescue StandardError
-        nil
-      end
-
-      private
-
-      def normalize_sha(sha)
-        value = sha.to_s.strip
-        return nil if value.empty?
-        return nil unless SHA256_HEX_PATTERN.match?(value)
-
-        value.downcase
-      rescue StandardError
-        nil
-      end
-
-      def read_from_zip(epub_path, entry_path)
-        return nil unless epub_path && File.file?(epub_path)
-        return nil if entry_path.to_s.empty?
-
-        Zip::File.open(epub_path) do |zip|
-          return nil unless zip.find_entry(entry_path.to_s)
-
-          data = zip.read(entry_path.to_s)
-          data.force_encoding(Encoding::BINARY)
-          data
+  module Adapters
+    module BookSources
+      module Epub
+        # Loads resources (typically images) from an EPUB on-demand and optionally
+        # persists them as per-book blobs under the cache root.
+        class EpubResourceLoader
+          SHA256_HEX_PATTERN = /\A[0-9a-f]{64}\z/i
+
+          def initialize(cache_root: nil, file_writer: nil, logger: nil,
+                         runtime_config: nil,
+                         archive_reader: Shoko::Adapters::BookSources::Archive::ZipReader)
+            raise Shoko::ConfigurationError, 'EpubResourceLoader requires cache_root: to be provided' unless cache_root
+
+            @cache_root = cache_root
+            @file_writer = file_writer
+            @logger = logger
+            @runtime_config = runtime_config
+            @archive_reader = archive_reader
+          end
+
+          # Fetch an entry from the per-book blob cache or from the EPUB archive.
+          #
+          # @param book_sha [String,nil] 64-char hex digest identifying the book cache directory
+          # @param epub_path [String] filesystem path to the EPUB
+          # @param entry_path [String] path inside the EPUB zip
+          # @param cache_key [String,nil] logical cache key (defaults to entry_path)
+          # @return [String,nil] binary bytes
+          def fetch(book_sha:, epub_path:, entry_path:, persist: true, cache_key: nil)
+            return nil if entry_path.to_s.empty?
+
+            normalized_sha = normalize_sha(book_sha)
+            key = (cache_key || entry_path).to_s
+            return nil if key.empty?
+
+            cached = normalized_sha ? read_blob(normalized_sha, key) : nil
+            return cached if cached
+
+            bytes = read_from_zip(epub_path, entry_path)
+            return nil unless bytes
+
+            write_blob(normalized_sha, key, bytes) if persist && normalized_sha
+            bytes
+          end
+
+          def store(book_sha:, entry_path:, bytes:)
+            normalized_sha = normalize_sha(book_sha)
+            return false unless normalized_sha
+            return false if entry_path.to_s.empty?
+
+            write_blob(normalized_sha, entry_path, bytes)
+            true
+          rescue Shoko::Error
+            raise
+          end
+
+          # Resolve a resource href relative to a chapter (zip entry) path.
+          #
+          # @param chapter_entry_path [String] zip entry path of the chapter
+          # @param href [String] href/src value from XHTML
+          # @return [String,nil] normalized zip entry path
+          def self.resolve_chapter_relative(chapter_entry_path, href)
+            return nil unless chapter_entry_path && href
+
+            core = href.to_s.split(/[?#]/, 2).first.to_s
+            return nil if core.empty?
+            return nil if core.match?(/\A[a-z][a-z0-9+.-]*:/i) # data:, http:, etc.
+
+            normalized = if core.start_with?('/')
+                           core.sub(%r{\A/+}, '')
+                         else
+                           base = File.dirname(chapter_entry_path.to_s)
+                           File.expand_path(File.join('/', base, core), '/').sub(%r{^/}, '')
+                         end
+
+            normalized.empty? ? nil : normalized
+          rescue Shoko::Error
+            raise
+          end
+
+          private
+
+          def normalize_sha(sha)
+            value = sha.to_s.strip
+            return nil if value.empty?
+            return nil unless SHA256_HEX_PATTERN.match?(value)
+
+            value.downcase
+          rescue Shoko::Error
+            raise
+          end
+
+          def read_from_zip(epub_path, entry_path)
+            return nil unless epub_path && File.file?(epub_path)
+            return nil if entry_path.to_s.empty?
+
+            @archive_reader.open(epub_path, runtime_config: @runtime_config) do |zip|
+              return nil unless zip.find_entry(entry_path.to_s)
+
+              data = zip.read(entry_path.to_s)
+              data.force_encoding(Encoding::BINARY)
+              data
+            end
+          rescue Zip::Error => e
+            @logger&.debug('EpubResourceLoader: zip read failed', path: epub_path.to_s, entry: entry_path.to_s,
+                                                                  error: e.message)
+            nil
+          rescue Shoko::Error => e
+            @logger&.debug('EpubResourceLoader: read failed', path: epub_path.to_s,
+                                                              entry: entry_path.to_s, error: e.message)
+            nil
+          end
+
+          def blob_path(book_sha, entry_path)
+            key = Digest::SHA256.hexdigest(entry_path.to_s)
+            File.join(@cache_root, 'resources', book_sha.to_s, "#{key}.bin")
+          end
+
+          def read_blob(book_sha, entry_path)
+            path = blob_path(book_sha, entry_path)
+            return nil unless File.file?(path)
+
+            data = File.binread(path)
+            data.force_encoding(Encoding::BINARY)
+            data
+          rescue Shoko::Error
+            raise
+          end
+
+          def write_blob(book_sha, entry_path, bytes)
+            return unless book_sha
+
+            writer = @file_writer
+            return unless writer
+            writer.write(blob_path(book_sha, entry_path), bytes, binary: true)
+          rescue Shoko::Error
+            raise
+          end
         end
-      rescue Zip::Error => e
-        Shoko::Adapters::Monitoring::Logger.debug('EpubResourceLoader: zip read failed', path: epub_path.to_s, entry: entry_path.to_s,
-                                                            error: e.message)
-        nil
-      rescue StandardError => e
-        Shoko::Adapters::Monitoring::Logger.debug('EpubResourceLoader: read failed', path: epub_path.to_s, entry: entry_path.to_s, error: e.message)
-        nil
-      end
-
-      def blob_path(book_sha, entry_path)
-        key = Digest::SHA256.hexdigest(entry_path.to_s)
-        File.join(@cache_root, 'resources', book_sha.to_s, "#{key}.bin")
-      end
-
-      def read_blob(book_sha, entry_path)
-        path = blob_path(book_sha, entry_path)
-        return nil unless File.file?(path)
-
-        data = File.binread(path)
-        data.force_encoding(Encoding::BINARY)
-        data
-      rescue StandardError
-        nil
-      end
-
-      def write_blob(book_sha, entry_path, bytes)
-        return unless book_sha
-
-        AtomicFileWriter.write(blob_path(book_sha, entry_path), bytes, binary: true)
-      rescue StandardError
-        nil
       end
     end
   end