typr 1.2.0 → 1.4.0

data/lib/terminal.rb

@@ -10,22 +10,70 @@ module Typr
   # Raw /dev/tty used for key input; falls back to $stdin when unavailable.
   INPUT = (IO.new IO.sysopen("/dev/tty", "r")) rescue $stdin
 
-  # KEY_* escape sequences come from the terminfo database (infocmp -L1).
-  `infocmp -L1`.split.each{ |info| key,value = info[0..-2].split("=")
-    if value
-      value.gsub! '\E', '\e'
-      value += "\\" if value[-1] == "\\"
-      eval "%s=\"%s\"" % [key.upcase,value] if key
-    end }
+  # KEY_* escapes and keypad sequences are precompiled into share/terminfo by
+  # bin/build_terminfo, so the runtime needs no ncurses/infocmp (e.g. Termux).
+  TERMINFO = begin
+    eval File.read(File.expand_path("../share/terminfo", __dir__))
+  rescue StandardError
+    {}
+  end
+  # Known-good fallback so KEY_* are always defined, even for TERM=dumb.
+  DEFAULT_KEYS = { "key_up" => "\eOA", "key_down" => "\eOB", "key_left" => "\eOD",
+    "key_right" => "\eOC", "key_home" => "\eOH", "key_end" => "\eOF",
+    "key_backspace" => "\x7f", "key_dc" => "\e[3~", "key_npage" => "\e[6~",
+    "key_ppage" => "\e[5~", "carriage_return" => "\r",
+    "keypad_xmit" => "\e[?1h\e=", "keypad_local" => "\e[?1l\e>",
+    "cursor_invisible" => "\e[?25l", "cursor_normal" => "\e[?25h",
+    "clear_screen" => "\e[H\e[2J", "user7" => "\e[6n" }
+  term = ENV["TERM"].to_s
+  entry = nil
+  [ term, term.sub(/-.*/, ""), "xterm" ].each do |name|
+    found = TERMINFO[name]
+    if found && found.any? { |cap, _| cap.start_with?("key_") }
+      entry = found
+      break
+    end
+  end
+  entry ||= {}
+  # Fill gaps with safe ANSI defaults, but never fabricate keypad modes:
+  # those must match the terminal exactly or arrows get misread.
+  DEFAULT_KEYS.each do |cap, seq|
+    next if cap.start_with?("keypad_") && !entry[cap]
+    const_set cap.upcase, entry[cap] || seq
+  end
 
   # Common key aliases and the line-erase escape sequence.
   ERASE_LINE = "\e[K"
+  # Reset foreground/background to the terminal defaults.
+  ORIG_COLORS = "\e[39;49m"
   KEY_ESCAPE = "\e"
   KEY_RETURN = CARRIAGE_RETURN
   KEY_TAB = "\t"
   KEY_PAGEDOWN = KEY_NPAGE
   KEY_PAGEUP = KEY_PPAGE
 
+  # Enable/disable mouse reporting. Universal private modes, independent of
+  # terminfo: 1000 = button press/release/wheel, 1006 = SGR coordinates.
+  MOUSE_ON = "\e[?1000h\e[?1006h"
+  MOUSE_OFF = "\e[?1000l\e[?1006l"
+
+  # A mouse event decoded from the input stream. +x+ / +y+ are 1-based
+  # terminal coordinates; +button+ is 0=left, 1=middle, 2=right, or 4-7 for
+  # the wheel (up/down/left/right); +modifiers+ holds the SGR shift/alt/ctrl
+  # bits. Non-widget code can test `key.is_a?(Typr::Mouse)`.
+  Mouse = Struct.new(:button, :x, :y, :action, :modifiers) do
+    def press?;   action == :press end
+    def release?; action == :release end
+    def wheel?;   button.between?(4, 7) end
+    def wheel_up?;   button == 4 end
+    def wheel_down?; button == 5 end
+    def left?;   button == 0 end
+    def middle?; button == 1 end
+    def right?;  button == 2 end
+    def to_s; "%s button=%i x=%i y=%i%s" % [ action, button, x, y,
+      ( modifiers > 0 ? " modifiers=#{modifiers}" : "" ) ] end
+  end
+
   # Text attributes (reset, bold, italic, ...) and named 8/256-color tables.
   MODES =  %i[ reset bold italic underline slow fast invert ]
   COLORS = %i[ black red green yellow blue magenta cyan white ]
