typr 1.1.0

data/lib/graphical.rb

@@ -0,0 +1,174 @@
+#!/usr/bin/ruby
+require 'sdl2'
+#require 'io/console'
+#require 'readline'
+require_relative 'frontend'
+  
+module Visuals
+  include SDL2
+
+public 
+  i=-1
+#  SDL2.init(SDL2::INIT_EVERYTHING)
+  SDL2.init(SDL2::INIT_VIDEO)
+  TTF.init
+  WINDOW = Window.create("visuals", 
+    Window::POS_CENTERED, #POS_UNDEFINED,
+    Window::POS_CENTERED, #POS_UNDEFINED,
+    1324, 768, 0)
+  GO = WINDOW.create_renderer(-1, 
+    Renderer::Flags::ACCELERATED|Renderer::Flags::TARGETTEXTURE)
+  Key.constants.each{ |c| c = c.to_s
+    eval 'KEY_'+c.upcase+'=Key::'+c }
+
+  def self.width;  WINDOW.size[0] / $charsize[1] end
+  def self.height; WINDOW.size[1] / $charsize[0] end
+  def self.row; $row end
+  def self.column; $col end
+  def self.x; $x end
+  def self.y; $y end
+  
+  
+  def color_for c
+    return unless c
+    c = COLORS[c] if c.is_a?( Symbol )
+    c.map{ |c| (c/1000.0*256).to_i }
+  end
+
+  def get_background; $color[1] end
+  def get_foreground; $color[0] end
+  def background color; return unless color
+    $color[1] = color_for( color ) end
+  def foreground color; 
+    $color[0] = (color ? color_for( color ) : $default[0]) end
+
+  def color c 
+    c = [c] unless c.is_a? Array and c.count == 2 #.flatten
+    foreground c[0]
+    background c[1]
+#    $letters[c] = (32.upto 126).map{ |n| n = n.chr
+#      [n, $font.render_blended( n, c )] }.to_h unless $letters[c]
+  end
+
+  def move col, row
+    $x = ($col = col) * $charsize[1] #width
+    $y = ($row = row) * $charsize[0] #$height 
+  end
+
+  def clear type = :screen #bg=
+    GO.draw_color = $default[1] #bg
+    case type 
+#      when Array; GO.fill_rect Rect.new() 
+      when :screen; GO.fill_rect Rect.new(0, 0, *WINDOW.size) 
+      when :line; GO.fill_rect Rect.new(
+        Visuals.x, Visuals.y, WINDOW.size[0], Visuals.y+$charsize[0])
+      when :down; GO.fill_rect Rect.new(
+        0, Visuals.y, *WINDOW.size)
+    end
+  end
+   
+  def show( str ) #solid_blended_shaded(
+    return unless str
+#    chars = str.chars.map{ |char| $letters[foreground][char] }
+#    width = chars.map( &:w ).sum 
+#    if $color[1] != $default[1] #get_background
+    if get_background
+      GO.draw_color = get_background
+      GO.fill_rect Rect.new($x, $y, str.size*$charsize[1], $charsize[0]) 
+    end
+#    GO.fill_rect Rect.new($x, $y, width, $charsize[0]) 
+#    text = Surface.new( width, $charsize[0], 32, 0, 0, 0, 0 )
+#    x=0
+#    for char in chars #.each{|c| 
+#      Surface.blit char, nil, text, Rect.new( x, 0, char.w, char.h )
+#      x += char.w
+#    end
+#    GO.copy GO.create_texture_from(text),nil,Rect.new($x, $y, width, $charsize[0])
+    text = str.rstrip
+    unless text.empty?
+      image = $font.render_blended( text, get_foreground )
+      GO.copy GO.create_texture_from( image ), nil,
+        Rect.new($x, $y, image.w, $charsize[0]) 
+    end 
+    move $col+str.size, $row
+  end
+
+  def refresh; GO.present end
+
+  def read input 
+    case input
+      when :event then e = Event.poll until e
+      when :key then 
+        e = Event.poll until e.is_a? Event::KeyDown
+        return e.sym.between?(32, 126) ? e.sym.chr : e.sym 
+      when :line#; line = ''              
+#        File.mkfifo( 'input' ) unless File.exist? 'input'
+#        Readline.output=input=open('input')
+#        Readline.output=input=StringIO.new
+#        fork{ Readline.readline }
+        x, y = Visuals.row, Visuals.column
+        listen = Thread.new{ 
+#          until (char = input.read) == $/
+#          until (line = Readline.line_buffer)[-1] == $/
+          loop do
+            move x, y
+            show line
+            sleep 0.1 
+          end        
+        } 
+        line = Readline.readline 
+        listen.terminate
+#        until input.string[-1]==$/
+        return line
+#        until (key = read :key) == KEY_RETURN
+#          str << key if key.is_a? String
+#        end
+#
+#        text = ""
+#        TextInput.start
+#        loop do
+##          ev = Event.poll
+#          case ev = read( :event )
+#            when Event::KeyDown
+#              if ev.sym == KEY_RETURN
+#                TextInput.stop
+#                return text 
+#              end
+#            when Event::TextInput 
+#              text += ev.text 
+#              show ev.text
+#              p ev.text
+#          end
+#        end
+    end
+  end
+
+  def self.exit
+  end
+
+  def self.init args={} 
+    $default = [ 
+      color_for( args[:foreground] || :grey80 ), 
+      color_for( args[:background] || :grey10 ) ]
+    $color = $default.dup
+    $charsize = args[:charsize] || [18,11]
+    $font = TTF.open( args[:font] || "/usr/share/fonts/X11/TTF/VeraMono.ttf", $charsize[0] )
+    move 0, 0
+  end
+  
+end
+
+if __FILE__ == $0
+#  require_relative 'base'
+  include Visuals
+  Visuals.init font:ARGV[0] #[[200,200,200],[20,20,20]], [80,50]
+  characters = (32..126).map(&:chr).join
+  loop do
+    clear
+    COLORS.keys.each_with_index{ |c,i| 
+      foreground c; move 0,i; show characters }
+    refresh
+#    GO.present
+    exit if read(:key) == KEY_ESCAPE
+  end
+end

