typr 1.1.2 → 1.2.0

data/lib/terminal.rb

@@ -1,285 +1,365 @@
-#!/usr/bin/ruby
-
 require 'io/console'
-require 'readline'
 require 'unicode/display_width'
 
-module Typr 
-#  alias :show :print
+## Terminal control: raw key input, line editing, cursor movement, ANSI colors
+# and terminal geometry. Widgets get the instance helpers via `include Typr`;
+# class-level helpers (Typr.width, Typr.read_key, ...) drive the whole screen.
+
+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
 
-  INPUT = (IO.new IO.sysopen "/dev/tty", "r")
-  `infocmp -L1`.split.each{ |info| key,value = info[0..-2].split("=") 
+  # KEY_* escape sequences come from the terminfo database (infocmp -L1).
+  `infocmp -L1`.split.each{ |info| key,value = info[0..-2].split("=")
     if value
-      # p key + value if key[/dis/]
-      # value[1] = ?e if value[0,2] == "\\E"
       value.gsub! '\E', '\e'
-      # value = '\x' + value[/\d+/].to_i(8).to_s(16).upcase if value[/\\\d+/]
-      # value = "\\x" + value[/\d+/].to_i(8).to_s(16).upcase if value[/\\\d+/]
       value += "\\" if value[-1] == "\\"
-      # eval "%s=\'%s\'" % [key.upcase,value] if key 
-      eval "%s=\"%s\"" % [key.upcase,value] if key 
-      #and key.start_with? "key_" 
+      eval "%s=\"%s\"" % [key.upcase,value] if key
     end }
-  
+
+  # Common key aliases and the line-erase escape sequence.
+  ERASE_LINE = "\e[K"
   KEY_ESCAPE = "\e"
   KEY_RETURN = CARRIAGE_RETURN
   KEY_TAB = "\t"
-  KEY_ENTER = CARRIAGE_RETURN
   KEY_PAGEDOWN = KEY_NPAGE
   KEY_PAGEUP = KEY_PPAGE
-  KEY_INSERT = KEY_IC
-  KEY_DELETE = KEY_DC
 
-  MODES =  %i[ reset bold faint italic underline slow fast invert ]
+  # 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 ]
+  COLOR_MAP = {
+    brown: 130, orange: 208, lime: 118, pink: 218,
+    maroon: 52, navy: 18, teal: 30, olive: 100,
+    coral: 203, tan: 180,
+    dark_red: 88, dark_green: 22, dark_yellow: 58,
+    dark_blue: 18, dark_magenta: 89, dark_cyan: 30
+  }
 
+  # Pad or clip +str+ to exactly +max+ cells, honoring +align+ (:left/:right),
+  # trimming from +side+, with an optional trailing +fade+.
   def prepare str, max, align=:left, side=:right, fade=false
     stop = width = real_size( str )
-    # unless str[0..max-1].ascii_only? and width == str.size
     unless str.ascii_only? and width == str.size
       stop = width = 0
       str.each_char do |c|
-        if c == ?\e 
+        if c == ?\e
           width -= str[stop..-1][/^\x1b\[[^m]+m|/].size-1
           stop += 1
         elsif (cwidth = (c.ascii_only? ? 1 : Unicode::DisplayWidth.of(c))) +
-          width >= max
+          width > max
           break
         else width += cwidth; stop += 1 end
-      end 
+      end
     end
-    # return 
-    if ( space = ( max - width ) ) > 0 #.clamp 0, max
+    if ( space = ( max - width ) ) > 0
       str = [ str[0..stop-1], " " * space ]
       str.reverse! if align == :right
       str.join
-    else #case align
-      # when :left; str = str[0..max-1]
-      # when :right; 
-      str = str[side == :left ? -max..-1 : 0..max-1]
-      # end
-      # str = fade str, align, str.length / 8 + 1 if fade
+    else
+      str = clip str, max, side
       str = fade str, side, fade if fade
       return str
     end
-    # return str.join
   end
-  
+
+  # Truncate +str+ to at most +max+ cells, keeping ANSI color tokens intact
+  # and clipping from +side+ (:left/:right).
+  def clip str, max, side
+    tokens = str.scan(/(\e\[[0-9;]*m)|([^\e]+)/).flatten.compact
+    tokens.reverse! if side == :left
+    kept, used = [], 0
+    tokens.each do |token|
+      if token[0] == ?\e
+        if side == :left
+          kept << token unless kept.empty?
+          break if used >= max
+        else
+          kept << token if used < max
+        end
+        next
+      end
+      break if used >= max
+      size = Unicode::DisplayWidth.of token
+      if used + size <= max
+        kept << token
+        used += size
+      elsif used < max
+        need = max - used
+        chars = token.chars
+        chars.reverse! if side == :left
+        width = 0
+        out = ""
+        chars.each do |char|
+          width += Unicode::DisplayWidth.of char
+          break if width > need
+          out << char
+        end
+        out.reverse! if side == :left
+        kept << out
+        used = max
+      end
+    end
+    kept.reverse!.join if side == :left
+    kept.join
+  end
+
+  # Blend the first (or last) +num+ characters of +str+ into greys to hint
+  # at clipping; +side+ selects which end fades.
   def fade str, side=:left, num=3
     isleft = side == :left
-    # chars = (side == ? 0..num : (-num-1..-2).to_a.reverse)
     chars = str[ isleft ? 0..num : -num..-1 ]
     chars = chars.chars.map.with_index do |char,id|
       id = chars.size-id unless isleft
       color_code( "grey#{(80/chars.size)*id+10}".to_sym ) + char
     end.join
-    # chars.each.with_index do |pos,id|
-    #   str.insert pos, color_code( "grey#{(80/chars.size)*id+10}".to_sym )
-      # str.insert pos, color_code( "grey#{(100/id+3)*10}".to_sym )
-    # end 
     return ( isleft ? chars + color_code($color[0]) + str[num+1..-1] :
       str[0..-num-1] + chars )
-
-      #+ color_code( $color[1] )
-    # return str
-    # length.times{|i| 
-    #   color [ ("grey"+((i+3)*10).to_s ).to_sym, @colors[:default][1] ]
-    #   show @directory[-space+i] }    
-    # color @colors[:default]
-    # show @directory[-space+6..-1] 
   end
-  # def printables str; str.dump.gsub(/\\e\[.+m|\"/, '') end
+
+  # Strip ANSI escape sequences from +str+.
   def printables str; str.gsub(/\x1b\[[^m]+m|/,'') end
-  # def real_size str; printables(str).size end
+
+  # Display width of +str+ after stripping ANSI escapes.
   def real_size str; Unicode::DisplayWidth.of( printables(str) ) end
-  
-    # $>.print "\e[%iJ" % %w[down line screen].index(mode.to_s) 
-  def move x=0,y=0; show move_code( x, y ) end	
+
+  # Coerce a string into Integer, Float, or Boolean when it matches those
+  # forms (yes/no, true/false); otherwise return it unchanged.
+  def coerce_type value
+    s = value.to_s
+    return nil if s.empty? or /\A(?:nil|NULL)\z/i.match(s)
+    case value
+       when /^-?[\d]+$/ then s.to_i
+       when /^-?\d*[\.\,]\d+$/ then s.to_f
+       when /\byes\z/i then true
+       when /\bno(ot)?\z/i then false
+       when /true\z/i then true
+       when /false\z/i then false
+       else value
+    end
+  end
+
+  # Move the cursor to column +x+, row +y+ (0-based); move_code returns the
+  # escape sequence without writing it.
+  def move x=0,y=0; draw move_code( x, y ) end
   def move_code x=0,y=0; "\e[%i;%if" % [ y+1, x+1 ] end
-  
-	def mode name; show mode_code(name) end
-	def mode_code name; if id = MODES.index(name.to_s) then "\e[#{ id }m" end end
-  
+
+  # Apply a text attribute (+mode+); mode_code returns the escape sequence
+  # without writing it.
+  def mode name; draw mode_code(name) end
+  def mode_code name; if id = MODES.index(name.to_s) then "\e[#{ id }m" end end
+
+  # Build the ANSI code for +color+ (a Symbol name, greyN, Integer palette id,
+  # or [r,g,b] / [fg,bg] Array), optionally as a background; when false the
+  # color is emitted as a foreground.
   def color_code color, bg=false
     color = color.to_sym if color.is_a? String
     case color
-      when Symbol; #color = color.to_s
+      when Symbol;
         if id = COLORS.index(color); "\e[#{ id + (bg ? 40 : 30) }m"
         elsif color[/^gr[ae]y\d{,2}$/]
           "\e[%i;5;%im" % [bg ? 48 : 38, 232 + (color[/\d+/].to_f/100*23).to_i]
+        elsif id = COLOR_MAP[color]
+          "\e[%i;5;%im" % [bg ? 48 : 38, id]
         end
       when Integer; "\e[%i;5;%im" % [ bg ? 48 : 38, color]
       when Array; case color.count
-        when 3; "\e[%i;2;%i;%i;%im" % [ bg ? 48 : 38, *color ] 
+        when 3; "\e[%i;2;%i;%i;%im" % [ bg ? 48 : 38, *color ]
         when 2; color_code( color[0] ) +  color_code( color[1], true )
       end
     end
   end
-	
-	def get_background; $color[1] end
+
+  # Read the current background/foreground color pair.
+  def get_background; $color[1] end
   def get_foreground; $color[0] end
-  def foreground c=$default[0]; $color[0]=c; show color_code(c) end
-  def background c=$default[1]; $color[1]=c; show color_code(c,true) end
-	# def color c=$default
- #    c = [c] unless c.is_a? Array and c.count == 2
- #    show color_code(c)
- #  end
+
+  # Set and apply the foreground/background color; +color+ sets both from a
+  # [fg, bg] pair, a single color, or the module default.
+  def foreground c=$default[0]; $color[0]=c; draw color_code(c) end
+  def background c=$default[1]; $color[1]=c; draw color_code(c,true) end
   def color c=$default
     c = [c] unless c.is_a? Array and c.count == 2
-    foreground c[0] if c[0] 
-    background c[1] if c[1] 
+    foreground c[0] if c[0]
+    background c[1] if c[1]
+  end
+
+  # Write raw +str+ to stdout.
+  def draw str; $>.print str end
+
+  # Clear the whole screen (:screen) or just the current line (:line).
+  def self.clear mode=:screen
+    $>.print( { screen: CLEAR_SCREEN, line: ERASE_LINE }[mode]  )
   end
 
-  def show str; $>.print str end
-  # def enable attr; mode attr end
-  # def disable attr=nil; mode :reset end
-  # def refresh; end
-  def self.clear mode=:screen 
-    $>.print( { screen: CLEAR_SCREEN, line: DELETE_LINE }[mode]  )
+  ## 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.
+
+  def self.read_key
+    return INPUT.raw{ |tty| tty.sysread 6 } rescue nil unless INPUT.tty?
+    INPUT.raw{ |tty| tty.sysread 6 } rescue return
   end
 
-  def self.read obj, prompt=''
-    case obj
-      when :key then INPUT.raw{ |tty| tty.sysread 6 } rescue return
-      when :line then line=Readline.readline prompt; print CURSOR_INVISIBLE;line
+  ## Interactive line editor used for string prompts (search, %str, ...).
+  #
+  # Renders +prompt+ and the query at (left, top) and edits it with
+  # arrow keys, ctrl-arrow word jumps, home/end, delete and backspace.
+  # Returns the query on enter, nil on escape. A block may inspect each
+  # keypress after it is applied; a non-nil return short-circuits the
+  # editor and becomes its return value. When stdin is not a tty, the
+  # query is read from a single line of piped input instead.
+  #
+  #   Typr.read_line "/" do |key, query, cursor|
+  #     filter query
+  #     nil
+  #   end
+
+  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
+      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
   end
 
+  # Display width of +str+ after stripping ANSI escapes.
+  def self.text_width str
+    Unicode::DisplayWidth.of( str.gsub(/\x1b\[[^m]+m/, '') )
+  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] == ' '
+    cursor -= 1 while cursor > 0 and str[cursor - 1] != ' '
+    cursor
+  end
+
+  # Move the cursor forward to the start of the next word in +str+.
+  def self.word_next str, cursor
+    cursor += 1 while cursor < str.length and str[cursor] == ' '
+    cursor += 1 while cursor < str.length and str[cursor] != ' '
+    cursor
+  end
+
+  # Query the terminal for the current [row, column] via DSR; [0, 0] when
+  # stdin is not a tty.
   def self.position
+    return [0, 0] unless $stdin.tty?
     result = ''
     $stdin.raw do |stdin|
-      $stdout << USER7 #"\e[6n"
+      $stdout << USER7
       $stdout.flush
       until (char = stdin.getc) == 'R'
         result << char if char
       end
     end
     result[/[\d;]+/].split(?;).map &:to_i
-    # m = res.match /(?<row>\d+);(?<column>\d+)/
-    # { row: Integer(m[:row]), column: Integer(m[:column]) }
   end
 
-  def self.size; IO.console.winsize end
+  # Terminal [rows, cols] (defaults to 24x80 when undetectable); width/height
+  # return the usable last column/row.
+  def self.size; IO.console&.winsize || [24, 80] end
   def self.width; size.last-1 end
-  def self.height; size.first end
+  def self.height; size.first - 1 end
+
+  # Current cursor row/column (see position).
   def self.row; position.first end
   def self.column; position.last end
-  def self.init default=[ :white, :black  ] 
-    $color = $default = default
-    # include Typr
-    # extend self
-    # Object.undef_method :read
-    print CURSOR_INVISIBLE
-    system "tput smkx"
+
+  # Call +block+ whenever the terminal is resized (SIGWINCH).
+  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.
+  def self.init default=[ :white, :black  ]
+    $default = default.dup
+    $color = $default.dup
+    if $stdin.tty?
+      print CURSOR_INVISIBLE
+      system "tput smkx"
+    end
   end
-  def self.exit; 
-	# background
+  # Restore the terminal: show the cursor, reset colors and clear the screen.
+  def self.exit;
   extend self
-  	
-  	$>.print CURSOR_NORMAL; 
-  	$>.print ORIG_COLORS; color; clear 
-  	
+    if $stdin.tty?
+      $>.print CURSOR_NORMAL;
+      $>.print ORIG_COLORS; color; clear
+    end
   end
 end
 
-# include Typr
-# extend Typr
-
 if __FILE__ == $0
 begin
   include Typr
-  Typr.init #background: :blue  
+  Typr.init
   colors = COLORS + (1..9).map{|i| "grey#{i*10}" }
   chars = (33..126).map(&:chr)
   slice = chars.count / colors.count + 1
   characters = chars.each_slice( slice ).map(&:join)
-  # key = read :key
   key,fg,bg = "",150,0
   Typr.clear
   loop do
-    # move 0,0
-    colors.each_with_index{ |color,y| 
-      characters.each_with_index{ |chars,x| 
-        foreground color.to_sym; 
-        background colors[x].to_sym; 
+    colors.each_with_index{ |color,y|
+      characters.each_with_index{ |chars,x|
+        foreground color.to_sym;
+        background colors[x].to_sym;
         move x*slice,y
-        show chars 
+        draw chars
       }
     }
-    (0...256).each{ |i| background i; show ' ' }
-    
-    move 0, Typr.height-1
+    (0...256).each{ |i| background i; draw ' ' }
+
+    move 0, Typr.height
     color [:white, :black]
-    # show "KEY: #{key}"
     p "KEY: %s / %s" % [key, key]
-    move 15, Typr.height-1
+    move 15, Typr.height
     color [fg,bg]
-    print "     %s / %s     " % [fg,bg] #).center 20
-    key = Typr.read(:key)
+    print "     %s / %s     " % [fg,bg]
+    key = Typr.read_key
     case key
       when KEY_UP; fg+=1
       when KEY_DOWN; fg-=1
       when KEY_LEFT; bg-=1
       when KEY_RIGHT; bg+=1
-      when KEY_ESCAPE; exit 
+      when KEY_ESCAPE; exit
     end
   end
 ensure
   Typr.exit
 end
 end
-
-
-#  KEY_ESC = 27
-#  KEY_TAB = 
-#  KEY_ESC = 27
-  # A_STANDOUT = :invert
-  # BG = :black      
-  # `infocmp -L`.read.join.split(', ').each{ |info| }
-  # .split('=').to_h
- 
-#   KEY_PAGEDOWN = "\e[6~"
-#   KEY_PAGEUP = "\e[5~"
-#   KEY_LEFT = "\e[D" 
-#   KEY_RIGHT = "\e[C"
-#   KEY_UP = "\e[A"
-#   KEY_DOWN = "\e[B"
-#   KEY_HOME = "\e[H" #xterm
-#   KEY_END = "\e[F" #xterm
-#   INSERT = "\e[2~" #xterm
-#   DELETE = "\e[3~" #xterm
-#   KEY_BACKSPACE = "\b" #xterm
-
-#    case ENV["TERM"]
-#      when 
-#    DELETE = "\e[P" #st
-#    INSERT = "\e[4h" #st
-#    BACKSPACE = "\x7F" #st 
-#    KEY_END = "\e[4~" #st
-
-#    KEY_HOME = "\e[7~" #urxvt
-#    KEY_END = "\e[8~" #urxvt
-
- 	# HIDE_CURSOR = "\e[?25l"
-	# SHOW_CURSOR = "\e[?25h"
-  # HEIGHT,WIDTH = IO.console.winsize
-
-
-  # def mod key,char,extra; 
-    # if key.length == 1; key = char + key.upcase
-    # elsif key[/~$/]; key[0..-2] + char
-    # else key[0..-2] + extra + key[-1].downcase end 
-  # end
-#    def shift key; mod key, "$" end
-  # def ctrl key; mod key, "^", "O" end
-  # def alt key; KEYMAP[:esc] + key end
-#    def clear mode=2; IO.console.erase_screen 1 end
-  #  def mode name; "\e[%im" % [(MODES.index name.to_s)] end
-  	# def ansi arg, type, inc=0
-  	#   case arg
-   #  	  when Integer; show "\e[%i;5;%im" % [ inc + 8, arg] 
-   #  	  else show "\e[%im" % [ ( type.index arg.to_s ) + inc ] 
-   #  	end
-   #  end 
-  
-