typr 1.1.0

data/lib/space.rb

@@ -0,0 +1,85 @@
+require_relative 'terminal.rb'
+
+module Typr
+
+##
+# Base layout class for all TUI widgets. Defines a viewport rectangle and border drawing.
+#
+# Boundaries accept integers (absolute), floats (0..1 fraction of terminal), Procs, or
+# negative ints (offset from opposite edge: -1 = last row/column).
+#
+# @example
+#   box = Space.new(left: 0, top: 2, right: 0.5, bottom: -4, border: :round)
+#   box.draw
+
+class Space
+include Typr
+
+%w[left top right bottom].each{ |name| method = <<STR
+  def %s_setting; @%s; end  
+  def %s
+    max=Typr.#{ name[/left|right/] ? 'width' : 'height' }
+    if !@%s;[max, #{name=='right' ? 'left+@max' :
+      'top+rows-1+headspace'}].min
+    elsif @%s.is_a? Proc; @%s.call
+    elsif @%s.is_a? Float; (max * @%s).round
+    elsif @%s.negative?; max+@%s+1
+    else @%s end
+  end
+STR
+eval( method % ([name]*11) ) }
+
+  attr_writer :left, :top, :right, :bottom
+  attr_accessor :margin, :colors, :interval, :borders
+
+  def width; right - left + 1 end
+  def height; bottom - top + 1 end
+
+  def start; @updater = Thread.new{ loop{draw; sleep @interval }} end
+  def stop; @updater.terminate end
+
+  def draw_border x,y,char
+    show move_code(x, y) + char unless not char or
+      x < 0 or x > Typr.width or y < 0 or y > Typr.height
+  end
+
+  def draw
+    return if @borders.empty?
+    color @colors[:border]
+    draw_border(left - 1, top - 1, @borders[:top_left])
+    draw_border(left, top - 1, @borders[:top] * width) if @borders[:top]
+    draw_border(right + 1, top - 1, @borders[:top_right])
+    (height+1).times do |pos|
+      draw_border(left - 1, top + pos, @borders[:left] )
+      draw_border(right + 1, top + pos, @borders[:right] )
+    end
+    draw_border(left - 1, bottom + 1, @borders[:bottom_left] )
+    draw_border(left, bottom + 1, @borders[:bottom] * width ) if @borders[:bottom]
+    draw_border(right + 1, bottom + 1, @borders[:bottom_right])
+  end
+
+  def border=(border)
+    chars = case border
+      when Symbol
+        { light: '──││┌┐└┘', heavy: '━━┃┃┏┓┗┛', double: '══║║╔╗╚╝',
+          round: '──││╭╮╰╯' }[border]
+      when String; if border.size == 1 then border * 8 else border.chars end
+      when nil; [nil] * 8
+    end
+    @borders = %w[top bottom left right top_left top_right bottom_left
+      bottom_right ].map.with_index{ |part,id| [part.to_sym, chars[id]] }.to_h if chars
+  end
+
+  def initialize args={}
+    @max, @keymap, @colors, @margin = 0, {}, {}, ' '
+    @left, @top, @interval, @borders = 0, 0, 1, {}
+  	args.each{ |name, value|
+      instance_variable_set ?@ + name.to_s, value }
+    @keymap = { exit: KEY_ESCAPE }.merge @keymap
+    @colors = { default: [:white, :black], border: [:white, :black] }.merge(@colors)
+    borders = @borders.dup
+    self.border = @border
+    @borders.merge! borders
+  end
+end
+end

data/lib/stack.rb