@@ -118,11 +166,16 @@ module Typr
       str[0..-num-1] + chars )
   end
 
-  # Strip ANSI escape sequences from +str+.
-  def printables str; str.gsub(/\x1b\[[^m]+m|/,'') end
+  # Strip ANSI escape sequences and control characters (except \n, \t)
+  # from shell-generated text, leaving only printable content.
+  def sanitize str
+    str.scrub
+       .gsub(/\e(?:\[[0-9;?]*[ -\/]*[@-~]|\][^\a\e]*(?:\a|\e\\)|[()=><0A])/, '')
+       .gsub(/[\x00-\x08\x0b-\x1f\x7f]/, '')
+  end
 
-  # Display width of +str+ after stripping ANSI escapes.
-  def real_size str; Unicode::DisplayWidth.of( printables(str) ) end
+  # Display width of +str+ after stripping ANSI escapes and control chars.
+  def real_size str; Unicode::DisplayWidth.of( sanitize(str) ) end
 
   # Coerce a string into Integer, Float, or Boolean when it matches those
   # forms (yes/no, true/false); otherwise return it unchanged.
@@ -196,11 +249,51 @@ module Typr
   ## Reads a single keypress in raw mode.
   #
   # Returns the key sequence as a String (e.g. "a" or "\e[A" for up-arrow),
-  # or nil when stdin is not a tty or input is unavailable.
+  # or a Typr::Mouse for a mouse report, or nil when stdin is not a tty or
+  # input is unavailable.
 
   def self.read_key
-    return INPUT.raw{ |tty| tty.sysread 6 } rescue nil unless INPUT.tty?
-    INPUT.raw{ |tty| tty.sysread 6 } rescue return
+    read = ->(tty) do
+      str = tty.sysread 6
+      if str.start_with?("\e[M") and str.size < 6
+        str << tty.sysread(6 - str.size) # X10 mouse reports
+      elsif str.start_with?("\e[")
+        # CSI sequences (arrows, SGR mouse, ...) end with a byte >= 0x40.
+        str << tty.sysread(1) until str[-1].ord >= 0x40
+      elsif str.start_with?("\eO") and str.size < 3
+        str << tty.sysread(3 - str.size) # SS3 (application) cursor keys
+      elsif str == "\e" and IO.select([tty], nil, nil, 0.03)
+        str << tty.read_nonblock(6) rescue nil # alt+key continuation
+      end
+      str
+    end
+    raw = (INPUT.raw{ |tty| read.call tty } rescue nil)
+    return unless raw
+    decode_mouse(raw) || raw
+  end
+
+  ## Decode a raw input string into a {Typr::Mouse} event, or nil when +raw+
+  # is not a mouse report. Handles both SGR (CSI < b ; x ; y M/m) and the
+  # legacy X10 (CSI M + three bytes) encodings.
+
+  def self.decode_mouse raw
+    if (m = raw.match(/\A\e\[<(\d+);(\d+);(\d+)([Mm])\z/))
+      code, x, y, final = m[1].to_i, m[2].to_i, m[3].to_i, m[4]
+    elsif raw.start_with?("\e[M")
+      code, x, y = raw.getbyte(3) - 32, raw.getbyte(4) - 32, raw.getbyte(5) - 32
+      final = code == 3 ? ?m : ?M
+    else
+      return nil
+    end
+    modifiers = code & 28
+    base = code & ~28
+    motion = (base & 32) != 0
+    wheel = base >= 64
+    button = wheel ? base - 64 + 4 : base & 3
+    action = if motion then :motion
+      elsif wheel then final == ?m ? :release : :press
+      else ( final == ?m or code == 3 ) ? :release : :press end
+    Mouse.new button, x, y, action, modifiers
   end
 
   ## Interactive line editor used for string prompts (search, %str, ...).
@@ -220,38 +313,44 @@ module Typr
   def self.read_line prompt='', left: 0, top: 0, initial: '', &block
     return $stdin.gets&.chomp unless $stdin.tty?
     query, cursor = initial.dup, initial.length
-    loop do
-      $>.print "\e[%i;%if" % [ top + 1, left + 1 ]
-      $>.print ERASE_LINE
-      $>.print prompt + query
-      $>.print "\e[%i;%if" % [ top + 1, left + 1 +
-        text_width( prompt + query[0...cursor] ) ]
-      key = read_key
-      return nil if key.nil? or key == KEY_ESCAPE
-      return query if key == KEY_RETURN or key == "\n"
-      case key
-        when KEY_LEFT, "\e[D";    cursor -= 1 if cursor > 0
-        when KEY_RIGHT, "\e[C";   cursor += 1 if cursor < query.length
-        when "\e[1;5D", "\eOd";   cursor = word_prev query, cursor
-        when "\e[1;5C", "\eOc";   cursor = word_next query, cursor
-        when KEY_HOME;            cursor = 0
-        when KEY_END;             cursor = query.length
-        when KEY_DC, "\e[3~";     query.slice!(cursor, 1) if cursor < query.length
-        when KEY_BACKSPACE, "\b"
-          if cursor > 0
-            query.slice!(cursor - 1, 1)
-            cursor -= 1
-          end
-        else
-          if key.is_a?(String) and key.each_char.all?{ |char| char.ord.between?(32, 126) }
-            query.insert(cursor, key)
-            cursor += key.length
-          end
+    $>.print CURSOR_NORMAL
+    begin
+      loop do
+        $>.print "\e[%i;%if" % [ top + 1, left + 1 ]
+        $>.print ERASE_LINE
+        before = text_width( prompt + query[0...cursor] )
+        offset = [ left + before - Typr.width, 0 ].max
+        $>.print slice_width( prompt + query, offset, Typr.width - left + 1 )
+        $>.print "\e[%i;%if" % [ top + 1, left + 1 + before - offset ]
+        key = read_key
+        return nil if key.nil? or key == KEY_ESCAPE
+        return query if key == KEY_RETURN or key == "\n"
+        case key
+          when KEY_LEFT, "\e[D";    cursor -= 1 if cursor > 0
+          when KEY_RIGHT, "\e[C";   cursor += 1 if cursor < query.length
+          when "\e[1;5D", "\eOd";   cursor = word_prev query, cursor
+          when "\e[1;5C", "\eOc";   cursor = word_next query, cursor
+          when KEY_HOME;            cursor = 0
+          when KEY_END;             cursor = query.length
+          when KEY_DC, "\e[3~";     query.slice!(cursor, 1) if cursor < query.length
+          when KEY_BACKSPACE, "\b"
+            if cursor > 0
+              query.slice!(cursor - 1, 1)
+              cursor -= 1
+            end
+          else
+            if key.is_a?(String) and key.each_char.all?{ |char| char.ord.between?(32, 126) }
+              query.insert(cursor, key)
+              cursor += key.length
+            end
+        end
+        cursor = 0 if cursor < 0
+        cursor = query.length if cursor > query.length
+        result = block.call( key, query, cursor ) if block
+        return result unless result.nil?
       end
-      cursor = 0 if cursor < 0
-      cursor = query.length if cursor > query.length
-      result = block.call( key, query, cursor ) if block
-      return result unless result.nil?
+    ensure
+      $>.print CURSOR_INVISIBLE
     end
   end
 
@@ -260,6 +359,28 @@ module Typr
     Unicode::DisplayWidth.of( str.gsub(/\x1b\[[^m]+m/, '') )
   end
 
+  # Visible substring of +str+ starting at display-width +offset+, at most
+  # +width+ cells wide. ANSI escapes are zero-width and carried through so
+  # color state applies inside the window.
+  def self.slice_width str, offset, width
+    vis = 0
+    slice = +""
+    i = 0
+    while i < str.length
+      if str[i] == "\e"
+        seq = str[i..][/\A\e(\[[0-9;?]*[ -\/]*[@-~]|\][^\a\e]*(?:\a|\e\\)|[()=>0-9])/]
+        slice << seq if seq
+        i += seq ? seq.length : 1
+        next
+      end
+      cell = Unicode::DisplayWidth.of(str[i])
+      vis += cell
+      slice << str[i] if vis > offset and vis <= offset + width
+      i += 1
+    end
+    slice
+  end
+
   # Move the cursor back to the start of the previous word in +str+.
   def self.word_prev str, cursor
     cursor -= 1 while cursor > 0 and str[cursor - 1] == ' '
@@ -303,21 +424,25 @@ module Typr
   def self.on_resize &block
     trap(:WINCH, &block)
   end
-  # Enter interactive mode: seed the default colors, hide the cursor and
-  # enable key-mode (application) escapes when stdin is a tty.
+  # Enter interactive mode: seed the default colors, hide the cursor, enable
+  # key-mode (application) escapes and mouse reporting when stdin is a tty.
   def self.init default=[ :white, :black  ]
     $default = default.dup
     $color = $default.dup
     if $stdin.tty?
       print CURSOR_INVISIBLE
-      system "tput smkx"
+      print KEYPAD_XMIT if defined?(KEYPAD_XMIT)
+      print MOUSE_ON
     end
   end
-  # Restore the terminal: show the cursor, reset colors and clear the screen.
+  # Restore the terminal: show the cursor, reset keypad/colors, disable mouse
+  # reporting and clear.
   def self.exit;
   extend self
     if $stdin.tty?
       $>.print CURSOR_NORMAL;
+      $>.print KEYPAD_LOCAL if defined?(KEYPAD_LOCAL)
+      $>.print MOUSE_OFF
       $>.print ORIG_COLORS; color; clear
     end
   end

data/lib/text.rb

@@ -191,6 +191,8 @@ module Typr
       self << @input
     end
 
+    # Reset state: +:search+ clears the pattern and highlights; +:all+ resets
+    # position, selection, and search; else falls through to {Stack#reset}.
     def reset type=:all
       case type
         when :search; highlight_clear
@@ -201,10 +203,13 @@ module Typr
 
     private
 
+    # Re-apply search for a live query (empty clears the highlights).
     def live_search query
       query.empty? ? highlight_clear : search(query)
     end
 
+    # Move to the next/previous match from the current position; returns the
+    # matched line id or nil when there are none.
     def step
       matches = @search[:matches]
       return nil if matches.empty?
@@ -221,6 +226,8 @@ module Typr
       return id
     end
 
+    # Interactive `/` prompt via Typr.read_line; Escape restores the previous
+    # search state, Enter searches (empty restores the last pattern).
     def search_prompt
       query = @search[:pattern].is_a?(String) ? @search[:pattern].dup : ''
       saved = { re: @re, pattern: @search[:pattern],

data/lib/typr.rb

@@ -1,7 +1,7 @@
 # typr is a Ruby library for building interactive terminal-based user interfaces.
 # It provides layout primitives, widgets, and event-driven interaction.
 #
-# == Widgets
+# == Classes
 #
 # * Typr::Grid   - Sortable, filterable table with formatted columns and row selection
 # * Typr::Text   - Scrollable text viewer with word/line picking and search
@@ -12,7 +12,7 @@
 #
 # == Terminal Control
 #
-#   Typr.init               # Initialize terminal (hide cursor, enable key mode)
+#   Typr.init               # Initialize terminal (hide cursor, enable key mode and mouse reporting)
 #   Typr.clear              # Clear entire screen
 #   Typr.clear :line        # Clear current line only
 #   key = Typr.read_key      # Read a single keypress
@@ -21,7 +21,7 @@
 #
 # == Layout Properties
 #
-# All widgets accept +left+, +top+, +right+, +bottom+ as:
+# All classes accept +left+, +top+, +right+, +bottom+ as:
 #   Integer  - absolute position
 #   Float    - fraction of terminal (0.0..1.0)
 #   Proc     - evaluated each layout pass