ncumbra 0.1.0 → 0.1.1

data/lib/umbra/table.rb

@@ -0,0 +1,260 @@
+# ----------------------------------------------------------------------------- #
+#         File: table.rb
+#  Description: widget for tabular data
+#       Author: j kepler  http://github.com/mare-imbrium/umbra/
+#         Date: 2018-05-06 - 09:56
+#      License: MIT
+#  Last update: 2018-05-22 14:46
+# ----------------------------------------------------------------------------- #
+#  table.rb  Copyright (C) 2018 j kepler
+
+##--------- Todo section ---------------
+## DONE w - next column, b - previous column
+## TODO paint lines as column separators. issue is panning.
+## TODO starting visual column (required when scrolling)
+## DONE change a value value_at(x,y, value) ; << ; delete_at 
+## TODO change column width interactively, hide column , move column
+## TODO maybe even column_color(n, color_pair, attr)
+## TODO sort on column/s.
+## TODO selection will have to be added. maybe we should have extended listbox after all. Or made multiline selectable.
+## DONE how to format the header
+## DONE formatting rows
+## DONE if we want to color specific columns based on values then I think we have to format (render) the row at the last 
+##      moment in print_row and not in advance
+## NOTE: we are setting the data in tabular, not list. So calling list() will give nil until a render has happened.
+##     callers will have to use data() instead of list() which is not consistent.
+## NOTE: current_index in this object refers to index including header and separator. It is not the offset in the data array.
+##    For that we need to adjust with @data_offset.
+#
+require 'forwardable'
+require 'umbra/tabular'
+require 'umbra/multiline'
+
+module Umbra
+  ##
+  ## A table of columnar data.
+  ## This uses Tabular as a table model and extends Multiline.
+  #
+  class Table < Multiline
+
+    extend Forwardable
+
+
+    ## tabular is the data model for Table.
+    ## It may be passed in in the constructor, or else is created when columns and data are passed in.
+    attr_accessor :tabular
+
+    ## color pair and attribute for header row
+    attr_accessor :header_color_pair, :header_attr
+
+    attr_accessor :rendered                 ## boolean, if data has changed, we need to re-render
+
+
+    ## Create a Table object passing either a Tabular object or columns and list
+    ## e.g. Table.new tabular: tabular
+    ##      Table.new columns: cols, list: mylist
+    ##
+    def initialize config={}, &block
+      if config.key? :tabular
+        @tabular = config.delete(:tabular)
+      else
+        cols = config.delete(:columns)
+        data = config.delete(:list)
+        @tabular = Tabular.new cols
+        if data
+          @tabular.data = data
+        end
+      end
+      @rendered = nil
+      super
+
+      bind_key(?w, "next column") { self.next_column }
+      bind_key(?b, "prev column") { self.prev_column }
+      bind_key(KEY_RETURN, :fire_action_event)
+      ## NOTE: a tabular object should be existing at this point.
+    end
+
+    ## returns the raw data as array of arrays in tabular
+    def data
+      @tabular.list
+    end
+
+
+    def data=(list)
+      @rendered = false
+      @tabular.data = list
+      @repaint_required = true
+      self.focusable = true
+      @pstart = @current_index = 0
+      @pcol               = 0
+      #$log.debug "  before table data= CHANGED "
+      #fire_handler(:CHANGED, self)    ## added 2018-05-08 - 
+    end
+
+    ## render the two-dimensional array of data as an array of Strings.
+    ## Calculates data_offset which is the row offset from which data starts.
+    def render
+      @data_offset = 0
+      @data_offset +=1 if @tabular.use_separator
+      @data_offset +=1 if @tabular.columns
+      self.list = @tabular.render
+    end
+
+    ## paint the table
+    def repaint
+      render if !@rendered
+      super
+
+      @rendered = true
+    end
+
+    ## Specify how to print the header and separator.
+    ## index can be 0 or 1
+    ## returns an array of color_pair and attribute
+    def color_of_header_row index, state
+        arr =  [ @header_color_pair || CP_MAGENTA, @header_attr || REVERSE ] 
+        return arr if index == 0
+        [ arr[0], NORMAL ]
+    end
+
+    ## Specify how the data rows are to be coloured.
+    ## Override this to have customised row coloring.
+    ## @return array of color_pair and attrib.
+    def color_of_data_row index, state, data_index
+      color_of_row(index, state)         ## calling superclass here
+    end
+
+    ## Print the row which could be header or data
+    ## @param index [Integer] - index of list, starting with header and separator
+    def print_row(win, row, col, str, index, state)
+      if index <= @data_offset - 1
+        _print_headings(win, row, col, str, index, state)
+      else
+        data_index = index - @data_offset  ## index into actual data object
+        _print_data(win, row, col, str, index, state, data_index)
+      end
+    end
+
+    ## Print the header row
+    ## index [Integer] - should be 0 or 1 (1 for optional separator)
+    def _print_headings(win, row, col, str, index, state)
+      arr = color_of_header_row(index, state)
+      win.printstring(row, col, str, arr[0], arr[1])
+    end
+
+
+
+    ## Print the data.
+    ## index is index into visual row, starting 0 for headings, and 1 for separator
+    ## data_index is index into actual data object. Use this if checking actual data array
+    def _print_data(win, row, col, str, index, state, data_index)
+      data_index = index - @data_offset  ## index into actual data object
+      arr = color_of_data_row(index, state, data_index)
+
+      win.printstring(row, col, str, arr[0], arr[1])
+    end
+    def color_of_column ix, value, defaultcolor
+      raise "unused yet"
+    end
+
+
+
+    def row_count
+      @tabular.list.size
+    end
+
+
+    ## return rowid (assumed to be first column)
+    def current_id
+      data = current_row_as_array()
+      return nil unless data
+      data.first
+    end
+    # How do I deal with separators and headers here - return nil
+    ## This returns all columns including hidden so rowid can be accessed
+    def current_row_as_array
+      data_index = @current_index - @data_offset  ## index into actual data object
+      return nil if data_index < 0                ## separator and heading
+      data()[data_index]
+    end
+
+    ## returns the current row as a hash with column name as key.
+    def current_row_as_hash
+      data = current_row_as_array
+      return nil unless data
+      columns = @tabular.columns
+      hash = columns.zip(data).to_h
+    end
+
+    ## Move cursor to next column
+    def next_column
+      @coffsets = @tabular._calculate_column_offsets unless @coffsets
+      #c = @column_pointer.next
+      current_column = current_column_offset() +1
+      if current_column > @tabular.column_count-1
+        current_column = 0
+      end
+      cp = @coffsets[current_column] 
+      @curpos = cp if cp
+      $log.debug " next_column #{@coffsets} :::: #{cp}, curpos=#{@curpos} "
+      set_col_offset @curpos
+      #down() if c < @column_pointer.last_index
+      #fire_column_event :ENTER_COLUMN
+    end
+
+    ## Move cursor to previous column
+    def prev_column
+      @coffsets = @tabular._calculate_column_offsets unless @coffsets
+      #c = @column_pointer.next
+      current_column = current_column_offset() -1
+      if current_column < 0 # 
+        current_column = @tabular.column_count-1
+      end
+      cp = @coffsets[current_column] 
+      @curpos = cp if cp
+      $log.debug " next_column #{@coffsets} :::: #{cp}, curpos=#{@curpos} "
+      set_col_offset @curpos
+      #down() if c < @column_pointer.last_index
+      #fire_column_event :ENTER_COLUMN
+    end
+
+    # Convert current cursor position to a table column
+    # calculate column based on curpos since user may not have
+    # used w and b keys (:next_column)
+    # @return [Integer] column index base 0
+    def current_column_offset
+      _calculate_column_offsets unless @coffsets
+      x = 0
+      @coffsets.each_with_index { |i, ix| 
+        if @curpos < i 
+          break
+        else 
+          x += 1
+        end
+      }
+      x -= 1 # since we start offsets with 0, so first auto becoming 1
+      return x
+    end
+
+    def header_row?
+      @current_index == 0 and @data_offset > 0
+    end
+
+    ## Handle case where ENTER/RETURN pressed on header row (so sorting can be done).
+    def fire_action_event
+      if header_row?
+        # TODO sorting here
+        $log.debug "  PRESSED ENTER on header row, TODO sorting here"
+      end
+      super
+    end
+
+    ## delegate calls to the tabular object
+    def_delegators :@tabular, :headings=, :columns= , :add, :add_row, :<< , :column_width, :column_align, :column_hide, :convert_value_to_text, :separator, :to_string, :x=, :y=, :column_unhide
+    def_delegators :@tabular, :columns , :numbering
+    def_delegators :@tabular, :column_hidden, :delete_at, :value_at
+
+  end # class 
+end # module
+
+#  vim:  comments=sr\:##,mb\:##,el\:#/,\:## :

