fatty 0.99.0 → 0.99.3

data/lib/fatty/curses/context.rb

@@ -19,9 +19,9 @@ module Fatty
     # Those responsibilities belong to EventSource and Renderer.
     #
     # Context exists so that all curses state is centralized and never leaks
-    # into Sessions, Views, or Terminal.
+    # into Sessions or Terminal.
     class Context
-      DEFAULT_ESC_DELAY = 25
+      DEFAULT_ESC_DELAY = 0
 
       attr_reader :input_win, :output_win, :status_win, :alert_win
       attr_reader :rows, :cols, :palette, :truecolor
@@ -33,8 +33,8 @@ module Fatty
       def start
         return self if @started
 
-        ::Curses.init_screen
         configure_escape_delay!
+        ::Curses.init_screen
         MouseConstants.ensure!
 
         ::Curses.raw
@@ -49,6 +49,33 @@ module Fatty
         self
       end
 
+      def started?
+        @started
+      end
+
+      def environment
+        data = {
+          started: started?,
+          truecolor: truecolor,
+          key_min: ::Curses::KEY_MIN,
+          key_max: ::Curses::KEY_MAX,
+        }
+        if started?
+          data.merge(
+            lines: ::Curses.lines,
+            cols: ::Curses.cols,
+            has_colors: ::Curses.has_colors?,
+            colors: ::Curses.colors,
+            color_pairs: ::Curses.color_pairs,
+            can_change_color: ::Curses.can_change_color?,
+          )
+        else
+          data
+        end
+      rescue StandardError
+        {}
+      end
+
       def configure_escape_delay!
         delay =
           if ENV["ESCDELAY"]
@@ -56,7 +83,7 @@ module Fatty
           else
             Fatty::Config.config.dig(:esc_delay)&.to_i
           end
-        delay = DEFAULT_ESC_DELAY if delay.nil? || delay <= 0
+        delay = DEFAULT_ESC_DELAY if delay.nil? || delay.negative?
         if ::Curses.respond_to?(:set_escdelay)
           ::Curses.set_escdelay(delay)
         else
@@ -136,122 +163,74 @@ module Fatty
           when "false", "no", "off", "0"
             false
           else
-            truecolor_env?
+            Fatty::Env.truecolor_detected?
           end
         Fatty.info(
           "truecolor=#{@truecolor} setting=#{setting.inspect} " \
             "TERM=#{ENV['TERM'].inspect} COLORTERM=#{ENV['COLORTERM'].inspect} " \
             "TERM_PROGRAM=#{ENV['TERM_PROGRAM'].inspect} TMUX=#{ENV.key?('TMUX')}",
-          tag: :themes,
+          tag: :theme,
         )
         @truecolor
       end
 
-      def truecolor_env?
-        colorterm = ENV["COLORTERM"].to_s
-        term = ENV["TERM"].to_s
-        term_program = ENV["TERM_PROGRAM"].to_s
-
-        colorterm.match?(/truecolor|24bit/i) ||
-          term.match?(/truecolor|24bit|direct/i) ||
-          term.match?(/kitty|wezterm|alacritty|ghostty|foot/i) ||
-          term_program.match?(/kitty|wezterm|alacritty|ghostty|iTerm/i)
-      end
-
-      # Map a Fatty::Ansi::Style to a curses attribute.
-      #
-      # - If style has no explicit fg/bg, keep the themed role pair.
-      # - If style specifies fg/bg, allocate/init a curses pair on demand.
-      #
-      # This is intentionally independent of theme roles; it is for SGR output
-      # runs inside the output pane.
-      def ansi_attr(style, fallback_role: :output)
-        base_pair_id = Fatty::Colors::Pairs::ROLE_TO_PAIR.fetch(fallback_role)
-        base_attr = ::Curses.color_pair(base_pair_id)
-
-        has_explicit = !(style.fg.nil? && style.bg.nil?)
-        attr =
-          if has_explicit
-            pair_id = ansi_pair_id(style.fg, style.bg, fallback_pair_id: base_pair_id)
-            ::Curses.color_pair(pair_id)
-          else
-            base_attr
-          end
-        attr |= ::Curses::A_BOLD if style.bold
-        attr |= ::Curses::A_UNDERLINE if style.underline
-        attr |= ::Curses::A_REVERSE if style.reverse
-        if style.italic && defined?(::Curses::A_ITALIC)
-          attr |= ::Curses::A_ITALIC
-        end
-        if style.strike && defined?(::Curses::A_HORIZONTAL)
-          attr |= ::Curses::A_HORIZONTAL
-        end
-        attr
-      end
-
       def apply_palette(palette)
