shoko 0.1.3 → 0.1.5

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

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../monitoring/logger.rb'
-require_relative '../monitoring/performance_monitor.rb'
-require_relative '../monitoring/perf_tracer.rb'
-require_relative '../storage/book_cache_pipeline.rb'
-require_relative 'epub/parsers/html_processor.rb'
-require_relative '../output/terminal/terminal_sanitizer.rb'
-require_relative '../../core/models/chapter.rb'
-require_relative '../../core/models/toc_entry.rb'
-
-module Shoko
-  module Adapters::BookSources
-    # Represents an EPUB document backed by the cache pipeline.
-    # The document always operates on in-memory chapter objects; no temporary
-    # extraction to disk is required.
-    class EPUBDocument
-    attr_reader :title, :chapters, :language, :source_path,
-                :cache_path, :cache_sha, :toc_entries, :metadata, :resources
-
-    def initialize(path, formatting_service: nil, background_worker: nil, progress_reporter: nil)
-      @open_path = File.expand_path(path)
-      @formatting_service = formatting_service
-      @background_worker = background_worker
-      @progress_reporter = progress_reporter
-      @formatting_pending = {}
-      @formatting_pending_mutex = Mutex.new
-
-      @title = fallback_title(@open_path)
-      @language = 'en_US'
-      @chapters = []
-      @toc_entries = []
-      @metadata = {}
-      @resources = {}
-      @chapter_hrefs = []
-      @spine_relative_paths = []
-      @opf_path = nil
-      @cache_path = nil
-      @source_path = @open_path
-      @loaded_from_cache = false
-      @book_payload = nil
-
-      load_via_pipeline!
-    rescue Shoko::Error => e
-      create_error_chapter(e)
-    rescue StandardError => e
-      Adapters::Monitoring::Logger.error('EPUBDocument initialization failed', path: @open_path, error: e.message)
-      create_error_chapter(e)
-    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 = fallback_plain_lines(chapter.raw_content) if chapter.lines.nil? || chapter.lines.empty?
-      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 = Adapters::Monitoring::PerformanceMonitor.time('import.pipeline') do
-        Adapters::Monitoring::PerfTracer.measure('cache.pipeline') do
-          Adapters::Storage::BookCachePipeline.new(progress_reporter: @progress_reporter)
-                                           .load(@open_path, formatting_service: @formatting_service)
-        end
-      end
-
-      apply_pipeline_result(result)
-    end
-
-    def apply_pipeline_result(result)
-      book = result.book
-      if defined?(Adapters::Monitoring::PerfTracer)
-        Adapters::Monitoring::PerfTracer.annotate(
-          cache_hit: result.loaded_from_cache,
-          chapters: Array(book&.chapters).size,
-          book: result.source_path || @open_path
-        )
-      end
-      @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
-      @book_payload = result.payload
-
-      @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
-      @chapter_hrefs = Array(book.chapter_hrefs).dup
-      @spine_relative_paths = Array(book.spine).dup
-      @opf_path = book.opf_path
-
-      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 StandardError
-      nil
-    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?
-
-      @chapters << Core::Models::Chapter.new(
-        number: '1',
-        title: 'Empty Book',
-        lines: ['This EPUB appears to be empty.'],
-        metadata: nil,
-        blocks: nil,
-        raw_content: nil
-      )
-      @toc_entries = []
-    end
-
-    def create_error_chapter(error)
-      @chapters = [
-        Core::Models::Chapter.new(
-          number: '1',
-          title: 'Error Loading',
-          lines: ["Error: #{error.message}"],
-          metadata: nil,
-          blocks: nil,
-          raw_content: nil
-        ),
-      ]
-      @toc_entries = []
-    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_plain_lines(content)
-      return [] unless content
-
-      text = Adapters::BookSources::Epub::Parsers::HTMLProcessor.html_to_text(content.to_s)
-      text.split("\n").map(&:rstrip)
-    end
-
-    def fallback_title(path)
-      raw = File.basename(path, File.extname(path)).tr('_', ' ')
-      Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(raw, preserve_newlines: false, preserve_tabs: false)
-    end
-
-    def enqueue_async_formatting(index, chapter)
-      already_enqueued = false
-      @formatting_pending_mutex.synchronize do
-        already_enqueued = @formatting_pending[index]
-        @formatting_pending[index] = true unless already_enqueued
-      end
-      return if already_enqueued
-
-      @background_worker.submit do
-        format_chapter_sync(index, chapter, raise_on_error: false)
-      ensure
-        @formatting_pending_mutex.synchronize do
-          @formatting_pending.delete(index)
-        end
-      end
-    rescue StandardError => e
-      Adapters::Monitoring::Logger.debug('Async formatting enqueue failed', error: e.message)
-    end
-
-    def format_chapter_sync(index, chapter, raise_on_error:)
-      Adapters::Monitoring::PerfTracer.measure('formatting.ensure') do
-        @formatting_service.ensure_formatted!(self, index, chapter)
-      end
-    rescue Shoko::FormattingError => e
-      Adapters::Monitoring::Logger.error('Formatting error', error: e.message, chapter: index + 1)
-      raise if raise_on_error
-    rescue StandardError => e
-      Adapters::Monitoring::Logger.debug('Formatting service failed', error: e.message, chapter: index + 1)
-      nil
-    end
-
-    def assign_toc_entries(entries)
-      href_to_index = {}
-      Array(@chapter_hrefs).each_with_index do |href, idx|
-        href_to_index[href] = idx if href
-      end
-
-      @toc_entries = Array(entries).map do |entry|
-        title = entry[:title] || entry['title']
-        href = entry[:href] || entry['href']
-        level = (entry[:level] || entry['level']).to_i
-        resolved = normalize_toc_href(href)
-        chapter_index = href_to_index[resolved]
-
-        if chapter_index && (chapter = @chapters[chapter_index]) && chapter.respond_to?(:title=) && (chapter.title.nil? || 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 normalize_toc_href(href)
-      return nil unless href
-
-      base = @opf_path ? File.dirname(@opf_path) : '.'
-      core = href.to_s.split('#', 2).first
-      File.expand_path(File.join('/', base, core), '/').sub(%r{^/}, '')
-    end
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-require_relative '../../output/terminal/terminal_sanitizer.rb'
-require_relative '../../storage/config_paths.rb'
-
-module Shoko
-  module Adapters::BookSources
-    class EPUBFinder
-      # Scans directories to locate EPUB files
-      class DirectoryScanner
-        def initialize(context)
-          @context = context
-        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 >= EPUBFinder::MAX_FILES
-
-            warn_debug "Scanning: #{dir}"
-            scan_directory(dir)
-          end
-        end
-
-        private
-
-        def build_directory_list
-          directories = priority_directories + other_directories
-          directories.uniq.select { |dir| safe_directory_exists?(dir) }
-        end
-
-        def priority_directories
-          [
-            Adapters::Storage::ConfigPaths.downloads_root,
-            '~/Books',
-            '~/Bücher', # German books directory
-            '~/Documents/Books',
-            '~/Downloads',
-            '~/Desktop',
-            '~/Documents',
-            '~/Library/Mobile Documents',
-          ].map { |dir| File.expand_path(dir) }
-        end
-
-        def other_directories
-          [
-            '~',
-            '~/Dropbox',
-            '~/Google Drive',
-            '~/OneDrive',
-          ].map { |dir| File.expand_path(dir) }
-        end
-
-        def safe_directory_exists?(dir)
-          Dir.exist?(dir)
-        rescue StandardError
-          false
-        end
-
-        def scan_directory(dir)
-          return unless @context.can_scan?(dir, EPUBFinder::MAX_DEPTH, EPUBFinder::MAX_FILES)
-
-          @context.mark_visited(dir)
-          process_entries(dir)
-        rescue Errno::EACCES, Errno::ENOENT, Errno::EPERM
-          # Skip directories we can't access
-        rescue StandardError => e
-          warn_debug "Error scanning #{dir}: #{e.message}"
-        end
-
-        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 epub_file?(path)
-            add_epub(path)
-          end
-        rescue StandardError
-          # Skip items we can't process
-        end
-
-        def process_directory(path)
-          return if skip_directory?(path)
-
-          DirectoryScanner.new(@context.with_deeper_depth).scan_directory(path)
-        end
-
-        def skip_directory?(path)
-          base = File.basename(path).downcase
-          EPUBFinder::SKIP_DIRS.map(&:downcase).include?(base)
-        end
-
-        def epub_file?(path)
-          path.downcase.end_with?('.epub') &&
-            File.readable?(path) &&
-            File.size(path).positive?
-        end
-
-        def add_epub(path)
-          raw_name = File.basename(path, '.epub').gsub(/[_-]/, ' ')
-          display_name = Shoko::Adapters::Output::Terminal::TerminalSanitizer.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 debug? = EPUBFinder::DEBUG_MODE
-
-        def warn_debug(msg)
-          warn msg if debug?
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Shoko
-  module Adapters::BookSources
-    class EPUBFinder
-      # 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

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

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-require 'zip'
-require 'rexml/document'
-
-require_relative '../../shared/errors.rb'
-require_relative 'epub/parsers/html_processor.rb'
-require_relative 'epub/parsers/opf_processor.rb'
-require_relative '../output/terminal/terminal_sanitizer.rb'
-require_relative 'epub/parsers/xml_text_normalizer.rb'
-require_relative '../../core/models/chapter.rb'
-require_relative '../../core/models/toc_entry.rb'
-require_relative '../monitoring/perf_tracer.rb'
-
-module Shoko
-  module Adapters::BookSources
-    # 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
-      DEFAULT_LANGUAGE = 'en_US'
-      CONTAINER_PATH   = 'META-INF/container.xml'
-
-      def initialize(formatting_service: nil, extract_resources: false, progress_reporter: nil)
-        @formatting_service = formatting_service
-        @extract_resources = !extract_resources.nil?
-        @progress_reporter = progress_reporter
-      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)
-        Zip::File.open(@epub_path) 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 = Adapters::BookSources::Epub::Parsers::OPFProcessor.new(opf_path, zip: zip)
-
-          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) : {}
-
-          Adapters::Storage::EpubCache::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::EPUBParseError.new(e.message, epub_path)
-      end
-
-      private
-
-      def read_container(zip)
-        Adapters::Monitoring::PerfTracer.measure('epub.read_container') do
-          normalize_text(zip.read(CONTAINER_PATH))
-        end
-      rescue Zip::Error
-        raise Shoko::EPUBParseError.new('Missing META-INF/container.xml', @epub_path)
-      end
-
-      def locate_opf_path(zip, container_xml)
-        Adapters::Monitoring::PerfTracer.measure('epub.locate_opf') do
-          doc = REXML::Document.new(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::EPUBParseError.new('Unable to locate OPF file', @epub_path)
-      rescue REXML::ParseException => e
-        raise Shoko::EPUBParseError.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)
-        Adapters::Monitoring::PerfTracer.measure('epub.read_text_entry') do
-          content = zip.read(path)
-          normalize_text(content)
-        end
-      end
-
-      def read_binary_entry(zip, path)
-        Adapters::Monitoring::PerfTracer.measure('epub.read_binary_entry') do
-          data = zip.read(path)
-          data.force_encoding(Encoding::BINARY)
-        end
-      end
-
-      def normalize_text(content)
-        Adapters::BookSources::Epub::Parsers::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?
-
-        Adapters::BookSources::Epub::Parsers::HTMLProcessor.extract_title(raw_content) || "Chapter #{number}"
-      end
-
-      def fallback_title(path)
-        raw = File.basename(path, File.extname(path)).tr('_', ' ')
-        Shoko::Adapters::Output::Terminal::TerminalSanitizer.sanitize(raw, preserve_newlines: false, preserve_tabs: false)
-      end
-
-      def report(message, progress: nil)
-        reporter = @progress_reporter
-        return unless reporter
-        return if message.nil? || message.to_s.strip.empty?
-
-        if reporter.respond_to?(:call)
-          reporter.call(message: message, progress: progress)
-        elsif reporter.respond_to?(:update_status)
-          reporter.update_status(message: message, progress: progress)
-        end
-      rescue StandardError
-        nil
-      end
-
-      def ratio(done, total)
-        denom = [total.to_f, 1.0].max
-        done.to_f / denom
-      end
-    end
-  end
-end