data/lib/umbra/tabular.rb

@@ -0,0 +1,431 @@
+#!/usr/bin/env ruby -w
+=begin
+  * Name          : A Quick take on tabular data. Readonly.
+  * Description   : To show tabular data inside a control, rather than going by the huge
+                    Table object, I want to create a simple, minimal table data generator.
+                    This will be thrown into a TextView for the user to navigate, select
+                    etc.
+                    I would use this applications where the tabular data is fairly fixed
+                    not where i want the user to select columns, move them, expand etc.
+  *               :
+  * Author        : jkepler
+  * Date          : 
+  * Last Update   : 2018-05-20 14:24
+  * License       : MIT
+=end
+
+## Todo Section --------------
+## What if user wishes to supply formatstring and override ours
+## ---------------------------
+
+
+# A simple tabular data generator. Given table data in arrays and a column heading row in arrays, it 
+# quickely generates tabular data. It only takes left and right alignment of columns into account.
+#   You may specify individual column widths. Else it will take the widths of the column names you supply 
+# in the startup array. You are encouraged to supply column widths.
+#   If no columns are specified, and no widths are given, it take the widths of the first row 
+# as a model to determine column widths. 
+#
+module Umbra
+
+  class Tabular
+    GUESSCOLUMNS = 30
+
+    def yield_or_eval &block
+      return unless block
+      if block.arity > 0
+        yield self
+      else
+        self.instance_eval(&block)
+      end
+    end
+
+
+    ## stores column info internally: name, width and alignment
+    class ColumnInfo < Struct.new(:name, :width, :index, :offset, :align, :hidden) 
+    end
+
+
+
+
+    ## an array of column titles
+    attr_reader :columns
+
+    ## data which is array of arrays: rows and columns
+    attr_reader :list
+
+    # boolean, does user want lines numbered
+    attr_accessor :numbering
+
+    attr_accessor :use_separator          ## boolean. Use a separator line after heading or not.
+
+    # x is the + character used a field delim in separators
+    # y is the field delim used in data rows, default is pipe or bar
+    attr_accessor :x, :y
+
+    # takes first optional argument as array of column names
+    # second optional argument as array of data arrays
+    # @yield self
+    #
+    def initialize cols=nil, *args, &block
+      @chash             = []                 # hash of column info, not used
+      @_skip_columns     = {}                 # internal, which columns not to calc width of since user has specified
+      @separ = @columns = @numbering =  nil
+      @y = '|'
+      @x = '+'
+      @use_separator = false
+      @_hidden_columns_flag = false
+      self.columns = cols if cols
+      if !args.empty?
+        self.data = args
+      end
+      yield_or_eval(&block) if block_given?
+    end
+    #
+    # set columns names .
+    ## NOTE that we are not clearing chash here. In case, someone changes table and columns.
+    # @param [Array<String>] column names, preferably padded out to width for column
+    def columns=(array)
+      #$log.debug "tabular got columns #{array.count} #{array.inspect} " if $log
+      @columns = array
+      @columns.each_with_index { |e,i| 
+        #@chash[i] = ColumnInfo.new(c, c.to_s.length) 
+        c = get_column(i)
+        c.name = e
+        c.width = e.to_s.length
+        #@chash[i] = c
+        #@cw[i] ||= c.to_s.length
+        #@calign[i] ||= :left # 2011-09-27 prevent setting later on
+      }
+    end
+    alias :headings= :columns=
+    #
+    # set data as an array of arrays
+    # @param [Array<Array>] data as array of arrays
+    def data=(list)
+      #puts "got data: #{list.size} " if !$log
+      #puts list if !$log
+      @list = list
+    end
+
+    # add a row of data 
+    # @param [Array] an array containing entries for each column
+    def add array
+      #$log.debug "tabular got add  #{array.count} #{array.inspect} " if $log
+      @list ||= []
+      @list << array
+    end
+    alias :<< :add
+    alias :add_row :add
+
+    # retrieve the column info structure for the given offset. The offset
+    # pertains to the visible offset not actual offset in data model. 
+    # These two differ when we move a column.
+    # @return ColumnInfo object containing width align color bgcolor attrib hidden
+    def get_column index
+      return @chash[index] if @chash[index]
+      # create a new entry since none present
+      c = ColumnInfo.new
+      c.index = index
+      @chash[index] = c
+      return c
+    end
+    # set width of a given column, any data beyond this will be truncated at display time.
+    # @param [Number] column offset, starting 0
+    # @param [Number] width
+    def column_width colindex, width=:NONE
+      if width == :NONE
+        #return @cw[colindex]
+        return get_column(colindex).width
+      end
+      @_skip_columns[colindex] = true   ## don't calculate col width for this.
+      get_column(colindex).width = width
+      self
+    end
+
+    def column_hidden colindex, flag=:NONE
+      if flag == :NONE
+        return get_column(colindex).hidden
+        #return @chide[colindex]
+      end
+      @_hidden_columns_flag = true if flag
+      #@chide[colindex] = flag
+      get_column(colindex).hidden = flag
+      self
+    end
+
+    # set alignment of given column offset
+    # @param [Number] column offset, starting 0
+    # @param [Symbol] :left, :right
+    def column_align colindex, lrc=:NONE
+      if lrc == :NONE
+        return get_column(colindex).align
+        #return @calign[colindex]
+      end
+      raise ArgumentError, "wrong alignment value sent" if ![:right, :left, :center].include? lrc
+      get_column(colindex).align = lrc
+      self
+    end
+
+    ## return an array of visible columns names
+    def visible_column_names
+      visible = []
+      @chash.each_with_index do |c, ix|
+        if !c.hidden
+          if block_given?
+            yield c.name, ix 
+          else
+            visible << c.name
+          end
+        end
+      end
+      return visible unless block_given?
+    end
+
+    ## returns the count of visible columns based on column names.
+    ## NOTE: what if no column names gives ???
+    def column_count
+      visible_column_names().count
+    end
+
+    # yields non-hidden columns (ColumnInfo) and the offset/index
+    # This is the order in which columns are to be printed
+    def each_column
+      @chash.each_with_index { |c, i| 
+        next if c.hidden
+        yield c,i if block_given?
+      }
+    end
+
+    ## for the given row, return visible columns as an array
+    ## @yield column and index
+    def visible_columns(row)
+      visible = []
+      row.each_with_index do |e, ix|
+        hid = @chash[ix].hidden
+        if !hid
+          if block_given?
+            yield e, ix
+          else
+            visible << e 
+          end
+        end
+      end
+      return visible if !block_given?
+    end
+
+    # 
+    # Now returns an array with formatted data
+    # @return [Array<String>] array of formatted data
+    def render
+      raise "tabular:: list is nil " unless @list
+      $log.debug "  render list:: #{@list.size} "
+      #$log.debug "  render list:1: #{@list} "
+      raise "tabular:: columns is nil " unless @columns
+      buffer = []
+      @separ = nil
+      _guess_col_widths
+      rows = @list.size.to_s.length
+      #@rows = rows
+      fmstr = _prepare_format
+      $log.debug "tabular: fmstr:: #{fmstr}"
+      $log.debug "tabular: cols: #{@columns}"
+      #$log.debug "tabular: data: #{@list}"
+
+      str = ""
+      if @numbering
+        str = " "*(rows+1)+@y
+      end
+      #str <<  fmstr % visible_column_names()
+      str <<  convert_heading_to_text(visible_column_names(), fmstr)
+      buffer << str
+      #puts "-" * str.length
+      buffer << separator if @use_separator
+      if @list    ## XXX why wasn't this done in _prepare_format ???? FIXME
+        if @numbering
+          fmstr = "%#{rows}d "+ @y + fmstr
+        end
+        #@list.each { |e| puts e.join(@y) }
+        count = 0
+        @list.each_with_index { |r,i|  
+          if r == :separator
+            buffer << separator
+            next
+          end
+          if @_hidden_columns_flag
+            r = visible_columns(r)
+          end
+          if @numbering
+            r.insert 0, count+1
+          end
+          #value = convert_value_to_text r, count
+          value = convert_value_to_text r, fmstr, i
+          buffer << value
+          count += 1
+        }
+      end
+      buffer
+    end
+
+    ## render_row
+    def convert_value_to_text r, fmstr, index
+      return fmstr % r;  
+    end
+    def convert_heading_to_text r, fmstr
+      return fmstr % r;  
+    end
+    # use this for printing out on terminal
+    # NOTE: Do not name this to_s as it will print the entire content in many places in debug statements
+    # @example
+    #     puts t.to_s
+    def to_string
+      render().join "\n"
+    end
+
+    def value_at x,y, value=:NONE
+      if value == :NONE
+        return @list[x, y]
+      end
+      @list[x, y] = value
+    end
+    def delete_at ix
+      return unless @list
+      raise ArgumentError, "Argument must be within 0 and #{@list.length}" if ix < 0 or ix >=  @list.length 
+      #fire_dimension_changed
+      #@list.delete_at(ix + @_header_adjustment)
+      @list.delete_at(ix)
+    end
+
+
+
+
+    def add_separator
+      @list << :separator
+    end
+
+    ## This refers to a separator line after the heading  and not a field separator.
+    ## Badly named !
+    def separator
+      return @separ if @separ
+      str = ""
+      if @numbering
+        str = "-"*(rows+1)+@x
+      end
+      each_column { | c, ix|
+        v = c.width
+        next if v == 0     ## hidden column
+        str << "-" * (v+1) + @x 
+      }
+      @separ = str.chop
+    end
+
+    ## This calculates and stores the offset at which each column starts.
+    ## Used when going to next column or doing a find for a string in the table.
+    def _calculate_column_offsets
+      total = 0
+      coffsets = []
+      ctr = 0
+      ## ix will have gaps in between for hidden fields
+      each_column { | c, ix|
+        v = c.width
+        coffsets[ctr] = total
+        ctr += 1
+        total += v + 2                         ## blank space plus separator
+      }
+      return coffsets
+    end
+
+
+    private
+    def _guess_col_widths  #:nodoc:
+      @list.each_with_index { |r, i| 
+        break if i > GUESSCOLUMNS
+        next if r == :separator
+        r.each_with_index { |c, j|
+          ## we need to skip those columns which user has specified
+          next if @_skip_columns[j] == true
+          #next if @chide[j]
+          next if @chash[j].hidden
+          x = c.to_s.length
+          w = @chash[j].width
+          if !w
+            @chash[j].width = x
+          else
+            @chash[j].width = x if x > w
+          end
+        }
+      }
+    end
+
+    ## prepare formatstring.
+    ## NOTE: this is not the final value.
+    ## render adds numbering to this, if user has set numbering option.!!!!
+    def _prepare_format  #:nodoc:
+      fmstr = nil
+      fmt = []
+      each_column { |c, i|
+        ## trying a zero for hidden columns
+        ## worked but an extra space is added below and the sep
+        w = c.width
+        case c.align
+        when :right
+          #fmt << "%.#{w}s "
+          fmt << "%#{w}.#{w}s "
+        else
+          fmt << "%-#{w}.#{w}s "
+        end
+      }
+      ## the next line will put a separator after hidden columns also
+      fmstr = fmt.join(@y)
+      #puts "format: #{fmstr} " # 2011-12-09 23:09:57
+      return fmstr
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  include Umbra
+  $log = nil
+  t = Tabular.new(['a', 'b'], [1, 2], [3, 4])
+  puts t.to_string
+  puts 
+  t = Tabular.new([" Name ", " Number ", "  Email    "])
+  t.add %w{ rahul 32 r@ruby.org }
+  t << %w{ _why 133 j@gnu.org }
+  t << %w{ Jane 1331 jane@gnu.org }
+  t.column_width 1, 10
+  t.column_align 1, :right
+  puts t.to_string
+  puts
+
+  s = Tabular.new do |b|
+    b.columns = %w{ country continent text }
+    b << ["india","asia","a warm country" ] 
+    b << ["japan","asia","a cool country" ] 
+    b << ["russia","europe","a hot country" ] 
+    b.column_width 2, 30
+  end
+  puts s.to_string
+  puts
+  puts "::::"
+  puts
+  s = Tabular.new do |b|
+    b.columns = %w{ place continent text }
+    b << ["india","asia","a warm country" ] 
+    b << ["japan","asia","a cool country" ] 
+    b << ["russia","europe","a hot country" ] 
+    b << ["sydney","australia","a dry country" ] 
+    b << ["canberra","australia","a dry country" ] 
+    b << ["ross island","antarctica","a dry country" ] 
+    b << ["mount terror","antarctica","a windy country" ] 
+    b << ["mt erebus","antarctica","a cold place" ] 
+    b << ["siberia","russia","an icy city" ] 
+    b << ["new york","USA","a fun place" ] 
+    b.column_width 0, 12
+    b.column_width 1, 12
+    b.numbering = true
+  end
+  puts s.to_string
+end
+
+#  vim:  comments=sr\:##,mb\:##,el\:#/,\:## :