shoko 0.1.3 → 0.1.5

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

@@ -5,157 +5,215 @@ require_relative 'constants/terminal_defaults'
 require_relative 'output'
 require_relative 'buffer'
 require_relative 'input'
+require_relative 'null_runtime_config'
+require_relative '../../../core/ports/outbound/runtime_config'
 
 module Shoko
-  module Adapters::Output::Terminal
-    # Facade that preserves the historical Terminal API
-    # while delegating to composable, testable components:
-    # - TerminalOutput
-    # - TerminalBuffer
-    # - TerminalInput
-    class Terminal
-      # Keep ANSI nested under Terminal for compatibility
-      ANSI = TerminalOutput::ANSI
-
-      # Defines constants for special keyboard keys to abstract away different
-      # terminal escape codes.
-      module Keys
-        UP = ["\e[A", "\eOA", 'k'].freeze
-        DOWN = ["\e[B", "\eOB", 'j'].freeze
-        ENTER = ["\r", "\n"].freeze
-        ESCAPE = ["\e", "\x1B", 'q'].freeze
-      end
-
-      @output = TerminalOutput.new($stdout)
-      @buffer_manager = TerminalBuffer.new(@output)
-      @input = TerminalInput.new
-      @buffer = @buffer_manager.buffer
-
-      class << self
-        # Expose a print wrapper for backward-compatible expectations in tests
-        def print(str)
-          @output.print(str)
-        end
-
-        def size
-          @input.size
-        end
-
-        def clear
-          print [ANSI::Control::CLEAR, ANSI::Control::HOME].join
-          clear_buffer_cache
-          $stdout.flush
-        end
-
-        def move(row, col)
-          # Historically this only queued the move; keep parity
-          @buffer << ANSI.move(row, col)
-        end
-
-        def write(row, col, text)
-          @buffer_manager.write(row, col, text)
-        end
-
-        def write_differential(row, col, text)
-          @buffer_manager.write_differential(row, col, text)
-        end
-
-        def clear_buffer_cache
-          @buffer_manager.clear_buffer_cache
-        end
-
-        def batch_write(&)
-          @buffer_manager.batch_write(&)
-        end
-
-        def start_frame(width: nil, height: nil)
-          if width && height
-            w = width.to_i
-            h = height.to_i
-          else
-            h, w = size
+  module Adapters
+    module Output
+      module Terminal
+        # Facade that preserves the historical Terminal API
+        # while delegating to composable, testable components:
+        # - TerminalOutput
+        # - TerminalBuffer
+        # - TerminalInput
+        class Terminal
+          # Keep ANSI nested under Terminal for compatibility
+          ANSI = TerminalOutput::ANSI
+
+          # Defines constants for special keyboard keys to abstract away different
+          # terminal escape codes.
+          module Keys
+            UP = ["\e[A", "\eOA", 'k'].freeze
+            DOWN = ["\e[B", "\eOB", 'j'].freeze
+            ENTER = ["\r", "\n"].freeze
+            ESCAPE = ["\e", "\x1B", 'q'].freeze
           end
 
-          @buffer_manager.start_frame(width: w, height: h)
-          @buffer = @buffer_manager.buffer
-        end
-
-        def end_frame
-          @buffer_manager.end_frame
-        end
-
-        # Queue raw control sequences (e.g., Kitty graphics) for the current frame.
-        # These are emitted before any row diffs.
-        def raw(text)
-          @buffer_manager.raw(text)
-        end
-
-        def setup
-          @input.setup_console
-          print ANSI::Control::SAVE_SCREEN
-          print ANSI::Control::HIDE_CURSOR
-          print ANSI::BG_DARK
-          clear
-          @input.setup_signal_handlers { cleanup }
-        end
-
-        def cleanup
-          print([
-            ANSI::Control::CLEAR,
-            ANSI::Control::HOME,
-            ANSI::Control::SHOW_CURSOR,
-            ANSI::Control::RESTORE_SCREEN,
-            ANSI::RESET,
-          ].join)
-          @output.flush
-          @input.cleanup_console
-        end
-
-        def read_key
-          @input.read_key
-        end
-
-        def read_key_blocking(timeout: nil)
-          @input.read_key_blocking(timeout: timeout)
-        end
-
-        def enable_mouse
-          @input.enable_mouse
-        end
-
-        def disable_mouse
-          @input.disable_mouse
-        end
-
-        def read_input_with_mouse(timeout: nil)
-          @input.read_input_with_mouse(timeout: timeout)
-        end
-
-        def setup_signal_handlers(&cleanup_callback)
-          @input.setup_signal_handlers(&cleanup_callback)
-        end
-
-        def buffer
-          @buffer
-        end
-
-        def buffer_manager
-          @buffer_manager
-        end
-
-        def output
-          @output
-        end
-
-        def input
-          @input
-        end
-
-        def reset!
+          @runtime_config = Shoko::Adapters::Output::Terminal::NullRuntimeConfig.instance
           @output = TerminalOutput.new($stdout)
