shoko 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5060375164152dd31808e0548f1a525246af0d4708e037eb3590423730d4d6c6
-  data.tar.gz: a71558d1f38594e40ffe44d80f4d05dcdd1d1c43a23bb003ab42f74c9ffffeec
+  metadata.gz: a7a36fd324fdba1eed316344cfab543f5fef1bfa863c1b25fc3e644502978054
+  data.tar.gz: 5fc5820176929bd037c545901cdc0c611e98b593a90fc8da7a54d4a01b0cc359
 SHA512:
-  metadata.gz: 89e5372ed7369bb5631b4c190311303bbe8285602d5d7520060dc91f3c176c903f269a491d8b436f2c1d280717ddffd8b3498560aab076d7f7b7598ff76be0e8
-  data.tar.gz: b6ca5f48134e099a7b112c517bfa7efeb683606e3d25e66cdc27c8e6c6711615f49a7d2d7c4c75b7ef801e2d4286b3be8f3911dd00d726598093ee583c562198
+  metadata.gz: e29b072b4f0dc64eb6a18f36d3fcc1bf37fa9efa904b1827cccbe85c4c37860073e04c3eddc87fdab827b9d02e03958f54bd1714d58644cdff026caaacf93bfe
+  data.tar.gz: 0ffb950539fe1440f26149b1d75755811f2aaf541f900f6ab89051dc9e4e2550c1a07a9de32d83a3d6bac5a5f25a1184f7830cf3b39866eed458b71081fe9248

data/.bundle/config

@@ -1,3 +1,2 @@
 ---
 BUNDLE_PATH: "vendor/bundle"
-BUNDLE_WITHOUT: "development"

data/.rubocop.yml

@@ -1,6 +1,5 @@
 plugins:
   - rubocop-performance
-  - rubocop-rails
 
 AllCops:
   TargetRubyVersion: 3.3
@@ -36,24 +35,45 @@ Metrics/MethodLength:
   CountComments: false
   AllowedMethods:
     - 'initialize'
+    # Data schema definition - just a hash literal
+    - 'build_initial_state'
+    # Character-by-character algorithms where splitting obscures logic
+    - 'sanitize'
+    - 'wrap_cells'
+    - 'truncate_to'
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
 
 Metrics/AbcSize:
   Max: 20
+  AllowedMethods:
+    # Character-by-character algorithms
+    - 'wrap_cells'
+    - 'sanitize'
+    - 'truncate_to'
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
 
 Metrics/CyclomaticComplexity:
   Max: 8
+  AllowedMethods:
+    # Character-by-character algorithms - inherent complexity
+    - 'sanitize'
+    - 'truncate_to'
+    - 'wrap_cells'
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
 
 Metrics/PerceivedComplexity:
   Max: 9
+  AllowedMethods:
+    # Character-by-character algorithms - inherent complexity
+    - 'sanitize'
+    - 'truncate_to'
+    - 'wrap_cells'
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
@@ -71,6 +91,20 @@ Metrics/BlockLength:
     - 'spec/**/*'
     - 'test/**/*'
 
+# Naming
+Naming/PredicateMethod:
+  # Allow handler methods that return boolean for control flow
+  AllowedMethods:
+    - handle_overlay_click
+    - handle_sidebar_interaction
+    - handle_sidebar_tab_click
+    - handle_sidebar_toc_click
+    - handle_sidebar_wheel
+    - handle_sidebar_scroll_drag
+    - start_sidebar_scroll_drag
+    - cancel_via_ui
+    - dispatch_to_mode
+
 # Style
 Style/Documentation:
   Enabled: true
@@ -119,6 +153,3 @@ Lint/UselessAssignment:
 
 Lint/DuplicateMethods:
   Enabled: true
-
-Rails:
-  Enabled: false

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 
 group :development do
   gem 'reek'
+  gem 'rake'
   gem 'rubocop', require: false
   gem 'rubocop-performance', require: false
   gem 'rubocop-rails', require: false

