shoko 0.1.3 → 0.1.5

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

@@ -5,156 +5,237 @@ require_relative 'constants/terminal_defaults'
 require_relative 'input/decoder'
 
 module Shoko
-  module Adapters::Output::Terminal
-    # TerminalInput encapsulates input reading, console modes, and size queries.
-    class TerminalInput
-      SIZE_CACHE_INTERVAL = 0.5
-      READ_CHUNK_BYTES = 4096
-
-      def initialize(input: $stdin, output: $stdout, esc_timeout: Decoder::DEFAULT_ESC_TIMEOUT,
-                     sequence_timeout: Decoder::DEFAULT_SEQUENCE_TIMEOUT)
-        @console = nil
-        @size_cache = { width: nil, height: nil, checked_at: nil }
-        @input = input
-        @output = output
-        @decoder = Decoder.new(esc_timeout: esc_timeout, sequence_timeout: sequence_timeout)
-      end
+  module Adapters
+    module Output
+      module Terminal
+        # TerminalInput encapsulates input reading, console modes, and size queries.
+        class TerminalInput
+          SIZE_CACHE_INTERVAL = 0.5
+          READ_CHUNK_BYTES = 4096
+          OSC_QUERY_BG = "\e]11;?\a"
+          OSC_TERMINATOR_BEL = "\a"
+          OSC_TERMINATOR_ST = "\e\\"
+          OSC_BG_PATTERN = %r{\e\]11;rgb:([0-9a-fA-F]{1,4})/([0-9a-fA-F]{1,4})/([0-9a-fA-F]{1,4})}
+
+          def initialize(input: $stdin, output: $stdout, esc_timeout: Decoder::DEFAULT_ESC_TIMEOUT,
+                         sequence_timeout: Decoder::DEFAULT_SEQUENCE_TIMEOUT)
+            @console = nil
+            @size_cache = { width: nil, height: nil, checked_at: nil }
+            @input = input
+            @output = output
+            @decoder = Decoder.new(esc_timeout: esc_timeout, sequence_timeout: sequence_timeout)
+          end
 
-      def size
-        update_size_cache if cache_expired?
-        [@size_cache[:height], @size_cache[:width]]
-      end
+          def size
+            update_size_cache if cache_expired?
+            [@size_cache[:height], @size_cache[:width]]
+          end
 
-      def setup_console
-        $stdout.sync = true
-        @console = resolve_console
-        @console.raw! if @console.respond_to?(:raw!)
-      end
+          def setup_console
+            $stdout.sync = true
+            @console = resolve_console
+            @console.raw!
+          end
 
-      def cleanup_console
-        @console.cooked! if @console.respond_to?(:cooked!)
-        @console = nil
-      end
+          def cleanup_console
+            @console.cooked! if @console
+            @console = nil
+          end
 
-      def with_raw_console(&)
-        console = resolve_console
-        console.raw(&)
-      end
+          def with_raw_console(&)
+            console = resolve_console
+            console.raw(&)
+          end
 
-      def read_key
-        with_raw_console do
-          pump_input
-          @decoder.next_token(now: monotonic_now)
-        end
-      rescue IO::WaitReadable, EOFError
-        nil
-      end
+          def read_key
+            with_raw_console do
+              pump_input
+              @decoder.next_token(now: monotonic_now)
+            end
+          rescue IO::WaitReadable, EOFError
+            return
+          end
 
-      def read_key_blocking(timeout: nil)
-        deadline = timeout ? monotonic_now + timeout.to_f : nil
-        loop do
-          key = read_key
-          return key if key
+          def read_key_blocking(timeout: nil)
+            deadline = timeout ? monotonic_now + timeout.to_f : nil
+            loop do
+              key = read_key
+              return key if key
+
+              now = monotonic_now
+              remaining = deadline ? (deadline - now) : nil
+              return nil if remaining && remaining <= 0
+
+              pending = @decoder.pending_timeout(now: now)
+              wait = if pending && remaining
+                       [pending, remaining].min
+                     else
+                       pending || remaining
+                     end
+
+              if wait
+                next if wait <= 0
+
+                @input.wait_readable(wait)
+              else
+                @input.wait_readable
+              end
+            end
+          end
 
-          now = monotonic_now
-          remaining = deadline ? (deadline - now) : nil
-          return nil if remaining && remaining <= 0
+          # Mouse support
+          def enable_mouse
+            # 1003 enables any-motion reporting so hover can drive popup highlighting.
+            @output.print "\e[?1002h\e[?1003h\e[?1006h"
+            @output.flush
+          end
+
+          def disable_mouse
+            @output.print "\e[?1002l\e[?1003l\e[?1006l"
+            @output.flush
+          end
 
-          pending = @decoder.pending_timeout(now: now)
-          wait = if pending && remaining
-                   [pending, remaining].min
-                 else
-                   pending || remaining
-                 end
+          def read_input_with_mouse(timeout: nil)
+            read_key_blocking(timeout: timeout)
+          end
 
-          if wait
-            next if wait <= 0
+          def query_default_background(timeout: 0.2)
+            return nil unless @input.tty?
 
