shoko 0.1.0

data/lib/shoko/adapters/monitoring/perf_tracer.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'time'
+module Shoko
+  module Adapters::Monitoring
+    # Collects per-open performance timings when DEBUG_PERF=1.
+    module PerfTracer
+      SESSION_KEY = :shoko_perf_session
+      STAGES = [
+        'open.invoke',
+        'cache.pipeline',
+        'cache.lookup',
+        'zip.read',
+        'opf.parse',
+        'xhtml.normalize',
+        'pagination.build',
+        'formatting.ensure',
+        'page_map.hydrate',
+        'render.first_paint.ttfp',
+      ].freeze
+
+      @profile_path = begin
+        primary = ENV.fetch('SHOKO_PROFILE_PATH', '').to_s.strip
+        primary.empty? ? nil : primary
+      end
+
+      module_function
+
+      def profile_path=(path)
+        @profile_path = path
+      end
+
+      def enabled?
+        return @enabled unless @enabled.nil?
+
+        raw = ENV.fetch('DEBUG_PERF', nil)
+        env_enabled = raw && raw.to_s.strip == '1'
+        @enabled = env_enabled || @profile_path
+      end
+
+      alias active? enabled?
+
+      def start_open(path)
+        return unless enabled?
+
+        session = Session.new(path)
+        Thread.current[SESSION_KEY] = session
+        session
+      end
+
+      def current_session
+        Thread.current[SESSION_KEY]
+      end
+
+      def measure(stage, &)
+        session = current_session
+        return yield unless session
+
+        session.measure(stage, &)
+      end
+
+      def record(stage, duration)
+        session = current_session
+        session&.record(stage, duration)
+      end
+
+      def complete(open_type:, total_duration: nil)
+        session = current_session
+        return unless session
+
+        session.add_metadata(open_type: open_type)
+        session.record('open.invoke', total_duration) if total_duration
+        session.open_type = open_type
+        session.emit
+      ensure
+        clear_session
+      end
+
+      def clear_session
+        Thread.current[SESSION_KEY] = nil
+      end
+
+      def cancel
+        clear_session
+      end
+
+      def annotate(metadata)
+        session = current_session
+        session&.add_metadata(metadata)
+      end
+
+      # Internal per-open timing tracker.
+      class Session
+        attr_accessor :open_type
+
+        def initialize(path)
+          @path = path
+          @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @timings = Hash.new(0.0)
+          @open_type = 'unknown'
+          @metadata = { book: path }
+        end
+
+        def measure(stage)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          yield
+        ensure
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+          @timings[stage] += duration if duration
+        end
+
+        def record(stage, duration)
+          @timings[stage] += duration.to_f
+        end
+
+        def add_metadata(hash)
+          return unless hash.is_a?(Hash)
+
+          hash.each do |k, v|
+            @metadata[k.to_sym] = v unless v.nil?
+          end
+        end
+
+        def emit
+          total = @timings['open.invoke']
+          total = elapsed unless total.positive?
+          fields = ["perf open=#{open_type_label}"]
+          PerfTracer::STAGES.each do |stage|
+            duration = stage == 'open.invoke' ? total : @timings[stage]
+            fields << "#{stage}=#{format_ms(duration)}"
+          end
+          line_one = [
+            "time=#{timestamp}",
+            "book=#{@metadata[:book]}",
+            ("cache_hit=#{@metadata[:cache_hit]}" if @metadata.key?(:cache_hit)),
+            ("pagination_cache=#{@metadata[:pagination_cache]}" if @metadata.key?(:pagination_cache)),
+            ("chapters=#{@metadata[:chapters]}" if @metadata.key?(:chapters)),
+            "open_type=#{open_type_label}",
+          ].compact.join(' ')
+          output = [line_one, "stages #{fields[1..].join(' ')}", '---'].join("\n")
+          write_output(output)
+        end
+
+        private
+
+        def timestamp
+          Time.now.utc.iso8601
+        rescue StandardError
+          Time.now.to_s
+        end
+
+        def open_type_label
+          label = @open_type.to_s.strip
+          label.empty? ? 'unknown' : label
+        end
+
+        def elapsed
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at
+        end
+
+        def format_ms(seconds)
+          ms = (seconds.to_f * 1000.0)
+          "#{ms.round}ms"
+        end
+
+        def write_output(text)
+          path = PerfTracer.instance_variable_get(:@profile_path)
+          if path && !path.to_s.strip.empty?
+            begin
+              FileUtils.mkdir_p(File.dirname(path))
+              File.open(path, 'a') { |f| f.puts(text) }
+              return
+            rescue StandardError
+              # fall through to stdout
+            end
+          end
+          $stdout.puts(text)
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/monitoring/performance_monitor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Shoko
+  module Adapters::Monitoring
+    # Performance monitoring for the application.
+    # Tracks execution times, memory usage, and provides profiling capabilities.
+    #
+    # @example Timing a block
+    #   PerformanceMonitor.time("epub_parsing") do
+    #     EPUBDocument.new(path)
+    #   end
+    #
+    # @example Getting metrics
+    #   puts PerformanceMonitor.metrics
+    class PerformanceMonitor
+      class << self
+        # Storage for performance metrics
+        def metrics
+          @metrics ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        # Time a block of code
+        #
+        # @param label [String] Label for the timing
+        # @yield Block to time
+        # @return [Object] Result of the block
+        def time(label)
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          start_memory = current_memory_usage
+
+          result = yield
+
+          end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end_memory = current_memory_usage
+
+          duration = end_time - start_time
+          memory_delta = end_memory - start_memory
+
+          record_metric(label, duration, memory_delta)
+
+          result
+        end
+
+        # Record a metric
+        #
+        # @param label [String] Metric label
+        # @param duration [Float] Duration in seconds
+        # @param memory_delta [Integer] Memory change in bytes
+        def record_metric(label, duration, memory_delta)
+          metrics[label] << ({
+            timestamp: Time.now,
+            duration:,
+            memory_delta:,
+          })
+
+          # Log slow operations
+          return unless duration > 1.0
+
+          Shoko::Adapters::Monitoring::Logger.warn('Slow operation detected',
+                      label:,
+                      duration: "#{(duration * 1000).round(2)}ms")
+        end
+
+        # Get statistics for a metric
+        #
+        # @param label [String] Metric label
+        # @return [Hash] Statistics
+        def stats(label)
+          data = metrics[label]
+          return nil if data.empty?
+
+          calculate_statistics(data)
+        end
+
+        # Clear all metrics
+        def clear
+          @metrics = nil
+        end
+
+        private
+
+        def calculate_statistics(data)
+          durations = data.map { |m| m[:duration] }
+
+          {
+            count: data.size,
+            total: durations.sum,
+            average: calculate_average(durations),
+            min: durations.min,
+            max: durations.max,
+            last: durations.last,
+          }
+        end
+
+        def calculate_average(durations)
+          durations.sum / durations.size
+        end
+
+        # Get current memory usage in bytes
+        #
+        # @return [Integer] Memory usage
+        def current_memory_usage
+          # This is a simplified version - in production you might use
+          # more sophisticated memory profiling
+          GC.stat[:total_allocated_objects] * 40 # Rough estimate
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/clipboard/clipboard_service.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/services/base_service.rb'
+require 'English'
+
+module Shoko
+  module Adapters
+    module Output
+      module Clipboard
+        # Domain service for clipboard operations with dependency injection.
+        # Migrated from legacy Services::ClipboardService to follow DI pattern.
+        class ClipboardService < BaseService
+          # Error raised when clipboard operations fail
+          class ClipboardError < StandardError; end
+
+        # Copy text to system clipboard
+        def copy_text?(text)
+          return false if text.nil? || text.strip.empty?
+
+          command = detect_clipboard_command
+          return false unless command
+
+          success = execute_clipboard_command(command, text)
+
+          if success
+            log_success(text.length)
+            true
+          else
+            log_failure
+            false
+          end
+        end
+
+        # Copy text with user feedback
+        def copy_with_feedback(text)
+          if copy_text?(text)
+            yield(' Copied to clipboard!') if block_given?
+            true
+          else
+            yield(' Failed to copy to clipboard') if block_given?
+            false
+          end
+        rescue ClipboardError => e
+          yield(" Copy failed: #{e.message}") if block_given?
+          false
+        end
+
+        # Check if clipboard functionality is available
+        def available?
+          !detect_clipboard_command.nil?
+        end
+
+        private
+
+        def detect_clipboard_command
+          case RUBY_PLATFORM
+          when /darwin/
+            command_exists?('pbcopy') ? ['pbcopy'] : nil
+          when /linux/
+            if command_exists?('xclip')
+              ['xclip', '-selection', 'clipboard']
+            elsif command_exists?('xsel')
+              ['xsel', '--clipboard', '--input']
+            elsif command_exists?('wl-copy')
+              ['wl-copy']
+            end
+          when /mswin|mingw|cygwin/
+            ['clip']
+          end
+        end
+
+        def command_exists?(command)
+          name = command.to_s.strip
+          return false if name.empty?
+
+          path_env = ENV.fetch('PATH', '')
+          exts = if RUBY_PLATFORM.match?(/mswin|mingw|cygwin/i)
+                   raw = ENV.fetch('PATHEXT', '.EXE;.BAT;.CMD')
+                   parsed = raw.split(';').map(&:strip).reject(&:empty?)
+                   (parsed + parsed.map(&:downcase) + ['']).uniq
+                 else
+                   ['']
+                 end
+
+          path_env.split(File::PATH_SEPARATOR).any? do |dir|
+            exts.any? do |ext|
+              candidate = File.join(dir, "#{name}#{ext}")
+              File.file?(candidate) && File.executable?(candidate)
+            end
+          end
+        rescue StandardError
+          false
+        end
+
+        def execute_clipboard_command(command, text)
+          IO.popen(command, 'w') do |pipe|
+            pipe.write(text)
+          end
+          $CHILD_STATUS.success?
+        rescue Errno::ENOENT, Errno::EPIPE
+          false
+        end
+
+        def log_success(char_count)
+          return unless registered?(:logger)
+
+          resolve(:logger).info('Text copied to clipboard', chars: char_count)
+        end
+
+        def log_failure
+          return unless registered?(:logger)
+
+          resolve(:logger).warn('Failed to copy text to clipboard')
+        end
+
+        protected
+
+        def required_dependencies
+          [] # Logger is optional
+        end
+      end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/formatting/formatting_service/line_assembler/image_builder.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require_relative '../../../../../core/models/content_block.rb'
+
+module Shoko
+  module Adapters::Output::Formatting
+      class FormattingService
+        class LineAssembler
+          # Builds display lines and metadata for block-level and inline images.
+          class ImageBuilder
+            include Shoko::Core::Models
+
+            MAX_ID = 4_294_967_295
+            RENDERABLE_IMAGE_EXTENSIONS = %w[.png .jpg .jpeg].freeze
+
+            def initialize(width:, chapter_index:, chapter_source_path:, max_image_rows: nil)
+              @width = width.to_i
+              @chapter_index = chapter_index
+              @chapter_source_path = chapter_source_path
+              @max_image_rows = normalized_max_image_rows(max_image_rows)
+              @inline_image_counter = 0
+            end
+
+            def block_lines(block, block_index:, base_metadata:)
+              render = base_metadata.merge(image_render: block_render_metadata(block, block_index))
+              image_lines(render, rows: render.dig(:image_render, :rows).to_i)
+            end
+
+            def inline_lines(inline, indent_cols)
+              @inline_image_counter += 1
+              cols_available = [@width - indent_cols.to_i, 1].max
+              render = inline_metadata(inline, cols_available, indent_cols.to_i, @inline_image_counter)
+              image_lines(render, rows: render.dig(:image_render, :rows).to_i)
+            end
+
+            def renderable_block_image?(block)
+              image = (block.metadata || {})[:image] || (block.metadata || {})['image'] || {}
+              src = image[:src] || image['src']
+              renderable_image_src?(src)
+            rescue StandardError
+              false
+            end
+
+            def renderable_image_src?(src)
+              return false if src.nil? || src.to_s.empty?
+
+              ext = File.extname(src.to_s.split(/[?#]/, 2).first.to_s).downcase
+              RENDERABLE_IMAGE_EXTENSIONS.include?(ext)
+            rescue StandardError
+              false
+            end
+
+            private
+
+            def normalized_max_image_rows(value)
+              rows = value.to_i
+              rows.positive? ? rows : nil
+            end
+
+            def block_render_metadata(block, block_index)
+              {
+                cols: @width,
+                rows: rows_for(@width),
+                placement_id: placement_id_for_block(block, block_index),
+              }
+            end
+
+            def inline_metadata(inline, cols_available, indent_cols, index)
+              src = inline.is_a?(Hash) ? (inline[:src] || inline['src']) : nil
+              alt = inline.is_a?(Hash) ? (inline[:alt] || inline['alt']) : nil
+              {
+                block_type: :image,
+                chapter_index: @chapter_index,
+                chapter_source_path: @chapter_source_path,
+                image: { src: src, alt: alt },
+                inline_image: true,
+                image_render: {
+                  cols: cols_available,
+                  rows: rows_for(cols_available),
+                  placement_id: placement_id_for_inline(src, index),
+                  col_offset: indent_cols,
+                },
+              }
+            end
+
+            def image_lines(metadata, rows:)
+              Array.new(rows) do |row_index|
+                DisplayLine.new(
+                  text: '',
+                  segments: [],
+                  metadata: metadata.merge(
+                    image_render_line: row_index.zero?,
+                    image_line_index: row_index,
+                    image_spacer: !row_index.zero?
+                  )
+                )
+              end
+            end
+
+            def rows_for(cols)
+              estimate = (cols.to_i * 0.5).round
+              estimate = estimate.clamp(4, 18)
+              estimate = [estimate, @max_image_rows].min if @max_image_rows
+              [estimate, 1].max
+            rescue StandardError
+              8
+            end
+
+            def placement_id_for_block(block, block_index)
+              image = (block.metadata || {})[:image] || (block.metadata || {})['image'] || {}
+              src = image[:src] || image['src'] || ''
+              hashed_id("#{chapter_seed}|#{src}|#{block_index}")
+            rescue StandardError
+              clamp_id(block_index.to_i + 1)
+            end
+
+            def placement_id_for_inline(src, index)
+              hashed_id("#{chapter_seed}|#{src}|inline|#{index}")
+            rescue StandardError
+              clamp_id(index.to_i + 1)
+            end
+
+            def chapter_seed
+              @chapter_source_path.to_s
+            end
+
+            def hashed_id(seed)
+              raw = Digest::SHA1.digest(seed.to_s)
+              int = raw.unpack1('N')
+              int.zero? ? 1 : int
+            rescue StandardError
+              1
+            end
+
+            def clamp_id(value)
+              int = value.to_i
+              int = 1 if int <= 0
+              return int if int <= MAX_ID
+
+              reduced = int % MAX_ID
+              reduced.zero? ? 1 : reduced
+            end
+          end
+        end
+      end
+  end
+end