@@ -0,0 +1,278 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# frozen_string_literal: true
+
+module Typr
+
+  ##
+  # A vertically scrollable list of items displayed one per row or column.
+  #
+  # Provides paging, keyboard navigation, key-hint overlays, and alternating
+  # row colors. Subclasses Grid, Text, and Browser add domain-specific
+  # rendering on top of this foundation.
+  #
+  # == Key bindings (overridable via +keymap+):
+  #
+  #   KEY_TAB    -> cycle       (advance hint numbering to the next chunk)
+  #   KEY_RETURN -> confirm     (returns currently selected items, or nil)
+  #   KEY_ESCAPE -> exit        (abort selection and return nil)
+  #   KEY_UP / KEY_DOWN            (step by one row in the given direction)
+  #   KEY_PAGEUP / KEY_PAGEDOWN  (jump by one viewport height)
+  #   KEY_HOME / KEY_END           (jump to first or last pageable row)
+
+  class Stack < Space
+    ## Widget configuration. +left+, +top+, +right+, +bottom+ set the viewport; see {Space}.
+    ## +alternate+ toggles striped rows (+:grey10+ background alternating with the default bg).
+
+    attr_accessor :start, :keymap, :selected, :header
+    attr_accessor :separator, :hints, :hints_start
+
+    ##
+    # Returns a +Range+ of internal data indices visible on the current page.
+    #
+    #   stack.page   #=> 0..14
+
+    def page; @start..(@start + height - 1) end
+
+    ##
+    # The number of rows reserved for a header bar within the widget's footprint.
+    #
+    #   stack.headspace   #=> 1  (if header is set)
+    #   stack.headspace   #=> 0  (if no header)
+
+    def headspace; @header ? 1 : 0 end
+
+    ##
+    # The usable height after subtracting any header space.
+    #
+    #   stack.height   #=> 14
+
+    def height; super - headspace end
+
+    ##
+    # Placeholder renderer used when no subclass overrides +print+ for an item id.
+    #
+    #   stack.print 42   # renders a blank row
+
+    def print id; show " " * (width-@margin.size) end
+
+    ##
+    # Resets widget state by one or more categories.
+    #
+    #   stack.reset              # resets position and selection
+    #   stack.reset :position    # only scrolls back to top
+    #   stack.reset :selection   # clears all selected rows/columns/fields
+    #   stack.reset [:display, :format]
+
+    def reset type=:all
+      case type
+        when Array; type.each{ |type| reset type }
+        when :position; @start = @hints_start = 0
+        when :selection; @selected = @selected.keys.map{ |type| [ type, [] ] }.to_h
+        when :all; reset [ :position, :selection ]
+      end
+    end
+
+    ##
+    # Renders the numeric key-hint overlay for items in the current page.
+    #
+    #   stack.draw_hints            # vertical hints along left margin
+    #   stack.draw_hints :column, 2 # horizontal hints across columns of row 2
+
+    def draw_hints type=nil, row_id=0
+      color @colors[ :hints ]
+      if type.to_s[ /column/ ]
+        positions( row_id )[ @hints_start..-1 ].each_with_index{ |pos, idx|
+          move( left + pos, top + row_id )
+          show @hints[idx] }
+      else @hints.chars.each_with_index{ |char, idx|
+        pos = idx + @hints_start + headspace
+        break if pos > [height, rows-1+headspace].min
+        move( left, top + pos )
+        show char }
+      end
+    end
+
+    ##
+    # Renders the full widget: header bar (if present), all visible items with background
+    # coloring and alternating stripes, a selected-item highlight, and bottom borders.
+    #
+    # This method is called by your application's main loop each frame; it does not handle
+    # events itself (see {#send}).
+
+    def draw
+      if @header
+        color @colors[ :header ]
+        move left,top
+        show @margin
+        print :header
+      end
+      list = page.to_a
+      list[ height-1 ] = nil if list.length < height
+      for id, relative_id in list.each_with_index
+      	move left,top + relative_id + headspace
+        foreground ( @colors[:rows][id] || @colors[:default][0] )
+        select = @selected[ :rows ].include?( id )
+        dark=!dark if @alternate
+        background ( select ? @colors[:selected] :
+          (@alternate and dark) ? @colors[:alternate] : @colors[:default][1] )
+        show @margin
+        print id
+        background if select
+      end
+      background
+      super
+    end
+
+    ##
+    # Dispatches a key from the terminal to its semantic action and clamps the current page
+    # offset.
+    #
+    #   stack.send Typr::KEY_UP      # scrolls up one row
+    #   stack.send Typr::KEY_RETURN   # confirms selection
+
+    def send key#, map=nil
+      response = eval @keymap.invert[key].to_s if @keymap.values.include? key
+      @start = rows - height if @start > rows - height
+      @start = 0 if @start < 0
+      return response
+    end
+
+    ## Scroll to the top of the dataset.
+    #
+    #   stack.to_top
+
+    def to_top; @start = 0; return end
+
+    ## Scroll to the bottom pageable position (last row minus viewport height).
+    #
+    #   stack.to_bottom
+
+    def to_bottom; @start = rows - height; return end
+
+    ## Step down by one row.
+    #
+    #   stack.down
+
+    def down; @start += 1; return end
+
+    ## Step up by one row.
+    #
+    #   stack.up
+
+    def up; @start -= 1; return end
+
+    ## Jump down by one viewport of rows.
+    #
+    #   stack.page_down
+
+    def page_down; @start += height; return end
+
+    ## Jump up by one viewport of rows.
+    #
+    #   stack.page_up
+
+    def page_up; @start -= height; return end
+
+    ##
+    # Blocks the calling thread and lets the user interactively pick items from the current
+    # page using hint characters or arrow keys. After selection, the user must press Return to
+    # confirm (or Escape to abort).
+    #
+    # The +type+ argument controls what kind of picker is shown:
+    #
+    #   Symbol/String type           | Purpose
+    #   -----------------------------|-------------------------------------------
+    #   +:row, +"file"+              | Pick a single row id
+    #   +"rows"+                     | Multi-select rows
+    #   +:column, +"field"+          | Nested: pick a row then a column
+    #   +:fields+                    | Multi-select fields
+    #   +:none+                      | Navigation-only mode
+    #   anything with +relative_|    | Returns the internal integer index
+    #
+    #   stack.pick                # single row picker
+    #   stack.pick :column, 3     # pick a column in row 3
+    #   stack.pick "rows"         # multi-select rows
+
+    def pick type = :row, row=0 #, key=nil
+      @hints_start = 0
+      type = type.to_s
+      multiple = type[-1] == ?s
+      loop do
+        if type['field']
+          row = pick( :row ) or return
+          column = pick( :column, page.to_a.index( row  + headspace)) or return
+          value = [ row , column ]
+        else
+          draw
+          draw_hints type, row unless type['none']
+          limit = type['row'] ? height : positions(row).count
+          key = Typr.read :key
+          if key.is_a?(String) and value =
+            @hints[0..limit-@hints_start-1].index(key)
+            value += @hints_start
+            relative = value + @start if type['relative_']
+            if type['row'] then value = page.to_a[ value ]
+            elsif type['column'] and @sequence; value = @sequence[value] end
+          end unless type['none']
+        end
+
+        if value
+          type = type[9..-1] if type['relative_']
+          type += ?s unless multiple
+          type = type.to_sym
+          if @selected[type].include? value
+            @selected[type].delete value
+          else @selected[type] << value end if multiple
+          return relative || value unless multiple
+        else
+          case key
+            when @keymap[:exit]; return
+            when @keymap[:confirm]; return @selected[type]
+            else send key #if type['id']
+          end
+        end
+      end
+    end
+
+    ##
+    # Advance the numeric hints by one full set of hint characters so that newly-fitted
+    # items beyond the first viewport also get labeled numbers.
+    #
+    #   stack.cycle   # hints now start at index 10 (or wrap back to 0)
+
+    def cycle
+      @hints_start += @hints.size
+      @hints_start = 0 if @hints_start > [height-1, rows-1+headspace].min
+      return
+    end
+
+    ##
+    # Constructs a Stack widget.
+    #
+    # All positional and visual parameters from {Space#initialize} are available. Additionally:
+    #
+    #   Option          | Default | Description
+    #   ----------------|---------|-------------------------------------------
+    #   +keysyms+       | {}      | Custom key-to-method mappings
+    #   +hints+         | +"1234..."+ | Characters used in the hint overlay
+    #   +alternate+     | true    | Striped row backgrounds
+    #   +header+        | nil     | Label shown in a header bar
+    #   +separator+     | +" "+   | String drawn between columns (used by Grid)
+
+    def initialize args={}
+      @keymap, @separator, @selected = {}, " ", {}
+      @start, @hints_start, @highlight = 0, 0, 0#A_STANDOUT
+      @alternate = true
+      super #args
+      @colors = { hints: [255, :black ], header: [232,:grey60 ],
+        selected: :grey25, alternate: :grey10, rows: {} }.merge @colors
+      @selected = { fields:[], columns:[], rows:[] }.merge @selected
+      @keymap = { cycle: KEY_TAB, confirm: KEY_RETURN, exit: KEY_ESCAPE,
+        page_down: KEY_PAGEDOWN, page_up: KEY_PAGEUP, up: KEY_UP,
+        down: KEY_DOWN, to_top: KEY_HOME, to_bottom: KEY_END }.merge @keymap
+      @hints ||= "1234567890qwertyuiopasdfghjklzxcvbnm-=[];'\,./"
+    end
+  end
+
+end