+        reset_ansi_pairs!
+
         if ::Curses.has_colors?
           ::Curses.start_color
           ::Curses.use_default_colors if ::Curses.respond_to?(:use_default_colors)
+
           palette.each_value do |entry|
             next unless entry[:pair]
 
             ::Curses.init_pair(entry[:pair], entry[:fg], entry[:bg])
           end
         end
-        @palette = palette
-      end
-
-      private
-
-      def ensure_started!
-        return if @started
-
-        raise "Curses::Context not started"
-      end
-
-      def close_windows
-        @output_win&.close
-        @input_win&.close
-        @alert_win&.close
-        @status_win&.close
 
-        @output_win = nil
-        @input_win = nil
-        @alert_win = nil
-        @status_win = nil
+        @palette = palette
       end
 
-      # Generate a map from [fg, bg] pairs to Cuses pair ids.
-      def ansi_pair_id(fg, bg, fallback_pair_id:)
-        has_colors = ::Curses.has_colors?
-        return fallback_pair_id unless has_colors
+      # Return a curses color-pair id for an ANSI foreground/background pair.
+      #
+      # This owns the dynamic ANSI pair cache. Renderers decide which fg/bg
+      # indexes they want; Context decides whether a pair can be allocated.
+      def ansi_pair_for(fg, bg, fallback_pair_id:)
+        return fallback_pair_id unless ::Curses.has_colors?
 
         @ansi_pairs ||= {}
         @ansi_pair_limit ||= begin
-          ::Curses.color_pairs
-        rescue StandardError
-          256
-        end
+                               ::Curses.color_pairs.to_i
+                             rescue StandardError
+                               256
+                             end
 
-        key = [fg || -1, bg || -1]
+        key = [fg.nil? ? -1 : fg.to_i, bg.nil? ? -1 : bg.to_i]
         cached = @ansi_pairs[key]
         return cached if cached
 
-        # Leave low pair ids for stable theme roles.
-        start_id = 64
+        start_id = Fatty::Colors::Pairs::ROLE_TO_PAIR.values.max + 1
         @ansi_next_pair_id ||= start_id
         @ansi_next_pair_id = start_id if @ansi_next_pair_id < start_id
 
-        if @ansi_next_pair_id >= @ansi_pair_limit
+        if @ansi_pair_limit.positive? && @ansi_next_pair_id >= @ansi_pair_limit
+          Fatty.debug(
+            "ansi_pair_for exhausted next=#{@ansi_next_pair_id.inspect} " \
+            "limit=#{@ansi_pair_limit.inspect} fg=#{fg.inspect} bg=#{bg.inspect} " \
+            "fallback=#{fallback_pair_id.inspect}",
+            tag: :theme,
+          )
           @ansi_pairs[key] = fallback_pair_id
         else
           pair_id = @ansi_next_pair_id
           @ansi_next_pair_id += 1
 
-          fg_i = fg.nil? ? -1 : fg.to_i
-          bg_i = bg.nil? ? -1 : bg.to_i
-          ::Curses.init_pair(pair_id, fg_i, bg_i)
+          ::Curses.init_pair(
+            pair_id,
+            fg.nil? ? -1 : fg.to_i,
+            bg.nil? ? -1 : bg.to_i,
+          )
+
           @ansi_pairs[key] = pair_id
         end
 
@@ -260,7 +239,30 @@ module Fatty
 
       def reset_ansi_pairs!
         @ansi_pairs = {}
