shoko 0.1.0

data/lib/shoko/core/services/selection_service.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative '../models/selection_anchor'
+require_relative '../../application/selectors/reader_selectors'
+
+module Shoko
+  module Core
+    module Services
+      # Service to normalize selection ranges and extract text from rendered_lines
+      # Centralizes logic used by UIController and MouseableReader
+      class SelectionService < BaseService
+        # Convenience helper: extract selection text directly from state.
+        # If selection_range is nil, uses state[:reader][:selection].
+        def extract_from_state(state, selection_range = nil)
+          return '' unless state
+
+          range = selection_range || state.get(%i[reader selection])
+          rendered = Shoko::Application::Selectors::ReaderSelectors.rendered_lines(state)
+          extract_text(range, rendered)
+        end
+
+        # Extract selected text from selection_range using rendered_lines in state
+        # @param selection_range [Hash] {:start=>{x:,y:}, :end=>{x:,y:}}
+        # @param rendered_lines [Hash<Integer, Hash>] mapping of line_id => {row:, col:, col_end:, width:, text:}
+        # @return [String]
+        def extract_text(selection_range, rendered_lines)
+          return '' unless selection_range && rendered_lines && !rendered_lines.empty?
+
+          coordinate_service = resolve(:coordinate_service)
+          normalized = coordinate_service.normalize_selection_range(selection_range, rendered_lines)
+          return '' unless normalized
+
+          start_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized[:start])
+          end_anchor = Shoko::Core::Models::SelectionAnchor.from(normalized[:end])
+          return '' unless start_anchor && end_anchor
+
+          geometry_index = build_geometry_index(rendered_lines)
+          return '' if geometry_index.empty?
+
+          ordered = order_geometry(geometry_index.values)
+          start_idx = ordered.find_index { |geo| geo.key == start_anchor.geometry_key }
+          end_idx = ordered.find_index { |geo| geo.key == end_anchor.geometry_key }
+          return '' unless start_idx && end_idx
+
+          text_lines = []
+
+          ordered[start_idx..end_idx].each do |geometry|
+            start_cell = geometry.key == start_anchor.geometry_key ? start_anchor.cell_index : 0
+            end_cell = geometry.key == end_anchor.geometry_key ? end_anchor.cell_index : geometry.cells.length
+
+            next if end_cell < start_cell
+
+            start_char = char_index_for_cell(geometry, start_cell)
+            end_char = char_index_for_cell(geometry, end_cell)
+            segment = geometry.plain_text[start_char...end_char]
+            next if segment.nil?
+
+            text_lines << segment
+          end
+
+          text_lines.join("\n")
+        end
+
+        # Normalize a selection range using the coordinate service and rendered_lines
+        #
+        # @param state [Application::Infrastructure::ObserverStateStore]
+        # @param selection_range [Hash]
+        # @return [Hash, nil] normalized range or nil when normalization fails
+        def normalize_range(state, selection_range)
+          return nil unless selection_range
+          return selection_range if anchor_range?(selection_range)
+
+          coordinate_service = resolve(:coordinate_service)
+          rendered = Shoko::Application::Selectors::ReaderSelectors.rendered_lines(state)
+          coordinate_service.normalize_selection_range(selection_range, rendered)
+        rescue StandardError
+          nil
+        end
+
+        protected
+
+        def required_dependencies
+          [:coordinate_service]
+        end
+
+        private
+
+        def anchor_range?(range)
+          return false unless range.is_a?(Hash)
+
+          start_anchor = range[:start] || range['start']
+          start_anchor.is_a?(Hash) && (start_anchor.key?(:geometry_key) || start_anchor.key?('geometry_key'))
+        end
+
+        def build_geometry_index(rendered_lines)
+          rendered_lines.each_with_object({}) do |(_key, info), acc|
+            geometry = info[:geometry]
+            next unless geometry
+
+            acc[geometry.key] = geometry
+          end
+        end
+
+        def order_geometry(geometries)
+          geometries.sort_by do |geo|
+            [geo.page_id || 0, geo.line_offset || 0, geo.column_id || 0, geo.row || 0, geo.column_origin || 0]
+          end
+        end
+
+        def char_index_for_cell(geometry, cell_index)
+          cells = geometry.cells
+          return 0 if cells.empty?
+
+          if cell_index <= 0
+            0
+          elsif cell_index >= cells.length
+            geometry.plain_text.length
+          else
+            cells[cell_index].char_start
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/validator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Core
+    # Base validator class providing common validation patterns.
+    # Subclasses should implement specific validation logic.
+    #
+    # @abstract
+    class Validator
+      # Validation errors collection
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      # Check if validation passed
+      #
+      # @return [Boolean] true if no errors
+      def valid?
+        @errors.empty?
+      end
+
+      # Add an error message
+      #
+      # @param field [Symbol] Field name
+      # @param message [String] Error message
+      def add_error(field, message)
+        @errors << { field:, message: }
+      end
+
+      # Clear all errors
+      def clear_errors
+        @errors = []
+      end
+
+      # Validate presence of a value
+      #
+      # @param value [Object] Value to check
+      # @param field [Symbol] Field name for error reporting
+      # @param message [String] Custom error message
+      # @return [Boolean] Validation result
+      def presence_valid?(value, field, message = "can't be blank")
+        return true if value && !value.to_s.strip.empty?
+
+        add_error(field, message)
+        false
+      end
+
+      RangeValidationContext = Struct.new(:value, :range, :field, :message)
+      FormatValidationContext = Struct.new(:value, :pattern, :field, :message)
+
+      # Validate that a value falls within a range
+      #
+      # @param context [RangeValidationContext] Validation parameters
+      # @return [Boolean] Validation result
+      def range_valid?(context)
+        return true if context.range.include?(context.value)
+
+        add_error(context.field, context.message || 'must be between')
+        false
+      end
+
+      # Validate that a value matches a regular expression pattern
+      #
+      # @param context [FormatValidationContext] Validation parameters
+      # @return [Boolean] Validation result
+      def format_valid?(context)
+        return true if context.value&.match?(context.pattern)
+
+        add_error(context.field, context.message || 'has invalid format')
+        false
+      end
+    end
+  end
+end