-            @input.wait_readable(wait)
-          else
-            @input.wait_readable
+            @output.print(OSC_QUERY_BG)
+            @output.flush
+            response = read_osc_response(timeout: timeout)
+            parse_osc_rgb(response)
+          rescue Shoko::Error
+            raise
           end
-        end
-      end
 
-      # Mouse support
-      def enable_mouse
-        @output.print "\e[?1002h\e[?1006h"
-        @output.flush
-      end
+          def setup_signal_handlers(&cleanup_callback)
+            %w[INT TERM].each do |signal|
+              trap(signal) do
+                cleanup_callback&.call
+                exit(0)
+              end
+            end
+          end
 
-      def disable_mouse
-        @output.print "\e[?1002l\e[?1006l"
-        @output.flush
-      end
+          def drain_input(timeout: 0.05)
+            return nil unless @input.tty?
+
+            deadline = monotonic_now + timeout.to_f
+            loop do
+              remaining = deadline - monotonic_now
+              break if remaining <= 0
+
+              ready = @input.wait_readable(remaining)
+              break unless ready
+
+              begin
+                @input.read_nonblock(READ_CHUNK_BYTES)
+              rescue IO::WaitReadable
+                next
+              rescue EOFError
+                break
+              end
+            end
+          rescue Shoko::Error
+            raise
+          end
 
-      def read_input_with_mouse(timeout: nil)
-        read_key_blocking(timeout: timeout)
-      end
+          private
 
-      def setup_signal_handlers(&cleanup_callback)
-        %w[INT TERM].each do |signal|
-          trap(signal) do
-            cleanup_callback&.call
-            exit(0)
+          def cache_expired?
+            now = Time.now
+            checked = @size_cache[:checked_at]
+            checked.nil? || now - checked > SIZE_CACHE_INTERVAL
           end
-        end
-      end
 
-      private
+          def update_size_cache
+            h, w = fetch_terminal_size
+            @size_cache = { width: w, height: h, checked_at: Time.now }
+          end
 
-      def cache_expired?
-        now = Time.now
-        checked = @size_cache[:checked_at]
-        checked.nil? || now - checked > SIZE_CACHE_INTERVAL
-      end
+          def fetch_terminal_size
+            IO.console.winsize
+          rescue Shoko::Error
+            default_dimensions
+          end
 
-      def update_size_cache
-        h, w = fetch_terminal_size
-        @size_cache = { width: w, height: h, checked_at: Time.now }
-      end
+          def default_dimensions
+            [Adapters::Output::Terminal::TerminalDefaults::DEFAULT_ROWS,
+             Adapters::Output::Terminal::TerminalDefaults::DEFAULT_COLUMNS]
+          end
 
-      def fetch_terminal_size
-        IO.console.winsize
-      rescue StandardError
-        default_dimensions
-      end
+          def resolve_console
+            return @console if @console
 
-      def default_dimensions
-        [Adapters::Output::Terminal::TerminalDefaults::DEFAULT_ROWS,
-         Adapters::Output::Terminal::TerminalDefaults::DEFAULT_COLUMNS]
-      end
+            console = IO.console
+            if console
+              @console = console
+              return console
+            end
 
-      def resolve_console
-        return @console if @console
+            if @input.tty?
+              @console = @input
+              return @input
+            end
 
-        console = IO.console
-        if console
-          @console = console
-          return console
-        end
+            raise Shoko::TerminalUnavailableError
+          end
 
-        if @input.respond_to?(:tty?) && @input.tty? && @input.respond_to?(:raw)
-          @console = @input
-          return @input
-        end
+          def pump_input
+            loop do
+              chunk = @input.read_nonblock(READ_CHUNK_BYTES)
+              @decoder.feed(chunk)
+            end
+          rescue IO::WaitReadable, EOFError
+            return
+          end
 
-        raise Shoko::TerminalUnavailableError
-      end
+          def read_osc_response(timeout:)
+            deadline = monotonic_now + timeout.to_f
+            buffer = +''.b
 
-      def pump_input
-        loop do
-          chunk = @input.read_nonblock(READ_CHUNK_BYTES)
-          @decoder.feed(chunk)
-        end
-      rescue IO::WaitReadable, EOFError
-        nil
-      end
+            loop do
+              remaining = deadline - monotonic_now
+              return nil if remaining <= 0
+
+              ready = @input.wait_readable(remaining)
+              return nil unless ready
+
+              chunk = @input.read_nonblock(READ_CHUNK_BYTES)
+              buffer << chunk
+              break if buffer.include?(OSC_TERMINATOR_BEL) || buffer.include?(OSC_TERMINATOR_ST)
+            rescue IO::WaitReadable
+              next
+            rescue EOFError
+              break
+            end
+
+            buffer
+          end
+
+          def parse_osc_rgb(response)
+            return nil unless response
+
+            match = response.match(OSC_BG_PATTERN)
+            return nil unless match
 
