shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/output/terminal/terminal_service.rb

@@ -1,138 +1,154 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/services/base_service.rb'
+require_relative '../../base_adapter'
+require_relative '../../../core/ports/outbound/runtime_config'
 
 module Shoko
-  module Adapters::Output::Terminal
-      # Terminal interaction service for mouse and rendering coordination
-      class TerminalService < BaseService
-        # Maintain a global session depth so nested setup/cleanup calls
-        # (e.g., menu -> reader) don't flicker or drop to shell.
-        class << self
+  module Adapters
+    module Output
+      module Terminal
+        # Terminal interaction service for mouse and rendering coordination
+        class TerminalService < Shoko::Adapters::BaseAdapter
+          # Session depth tracks nested setup/cleanup calls
+          # (e.g., menu -> reader) to avoid flicker or dropping to shell.
           attr_accessor :session_depth
-        end
-        @session_depth = 0
 
-        def enable_mouse
-          Terminal.enable_mouse
-        end
+          def initialize(runtime_config:, logger: nil)
+            super(logger: logger)
+            unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+              raise ArgumentError, 'runtime_config must implement Core::Ports::Outbound::RuntimeConfig'
+            end
 
-        def disable_mouse
-          Terminal.disable_mouse
-        end
+            @runtime_config = runtime_config
+            @session_depth = 0
+            @active = false
+          end
 
-        def read_input_with_mouse(timeout: nil)
-          Terminal.read_input_with_mouse(timeout: timeout)
-        end
+          def enable_mouse
+            Terminal.enable_mouse
+          end
 
-        def read_key
-          Terminal.read_key
-        end
+          def disable_mouse
+            Terminal.disable_mouse
+          end
 
-        def size
-          Terminal.size
-        end
+          def read_input_with_mouse(timeout: nil)
+            Terminal.read_input_with_mouse(timeout: timeout)
+          end
 
-        def end_frame
-          Terminal.end_frame
-        end
+          def read_key
+            Terminal.read_key
+          end
 
-        def setup
-          previous_depth = TerminalService.session_depth || 0
-          depth = previous_depth + 1
-          TerminalService.session_depth = depth
-          logger&.debug('terminal.setup', depth: depth)
-          return if previous_depth.positive?
-
-          Terminal.setup
-        rescue StandardError => e
-          TerminalService.session_depth = previous_depth
-          logger&.error('terminal.setup_failed', error: e.message)
-          raise
-        end
+          def size
+            Terminal.size
+          end
 
-        def cleanup(force: false)
-          return force_cleanup! if force
+          def end_frame
+            Terminal.end_frame
+          end
 
-          depth = decrement_session_depth
-          logger&.debug('terminal.cleanup', depth: depth)
-          return if depth.positive?
+          def setup
+            previous_depth = @session_depth || 0
+            depth = previous_depth + 1
+            @session_depth = depth
+            logger&.debug('terminal.setup', depth: depth)
+            return if previous_depth.positive?
+
+            Terminal.setup
+            @active = true
+          rescue Shoko::Error => e
+            @session_depth = previous_depth
+            @active = false if previous_depth.zero?
+            logger&.error('terminal.setup_failed', error: e.message)
+            raise
+          end
 
-          perform_terminal_cleanup
-        rescue StandardError => e
-          logger&.error('terminal.cleanup_failed', error: e.message)
-          raise
-        end
+          def cleanup(force: false)
+            return force_cleanup! if force
 
-        def force_cleanup
-          cleanup(force: true)
-        end
+            depth_before = @session_depth || 0
+            depth = decrement_session_depth
+            logger&.debug('terminal.cleanup', depth: depth)
+            return if depth_before.zero? || depth.positive?
 
-        def start_frame(width: nil, height: nil)
-          Terminal.start_frame(width: width, height: height)
-        end
+            perform_terminal_cleanup
+            @active = false
+          rescue Shoko::Error => e
+            logger&.error('terminal.cleanup_failed', error: e.message)
+            raise
+          end
 
-        def read_key_blocking(timeout: nil)
-          Terminal.read_key_blocking(timeout: timeout)
-        end
+          # Ensure session depth is at least the expected value (for nested sessions)
+          # This guards against depth getting out of sync
+          def ensure_session_depth(minimum_depth)
+            current = @session_depth || 0
+            return if current >= minimum_depth
 
-        # Read one blocking key, then drain a few non-blocking extras.
-        # Returns an array of keys, or [] if nothing was read.
-        #
-        # @param limit [Integer] maximum total keys to return
-        # @return [Array<String>]
-        def read_keys_blocking(limit: 10, timeout: nil)
-          first = read_key_blocking(timeout: timeout)
-          return [] unless first
-
-          keys = [first]
-          while (extra = read_key)
-            keys << extra
-            break if keys.size >= limit
-          end
-          keys
-        end
+            logger&.warn('terminal.depth_correction', current: current, expected: minimum_depth)
+            @session_depth = minimum_depth
+          end
 