data/lib/shoko/shared/errors.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Shoko
+  # Base error class for Shoko
+  class Error < StandardError; end
+
+  # Raised when EPUB file cannot be parsed
+  class EPUBParseError < Error
+    attr_reader :file_path
+
+    def initialize(message, file_path)
+      super("Failed to parse EPUB at #{file_path}: #{message}")
+      @file_path = file_path
+    end
+  end
+
+  # Raised when required file is not found
+  class FileNotFoundError < Error
+    attr_reader :file_path
+
+    def initialize(file_path)
+      super("File not found: #{file_path}")
+      @file_path = file_path
+    end
+  end
+
+  # Raised when configuration is invalid
+  class ConfigurationError < Error; end
+
+  # Raised when no interactive terminal is available
+  class TerminalUnavailableError < Error
+    def initialize
+      super('Interactive terminal not available')
+    end
+  end
+
+  # Raised when reader state is invalid
+  class InvalidStateError < Error
+    attr_reader :state
+
+    def initialize(message, state)
+      super("Invalid reader state: #{message}")
+      @state = state
+    end
+  end
+
+  # Raised when navigation is not possible
+  class NavigationError < Error
+    attr_reader :direction, :reason
+
+    def initialize(direction, reason)
+      super("Cannot navigate #{direction}: #{reason}")
+      @direction = direction
+      @reason = reason
+    end
+  end
+
+  # Raised when bookmark operation fails
+  class BookmarkError < Error
+    attr_reader :operation
+
+    def initialize(operation, message)
+      super("Bookmark #{operation} failed: #{message}")
+      @operation = operation
+    end
+  end
+
+  # Raised when rendering fails
+  class RenderError < Error
+    attr_reader :component
+
+    def initialize(component, message)
+      super("Rendering failed in #{component}: #{message}")
+      @component = component
+    end
+  end
+
+  # Raised when content normalization produces no semantic blocks
+  class FormattingError < Error
+    attr_reader :source
+
+    def initialize(source, message)
+      super("Formatting failed for #{source}: #{message}")
+      @source = source
+    end
+  end
+
+  # Raised when cached book data cannot be loaded or is incompatible.
+  class CacheLoadError < Error
+    attr_reader :path
+
+    def initialize(path, message = 'Cache is corrupt or incompatible')
+      super("Cache load failed for #{path}: #{message}")
+      @path = path
+    end
+  end
+end

data/lib/shoko/shared/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Shoko
+  VERSION = '0.1.0'
+end