-        @ansi_next_pair_id = 1
+        @ansi_next_pair_id = nil
+        @ansi_pair_limit = nil
+      end
+
+      private
+
+      # simplecov:disable
+
+      def ensure_started!
+        return if @started
+
+        raise "Curses::Context not started"
+      end
+
+      def close_windows
+        @output_win&.close
+        @input_win&.close
+        @alert_win&.close
+        @status_win&.close
+
+        @output_win = nil
+        @input_win = nil
+        @alert_win = nil
+        @status_win = nil
       end
 
       def enable_bracketed_paste!

data/lib/fatty/curses/event_source.rb

@@ -23,6 +23,13 @@ module Fatty
         ::Curses::BUTTON3_TRIPLE_CLICKED => :right_triple_clicked
       }.freeze
 
+      SCROLL_UP_BSTATE = ::Curses::BUTTON4_PRESSED
+      SCROLL_DOWN_BSTATE = 0x10000000
+      MOUSE_MODIFIER_MASK =
+        ::Curses::BUTTON_CTRL |
+        ::Curses::BUTTON_ALT |
+        ::Curses::BUTTON_SHIFT
+
       ESCAPE_LOOKAHEAD_MS = 0
 
       BRACKETED_PASTE_START = "[200~"
@@ -30,32 +37,64 @@ module Fatty
 
       attr_reader :context, :key_decoder
 
-      def initialize(context:, key_decoder:, poll_ms: 200)
+      def initialize(context: Context.new, key_decoder: nil, poll_ms: 200)
         @context = context
-        @key_decoder = key_decoder
+        @key_decoder = key_decoder || KeyDecoder.new
         @poll_ms = poll_ms.to_i
         configure_input_polling!
       end
 
       def next_event
-        raw = read_raw
+        pending_events.shift || read_event
+      end
+
+      def interrupt_pending?
+        command = read_event(timeout_ms: 0)
+        interrupted = interrupt_command?(command)
+
+        pending_events << command if command && !interrupted
+        interrupted
+      end
+
+      private
+
+      # simplecov:disable
+
+      def read_event(timeout_ms: @poll_ms)
+        raw = read_raw(timeout_ms:)
         return unless raw
 
         if raw.is_a?(Fatty::MouseEvent)
-          return [:key, raw]
+          Command.session(:active, :key, event: raw)
+        elsif raw.is_a?(Array) && raw.first == :paste
+          # This :terminal_paste is a terminal bracketed-paste event, not an
+          # editor paste action. Treat the pasted bytes as one insert
+          # operation instead of decoding them as individual key events.
+          Command.session(:active, :terminal_paste, text: raw.last)
+        elsif (ev = @key_decoder.decode(raw))
+          if ev.key == :resize
+            Command.terminal(:resize)
+          else
+            Command.session(:active, :key, event: ev)
+          end
+        else
+          Fatty.warn("undecoded input: #{raw.inspect}", tag: :input)
+          nil
         end
+      end
 
-        if raw.is_a?(Array) && raw.first == :paste
-          return [:cmd, :paste, { text: raw.last }]
-        end
+      def interrupt_command?(command)
+        return false unless command&.action == :key
 
-        ev = @key_decoder.decode(raw)
-        return unless ev
+        event = command.payload[:event]
+        return false unless event.is_a?(Fatty::KeyEvent)
 
-        [:key, ev]
+        event.ctrl? && [:c, :g].include?(event.key)
       end
 
-      private
+      def pending_events
+        @pending_events ||= []
+      end
 
       def window
         context.input_win
@@ -70,54 +109,98 @@ module Fatty
         win.timeout = @poll_ms if win.respond_to?(:timeout=)
       end
 
-      def read_raw
+      def read_raw(timeout_ms: @poll_ms)
         return unless window
 
-        window.timeout = @poll_ms if window.respond_to?(:timeout=)
+        pending = read_pending_raw
+        return pending if pending
+
+        window.timeout = timeout_ms if window.respond_to?(:timeout=)
 
         ch = window.getch
         return if ch == -1
         return unless ch
 
+        log_keycode(ch)
+
         if ch.is_a?(Integer) && ch == ::Curses::KEY_MOUSE
           mouse = ::Curses.getmouse
           Fatty.debug("EventSource#read_raw: bstate=#{mouse&.bstate}", tag: :mouse)
           return decode_mouse(mouse)
         end
 