-        # Create a surface for component rendering
-        def create_surface
-          Shoko::Adapters::Output::Ui::Components::Surface.new(Terminal)
-        end
+          def force_cleanup
+            cleanup(force: true)
+          end
 
-        protected
+          def start_frame(width: nil, height: nil)
+            Terminal.start_frame(width: width, height: height, runtime_config: @runtime_config)
+          end
 
-        def required_dependencies
-          [] # No dependencies required
-        end
+          def read_key_blocking(timeout: nil)
+            Terminal.read_key_blocking(timeout: timeout)
+          end
 
-        private
+          # Read one blocking key, then drain a few non-blocking extras.
+          # Returns an array of keys, or [] if nothing was read.
+          #
+          # @param limit [Integer] maximum total keys to return
+          # @return [Array<String>]
+          def read_keys_blocking(limit: 10, timeout: nil)
+            first = read_key_blocking(timeout: timeout)
+            return [] unless first
+
+            keys = [first]
+            while (extra = read_key)
+              keys << extra
+              break if keys.size >= limit
+            end
+            keys
+          end
 
-        def logger
-          @logger ||= begin
-            resolve(:logger)
-          rescue StandardError
-            nil
+          # Create a surface for component rendering
+          def output
+            Terminal
           end
-        end
 
-        def force_cleanup!
-          depth = TerminalService.session_depth || 0
-          logger&.warn('terminal.cleanup.force', depth: depth)
-          TerminalService.session_depth = 0
-          perform_terminal_cleanup
-        end
+          private
 
-        def decrement_session_depth
-          depth = TerminalService.session_depth
-          return 0 unless depth
+          def force_cleanup!
+            depth = @session_depth || 0
+            return unless @active || depth.positive?
 
-          new_depth = depth.positive? ? depth - 1 : 0
-          TerminalService.session_depth = new_depth
-          new_depth
-        end
+            logger&.warn('terminal.cleanup.force', depth: depth)
+            @session_depth = 0
+            perform_terminal_cleanup
+            @active = false
+          end
 
-        def perform_terminal_cleanup
-          Terminal.cleanup
+          def decrement_session_depth
+            depth = @session_depth
+            return 0 unless depth
+
+            new_depth = depth.positive? ? depth - 1 : 0
+            @session_depth = new_depth
+            new_depth
+          end
+
+          def perform_terminal_cleanup
+            Terminal.cleanup
+          end
         end
       end
     end
+  end
 end

data/lib/shoko/adapters/output/terminal/terminal_session_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/terminal_session'
+
+module Shoko
+  module Adapters
+    module Output
+      module Terminal
+        # Port adapter exposing terminal lifecycle operations to application services.
+        class TerminalSessionAdapter
+          include Shoko::Core::Ports::Outbound::TerminalSession
+
+          def initialize(terminal_service:)
+            @terminal_service = terminal_service
+          end
+
+          def setup
+            @terminal_service.setup
+          end
+
+          def cleanup
+            @terminal_service.cleanup
+          end
+
+          def size
+            @terminal_service.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/terminal/text_metrics.rb

@@ -1,272 +1,13 @@
 # frozen_string_literal: true
 
+require_relative '../../../shared/terminal/text_metrics'
+
 module Shoko
   module Adapters
     module Output
       module Terminal