data/lib/shoko/test_support/terminal_double.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Shoko
+  # Test-only helpers and doubles for terminal interactions.
+  module TestSupport
+    # Lightweight replacement for the production Terminal facade that keeps
+    # tests deterministic and side-effect free. All terminal operations become
+    # in-memory recordings so specs can make assertions without touching an
+    # actual TTY.
+    class TerminalDouble
+      ANSI = Shoko::Adapters::Output::Terminal::TerminalOutput::ANSI
+
+      class << self
+        attr_accessor :default_height, :default_width
+
+        def reset!
+          @writes = []
+          @printed = []
+          @moves = []
+          @clears = []
+          @mouse_events = []
+          @input_queue = Queue.new
+          @default_height = 24
+          @default_width = 80
+        end
+
+        def writes
+          @writes ||= []
+        end
+
+        def printed
+          @printed ||= []
+        end
+
+        def moves
+          @moves ||= []
+        end
+
+        def clears
+          @clears ||= []
+        end
+
+        def mouse_events
+          @mouse_events ||= []
+        end
+
+        def push_input(*keys)
+          ensure_input_queue
+          keys.flatten.each { |k| @input_queue << k }
+        end
+
+        def drain_input
+          ensure_input_queue
+          drained = []
+          loop do
+            drained << @input_queue.pop(true)
+          rescue ThreadError
+            break
+          end
+          drained
+        end
+
+        def size=(tuple)
+          @default_height, @default_width = tuple
+        end
+
+        def size
+          [@default_height || 24, @default_width || 80]
+        end
+
+        def setup
+          @setup_calls = setup_calls + 1
+        end
+
+        def cleanup
+          @cleanup_calls = cleanup_calls + 1
+        end
+
+        def setup_calls
+          @setup_calls ||= 0
+        end
+
+        def cleanup_calls
+          @cleanup_calls ||= 0
+        end
+
+        def start_frame(**_kwargs)
+          # no-op, but record for assertions if needed
+          @frame_started = true
+        end
+
+        def end_frame
+          @frame_started = false
+        end
+
+        def frame_started?
+          !!@frame_started
+        end
+
+        def clear
+          clears << :clear
+        end
+
+        def move(row, col)
+          moves << [row, col]
+        end
+
+        def write(row, col, text)
+          writes << { row:, col:, text: text.to_s }
+        end
+
+        def write_differential(row, col, text)
+          write(row, col, text)
+        end
+
+        def clear_buffer_cache
+          # Nothing cached in the double; keep interface parity.
+        end
+
+        def batch_write
+          yield if block_given?
+        end
+
+        def print(str)
+          printed << str.to_s
+        end
+
+        def flush
+          # no-op
+        end
+
+        def enable_mouse
+          mouse_events << :enabled
+        end
+
+        def disable_mouse
+          mouse_events << :disabled
+        end
+
+        def read_key
+          pop_key(non_block: true)
+        end
+
+        def read_key_blocking(timeout: nil)
+          pop_key(timeout: timeout || 0.1)
+        end
+
+        def read_input_with_mouse(timeout: nil)
+          read_key_blocking(timeout: timeout)
+        end
+
+        private
+
+        def ensure_input_queue
+          @ensure_input_queue ||= Queue.new
+        end
+
+        def pop_key(non_block: false, timeout: nil)
+          ensure_input_queue
+          if non_block
+            @input_queue.pop(true)
+          elsif timeout
+            @input_queue.pop(timeout: timeout)
+          else
+            @input_queue.pop
+          end
+        rescue ThreadError
+          nil
+        end
+      end
+    end
+
+    TerminalDouble.reset!
+  end
+end

data/lib/shoko/test_support/test_mode.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'terminal_double'
+
+module Shoko
+  module TestSupport
+    # Central hook that enables deterministic test behaviour by swapping in
+    # lightweight adapters and updating the dependency container.
+    module TestMode
+      module_function
+
+      def active?
+        primary = ENV.fetch('SHOKO_TEST_MODE', '').to_s.strip
+        primary == '1'
+      end
+
+      def activate!
+        return unless active?
+
+        install_terminal_double!
+        silence_logger!
+      end
+
+      def configure_container(container)
+        return unless active?
+
+        container.register_singleton(:terminal_service) do |c|
+          TestTerminalService.new(c)
+        end
+      end
+
+      # Test-specialised terminal service that exposes helpers for enqueuing
+      # deterministic input sequences while delegating behaviour to the base
+      # implementation (now backed by the TerminalDouble).
+      class TestTerminalService < Shoko::Adapters::Output::Terminal::TerminalService
+        def queue_input(*keys)
+          Shoko::TestSupport::TerminalDouble.push_input(*keys)
+        end
+
+        def drain_input
+          Shoko::TestSupport::TerminalDouble.drain_input
+        end
+
+        def configure_size(height:, width:)
+          Shoko::TestSupport::TerminalDouble.size = [height, width]
+        end
+      end
+
+      def install_terminal_double!
+        return if @terminal_installed
+
+        real_terminal = (Shoko.const_get(:Terminal) if Shoko.const_defined?(:Terminal, false))
+        Shoko.const_set(:RealTerminal, real_terminal) unless Shoko.const_defined?(:RealTerminal)
+        Shoko.send(:remove_const, :Terminal) if Shoko.const_defined?(:Terminal, false)
+        Shoko.const_set(:Terminal, Shoko::TestSupport::TerminalDouble)
+        Shoko::TestSupport::TerminalDouble.reset!
+        @terminal_installed = true
+      end
+
+      def silence_logger!
+        return unless defined?(Shoko::Adapters::Monitoring::Logger)
+
+        begin
+          Shoko::Adapters::Monitoring::Logger.output = logger_null_io
+          Shoko::Adapters::Monitoring::Logger.level = :fatal
+        rescue StandardError
+          nil
+        end
+      end
+
+      def logger_null_io
+        @null_logger_io ||= File.open(File::NULL, 'w')
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end