data/Shoko.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'lib/shoko/shared/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'shoko'
+  spec.version = Shoko::VERSION
+  spec.authors = ['Shoko']
+  spec.email = ['ruby.computer770@passinbox.com']
+
+  spec.summary = 'Terminal EBook Reader'
+  spec.description = 'Terminal EBook Reader'
+  spec.homepage = 'https://sr.ht/~shayan/Shoko/'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 4.0.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+
+  # Specify which files should be added to the gem
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.end_with?('.gem') ||
+        (f == __FILE__) ||
+        f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end.select { |f| File.file?(f) }
+  end
+  spec.bindir = 'bin'
+  spec.executables = %w[shoko start]
+  spec.require_paths = ['lib']
+
+  # Development dependencies are managed in the Gemfile
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/bin/shoko

@@ -6,8 +6,8 @@ lib_dir = File.join(app_root, 'lib')
 $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
 
 begin
-  gemspec = Dir[File.join(app_root, '*.gemspec')].first
-  if gemspec && File.exist?(File.join(app_root, 'Gemfile'))
+  # Only activate Bundler when explicitly running under it (e.g. bundle exec).
+  if ENV['BUNDLE_GEMFILE'] || ENV['BUNDLE_BIN_PATH']
     require 'bundler/setup'
   end
 rescue LoadError

data/bin/start

@@ -6,8 +6,8 @@ lib_dir = File.join(app_root, 'lib')
 $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
 
 begin
-  gemspec = Dir[File.join(app_root, '*.gemspec')].first
-  if gemspec && File.exist?(File.join(app_root, 'Gemfile'))
+  # Only activate Bundler when explicitly running under it (e.g. bundle exec).
+  if ENV['BUNDLE_GEMFILE'] || ENV['BUNDLE_BIN_PATH']
     require 'bundler/setup'
   end
 rescue LoadError

data/lib/shoko/adapters/base_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters
+    # Base class for adapters in the hexagonal architecture.
+    # Adapters connect ports to external infrastructure (UI, databases, etc.)
+    # and should NOT extend Core's BaseService.
+    #
+    # This class provides a simple dependency injection pattern via constructor kwargs
+    # without the `resolve()` semantics of BaseService.
+    class BaseAdapter
+      # @param logger [Object, nil] Optional logger for debugging
+      def initialize(logger: nil)
+        @logger = logger
+      end
+
+      protected
+
+      attr_reader :logger
+
+      def log_debug(message, **context)
+        logger&.debug(message, **context)
+      end
+
+      def log_error(message, **context)
+        logger&.error(message, **context)
+      end
+    end
+  end
+end

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../monitoring/performance_monitor.rb'
 require_relative 'epub_document'
 
 module Shoko
@@ -8,8 +7,14 @@ module Shoko
     # Document service for loading and accessing EPUB content.
     # Provides clean interface to document operations without coupling to controllers.
     class DocumentService
-      def initialize(epub_path, wrapping_service = nil, formatting_service: nil, background_worker: nil,
-                     progress_reporter: nil)
+      # @param epub_path [String] Path to EPUB file
+      # @param wrapping_service [Object, nil] Wrapping service
+      # @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::Logging] Logger adapter (required)
+      def initialize(epub_path, wrapping_service = nil, logger:, formatting_service: nil, background_worker: nil,
+                     progress_reporter: nil, instrumentation: nil)
         @epub_path = epub_path
         @document = nil
         @content_cache = {}
@@ -17,20 +22,24 @@ module Shoko
         @formatting_service = formatting_service
         @background_worker = background_worker
         @progress_reporter = progress_reporter
+        @logger = logger
+        @instrumentation = instrumentation
       end
 
       # Load the EPUB document
       #
       # @return [EPUBDocument] Loaded document
       def load_document
-        @document ||= Adapters::Monitoring::PerformanceMonitor.time('import.document.load') do
+        @document ||= instrument('import.document.load') do
           EPUBDocument.new(@epub_path,
                            formatting_service: @formatting_service,
                            background_worker: @background_worker,
-                           progress_reporter: @progress_reporter)
+                           progress_reporter: @progress_reporter,
+                           logger: @logger,
+                           instrumentation: @instrumentation)
         end
       rescue StandardError => e
-        Adapters::Monitoring::Logger.error('Failed to load document', path: @epub_path, error: e.message)
+        @logger.error('Failed to load document', path: @epub_path, error: e.message)
         create_error_document(e.message)
       end
 