data/lib/terminal.rb

@@ -0,0 +1,286 @@
+#!/usr/bin/ruby
+
+require 'io/console'
+require 'readline'
+require 'unicode/display_width'
+
+module Typr 
+#  alias :show :print
+
+  INPUT = (IO.new IO.sysopen "/dev/tty", "r")
+  OUTPUT = (IO.new IO.sysopen "/dev/stdin", "w")
+  `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_" 
+    end }
+  
+  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 ]
+  COLORS = %i[ black red green yellow blue magenta cyan white ]
+
+  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 
+          width -= str[stop..-1][/^\x1b\[[^m]+m|/].size-1
+          stop += 1
+        elsif (cwidth = (c.ascii_only? ? 1 : Unicode::DisplayWidth.of(c))) +
+          width >= max
+          break
+        else width += cwidth; stop += 1 end
+      end 
+    end
+    # return 
+    if ( space = ( max - width ) ) > 0 #.clamp 0, max
+      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
+      str = fade str, side, fade if fade
+      return str
+    end
+    # return str.join
+  end
+  
+  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
+  def printables str; str.gsub(/\x1b\[[^m]+m|/,'') end
+  # def real_size str; printables(str).size end
+  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	
+  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
+  
+  def color_code color, bg=false
+    color = color.to_sym if color.is_a? String
+    case color
+      when Symbol; #color = color.to_s
+        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]
+        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 2; color_code( color[0] ) +  color_code( color[1], true )
+      end
+    end
+  end
+	
+	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
+  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] 
+  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]  )
+  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
+    end
+  end
+
+  def self.position
+    result = ''
+    $stdin.raw do |stdin|
+      $stdout << USER7 #"\e[6n"
+      $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
+  def self.width; size.last-1 end
+  def self.height; size.first end
+  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"
+  end
+  def self.exit; 
+	# background
+  extend self
+  	
+  	$>.print CURSOR_NORMAL; 
+  	$>.print ORIG_COLORS; color; clear 
+  	
+  end
+end
+
+# include Typr
+# extend Typr
+
+if __FILE__ == $0
+begin
+  include Typr
+  Typr.init #background: :blue  
+  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; 
+        move x*slice,y
+        show chars 
+      }
+    }
+    (0...256).each{ |i| background i; show ' ' }
+    
+    move 0, Typr.height-1
+    color [:white, :black]
+    # show "KEY: #{key}"
+    p "KEY: %s / %s" % [key, key]
+    move 15, Typr.height-1
+    color [fg,bg]
+    print "     %s / %s     " % [fg,bg] #).center 20
+    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 
+    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 
+  
+