-        if Fatty::Config.config.dig(:log, :tags)&.include?(:keycode)
-          Fatty.debug(
-            :curses_getch,
-            tag: :keycode,
-            ch_class: ch.class.name,
-            ch_inspect: ch.inspect,
-            ch_int: (ch.is_a?(Integer) ? ch : nil),
-            ch_chr: (ch.is_a?(Integer) && ch.between?(0, 255) ? ch.chr : nil),
-          )
-        end
+        return ch unless escape_char?(ch)
 
-        if ch.is_a?(Integer) && ch == 27
-          nxt = with_window_timeout(ESCAPE_LOOKAHEAD_MS) { window.getch }
+        read_escape_raw(ch)
+      end
 
-          if nxt == -1 || !nxt
-            ch
-          elsif nxt == "[".ord || nxt == "["
-            suffix = read_escape_suffix
-            seq = "[" + suffix
-
-            if seq == BRACKETED_PASTE_START
-              [:paste, read_bracketed_paste]
-            else
-              [ch, nxt]
-            end
+      def read_escape_raw(ch)
+        nxt = with_window_timeout(escape_lookahead_ms) { window.getch }
+        return ch if nxt == -1 || !nxt
+
+        if csi_prefix?(nxt)
+          suffix = read_escape_suffix
+          seq = "[" + suffix
+          if seq == BRACKETED_PASTE_START
+            [:paste, read_bracketed_paste]
           else
+            push_pending_raw(*suffix.chars.reverse)
+            push_pending_raw(nxt)
+            ch
+          end
+        elsif ss3_prefix?(nxt)
+          suffix = with_window_timeout(escape_lookahead_ms) { window.getch }
+          if suffix == -1 || !suffix
             [ch, nxt]
+          else
+            [ch, nxt, suffix]
           end
         else
-          ch
+          [ch, nxt]
+        end
+      end
+
+      def ss3_prefix?(ch)
+        ch == "O".ord || ch == "O"
+      end
+
+      def read_pending_raw
+        @pending_raw ||= []
+        @pending_raw.shift
+      end
+
+      def push_pending_raw(*values)
+        @pending_raw ||= []
+        values.each do |value|
+          @pending_raw.unshift(value)
         end
       end
 
+      def escape_lookahead_ms
+        Fatty::Config.config.fetch(:esc_delay, ESCAPE_LOOKAHEAD_MS).to_i
+      end
+
+      def escape_char?(ch)
+        ch.is_a?(Integer) && ch == 27
+      end
+
+      def csi_prefix?(ch)
+        ch == "[".ord || ch == "["
+      end
+
+      def log_keycode(ch)
+        return unless Fatty::Config.config.dig(:log, :tags)&.include?(:keycode)
+
+        Fatty.debug(
+          :curses_getch,
+          tag: :keycode,
+          ch_class: ch.class.name,
+          ch_inspect: ch.inspect,
+          ch_int: (ch.is_a?(Integer) ? ch : nil),
+          ch_chr: (ch.is_a?(Integer) && ch.between?(0, 255) ? ch.chr : nil),
+        )
+      end
+
       def with_window_timeout(ms)
         result = nil
         win = window
@@ -158,16 +241,21 @@ module Fatty
       end
 
       def mouse_button_from_bstate(bstate)
-        return :scroll_up   if (bstate & ::Curses::BUTTON4_PRESSED).positive?
-        return :scroll_down if (bstate & ::Curses::BUTTON5_PRESSED).positive?
+        button_state = bstate & ~MOUSE_MODIFIER_MASK
+        return :scroll_up if (button_state & SCROLL_UP_BSTATE).positive?
+        return :scroll_down if (button_state & SCROLL_DOWN_BSTATE).positive?
 
         MOUSE_BSTATE_BUTTON_MAP.each do |mask, button|
-          return button if (bstate & mask).positive?
+          return button if (button_state & mask).positive?
         end
 
         nil
       end
 
