shoko 0.1.0

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

@@ -0,0 +1,268 @@
+# 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

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Shoko
+  module Adapters::BookSources
+    # Thin HTTP client for the Gutendex API.
+    class GutendexClient
+      class Error < StandardError; end
+
+      API_ROOT = 'https://gutendex.com/books'
+
+      def initialize(logger: nil, open_timeout: 5, read_timeout: 15)
+        @logger = logger
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+      end
+
+      def search(query:, page_url: nil)
+        uri = page_url ? normalize_uri(page_url, base: API_ROOT) : build_query_uri(query)
+        request_json(uri)
+      end
+
+      def download(url, dest_path, &)
+        uri = normalize_uri(url, base: API_ROOT)
+        request_download(uri, dest_path, &)
+      end
+
+      private
+
+      def build_query_uri(query)
+        uri = URI.parse(API_ROOT)
+        q = query.to_s.strip
+        uri.query = URI.encode_www_form(search: q) unless q.empty?
+        uri
+      end
+
+      def request_json(uri, limit = 2)
+        response = request(uri)
+        return parse_json(response) if response.is_a?(Net::HTTPSuccess)
+
+        if response.is_a?(Net::HTTPRedirection) && limit.positive?
+          redirect = resolve_redirect_uri(uri, response['location'])
+          return request_json(redirect, limit - 1)
+        end
+
+        raise Error, "Request failed (#{response.code})"
+      end
+
+      def parse_json(response)
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        raise Error, "Invalid JSON response: #{e.message}"
+      end
+
+      def request_download(uri, dest_path, limit = 2, &on_progress)
+        response = request(uri) do |http|
+          http.request(Net::HTTP::Get.new(uri)) do |resp|
+            if resp.is_a?(Net::HTTPSuccess)
+              stream_response(resp, dest_path, &on_progress)
+            else
+              resp
+            end
+          end
+        end
+
+        if response.is_a?(Net::HTTPRedirection) && limit.positive?
+          redirect = resolve_redirect_uri(uri, response['location'])
+          return request_download(redirect, dest_path, limit - 1, &on_progress)
+        end
+
+        return response if response.is_a?(Net::HTTPSuccess)
+
+        raise Error, "Download failed (#{response.code})"
+      end
+
+      def stream_response(response, dest_path)
+        return response unless response.is_a?(Net::HTTPSuccess)
+
+        total = response['Content-Length'].to_i
+        downloaded = 0
+        File.open(dest_path, 'wb') do |file|
+          response.read_body do |chunk|
+            file.write(chunk)
+            downloaded += chunk.bytesize
+            yield(downloaded, total) if block_given?
+          end
+        end
+        response
+      end
+
+      def request(uri, &)
+        uri = normalize_uri(uri, base: API_ROOT)
+        raise Error, "Invalid URL: #{uri}" unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        if block_given?
+          http.start(&)
+        else
+          http.get(uri.request_uri)
+        end
+      rescue StandardError => e
+        @logger&.error('Gutendex request failed', error: e.message, url: uri.to_s)
+        raise Error, e.message
+      end
+
+      def normalize_uri(input, base: nil)
+        uri = input.is_a?(URI) ? input : URI.parse(input.to_s)
+        return uri if uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+
+        if base
+          base_uri = base.is_a?(URI) ? base : URI.parse(base.to_s)
+          begin
+            joined = URI.join(base_uri.to_s, uri.to_s)
+            return joined if joined.is_a?(URI::HTTP) || joined.is_a?(URI::HTTPS)
+          rescue URI::Error
+            # fall through
+          end
+        end
+
+        if uri.scheme.nil? && uri.host.nil?
+          candidate = uri.to_s
+          if candidate.start_with?('//')
+            candidate = "https:#{candidate}"
+          elsif /\A[a-z0-9.-]+\.[a-z]{2,}/i.match?(candidate)
+            candidate = "https://#{candidate}"
+          end
+
+          begin
+            parsed = URI.parse(candidate)
+            return parsed if parsed.is_a?(URI::HTTP) || parsed.is_a?(URI::HTTPS)
+          rescue URI::Error
+            # fall through
+          end
+        end
+
+        uri
+      end
+
+      def resolve_redirect_uri(base_uri, location)
+        normalize_uri(location, base: base_uri)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'epub_finder'
+
+module Shoko
+  module Adapters::BookSources
+    # Handles EPUB library scanning operations (filesystem/OS concerns)
+    class LibraryScanner
+      attr_accessor :scan_status, :scan_message, :epubs
+
+      def initialize
+        @epubs = []
+        @filtered_epubs = []
+        @scan_status = :idle
+        @scan_message = ''
+        @scan_thread = nil
+        @scan_results_queue = Queue.new
+      end
+
+      def load_cached
+        @epubs = EPUBFinder.scan_system(force_refresh: false) || []
+        @filtered_epubs = @epubs
+        @scan_status = @epubs.empty? ? :idle : :done
+        @scan_message = "Loaded #{@epubs.length} books from cache" if @scan_status == :done
+      rescue StandardError => e
+        @scan_status = :error
+        @scan_message = "Cache load failed: #{e.message}"
+        @epubs = []
+        @filtered_epubs = []
+      end
+
+      def start_scan(force: false)
+        return if @scan_thread&.alive?
+
+        initialize_scan
+        @scan_thread = create_scan_thread(force)
+      end
+
+      private
+
+      def initialize_scan
+        @scan_status = :scanning
+        @scan_message = 'Scanning for EPUB files...'
+        @epubs = []
+        @filtered_epubs = []
+      end
+
+      def create_scan_thread(force)
+        Thread.new do
+          perform_scan_operation(force)
+        rescue StandardError => e
+          handle_scan_error(e)
+        end
+      end
+
+      def perform_scan_operation(force)
+        epubs = EPUBFinder.scan_system(force_refresh: force) || []
+        sorted_epubs = epubs.sort_by { |e| (e['name'] || '').downcase }
+
+        @scan_results_queue.push(
+          status: :done,
+          epubs: sorted_epubs,
+          message: "Found #{sorted_epubs.length} books"
+        )
+      end
+
+      def handle_scan_error(error)
+        @scan_results_queue.push(
+          status: :error,
+          epubs: [],
+          message: "Scan failed: #{error.message[0..50]}"
+        )
+      end
+
+      public
+
+      def process_results
+        return if @scan_results_queue.empty?
+
+        result = @scan_results_queue.pop
+        @scan_status = result[:status]
+        @scan_message = result[:message]
+        result[:epubs]
+      end
+
+      def cleanup
+        @scan_thread&.kill
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Shoko
+  module Adapters::BookSources
+    # Computes a fast, stable fingerprint for a source EPUB file without
+    # reading the full file into memory. Intended to validate that a cache
+    # entry still corresponds to a local file when avoiding full SHA-256
+    # hashing on warm opens.
+    module SourceFingerprint
+      module_function
+
+      VERSION = 1
+      DEFAULT_CHUNK_BYTES = 64 * 1024
+
+      def compute(path, chunk_bytes: DEFAULT_CHUNK_BYTES)
+        return nil if path.nil? || path.to_s.empty?
+        return nil unless File.file?(path)
+
+        size_bytes = File.size(path)
+        chunk = normalize_chunk_bytes(chunk_bytes)
+
+        head = ''.b
+        tail = ''.b
+
+        File.open(path, 'rb') do |io|
+          head = io.read([size_bytes, chunk].min) || ''.b
+
+          if size_bytes > chunk
+            io.seek(-[chunk, size_bytes].min, ::IO::SEEK_END)
+            tail = io.read([chunk, size_bytes].min) || ''.b
+          end
+        end
+
+        buffer = "v#{VERSION}\0#{size_bytes}\0"
+        buffer << head
+        buffer << "\0"
+        buffer << tail
+
+        Digest::SHA256.hexdigest(buffer)
+      rescue StandardError
+        nil
+      end
+
+      def normalize_chunk_bytes(value)
+        bytes = Integer(value)
+        return DEFAULT_CHUNK_BYTES if bytes <= 0
+
+        bytes
+      rescue StandardError
+        DEFAULT_CHUNK_BYTES
+      end
+      private_class_method :normalize_chunk_bytes
+    end
+  end
+end