@@ -155,6 +164,14 @@ module Shoko
 
         yield chapter
       end
+
+      def instrument(label, &)
+        if @instrumentation
+          @instrumentation.measure(label, &)
+        else
+          yield
+        end
+      end
     end
 
     # Simple error document for when EPUB loading fails

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

@@ -1,95 +1,91 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require_relative '../../core/services/base_service.rb'
+require_relative '../base_adapter'
 require_relative '../storage/config_paths'
 
 module Shoko
   module Adapters::BookSources
-      # Coordinates Gutendex search + download to the local library.
-      class DownloadService < BaseService
-        class DownloadError < StandardError; end
-
-        def search(query:, page_url: nil)
-          payload = client.search(query: query, page_url: page_url)
-          {
-            count: payload['count'].to_i,
-            next: payload['next'],
-            previous: payload['previous'],
-            books: normalize_books(payload['results']),
-          }
-        end
-
-        def download(book)
-          url = pick_download_url(book)
-          raise DownloadError, 'No EPUB format available' unless url
-
-          dest_dir = downloads_root
-          FileUtils.mkdir_p(dest_dir)
-          dest_path = File.join(dest_dir, filename_for(book))
-          return { path: dest_path, existing: true } if File.exist?(dest_path)
+    # Coordinates Gutendex search + download to the local library.
+    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:, logger: nil)
+        super(logger: logger)
+        @client = gutendex_client
+      end
 
-          client.download(url, dest_path) { |done, total| yield(done, total) if block_given? }
-          { path: dest_path, existing: false }
-        end
+      def search(query:, page_url: nil)
+        payload = @client.search(query: query, page_url: page_url)
+        {
+          count: payload['count'].to_i,
+          next: payload['next'],
+          previous: payload['previous'],
+          books: normalize_books(payload['results']),
+        }
+      end
 
-        protected
+      def download(book)
+        url = pick_download_url(book)
+        raise DownloadError, 'No EPUB format available' unless url
 
-        def required_dependencies
-          [:gutendex_client]
-        end
+        dest_dir = downloads_root
+        FileUtils.mkdir_p(dest_dir)
+        dest_path = File.join(dest_dir, filename_for(book))
+        return { path: dest_path, existing: true } if File.exist?(dest_path)
 
-        private
+        @client.download(url, dest_path) { |done, total| yield(done, total) if block_given? }
+        { path: dest_path, existing: false }
+      end
 
-        def client
-          @client ||= resolve(:gutendex_client)
-        end
+      private
 
-        def downloads_root
-          Adapters::Storage::ConfigPaths.downloads_root
-        end
+      def downloads_root
+        Adapters::Storage::ConfigPaths.downloads_root
+      end
 
-        def normalize_books(items)
-          Array(items).map do |raw|
-            {
-              id: raw['id'],
-              title: raw['title'],
-              authors: Array(raw['authors']).filter_map { |a| a['name'] },
-              languages: Array(raw['languages']).map(&:to_s),
-              download_count: raw['download_count'],
-              formats: raw['formats'] || {},
-            }
-          end
+      def normalize_books(items)
+        Array(items).map do |raw|
+          {
+            id: raw['id'],
+            title: raw['title'],
+            authors: Array(raw['authors']).filter_map { |a| a['name'] },
+            languages: Array(raw['languages']).map(&:to_s),
+            download_count: raw['download_count'],
+            formats: raw['formats'] || {},
+          }
         end
+      end
 
-        def pick_download_url(book)
-          formats = value_for(book, :formats, 'formats', {})
-          return nil unless formats.respond_to?(:each)
+      def pick_download_url(book)
+        formats = value_for(book, :formats, 'formats', {})
+        return nil unless formats.respond_to?(:each)
 
-          keys = formats.keys.map(&:to_s)
-          epub_key = keys.find { |k| k.start_with?('application/epub+zip') } ||
-                     keys.find { |k| k.include?('application/epub') } ||
-                     keys.find { |k| k.include?('epub') }
-          return nil unless epub_key
+        keys = formats.keys.map(&:to_s)
+        epub_key = keys.find { |k| k.start_with?('application/epub+zip') } ||
+                   keys.find { |k| k.include?('application/epub') } ||
+                   keys.find { |k| k.include?('epub') }
+        return nil unless epub_key
 