+      def mouse_button_pressed?(button_state, const_name)
+        ::Curses.const_defined?(const_name) && (button_state & ::Curses.const_get(const_name)).positive?
+      end
+
       def read_escape_suffix
         suffix = +""
         done = false

data/lib/fatty/curses/key_decoder.rb

@@ -9,9 +9,29 @@ module Fatty
     # :ctrl, and :meta, in the KeyEvent so that the KeyMap can assign different
     # actions to the modified keys.
     class KeyDecoder
+      SS3_TO_EVENT = {
+        "j" => KeyEvent.new(key: :keypad_multiply),
+        "k" => KeyEvent.new(key: :keypad_plus),
+        "l" => KeyEvent.new(key: :keypad_comma),
+        "m" => KeyEvent.new(key: :keypad_minus),
+        "n" => KeyEvent.new(key: :keypad_decimal),
+        "o" => KeyEvent.new(key: :keypad_divide),
+        "p" => KeyEvent.new(key: :keypad_0),
+        "q" => KeyEvent.new(key: :keypad_1),
+        "r" => KeyEvent.new(key: :keypad_2),
+        "s" => KeyEvent.new(key: :keypad_3),
+        "t" => KeyEvent.new(key: :keypad_4),
+        "u" => KeyEvent.new(key: :keypad_5),
+        "v" => KeyEvent.new(key: :keypad_6),
+        "w" => KeyEvent.new(key: :keypad_7),
+        "x" => KeyEvent.new(key: :keypad_8),
+        "y" => KeyEvent.new(key: :keypad_9),
+        "M" => KeyEvent.new(key: :keypad_enter),
+      }.freeze
+
       attr_reader :map, :env
 
-      def initialize(env:)
+      def initialize(env: Env.detect)
         @env = env
         @map = {}
         load_builtin_map
@@ -26,7 +46,11 @@ module Fatty
         result =
           case raw
           when Array
-            decode_meta(raw)
+            if raw.length == 3 && ss3_sequence?(raw)
+              decode_ss3(raw)
+            else
+              decode_meta(raw)
+            end
           else
             decode_single(raw)
           end
@@ -36,6 +60,32 @@ module Fatty
 
       private
 
+      # simplecov:disable
+
+      def ss3_sequence?(raw)
+        raw[0] == 27 && raw[1] == "O"
+      end
+
+      def decode_ss3(raw)
+        _esc, _prefix, suffix = raw
+        event = SS3_TO_EVENT[raw_char_to_s(suffix)]
+        if event
+          KeyEvent.new(
+            key: event.key,
+            ctrl: event.ctrl?,
+            meta: event.meta?,
+            shift: event.shift?,
+            raw: raw,
+          )
+        else
+          KeyEvent.new(key: raw_char_to_s(suffix).to_sym, raw: raw)
+        end
+      end
+
+      def raw_char_to_s(value)
+        value.is_a?(Integer) ? value.chr : value.to_s
+      end
+
       # Handle the decoding of meta keys which are returned as an Array of the
       # escape code followed by another key, nxt, which can be either a String
       # or an Integer.
@@ -143,21 +193,35 @@ module Fatty
       # different terminal programs process keys.
       def load_user_config
         config = Fatty::Config.keydefs
-        Fatty.info("KeyDecode#load_user_config", config: config, tag: :keycode)
-        return unless config
+        return nil unless config
 
         terminal = @env[:terminal]
         Fatty.info("KeyDecoder#load_user_config: detected terminal `#{terminal}`")
         Fatty.info("KeyDecoder#load_user_config: only keydefs for `#{terminal}` will be loaded")
-        section = config.dig(:terminal, terminal.to_sym, :map)
+        section = keydef_section(config, terminal.to_s)
         return unless section
 
         section.each do |code, spec|
-          @map[Integer(code.to_s)] = KeyEvent.new(**normalize_spec(spec))
-          Fatty.debug("KeyDecoder#load_user_config: user keydef: code: #{code} -> #{spec}")
+          register_user_keydef(code.to_i, spec)
         end
       end
 