data/lib/shoko/adapters/input/annotations/mouse_handler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Input::Annotations
+    # Handles mouse events for text selection in the reader
+    class MouseHandler
+      attr_reader :selection_start, :selection_end, :selecting
+
+      def initialize
+        reset
+      end
+
+      # Parse ANSI mouse event
+      def parse_mouse_event(input)
+        return nil unless input =~ /\e\[<(\d+);(\d+);(\d+)([Mm])/
+
+        {
+          button: ::Regexp.last_match(1).to_i,
+          x: ::Regexp.last_match(2).to_i - 1, # Convert to 0-based
+          y: ::Regexp.last_match(3).to_i - 1,
+          released: ::Regexp.last_match(4) == 'm',
+        }
+      end
+
+      # Handle mouse event and update selection state
+      def handle_event(event)
+        return nil unless event
+
+        btn = event[:button]
+        rel = event[:released]
+        col = event[:x]
+        row = event[:y]
+
+        if btn.zero? && !rel # Left button pressed
+          start_selection(col, row)
+        elsif btn == 32 && @selecting # Mouse dragged
+          update_selection(col, row)
+        elsif rel && @selecting # Button released
+          finish_selection
+        end
+      end
+
+      # Get normalized selection range
+      def selection_range
+        return nil unless @selection_start && @selection_end
+
+        start_pos = @selection_start
+        end_pos = @selection_end
+
+        # Ensure start comes before end
+        sy = start_pos[:y]
+        ey = end_pos[:y]
+        start_pos, end_pos = end_pos, start_pos if sy > ey || (sy == ey && start_pos[:x] > end_pos[:x])
+
+        { start: start_pos, end: end_pos }
+      end
+
+      def reset
+        @selecting = false
+        @selection_start = nil
+        @selection_end = nil
+      end
+
+      private
+
+      def start_selection(col, row)
+        @selecting = true
+        @selection_start = { x: col, y: row }
+        @selection_end = { x: col, y: row }
+        { type: :selection_start }
+      end
+
+      def update_selection(col, row)
+        @selection_end = { x: col, y: row }
+        { type: :selection_drag }
+      end
+
+      def finish_selection
+        @selecting = false
+        { type: :selection_end }
+      end
+    end
+  end
+end