-        # Utility helpers for measuring and truncating strings (with ANSI support)
-        # while respecting grapheme clusters and terminal cell widths.
-        module TextMetrics
-      begin
-        require 'reline'
-        require 'reline/unicode'
-        DISPLAY_WIDTH = ->(str) { Reline::Unicode.calculate_width(str) }
-      rescue LoadError, NameError
-        DISPLAY_WIDTH = lambda do |str|
-          str.to_s.scan(/\X/).sum { |cluster| cluster.length }
-        end
-      end
-      TAB_SIZE = 4
-      CSI_REGEX = %r{\e\[[0-?]*[ -/]*[@-~]}
-      ANSI_REGEX = CSI_REGEX
-      TOKEN_REGEX = /#{CSI_REGEX}|\X/m
-
-      module_function
-
-      def visible_length(text)
-        cell_data_for(strip_ansi(text.to_s)).sum { |cell| cell[:display_width] }
-      end
-
-      def cell_data_for(text)
-        expanded = expand_tabs(text.to_s)
-        cells = []
-        char_index = 0
-        screen_x = 0
-
-        expanded.each_grapheme_cluster do |cluster|
-          grapheme_length = cluster.length
-          display_width = display_width_for(cluster)
-
-          cells << {
-            cluster: cluster,
-            char_start: char_index,
-            char_end: char_index + grapheme_length,
-            display_width: display_width,
-            screen_x: screen_x,
-          }
-
-          char_index += grapheme_length
-          screen_x += display_width
-        end
-
-        cells
-      end
-
-      def strip_ansi(text)
-        text.to_s.gsub(ANSI_REGEX, '')
-      end
-
-      def display_width_for(cluster)
-        return TAB_SIZE if cluster == "\t"
-        return 0 if cluster == "\u00AD"
-
-        width = DISPLAY_WIDTH.call(cluster)
-        width = 1 if width <= 0 && !cluster.empty?
-        width
-      rescue StandardError
-        cluster.length
-      end
-
-      def expand_tabs(text, tab_size: TAB_SIZE)
-        column = 0
-        buffer = +''
-        text.to_s.each_grapheme_cluster do |cluster|
-          if cluster == "\t"
-            spaces = tab_size - (column % tab_size)
-            buffer << (' ' * spaces)
-            column += spaces
-          else
-            buffer << cluster
-            column += display_width_for(cluster)
-          end
-        end
-        buffer
-      end
-
-      def wrap_plain_text(line, width)
-        normalized = expand_tabs(line.to_s)
-        return [''] if normalized.empty?
-        return [normalized] if width.to_i <= 0
-
-        wrapped = []
-        current_line = +''
-        current_width = 0
-
-        width_i = width.to_i
-
-        normalized.split(/\s+/).each do |word|
-          next if word.nil? || word.empty?
-
-          word_width = visible_length(word)
-
-          if current_width.zero?
-            current_line.replace(word)
-            current_width = word_width
-          elsif current_width + 1 + word_width <= width_i
-            current_line << ' ' unless current_line.empty?
-            current_line << word
-            current_width += 1 + word_width
-          else
-            wrapped << current_line.dup unless current_line.empty?
-            current_line.replace(word)
-            current_width = word_width
-          end
-        end
-
-        wrapped << current_line.dup unless current_line.empty?
-        wrapped = [''] if wrapped.empty?
-        wrapped
-      end
-
-      def truncate_to(text, width, start_column: 0)
-        max_width = width.to_i
-        return '' if max_width <= 0
-
-        str = text.to_s
-        return '' if str.empty?
-
-        # Fast-path: preserve original when it already fits and contains no tab/newline.
-        if !(str.include?("\t") || str.include?("\n") || str.include?("\r")) && (max_width >= visible_length(str))
-          return str
-        end
-
-        buffer = +''
-        current_width = 0
-        column = start_column.to_i
-
-        str.scan(TOKEN_REGEX).each do |token|
-          if token.start_with?("\e[")
-            buffer << token
-            next
-          end
-
-          next if token == "\e"
-
-          remaining = max_width - current_width
-          break if remaining <= 0
-
-          case token
-          when "\t"
-            spaces = TAB_SIZE - (column % TAB_SIZE)
-            take = [spaces, remaining].min
-            buffer << (' ' * take)
-            current_width += take
-            column += take
-          when "\n", "\r"
-            # Never allow newlines to affect terminal layout; treat as a space.
-            break if remaining < 1
-
-            buffer << ' '
-            current_width += 1
-            column += 1
-          else
-            token_width = display_width_for(token)
-            break if token_width > remaining
-
-            buffer << token
-            current_width += token_width
-            column += token_width
-          end
-        end
-
-        buffer
-      end
-
-      def pad_right(text, width, start_column: 0, pad: ' ')
-        w = width.to_i
-        return '' if w <= 0
-
-        clipped = truncate_to(text.to_s, w, start_column: start_column)
-        pad_len = w - visible_length(clipped)
-        pad_len.positive? ? (clipped + (pad.to_s * pad_len)) : clipped
-      end
-
-      def pad_left(text, width, start_column: 0, pad: ' ')
-        w = width.to_i
-        return '' if w <= 0
-
-        clipped = truncate_to(text.to_s, w, start_column: start_column)
-        pad_len = w - visible_length(clipped)
-        pad_len.positive? ? ((pad.to_s * pad_len) + clipped) : clipped
-      end
-
-      def pad_center(text, width, start_column: 0, pad: ' ')
-        w = width.to_i
-        return '' if w <= 0
-
-        clipped = truncate_to(text.to_s, w, start_column: start_column)
-        pad_len = w - visible_length(clipped)
-        return clipped unless pad_len.positive?
-
-        left = pad_len / 2
-        right = pad_len - left
-        (pad.to_s * left) + clipped + (pad.to_s * right)
-      end
-
-      # Wraps text by terminal cell width without splitting grapheme clusters.
-      # Preserves newlines and expands tabs relative to the provided start column.
-      #
-      # This is intended for UI text entry/display helpers (notes, dialogs),
-      # not for paragraph-aware ebook formatting.
-      def wrap_cells(text, width, start_column: 0)
-        w = width.to_i
-        return [''] if w <= 0
-
-        lines = []
-        line = +''
-        line_width = 0
-        column = start_column.to_i
-
-        text.to_s.each_grapheme_cluster do |cluster|
-          if cluster == "\n"
-            lines << line.dup
-            line.clear
-            line_width = 0
-            column = start_column.to_i
-            next
-          end
-
-          cluster = ' ' if cluster == "\r"
-
-          if cluster == "\t"
-            spaces = TAB_SIZE - (column % TAB_SIZE)
-            spaces.times do
-              if line_width >= w
-                lines << line.dup
-                line.clear
-                line_width = 0
-                column = start_column.to_i
-              end
-              line << ' '
-              line_width += 1
-              column += 1
-            end
-            next
-          end
-
-          cw = display_width_for(cluster)
-          next if cw <= 0
-          next if cw > w
-
-          if line_width.positive? && (line_width + cw > w)
-            lines << line.dup
-            line.clear
-            line_width = 0
-            column = start_column.to_i
-          end
-
-          break if cw > (w - line_width)
-
-          line << cluster
-          line_width += cw
-          column += cw
-        end
-
-        lines << line.dup
-        lines = [''] if lines.empty?
-        lines
-      end
-        end
+        # Output adapter wrapper around shared terminal text metrics primitives.
+        TextMetrics = Shoko::Shared::Terminal::TextMetrics
       end
     end
   end

data/lib/shoko/adapters/output/terminal/text_metrics_port_adapter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/text_metrics'
+require_relative '../../../core/ports/outbound/runtime_config'
+require_relative 'text_metrics'
+
+module Shoko
+  module Adapters
+    module Output
+      module Terminal
+        # Core port adapter that binds runtime-config toggles without global mutation.
+        class TextMetricsPortAdapter
+          include Shoko::Core::Ports::Outbound::TextMetrics
+
+          def initialize(runtime_config:)
+            unless runtime_config.is_a?(Shoko::Core::Ports::Outbound::RuntimeConfig)
+              raise ArgumentError, 'runtime_config must implement Core::Ports::Outbound::RuntimeConfig'
+            end
+
+            @runtime_config = runtime_config
+            TextMetrics.configure_runtime_config!(runtime_config: @runtime_config)
+          end
+
+          def wrap_plain_text(line, width)
+            with_runtime_config do
+              TextMetrics.wrap_plain_text(line, width)
+            end
+          end
+
+          private
+
+          def with_runtime_config
+            return yield unless @runtime_config
+
+            TextMetrics.with_runtime_config(config: @runtime_config) { yield }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/terminal/text_sanitizer_adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/ports/outbound/text_sanitizer'
+require_relative 'terminal_sanitizer'
+
+module Shoko
+  module Adapters
+    module Output
+      module Terminal
+        # Adapter implementing the TextSanitizer port.
+        # Delegates to TerminalSanitizer for safe text rendering.
+        class TextSanitizerAdapter
+          include Core::Ports::Outbound::TextSanitizer
+
+          def sanitize(text, preserve_newlines: true, max_length: nil)
+            sanitized = TerminalSanitizer.sanitize(text.to_s, preserve_newlines: preserve_newlines)
+            max_length ? sanitized[0, max_length] : sanitized
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/output/terminal_capabilities_adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/terminal_capabilities'
+require_relative 'kitty/kitty_graphics'
+
+module Shoko
+  module Adapters
+    module Output
+      # Adapter implementing the TerminalCapabilities port.
+      # Wraps KittyGraphics for terminal feature detection.
+      class TerminalCapabilitiesAdapter
+        include Core::Ports::Outbound::TerminalCapabilities
+
+        # Check if the terminal supports Kitty graphics protocol.
+        #
+        # @return [Boolean] True if Kitty graphics are supported
+        def kitty_graphics_supported?
+          Kitty::KittyGraphics.supported?
+        end
+      end
+    end
+  end
+end

data/lib/shoko/adapters/runtime/app_mode_runner_adapter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../core/ports/outbound/app_mode_runner'
+
+module Shoko
+  module Adapters
+    module Runtime
+      # Adapter bridging app mode execution to composed controllers.
+      class AppModeRunnerAdapter
+        include Shoko::Core::Ports::Outbound::AppModeRunner
+
+        def initialize(build_reader_controller:, build_menu_controller:)
+          @build_reader_controller = build_reader_controller
+          @build_menu_controller = build_menu_controller
+        end
+
+        def run_reader(path:)
+          @build_reader_controller.call(path).run
+        end
+
+        def run_menu
+          @build_menu_controller.call.run
+        end
+      end
+    end
+  end
+end