+      def register_user_keydef(code, spec)
+        @map[Integer(code.to_s)] = KeyEvent.new(**normalize_spec(spec))
+        Fatty.debug("KeyDecoder#load_user_config: user keydef: code: #{code} -> #{spec}", tag: :keycode)
+      end
+
+      # Because =fat_config= canonicalizes keys by translating hyphen (-) to
+      # underscore (_) so that the keys are valid ruby varaible names, we need
+      # to look for that variation of the terminal name to get the right
+      # section of the keydefs.yml config Hash.
+      def keydef_section(config, terminal)
+        config[terminal.to_sym] ||
+          config[terminal] ||
+          config[terminal.tr("-", "_").to_sym] ||
+          config[terminal.tr("-", "_")]
+      end
+
       # Add to the @map keydefs as assumed by the curses library, defined in the
       # constant Fatty::CUSRSES_TO_EVENT.  These can be overridden by the the
       # user config in #load_user_config.
@@ -171,11 +235,13 @@ module Fatty
 
       # Make sure the user config Hash uses symbols for its keys.  Return the
       # Hash as so corrected.
-      def normalize_spec(hash)
-        spec = hash.transform_keys(&:to_sym)
-        if spec[:key].is_a?(String)
-          spec[:key] = spec[:key].to_sym
+      def normalize_spec(value)
+        unless value.is_a?(Hash)
+          raise ArgumentError, "keydef spec must be a Hash, got #{value.class}: #{value.inspect}"
         end
+
+        spec = value.transform_keys(&:to_sym)
+        spec[:key] = spec[:key].to_sym if spec[:key].is_a?(String)
         spec
       end
     end

data/lib/fatty/env.rb

@@ -6,19 +6,22 @@ module Fatty
 
     def detect
       {
-        os: os,
         arch: arch,
+        os: os,
         ruby_platform: RUBY_PLATFORM,
+        screen: screen?,
+        ssh: ssh?,
         term: ENV["TERM"],
         terminal: detect_terminal_program,
         terminal_version: ENV["KONSOLE_VERSION"] || ENV["TERM_PROGRAM_VERSION"],
         tmux: tmux?,
-        screen: screen?,
-        ssh: ssh?,
-        curses: curses_info,
+        truecolor_detected: truecolor_detected?,
+        curses: {},
       }
     end
 
+    private
+
     # -----------------------
     # OS / platform
     # -----------------------
@@ -60,16 +63,29 @@ module Fatty
       return "ghostty"  if ENV["TERM_PROGRAM"]&.downcase == "ghostty"
       return "alacritty" if ENV.key?("ALACRITTY_LOG")
       return "terminator" if ENV.key?("TERMINATOR_UUID")
+      return "gnome-terminal" if ENV.key?("GNOME_TERMINAL_SCREEN") || ENV.key?("GNOME_TERMINAL_SERVICE")
+      return "vte" if ENV.key?("VTE_VERSION")
 
       if ENV.key?("TERM_PROGRAM")
         ENV["TERM_PROGRAM"]&.downcase
       elsif ENV.key?("TERM")
         ENV["TERM"]&.downcase
       else
-        'unknown'
+        "unknown"
       end
     end
 
+    def self.truecolor_detected?
+      colorterm = ENV["COLORTERM"].to_s
+      term = ENV["TERM"].to_s
+      term_program = ENV["TERM_PROGRAM"].to_s
+
+      colorterm.match?(/truecolor|24bit/i) ||
+        term.match?(/truecolor|24bit|direct/i) ||
+        term.match?(/kitty|wezterm|alacritty|ghostty|foot/i) ||
+        term_program.match?(/kitty|wezterm|alacritty|ghostty|iTerm/i)
+    end
+
     def tmux?
       ENV.key?("TMUX")
     end
@@ -81,20 +97,5 @@ module Fatty
     def ssh?
       ENV.key?("SSH_TTY") || ENV.key?("SSH_CONNECTION")
     end
-
-    # -----------------------
-    # ncurses capabilities
-    # -----------------------
-
-    def curses_info
-      return {} unless defined?(::Curses)
-
-      {
-        key_min: ::Curses::KEY_MIN,
-        key_max: ::Curses::KEY_MAX,
-      }
-    rescue StandardError
-      {}
-    end
   end
 end