data/lib/grid.rb

@@ -0,0 +1,431 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative 'space.rb'
+
+module Typr
+
+  ##
+  # A sortable, filterable, multi-column table widget.
+  #
+  #   grid = Typr::Grid.new(
+  #     input:  [ ["Alice", 30], ["Bob", 25] ],
+  #     header: [:name, :age],
+  #     format: [:max, :right]
+  #   )
+  #   grid.draw
+  #
+  # Column format tokens: +Integer+ (fixed width), +:min+ (auto), +:max+ (fill remaining).
+  #
+  # Built-in procs: +:filetree+, +:datetime+, +:magnitudes+, +:convert+.
+
+  class Grid < Stack # Table
+    attr_accessor :format, :procs, :filters, :data, :map
+    attr_accessor :align, :rawsort, :rawfilter
+    attr_writer :sequence
+
+    ##
+    # Number of rows currently visible (filtered count, or total).
+    #
+    #   grid.rows  #=> 2
+    #
+    # @return [Integer]
+
+    def rows; (@map || @data || [] ).count end
+
+    ##
+    # Row identifiers: Hash keys or integer range.
+    #
+    #   grid.ids  #=> [0, 1]
+    #
+    # @return [Array<Object>]
+
+    def ids; @map || ( is_hash? ?
+      @data.keys : (@data||[]).count.times.to_a ) end
+
+    ##
+    # Row ids visible on the current page after filtering.
+    #
+    #   grid.page  #=> [0, 1]
+    #
+    # @return [Array<Object>]
+
+    def page; ids[ super ] end
+
+    ##
+    # Column render order. Defaults to 0..n-1; override with +sequence=+.
+    #
+    #   grid.sequence  #=> [0, 1, 2]
+    #
+    # @return [Array<Integer>]
+
+    def sequence; @sequence || @columns.times.to_a end
+
+    ##
+    # Total number of data columns.
+    #
+    #   grid.columns  #=> 3
+    #
+    # @return [Integer]
+
+    def columns; @sequence ? @sequence.count : @columns end
+
+    ##
+    # True if data is a Hash.
+    #
+    #   grid.is_hash?  #=> false
+    #
+    # @return [Boolean]
+
+    def is_hash?; @data.is_a? Hash end
+
+    ##
+    # Retrieve a row by id.
+    #
+    #   grid[0]  #=> ["Alice", 30, "engineer"]
+    #
+    # @return [Array, nil]
+
+    def []( id ); @data[id] end
+
+    ##
+    # Set a row by id. Auto-detects numeric types and alignment.
+    #
+    #   grid[2] = ["Charlie", 35, "manager"]
+    #   grid[:charlie] = [35, "manager"]  # Hash-backed
+    #
+    # @param id [Integer, Object] row key
+    # @param row [Object, Array] field values
+
+    def []=( id,row )
+      @data ||= id.is_a?(Integer) ? [] : {}
+      row = [row] unless row.is_a? Array
+      row = [id] + row if is_hash?
+      row.flatten! if is_hash?
+      @data[id] = row.map.with_index{ |field, column|
+        if column == @columns
+          @colors[:columns][column] ||= [:grey90,:grey60][column%2]
+          @format[column] ||= :min
+          @columns += 1
+        end
+        field = @functions[ :convert ].call field unless @ignore[column]
+        @align[column] ||= [Integer,Float].include?(field.class) ?
+          :right : :left
+        field
+      }
+      process id
+      filter id
+    end
+
+    ##
+    # Set column headers. Symbols are auto-defined as +UPCASE_I+ constants.
+    #
+    #   grid.header = [:name, :age]
+    #   # defines NAME_0 = "name", AGE_1 = "age"
+    #
+    # @param h [Array<String, Symbol>]
+
+    def header=( h ); super
+      h.each_with_index{ |h,i| Typr.module_eval h.upcase+?=+i.to_s } if
+        h.is_a? Array
+    end
+
+    ##
+    # Reset grid state.
+    #
+    #   grid.reset :all       # everything
+    #   grid.reset :display   # filters, sort, map
+    #   grid.reset :format    # widths, maxed
+    #
+    # @param type [:all, :display, :format, Array<Symbol>]
+
+    def reset type=:all
+      case type
+        when :display; @map = nil; @sort = nil; @filters.clear
+        when :format; @widths.clear; @maxed = false
+        when :all; reset [:display, :format]
+      end
+      super
+    end
+
+    ##
+    # Clear all data, columns, and transforms.
+    #
+    #   grid.clear
+    #
+    # @return [void]
+
+    def clear
+      @columns = 0; @layer = @map = @data = nil
+      reset [:format, :positions, :selection]
+    end
+
+    ##
+    # Apply column processors to a row's cells, storing results in +@layer+.
+    #
+    #   grid.process(0)
+    #
+    # @param row [Integer] row id
+
+    def process row #=:all
+      @layer ||= @data.class.new
+      return if @procs.empty?
+      @layer[row] = @procs.map{ |col,proc|
+        proc = @functions[proc] if proc.is_a? Symbol
+        cell = @data[row][col]
+        next unless cell
+        [ col, proc.lambda? ? proc.call( cell ) : proc.call( cell, row, col ) ] unless
+          cell.is_a?(Proc) }.to_h
+    end
+
+    ##
+    # Add a column filter (substring or regex).
+    #
+    #   grid.add_filter(0, "Ali")    # name contains "Ali"
+    #   grid.add_filter(1, /^\d{2}$/) # age matches regex
+    #
+    # @param column [Integer, Symbol]
+    # @param query [String, Regexp]
+
+    def add_filter column=nil, query=nil
+      return unless column and query
+      @filters << [column, query]
+      filter :all
+      return
+    end
+
+    ##
+    # Test whether a row passes all active filters.
+    #
+    #   grid.check(0)  #=> true
+    #
+    # @param row [Integer]
+    # @return [Boolean]
+
+    def check row
+      @filters.reject{ |column,query|
+        ( (@procs[column] and not @rawfilter[column]) ?
+          @layer : @data )[row][column].to_s[query] }.empty?
+    end
+
+    ##
+    # Apply or revise filters. +:all+ recomputes the full map; a row id adds/removes it.
+    #
+    #   grid.filter :all
+    #   grid.filter 0
+    #
+    # @param row [Integer, Symbol]
+
+    def filter row=:all
+      return if @filters.empty?
+      if row == :all
+        @map = ids.select{ |id| check id }
+        @start = 0
+      elsif check row then
+        @map ||= []
+        @map << row unless @map.include? row
+      else @map.delete(row) if @map end
+    end
+
+    ##
+    # Current sort column name (when called with arg) or index (without).
+    #
+    #   grid.sort_by :age
+    #   grid.sorted_by       #=> "age"
+    #   grid.sorted_by true  #=> "age"
+    #
+    # @param name [Boolean] pass truthy to get display name
+    # @return [String, Integer, false, nil]
+
+    def sorted_by name=false; (name and @sort) ? @header[@sort] : @sort end
+
+    ##
+    # Sort by column (toggle direction on repeat).
+    #
+    #   grid.sort_by :age
+    #   grid.sort_by :age  # reverses
+    #
+    # @param column [Integer, Symbol]
+
+    def sort_by column
+      column = @header.index( column.to_s ) if column.is_a? Symbol
+      if @sort and (column == @sort) then @reverse = !@reverse
+      else @sort = column end
+      sort
+    end
+
+    ##
+    # Execute the sort and update +@map+.
+    #
+    # @return [false, void]
+
+    def sort
+      return false unless @sort
+      data = (@procs[@sort] and not @rawsort[@sort]) ? @layer : @data
+      @map = ids.sort{ |a,b| (data[a][@sort] <=> data[b][@sort]) || 0 }
+      @map.reverse! if @reverse
+      return
+    end
+
+    ##
+    # Pixel width for a single visual column (includes +:max+ bonus).
+    #
+    #   grid.width_for(0)  #=> 12
+    #
+    # @param col [Integer] visual column index
+    # @return [Integer]
+
+    def width_for col
+      @widths[col] + ( @format[sequence[col]] == :max ? @rest : 0 )
+    end
+
+    ##
+    # X-offset for each visual column on a row.
+    #
+    #   grid.positions  #=> [0, 13, 25]
+    #
+    # @param row [Integer]
+    # @return [Array<Integer>]
+
+    def positions row=0; x=0
+      [0] + (sequence.count-1).times.map{ |id|
+        x += width_for(id) + @separator.size }
+    end
+
+    ##
+    # Compute column widths from visible data and render the grid.
+    #
+    #   grid.draw
+    #
+    # @return [void]
+
+    def draw
+      if not @data or @data.empty? or ( @map and @map.empty? )
+        @widths = [ width/columns ] * columns if @widths.count < columns
+        @rest = 0
+        return super
+      end
+      for row in page.compact
+        fields = @data[row].dup
+        fields = [ fields ] unless fields.is_a?(Array)
+        for col,id in sequence.each_with_index
+          field = fields[col]
+          if field.is_a? Proc
+            field = field.call
+            field = @procs[col].call field,row,col if @procs[col]
+            @layer[row] ||= {}
+            @layer[row][col] = field
+          end
+          field = @layer[row][col] if @procs[col]
+          if @format[col].is_a? Integer
+            @widths[id] ||= @format[col]
+          else
+            @widths[id] ||= 0
+            size = real_size( field.to_s )
+            @widths[id] = size if size > @widths[id]
+          end
+        end
+      end
+      gaps = @margin.size + @separator.size * (columns - 1)
+      sum = @widths.sum
+      @max = sum + gaps - 1
+      space = width - gaps
+      if (extra = sum - space  ) > 0
+        extra.times{ |i| @widths[ @widths.index(@widths.max) ] -= 1 }
+        @rest = 0
+      else
+        format = @format.values_at( *sequence )
+        @rest = space - sum / format.count(:max) if format.include? :max
+      end
+      super
+    end
+
+    ##
+    # Render a single row or the header bar to the terminal.
+    #
+    #   grid.print :header
+    #   grid.print 0
+    #
+    # @param row [Integer, Symbol] row id, or +:header+
+
+    def print row=nil
+      return super unless row
+      header = ( row == :header )
+      return show @header[0..width-1].ljust(width) if
+        header and @header.is_a? String
+      fields = (header ? @header : @data[row] ).dup
+      @layer[row].each{ |col,value| fields[col] = value } if
+        @layer[row] if @layer unless header
+  	    for col,id in sequence.each_with_index
+        show @separator unless id == 0
+        select = ( @selected[:columns].include? col or
+          @selected[:fields].include? [row,col] ) unless
+            @selected[:rows].include?(row) or header
+        color( @colors[:fields][[row,col]] ||
+          @colors[:columns][col] || @colors[:default] ) unless header
+        background @colors[:selected] if select
+        show prepare( fields[col].to_s, width_for( id ), @align[col] )
+        background @colors[:default][1] if select
+      end
+    end
+
+    ##
+    # Append multiple rows at once. Returns +self+ for chaining.
+    #
+    #   grid << [["Dave", 28], ["Eve", 32]]
+    #   grid << { alice: [30, "eng"] }
+    #
+    # @param data [Enumerable<Array>, Enumerable<Hash>]
+    # @return [self]
+
+    def << (data)
+      @data ||= data.class.new
+      skip = @data.size
+      data.each_with_index{ |row, id|
+        self[ is_hash? ? row.shift : id + skip ] = row }
+      sort
+    end
+
+    ##
+    # Construct a Grid.
+    #
+    #   grid = Typr::Grid.new(
+    #     input:  [ ["Alice", 30], ["Bob", 25] ],
+    #     header: [:name, :age],
+    #     format: [:max, :min],
+    #     procs:  { 1 => :magnitudes },
+    #     colors: { columns: [:cyan, nil] }
+    #   )
+    #
+    # @param args [Hash] +input+, +header+, +format+, +procs+, +colors+, +align+, +functions+
+
+    def initialize args={}
+      @columns,@functions = 0,{}
+      @ignore,@rawfilter,@rawsort,@reverse = [],[],[],false
+      @filters,@procs = [],{}
+      @align,@format,@widths,@totals = [],[],[],[]
+      super #args
+      @colors = { columns: [], fields: {} }.merge ( @colors  )
+      @selected = { fields:[], columns:[] }.merge @selected
+      @functions = {
+        filetree: Proc.new{ |f| f.gsub /.*\/[^$]/, ' ' },
+        datetime: Proc.new{|sec|Time.at(sec).strftime"%y-%m-%d %H:%M" rescue ??},
+        magnitudes: Proc.new{ |size| mag = (size.to_s.length-1) / 3
+          mag>0 ? (size.to_s.insert -(mag*3+1), ?.)[0..4] + %w[B K M G T][mag] :
+          size rescue size },
+        convert:  Proc.new{ |value|
+          case value.to_s
+            when /^[\d]+$/ then value.to_s.to_i
+            when /^\d*[\.\,]\d+$/ then value.to_s.to_f
+            else value
+          end } }
+
+      if @input
+        self << @input
+        @input = nil
+      end
+    end
+  end
+
+end