-          @buffer_manager = TerminalBuffer.new(@output)
+          @buffer_manager = TerminalBuffer.new(@output, runtime_config: @runtime_config)
           @input = TerminalInput.new
           @buffer = @buffer_manager.buffer
+          @color_mode = nil
+
+          class << self
+            # Expose a print wrapper for backward-compatible expectations in tests
+            def print(str)
+              @output.print(str)
+            end
+
+            def size
+              @input.size
+            end
+
+            def clear
+              print [ANSI::Control::CLEAR, ANSI::Control::HOME].join
+              clear_buffer_cache
+              $stdout.flush
+            end
+
+            def move(row, col)
+              # Historically this only queued the move; keep parity
+              @buffer << ANSI.move(row, col)
+            end
+
+            def write(row, col, text)
+              @buffer_manager.write(row, col, text)
+            end
+
+            def write_differential(row, col, text)
+              @buffer_manager.write_differential(row, col, text)
+            end
+
+            def clear_buffer_cache
+              @buffer_manager.clear_buffer_cache
+            end
+
+            def batch_write(&)
+              @buffer_manager.batch_write(&)
+            end
+
+            def start_frame(width: nil, height: nil, runtime_config: nil)
+              configure_runtime_config(runtime_config) if runtime_config
+              if width && height
+                w = width.to_i
+                h = height.to_i
+              else
+                h, w = size
+              end
+
+              @buffer_manager.start_frame(width: w, height: h, runtime_config: @runtime_config)
+              @buffer = @buffer_manager.buffer
+            end
+
+            def end_frame
+              @buffer_manager.end_frame
+            end
+
+            # Queue raw control sequences (e.g., Kitty graphics) for the current frame.
+            # These are emitted before any row diffs.
+            def raw(text)
+              @buffer_manager.raw(text)
+            end
+
+            def setup
+              @input.setup_console
+              print ANSI::Control::SAVE_SCREEN
+              print ANSI::Control::HIDE_CURSOR
+              print ANSI::DEFAULT_BG
+              clear
+              @input.setup_signal_handlers { cleanup }
+              refresh_color_mode
+            end
+
+            def cleanup
+              @input&.drain_input
+              print([
+                ANSI::Control::CLEAR,
+                ANSI::Control::HOME,
+                ANSI::Control::SHOW_CURSOR,
+                ANSI::Control::RESTORE_SCREEN,
+                ANSI::RESET,
+              ].join)
+              @output.flush
+              @input.cleanup_console
+            end
+
+            def read_key
+              @input.read_key
+            end
+
+            def read_key_blocking(timeout: nil)
+              @input.read_key_blocking(timeout: timeout)
+            end
+
+            def enable_mouse
+              @input.enable_mouse
+            end
+
+            def disable_mouse
+              @input.disable_mouse
+            end
+
+            def read_input_with_mouse(timeout: nil)
+              @input.read_input_with_mouse(timeout: timeout)
+            end
+
+            def setup_signal_handlers(&)
+              @input.setup_signal_handlers(&)
+            end
+
+            attr_reader :buffer, :buffer_manager, :output, :input
+
+            def reset!
+              @output = TerminalOutput.new($stdout)
+              @buffer_manager = TerminalBuffer.new(@output, runtime_config: @runtime_config)
+              @input = TerminalInput.new
+              @buffer = @buffer_manager.buffer
+              @color_mode = nil
+            end
+
+            def configure_runtime_config(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
+            end
+
+            def color_mode
+              @color_mode ||= detect_color_mode
+            end
+
+            def refresh_color_mode
+              @color_mode = detect_color_mode
+            end
+
+            private
+
+            def detect_color_mode
+              override = ENV['SHOKO_COLOR_MODE'].to_s.downcase
+              return :light if override == 'light'
+              return :dark if override == 'dark'
+
+              colorfgbg = ENV.fetch('COLORFGBG', '')
+              mode = mode_from_colorfgbg(colorfgbg)
+              return mode if mode
+
+              if osc_query_enabled?
+                rgb = @input&.query_default_background
+                return mode_from_rgb(rgb) if rgb
+              end
+
+              :dark
+            end
+
+            def osc_query_enabled?
+              value = ENV.fetch('SHOKO_ENABLE_OSC_QUERY', '').to_s.strip.downcase
+              %w[1 true yes on].include?(value)
+            end
+
+            def mode_from_colorfgbg(value)
+              bg_value = value.to_s.split(';').last
+              return nil if bg_value.nil? || bg_value.empty?
+
+              bg = begin
+                Integer(bg_value)
+              rescue Shoko::Error
+                raise
+              end
+              return nil unless bg
+
+              bg >= 7 ? :light : :dark
+            end
+
+            def mode_from_rgb(rgb)
+              r, g, b = rgb
+              luminance = (0.2126 * r) + (0.7152 * g) + (0.0722 * b)
+              luminance >= 0.6 ? :light : :dark
+            end
+          end
         end
       end
     end

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

@@ -1,242 +1,17 @@
 # frozen_string_literal: true
 
+require_relative '../../../shared/terminal/text_sanitizer'
+
 module Shoko
   module Adapters
     module Output
       module Terminal
-        # Sanitizes untrusted text before it is rendered in a terminal.
+        # Backward-compatible alias for shared terminal text sanitizer primitive.
         #
-        # Removes ANSI/VT control sequences (OSC/DCS/CSI/etc.) and drops C0/C1 control
-        # characters to prevent terminal escape injection and layout corruption.
-        module TerminalSanitizer
-      module_function
-
-      # Pre-sanitizer for XML/XHTML sources before feeding them to an XML parser.
-      #
-      # Some EPUBs (and malicious inputs) include numeric character references to
-      # disallowed control characters (e.g. `` / ``), which can cause
-      # REXML to raise parse errors. To keep parsing resilient, this method:
-      # - Decodes *numeric* references for C0/C1/DEL into real codepoints so the
-      #   control-sequence scanner can remove the entire escape sequence.
-      # - Drops numeric references to codepoints that are invalid in XML 1.0.
-      #
-      # It intentionally does not decode non-control references (e.g. `<`)
-      # because doing so can change document structure before parsing.
-      def sanitize_xml_source(text, preserve_newlines: true, preserve_tabs: true)
-        return '' if text.nil?
-
-        str = coerce_utf8(String(text))
-        return '' if str.empty?
-
-        pre = decode_control_numeric_references(str)
-        sanitize(pre, preserve_newlines: preserve_newlines, preserve_tabs: preserve_tabs)
-      rescue StandardError
-        sanitize(text.to_s, preserve_newlines: preserve_newlines, preserve_tabs: preserve_tabs)
-      end
-
-      # @param text [String,nil]
-      # @param preserve_newlines [Boolean] keep `\n` (and normalize `\r` to `\n`)
-      # @param preserve_tabs [Boolean] keep `\t`
-      # @return [String] UTF-8 string safe for terminal rendering
-      def sanitize(text, preserve_newlines: false, preserve_tabs: false)
-        return '' if text.nil?
-
-        str = String(text)
-        return '' if str.empty?
-
-        str = coerce_utf8(str)
-        cps = str.codepoints
-        return '' if cps.empty?
-
-        out = +''
-        out.force_encoding(Encoding::UTF_8)
-
-        i = 0
-        while i < cps.length
-          cp = cps[i]
-
-          case cp
-          when 0x1B # ESC
-            i = skip_esc_sequence(cps, i + 1)
-            next
-          when 0x9B # CSI (8-bit)
-            i = skip_csi_sequence(cps, i + 1)
-            next
-          when 0x9D # OSC (8-bit)
-            i = skip_osc_sequence(cps, i + 1, c1_variant: true)
-            next
-          when 0x90, 0x98, 0x9E, 0x9F # DCS, SOS, PM, APC (8-bit)
-            i = skip_string_sequence(cps, i + 1, c1_variant: true)
-            next
-          end
-
-          if cp == 0x0A # \n
-            out << (preserve_newlines ? "\n" : ' ')
-            i += 1
-            next
-          end
-
-          if cp == 0x0D # \r
-            out << (preserve_newlines ? "\n" : ' ')
-            i += 1
-            next
-          end
-
-          if cp == 0x09 # \t
-            out << (preserve_tabs ? "\t" : ' ')
-            i += 1
-            next
-          end
-
-          if control_codepoint?(cp)
-            i += 1
-            next
-          end
-
-          out << cp
-          i += 1
-        end
-
-        out
-      rescue StandardError
-        String(text).encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\uFFFD")
-      end
-
-      # Input filter for single-character text entry (search fields, editors).
-      # Prevents inserting C0/C1 control characters and DEL.
-      def printable_char?(key)
-        return false unless key.is_a?(String)
-        return false unless key.length == 1
-
-        cp = key.ord
-        return false if cp < 0x20
-        return false if cp == 0x7F
-        return false if cp.between?(0x80, 0x9F)
-
-        true
-      rescue StandardError
-        false
-      end
-
-      def coerce_utf8(str)
-        return str if str.encoding == Encoding::UTF_8 && str.valid_encoding?
-
-        str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\uFFFD")
-      rescue StandardError
-        str.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\uFFFD")
-      end
-      private_class_method :coerce_utf8
-
-      def control_codepoint?(codepoint)
-        return true if codepoint < 0x20
-        return true if codepoint == 0x7F
-        return true if codepoint.between?(0x80, 0x9F)
-
-        false
-      end
-      private_class_method :control_codepoint?
-
-      def skip_esc_sequence(codepoints, index)
-        return codepoints.length if index >= codepoints.length
-
-        lead = codepoints[index]
-        case lead
-        when 0x5B # '[' CSI
-          skip_csi_sequence(codepoints, index + 1)
-        when 0x5D # ']' OSC
-          skip_osc_sequence(codepoints, index + 1, c1_variant: false)
-        when 0x50, 0x58, 0x5E, 0x5F # 'P' DCS, 'X' SOS, '^' PM, '_' APC
-          skip_string_sequence(codepoints, index + 1, c1_variant: false)
-        else
-          # 2-byte escape sequence (ESC + final byte)
-          index + 1
-        end
-      end
-      private_class_method :skip_esc_sequence
-
-      def skip_csi_sequence(codepoints, index)
-        while index < codepoints.length
-          cp = codepoints[index]
-          index += 1
-          # Final byte is 0x40..0x7E
-          break if cp.between?(0x40, 0x7E)
-        end
-        index
-      end
-      private_class_method :skip_csi_sequence
-
-      def skip_osc_sequence(codepoints, index, c1_variant:)
-        while index < codepoints.length
-          cp = codepoints[index]
-
-          return index + 1 if cp == 0x07 # BEL
-
-          return index + 2 if !c1_variant && cp == 0x1B && codepoints[index + 1] == 0x5C # ESC \
-
-          return index + 1 if c1_variant && cp == 0x9C # ST (8-bit)
-
-          # Allow ESC \ as terminator even for 8-bit variants (robustness).
-          return index + 2 if cp == 0x1B && codepoints[index + 1] == 0x5C
-
-          index += 1
-        end
-        index
-      end
-      private_class_method :skip_osc_sequence
-
-      def skip_string_sequence(codepoints, index, c1_variant:)
-        while index < codepoints.length
-          cp = codepoints[index]
-
-          return index + 1 if c1_variant && cp == 0x9C # ST
-
-          return index + 2 if cp == 0x1B && codepoints[index + 1] == 0x5C # ESC \
-
-          index += 1
-        end
-        index
-      end
-      private_class_method :skip_string_sequence
-
-      def decode_control_numeric_references(str)
-        # Hex numeric references
-        out = str.gsub(/&#x([0-9A-Fa-f]+);/) do |match|
-          cp = Regexp.last_match(1).to_i(16)
-          replacement_for_xml_numeric_ref(cp, match)
-        end
-
-        # Decimal numeric references
-        out.gsub(/&#(\d+);/) do |match|
-          cp = Regexp.last_match(1).to_i
-          replacement_for_xml_numeric_ref(cp, match)
-        end
-      end
-      private_class_method :decode_control_numeric_references
-
-      def replacement_for_xml_numeric_ref(codepoint, original)
-        return '' unless codepoint.is_a?(Integer)
-
-        # Decode control characters so the escape-sequence scanner can remove the
-        # full sequence (e.g. ESC + '[' + ... + 'm').
-        return [codepoint].pack('U') if codepoint < 0x20 || codepoint == 0x7F || codepoint.between?(0x80, 0x9F)
-
-        # Drop codepoints that are not valid in XML 1.0.
-        xml_allowed_codepoint?(codepoint) ? original : ''
-      rescue StandardError
-        ''
-      end
-      private_class_method :replacement_for_xml_numeric_ref
-
-      def xml_allowed_codepoint?(codepoint)
-        return true if [0x09, 0x0A, 0x0D].include?(codepoint)
-        return true if codepoint.between?(0x20, 0xD7FF)
-        return true if codepoint.between?(0xE000, 0xFFFD)
-        return true if codepoint.between?(0x10000, 0x10FFFF)
-
-        false
-      end
-      private_class_method :xml_allowed_codepoint?
-        end
+        # The actual implementation now lives under shared/terminal.
+        # This module delegates calls to the shared implementation so
+        # existing code continues to work without changes.
+        TerminalSanitizer = Shoko::Shared::Terminal::TextSanitizer
       end
     end
   end