-          formats[epub_key] || formats[epub_key.to_sym]
-        end
-
-        def filename_for(book)
-          id = value_for(book, :id, 'id', 'book').to_s
-          title = value_for(book, :title, 'title', 'book').to_s
-          slug = title.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')
-          slug = "book-#{id}" if slug.empty?
-          "#{slug}-#{id}.epub"
-        end
+        formats[epub_key] || formats[epub_key.to_sym]
+      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)
+      def filename_for(book)
+        id = value_for(book, :id, 'id', 'book').to_s
+        title = value_for(book, :title, 'title', 'book').to_s
+        slug = title.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')
+        slug = "book-#{id}" if slug.empty?
+        "#{slug}-#{id}.epub"
+      end
 
-          default
-        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)
 
+        default
       end
+    end
   end
 end

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

@@ -3,9 +3,8 @@
 require 'digest'
 require 'zip'
 
-require_relative '../../storage/atomic_file_writer.rb'
-require_relative '../../storage/cache_paths.rb'
-require_relative '../../monitoring/logger.rb'
+require_relative '../../storage/atomic_file_writer'
+require_relative '../../storage/cache_paths'
 
 module Shoko
   module Adapters::BookSources::Epub
@@ -14,8 +13,9 @@ module Shoko
     class EpubResourceLoader
       SHA256_HEX_PATTERN = /\A[0-9a-f]{64}\z/i
 
-      def initialize(cache_root: CachePaths.cache_root)
+      def initialize(cache_root: Shoko::Adapters::Storage::CachePaths.cache_root, logger: nil)
         @cache_root = cache_root
+        @logger = logger
       end
 
       # Fetch an entry from the per-book blob cache or from the EPUB archive.
@@ -101,11 +101,12 @@ module Shoko
           data
         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)
+        @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)
+        @logger&.debug('EpubResourceLoader: read failed', path: epub_path.to_s,
+                                                          entry: entry_path.to_s, error: e.message)
         nil
       end
 

data/lib/shoko/adapters/book_sources/epub/parsers/html_processor.rb

@@ -2,8 +2,7 @@
 
 require 'cgi'
 
-require_relative '../../../monitoring/perf_tracer.rb'
-require_relative '../../../output/terminal/terminal_sanitizer.rb'
+require_relative '../../../output/terminal/terminal_sanitizer'
 
 module Shoko
   module Adapters::BookSources::Epub::Parsers
@@ -16,11 +15,7 @@ module Shoko
       end
 
       def self.html_to_text(html)