data/lib/line.rb

@@ -0,0 +1,99 @@
+require_relative 'space'
+
+module Typr
+
+# A single-line UI element for displaying text and collecting input.
+#
+# == Example
+#
+#   line = Line.new( top: 5, left: 10, width: 40 )
+#   line.draw "Hello world"
+#   line.append " more"
+#   line.ask([ ["Name?", :string], ["Age?", :integer] ])
+
+class Line < Space
+  attr_accessor :default, :prompt, :bindings, :data
+
+  # Render +msg+ (String, Proc, or Space) on this line.
+  #
+  #   line.draw "status: ok"
+  #   line.draw Proc.new { show_time }
+
+  def draw msg=@data
+    @data = msg
+    move left, top
+    color @colors[:default]
+    case msg
+      when Proc; msg.call
+      when Space; msg.draw
+      when String; show( prepare msg, width )
+    end
+  end
+
+  # Append +str+ to the current content and redraw.
+  #
+  #   line.draw "hello"
+  #   line.append " world"   #=> "hello world"
+  #   line << "!"            #=> "hello world!"
+
+  def append(str); draw @data+str end
+  alias :<< :append
+
+  # Display keybinding help in a floating grid.
+  #
+  #   line.bindings = ["Ctrl-S: Save", "Ctrl-Q: Quit"]
+  #   line.help
+
+  def help conf={}
+    Grid.new( { input: ['']+@bindings+[''], top: 3, left:0.4,
+      header: "KEYBINDINGS",
+      colors: { header: [:white,:black], border:[:white,:grey10] },
+      alternate: false, border: ' ' }.merge conf ).pick :none
+    return
+  end
+
+  # Reset the line to its default text or prompt.
+  #
+  #   line.reset
+
+  def reset; draw( @default || ( @bindings || [@prompt] ).join(' ') ) end
+
+  # Prompt the user with a sequence of questions.
+  # +sentence+ is an array of [question, type] pairs.
+  # Returns a single answer or an array when multiple questions.
+  #
+  #   line.ask([ ["Name?", :string] ])             #=> "Alice"
+  #   line.ask([ ["Name?", :string], ["Ok?", ["y","n"]] ])  #=> ["Alice", "y"]
+
+  def ask sentence
+    answer = []
+    move left, top
+    Typr.clear :line
+    draw @prompt
+    for question, object in sentence
+      color( @colors[:question] )
+      append " " + question.to_s + " "
+      column = Typr.column
+      color( @colors[:answer] )
+      case object
+        when Array then answer << object.first.pick( object.last )
+        else answer << Typr.read( object, @data )
+      end
+      return if !answer.last or answer.last == @keymap[:exit]
+      move column, top
+      append answer.last.to_s
+    end
+    return ( answer.one? ? answer.first : answer )
+  end
+
+  def initialize args
+    @right= -1
+    @prompt = ?>
+    super
+    @bottom = @top
+    @colors = { question: :green, answer: :yellow }.merge @colors
+    reset
+  end
+end
+
+end