-      def monotonic_now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      rescue StandardError
-        Time.now.to_f
+            match.captures.map { |hex| normalize_component(hex) }
+          end
+
+          def normalize_component(hex)
+            value = hex.to_i(16)
+            max = hex.length > 2 ? 65_535.0 : 255.0
+            value / max
+          end
+
+          def monotonic_now
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          rescue Shoko::Error
+            Time.now.to_f
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../shared/runtime/null_runtime_config'
+require_relative '../../../core/ports/outbound/runtime_config'
+
+module Shoko
+  module Adapters
+    module Output
+      module Terminal
+        # Output-local null runtime config implementing outbound RuntimeConfig.
+        class NullRuntimeConfig < Shoko::Shared::Runtime::NullRuntimeConfig
+          include Shoko::Core::Ports::Outbound::RuntimeConfig
+
+          Core::Ports::Outbound::RuntimeConfig.instance_methods(false).each do |method_name|
+            define_method(method_name) do |*args, **kwargs, &block|
+              self.class.superclass.instance_method(method_name).bind_call(self, *args, **kwargs, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,105 +1,52 @@
 # frozen_string_literal: true
 
 require 'io/console'
+require_relative '../../../shared/terminal/ansi'
 
 module Shoko
-  module Adapters::Output::Terminal
-    # TerminalOutput handles ANSI sequences and direct writes to an IO stream.
-    class TerminalOutput
-    attr_reader :io
-
-    def initialize(io = $stdout)
-      @io = io
-    end
-
-    # A collection of ANSI escape codes and helpers
-    module ANSI
-      RESET = "\e[0m"
-      BOLD = "\e[1m"
-      DIM = "\e[2m"
-      ITALIC = "\e[3m"
-      REVERSE = "\e[7m"
-
-      BLACK = "\e[30m"
-      RED = "\e[31m"
-      GREEN = "\e[32m"
-      YELLOW = "\e[33m"
-      BLUE = "\e[34m"
-      MAGENTA = "\e[35m"
-      CYAN = "\e[36m"
-      WHITE = "\e[37m"
-      GRAY = "\e[90m"
-      LIGHT_GREY = "\e[37;1m"
-
-      BRIGHT_RED = "\e[91m"
-      BRIGHT_GREEN = "\e[92m"
-      BRIGHT_YELLOW = "\e[93m"
-      BRIGHT_BLUE = "\e[94m"
-      BRIGHT_MAGENTA = "\e[95m"
-      BRIGHT_CYAN = "\e[96m"
-      BRIGHT_WHITE = "\e[97m"
-
-      BG_DARK = "\e[48;5;236m"
-      BG_BLACK = "\e[40m"
-      BG_BLUE = "\e[44m"
-      BG_CYAN = "\e[46m"
-      BG_GREY = "\e[48;5;240m"
-      BG_SLATE = "\e[48;5;238m"
-      BG_SOFT_GREEN = "\e[48;5;65m"
-      BG_BRIGHT_GREEN = "\e[102m"
-      BG_BRIGHT_YELLOW = "\e[103m"
-      BG_BRIGHT_WHITE = "\e[107m"
-
-      module Control
-        CLEAR = "\e[2J"
-        HOME = "\e[H"
-        HIDE_CURSOR = "\e[?25l"
-        SHOW_CURSOR = "\e[?25h"
-        SAVE_SCREEN = "\e[?1049h"
-        RESTORE_SCREEN = "\e[?1049l"
+  module Adapters
+    module Output
+      module Terminal
+        # TerminalOutput handles ANSI sequences and direct writes to an IO stream.
+        class TerminalOutput
+          attr_reader :io
+
+          def initialize(io = $stdout)
+            @io = io
+          end
+
+          ANSI = Shoko::Shared::Terminal::Ansi
+
+          def print(str)
+            io.print(str)
+          end
+
+          def flush
+            io.flush
+          end
+
+          def clear
+            print(ANSI::Control::CLEAR + ANSI::Control::HOME)
+            flush
+          end
+
+          def hide_cursor
+            print(ANSI::Control::HIDE_CURSOR)
+          end
+
+          def show_cursor
+            print(ANSI::Control::SHOW_CURSOR)
+          end
+
+          def save_screen
+            print(ANSI::Control::SAVE_SCREEN)
+          end
+
+          def restore_screen
+            print(ANSI::Control::RESTORE_SCREEN)
+          end
+        end
       end
-
-      def self.move(row, col)
-        "\e[#{row};#{col}H"
-      end
-
-      def self.clear_line
-        "\e[2K"
-      end
-
-      def self.clear_below
-        "\e[J"
-      end
-    end
-
-    def print(str)
-      io.print(str)
-    end
-
-    def flush
-      io.flush
-    end
-
-    def clear
-      print(ANSI::Control::CLEAR + ANSI::Control::HOME)
-      flush
-    end
-
-    def hide_cursor
-      print(ANSI::Control::HIDE_CURSOR)
-    end
-
-    def show_cursor
-      print(ANSI::Control::SHOW_CURSOR)
-    end
-
-    def save_screen
-      print(ANSI::Control::SAVE_SCREEN)
-    end
-
-    def restore_screen
-      print(ANSI::Control::RESTORE_SCREEN)
-    end
     end
   end
 end