-        if Shoko::Adapters::Monitoring::PerfTracer.enabled?
-          Shoko::Adapters::Monitoring::PerfTracer.measure('xhtml.normalize') { normalize_html(html) }
-        else
-          normalize_html(html)
-        end
+        normalize_html(html)
       end
 
       BLOCK_REPLACEMENTS = {

data/lib/shoko/adapters/book_sources/epub/parsers/metadata_extractor.rb

@@ -4,6 +4,7 @@ require 'zip'
 require 'rexml/document'
 
 require_relative 'opf_processor'
+require_relative 'rexml_safe_parser'
 
 module Shoko
   module Adapters::BookSources::Epub::Parsers
@@ -25,7 +26,7 @@ module Shoko
 
       def self.find_opf_path(zip)
         container_xml = zip.read('META-INF/container.xml')
-        container = REXML::Document.new(container_xml)
+        container = REXMLSafeParser.parse(container_xml)
         rootfile = container.elements['//rootfile']
         return nil unless rootfile
 

data/lib/shoko/adapters/book_sources/epub/parsers/opf/navigation_traversal.rb

@@ -3,6 +3,7 @@
 require 'rexml/document'
 
 require_relative 'navigation_context'
+require_relative '../rexml_safe_parser'
 require_relative 'navigation_walker'
 require_relative 'navigation_result'
 
@@ -78,7 +79,7 @@ module Shoko
         content = @entry_reader.safe_read_entry(path)
         return nil unless content
 
-        doc = REXML::Document.new(content)
+        doc = REXMLSafeParser.parse(content)
         nav_list_from_document(doc)
       rescue REXML::ParseException
         nil
@@ -93,7 +94,7 @@ module Shoko
 
       def nav_map_from_path(path)
         ncx_content = @entry_reader.read_entry(path)
-        ncx = REXML::Document.new(ncx_content)
+        ncx = REXMLSafeParser.parse(ncx_content)
         ncx.elements['//navMap']
       rescue StandardError
         nil

data/lib/shoko/adapters/book_sources/epub/parsers/opf_processor.rb

@@ -3,7 +3,7 @@
 require 'cgi'
 require 'rexml/document'
 
-require_relative '../../../monitoring/perf_tracer.rb'
+require_relative 'rexml_safe_parser'
 require_relative 'opf/entry_reader'
 require_relative 'opf/metadata_extractor'
 require_relative 'opf/navigation_extractor'
@@ -18,12 +18,13 @@ module Shoko
 
       attr_reader :toc_entries
 
-      def initialize(opf_path, zip: nil)
+      def initialize(opf_path, zip: nil, instrumentation: nil)
         @opf_path = opf_path
+        @instrumentation = instrumentation
         @entry_reader = OPFEntryReader.new(opf_path, zip: zip)
         content = read_opf_content
-        @opf = Shoko::Adapters::Monitoring::PerfTracer.measure('opf.parse') do
-          REXML::Document.new(content)
+        @opf = instrument('opf.parse') do
+          REXMLSafeParser.parse(content)
         end
         @toc_entries = []
         @navigation_extractor = OPFNavigationExtractor.new(opf: @opf, entry_reader: @entry_reader)
@@ -66,7 +67,7 @@ module Shoko
 
       def read_opf_content
         raw = if @entry_reader.zip?
-                Shoko::Adapters::Monitoring::PerfTracer.measure('zip.read') do
+                instrument('zip.read') do
                   @entry_reader.read_raw(@opf_path)
                 end
               else
@@ -75,6 +76,14 @@ module Shoko
         @entry_reader.normalize_xml_text(raw)
       end
 
+      def instrument(label, &)
+        if @instrumentation
+          @instrumentation.measure(label, &)
+        else
+          yield
+        end
+      end
+
       def manifest_item_id_href(item)
         attrs = item.attributes
         [attrs['id'], attrs['href']]

data/lib/shoko/adapters/book_sources/epub/parsers/rexml_safe_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+require 'rexml/security'
+
+module Shoko
+  module Adapters::BookSources::Epub::Parsers
+    # Centralized REXML parser with hardened entity expansion limits.
+    module REXMLSafeParser
+      module_function
+
+      DEFAULT_ENTITY_EXPANSION_LIMIT = 10_000
+      DEFAULT_ENTITY_EXPANSION_TEXT_LIMIT = 2_000_000
+
+      def parse(xml)
+        apply_security_limits
+        REXML::Document.new(xml)
+      end
+
+      def apply_security_limits
+        limit = integer_env('SHOKO_REXML_ENTITY_LIMIT', DEFAULT_ENTITY_EXPANSION_LIMIT)
+        text_limit = integer_env('SHOKO_REXML_TEXT_LIMIT', DEFAULT_ENTITY_EXPANSION_TEXT_LIMIT)
+
+        if defined?(REXML::Security) && REXML::Security.respond_to?(:entity_expansion_limit=)
+          REXML::Security.entity_expansion_limit = limit
+        end
+        if defined?(REXML::Security) && REXML::Security.respond_to?(:entity_expansion_text_limit=)
+          REXML::Security.entity_expansion_text_limit = text_limit
+        end
+        if defined?(REXML::Document) && REXML::Document.respond_to?(:entity_expansion_text_limit=)
+          REXML::Document.entity_expansion_text_limit = text_limit
+        end
+      rescue StandardError
+        nil
+      end
+      private_class_method :apply_security_limits
+
+      def integer_env(key, fallback)
+        value = ENV.fetch(key, '').to_s.strip
+        return fallback if value.empty?
+
+        parsed = value.to_i
+        parsed.positive? ? parsed : fallback
+      rescue StandardError
+        fallback
+      end
+      private_class_method :integer_env
+    end
+  end
+end