ncumbra 0.1.0

data/lib/umbra/widget.rb

@@ -0,0 +1,220 @@
+##
+# Basic widget class superclass. Anything embedded in a form should
+# extend this, if it wants to be repainted or wants focus. Otherwise.
+# form will be unaware of it.
+# 2018-03-08 - 
+#require 'umbra/form'    # for EventHandler !!!
+require 'umbra/eventhandler'         # for register_events and fire_handler etc
+require 'umbra/keymappinghandler'    # for bind_key and process_key
+
+module Umbra
+class FieldValidationException < RuntimeError
+end
+class Widget   
+    include EventHandler
+    include KeyMappingHandler
+  # common interface for text related to a field, label, textview, button etc
+  attr_accessor :text, :width, :height
+
+  # foreground and background colors when focussed. Currently used with buttons and field
+  # Form checks and repaints on entry if these are set.
+  attr_accessor :highlight_color_pair
+  attr_accessor :highlight_attr
+
+  # NOTE: 2018-03-04 - user will have to call repaint_required if he changes color or coordinates.
+  attr_accessor  :row, :col                   # location of object
+  #attr_writer :color, :bgcolor               # normal foreground and background 2018-03-08 - now color_pair
+  # moved to a method which calculates color 2011-11-12 
+  attr_accessor  :color_pair                  # instead of colors give just color_pair
+  attr_accessor  :attr                        # attribute bold, normal, reverse
+  attr_accessor  :name                        # name to refr to or recall object by_name
+  attr_accessor :curpos                       # cursor position inside object - column, not row.
+  attr_reader  :config                        # can be used for popping user objects too
+  #attr_accessor  :form                       # made accessor 2008-11-27 22:32 so menu can set
+  attr_accessor  :graphic                     # window which should be set by form when adding 2018-03-19
+  attr_accessor :state                        # normal, selected, highlighted
+  attr_reader  :row_offset, :col_offset       # where should the cursor be placed to start with
+  attr_accessor  :visible                     # boolean     # 2008-12-09 11:29 
+  # if changing focusable property of a field after form creation, you may need to call
+  # pack again, or atl east update_focusables
+  attr_reader   :focusable                   # boolean     can this get focus # 2018-03-21 - 23:13 
+  # 2018-03-04 - we should use modified as accessor unless it is due to setting forms modified
+  # 2018-03-22 - making it accessor
+  attr_accessor :modified                     # boolean, value modified or not (moved from field 2009-01-18 00:14 )
+  #attr_accessor  :help_text                   # added 2009-01-22 17:41 can be used for status/tooltips
+
+  #attr_accessor :parent_component  # added 2010-01-12 23:28 BUFFERED - to bubble up
+
+  # NOTE state takes care of this and is set by form. boolean
+  attr_reader :focussed                    # is this widget in focus, so they may paint differently
+
+  # height percent and width percent used in stacks and flows.
+  #attr_accessor :height_pc, :width_pc        # may bring this back
+
+  # descriptions for each key set in _key_map
+  # 2018-03-07 - NOT_SURE
+  attr_reader :key_label
+  attr_reader :handler                       # event handler
+  # adding as attr_accessor  2018-03-22 - 
+  # is a repaint required or not, boolean
+  attr_accessor  :repaint_required
+
+  def initialize aconfig={}, &block
+    @row_offset ||= 0
+    @col_offset ||= 0
+    @state = :NORMAL
+
+    @handler = nil # we can avoid firing if nil
+    # These are standard events for most widgets which will be fired by 
+    # Form. In the case of CHANGED, form fires if it's editable property is set, so
+    # it does not apply to all widgets.
+    # 2018-03-18 - proporty change is deprecated since we don't use dsl_property any longer
+    register_events( [:ENTER, :LEAVE, :CHANGED, :PROPERTY_CHANGE])
+    @repaint_required = true # added 2018-03-20 - so all widgets get it
+
+    aconfig.each_pair { |k,v| variable_set(k,v) }
+    #instance_eval &block if block_given?
+    if block_given?
+      if block.arity > 0
+        yield self
+      else
+        self.instance_eval(&block)
+      end
+    end
+  end
+
+  def variable_set var, val
+    send("#{var}=", val) 
+  end
+  def init_vars
+    # just in case anyone does a super. Not putting anything here
+    # since i don't want anyone accidentally overriding
+  end
+
+  # modified
+  ##
+  # typically read will be overridden to check if value changed from what it was on enter.
+  # getter and setter for modified (added 2009-01-18 12:31 )
+  def modified?
+    @modified
+  end
+  #def set_modified tf=true
+    #@modified = tf
+  #end
+  #alias :modified :set_modified
+
+  # triggered whenever a widget is entered.
+  # TODO should we not fix cursor at this point ?
+  def on_enter
+    @state = :HIGHLIGHTED    # duplicating since often these are inside containers
+    @focussed = true
+    if @handler && @handler.has_key?(:ENTER)
+      fire_handler :ENTER, self
+    end
+  end
+  ## Called when user exits a widget
+  # 2018-03-04 - Are we keeping this at all, can we avoid NOT_SURE
+  def on_leave
+    @state = :NORMAL    # duplicating since often these are inside containers
+    @focussed = false
+    if @handler && @handler.has_key?(:LEAVE)
+      fire_handler :LEAVE, self
+    end
+  end
+  ## 
+  # @return row and col of a widget where painting data actually starts
+  # row and col is where a widget starts. offsets usually take into account borders.
+  # the offsets typically are where the cursor should be positioned inside, upon on_enter.
+  def rowcol
+    return @row+@row_offset, @col+@col_offset
+  end
+  ## return the value of the widget.
+  def getvalue
+    @text
+  end
+  ##
+  # Am making a separate method since often value for print differs from actual value
+  def getvalue_for_paint
+    getvalue
+  end
+  ##
+  # default repaint method. Called by form for all widgets.
+  #  widget does not have display_length.
+  def repaint
+    r,c = rowcol
+    $log.debug("widget repaint : r:#{r} c:#{c} col:#{@color_pair}" )
+    value = getvalue_for_paint
+    len = @width || value.length
+    acolor = @color_pair 
+    @graphic.printstring r, c, "%-*s" % [len, value], acolor, attr()
+  end
+
+  def destroy
+    $log.debug "DESTROY : widget #{@name} "
+    panel = @window.panel
+    Ncurses::Panel.del_panel(panel.pointer) if !panel.nil?   
+    @window.delwin if !@window.nil?
+  end
+
+  # puts cursor on correct row.
+  def set_form_row
+    raise "uncalled set_form_row"
+    r, c = rowcol
+    setrowcol row, nil  # does not exist any longer
+  end
+  # set cursor on correct column, widget
+  # Ideally, this should be overriden, as it is not likely to be correct.
+  # NOTE: this is okay for some widgets but NOT for containers
+  # that will call their own components SFR and SFC
+  #Currently, Field has overriden this. +setrowcol+ does not exist any longer.
+  def set_form_col col1=@curpos
+    @curpos = col1 || 0 # 2010-01-14 21:02 
+    #@form.col = @col + @col_offset + @curpos
+    c = @col + @col_offset + @curpos
+    #$log.warn " #{@name} empty set_form_col #{c}, curpos #{@curpos}  , #{@col} + #{@col_offset} #{@form} "
+    setrowcol nil, c
+  end
+
+  ## 
+  # to be added at end of handle_key of widgets so instlalled actions can be checked
+  def handle_key(ch)
+    ret = process_key ch, self
+    return :UNHANDLED if ret == :UNHANDLED
+    0
+  end
+
+  # is the entire widget to be repainted including things like borders and titles
+  # earlier took a default of true, now must be explicit. Perhaps, not used currently.
+  def repaint_all(tf)
+    @repaint_all = tf
+    @repaint_required = tf
+  end
+  # shortcut for users to indicate that a widget should be redrawn since some property has been changed.
+  def touch
+    @repaint_required = true
+  end
+
+
+  # a general method for all widgets to override with their favorite or most meaninful event
+  # Ideally this is where the block in the constructor should land up.
+  # @since 1.5.0    2011-11-21 
+  # 2018-03-08 - NOT_SURE 
+  def command *args, &block
+    if event? :PRESS
+      bind_event :PRESS, *args, &block
+    else
+      bind_event :CHANGED, *args, &block
+    end
+  end
+  def _form=(aform)
+    @_form = aform
+  end
+  def focusable=(bool)
+    $log.debug "  inside focusable= with #{bool} "
+    @focusable = bool
+    @_form.update_focusables if @_form
+  end
+  #
+  ## ADD HERE WIDGET
+end #  
+end # module

data/lib/umbra/window.rb

@@ -0,0 +1,270 @@
+require 'ffi-ncurses'
+require 'ffi-ncurses/widechars'
+
+module Umbra
+
+  # attribute constants, use them to specify an attrib for a widget or window.
+  BOLD = FFI::NCurses::A_BOLD
+  REVERSE = FFI::NCurses::A_REVERSE
+  UNDERLINE = FFI::NCurses::A_UNDERLINE
+  NORMAL = FFI::NCurses::A_NORMAL
+
+  # color constants, use these when creating a color
+  COLOR_BLACK = FFI::NCurses::BLACK
+  COLOR_WHITE = FFI::NCurses::WHITE
+  COLOR_BLUE = FFI::NCurses::BLUE
+  COLOR_RED = FFI::NCurses::RED
+  COLOR_GREEN = FFI::NCurses::GREEN
+  COLOR_CYAN = FFI::NCurses::CYAN
+  COLOR_MAGENTA = FFI::NCurses::MAGENTA
+
+  # Initialize ncurses before any program.
+  # Reduce the value of $ncurses_timeout if you want a quicker response to Escape keys or continuous updates.
+  # I have set the default to 1000.
+  def init_curses
+    FFI::NCurses.initscr
+    FFI::NCurses.curs_set 1
+    FFI::NCurses.raw
+    FFI::NCurses.noecho
+    FFI::NCurses.keypad FFI::NCurses.stdscr, true
+    FFI::NCurses.scrollok FFI::NCurses.stdscr, true
+    if FFI::NCurses.has_colors
+      FFI::NCurses.start_color
+      std_colors
+    end
+
+  end
+
+  # COLOR_BLACK   0
+  # COLOR_RED     1
+  # COLOR_GREEN   2
+  # COLOR_YELLOW  3
+  # COLOR_BLUE    4
+  # COLOR_MAGENTA 5
+  # COLOR_CYAN    6
+  # COLOR_WHITE   7
+
+  # In case, the init_pairs are changed, then update these as well, so that the programs use the correct pairs.
+  CP_BLACK    = 0
+  CP_RED      = 1
+  CP_GREEN    = 2
+  CP_YELLOW   = 3
+  CP_BLUE     = 4
+  CP_MAGENTA  = 5
+  CP_CYAN     = 6
+  CP_WHITE    = 7
+  # defining various colors
+  # NOTE this should be done by application or else we will be changing this all the time.
+  def std_colors
+    FFI::NCurses.use_default_colors
+    # 2018-03-17 - changing it to ncurses defaults
+    FFI::NCurses.init_pair(0,  FFI::NCurses::BLACK,   -1)
+    FFI::NCurses.init_pair(1,  FFI::NCurses::RED,   -1)
+    FFI::NCurses.init_pair(2,  FFI::NCurses::GREEN,     -1)
+    FFI::NCurses.init_pair(3,  FFI::NCurses::YELLOW,   -1)
+    FFI::NCurses.init_pair(4,  FFI::NCurses::BLUE,    -1)
+    FFI::NCurses.init_pair(5,  FFI::NCurses::MAGENTA,  -1)
+    FFI::NCurses.init_pair(6,  FFI::NCurses::CYAN,    -1)
+    FFI::NCurses.init_pair(7,  FFI::NCurses::WHITE,    -1)
+    # ideally the rest should be done by application
+    #FFI::NCurses.init_pair(8,  FFI::NCurses::WHITE,    -1)
+    #FFI::NCurses.init_pair(9,  FFI::NCurses::BLUE,    -1)
+    FFI::NCurses.init_pair(10,  FFI::NCurses::BLACK, FFI::NCurses::CYAN)
+    FFI::NCurses.init_pair(12, FFI::NCurses::BLACK,   FFI::NCurses::BLUE)
+    FFI::NCurses.init_pair(13, FFI::NCurses::BLACK,   FFI::NCurses::MAGENTA)
+
+    FFI::NCurses.init_pair(14,  FFI::NCurses::WHITE, FFI::NCurses::CYAN)
+=begin
+  FFI::NCurses.init_pair(8,  FFI::NCurses::WHITE,   FFI::NCurses::BLUE)
+  FFI::NCurses.init_pair(9,  FFI::NCurses::BLUE,   FFI::NCurses::BLUE)
+  FFI::NCurses.init_pair(10, FFI::NCurses::BLACK,   FFI::NCurses::GREEN)
+  FFI::NCurses.init_pair(11, FFI::NCurses::BLACK,   FFI::NCurses::YELLOW)
+  FFI::NCurses.init_pair(12, FFI::NCurses::BLACK,   FFI::NCurses::BLUE)
+  FFI::NCurses.init_pair(13, FFI::NCurses::BLACK,   FFI::NCurses::MAGENTA)
+  FFI::NCurses.init_pair(14, FFI::NCurses::BLACK,   FFI::NCurses::CYAN)
+  FFI::NCurses.init_pair(15, FFI::NCurses::BLACK,   FFI::NCurses::WHITE)
+=end
+  end
+
+  # create and return a color_pair for a combination of bg and fg.
+  # This will always return the same color_pair so a duplicate one will not be created.
+  # @param bgcolor [Integer] color of background e.g., COLOR_BLACK
+  # @param fgcolor [Integer] color of foreground e.g., COLOR_WHITE
+  # @return [Integer] - color_pair which can be passed to #printstring, or used directly as #COLOR_PAIR(int)
+  def create_color_pair(bgcolor, fgcolor)
+    code = (bgcolor*10) + fgcolor
+    FFI::NCurses.init_pair(code, fgcolor, bgcolor)
+    return code
+  end
+  #
+  ## Window class 
+  #  Creates and manages the underlying window in which we write or place a form and fields.
+  #  The two important methods here are the constructor, and +destroy()+.
+  #  +pointer+ is important for making further direct calls to FFI::NCurses.
+  class Window 
+    # pointer to FFI routines, use when calling FFI directly.
+    attr_reader :pointer     # window pointer
+    attr_reader :panel      # panel associated with window
+    attr_reader :width, :height, :top, :left
+
+    # creates a window with given height, width, top and left.
+    # If no args given, creates a root window (i.e. full size).
+    # @param  height [Integer]
+    # @param  width [Integer]
+    # @param  top [Integer]
+    # @param  left [Integer]
+    def initialize h=0, w=0, top=0, left=0
+      @height, @width, @top, @left = h, w, top, left
+
+      @height = FFI::NCurses.LINES if @height == 0   # 2011-11-14 added since tired of checking for zero
+      @width = FFI::NCurses.COLS   if @width == 0
+      @pointer = FFI::NCurses.newwin(@height, @width, @top, @left) # added FFI 2011-09-6 
+
+      @panel = FFI::NCurses.new_panel(@pointer)
+      FFI::NCurses.keypad(@pointer, true)
+      return @pointer
+    end
+
+    # print string at x, y coordinates. replace this with the original one below
+    # @deprecated
+    def printstr(str, x=0,y=0)
+      win = @pointer
+      FFI::NCurses.wmove(win, x, y)
+      FFI::NCurses.waddstr win, str
+    end
+
+    # 2018-03-08 - taken from canis reduced
+    # print given string at row, col with given color and attributes
+    # @param row [Integer]  row to print on
+    # @param col [Integer]  column to print on
+    # @param color [Integer] color_pair created earlier
+    # @param attr [Integer] any of the four FFI attributes, e.g. A_BOLD, A_REVERSE
+    def printstring(r,c,string, color=0, att = FFI::NCurses::A_NORMAL)
+
+      #$log.debug "printstring recvd nil row #{r} or col #{c}, color:#{color},att:#{att}."  if $log
+      raise "printstring recvd nil row #{r} or col #{c}, color:#{color},att:#{att} " if r.nil? || c.nil?
+      att ||= FFI::NCurses::A_NORMAL
+      color ||= 0
+      raise "color is nil " unless color
+      raise "att is nil " unless att
+
+      FFI::NCurses.wattron(@pointer, FFI::NCurses.COLOR_PAIR(color) | att)
+      FFI::NCurses.mvwprintw(@pointer, r, c, "%s", :string, string);
+      FFI::NCurses.wattroff(@pointer, FFI::NCurses.COLOR_PAIR(color) | att)
+    end
+    ##
+    # Get a key from the standard input.
+    #
+    # This will get control keys and function keys but not Alt keys.
+    # This is usually called in a loop by the main program.
+    # It returns the ascii code (integer).
+    # 1 is Ctrl-a .... 27 is Esc
+    # FFI already has constants declared for function keys and control keys for checkin against.
+    # Can return a 3 or -1 if user pressed Control-C.
+    #
+    # NOTE: For ALT keys we need to check for 27/Esc and if so, then do another read
+    # with a timeout. If we get a key, then resolve. Otherwise, it is just ESC
+    # NOTE: this was working fine with nodelay. However, that would not allow an app to continuously
+    #    update the screen, as the getch was blocked. wtimeout allows screen to update without a key
+    #    being pressed. 2018-04-07 
+    # @return [Integer] ascii code of key. For undefined keys, returns a String representation.
+    def getch
+      FFI::NCurses.wtimeout(@pointer, $ncurses_timeout || 1000)
+      c = FFI::NCurses.wgetch(@pointer)
+      if c == 27
+
+        # don't wait for another key
+        FFI::NCurses.nodelay(@pointer, true)
+        k = FFI::NCurses.wgetch(@pointer)
+        if k == -1
+          # wait for key
+          #FFI::NCurses.nodelay(@pointer, false)
+          return 27
+        else
+          buf = ""
+          loop do
+            n = FFI::NCurses.wgetch(@pointer)
+            break if n == -1
+            buf += n.chr
+          end
+          # wait for next key
+          #FFI::NCurses.nodelay(@pointer, false)
+
+          # this works for all alt-keys but it messes with shift-function keys
+          # shift-function keys start with M-[ (91) and then have more keys
+          if buf == ""
+            return k + 128
+          end
+          #$log.debug "  getch buf is #{k.chr}#{buf} "
+          # returning a string key here which is for Shift-Function keys or other undefined keys.
+          key = 27.chr + k.chr + buf
+          return key
+
+        end
+      end
+      #FFI::NCurses.nodelay(@pointer, false) # this works but trying out for continueous updates
+      c
+    rescue SystemExit, Interrupt 
+      3      # is C-c
+    rescue StandardError
+      -1     # is C-c
+    end
+
+    # this works fine for basic, control and function keys
+    def OLDgetch
+      c = FFI::NCurses.wgetch(@pointer)
+    rescue SystemExit, Interrupt 
+      3      # is C-c
+    rescue StandardError
+      -1     # is C-c
+    end
+    alias :getkey :getch
+
+    # refresh the window (wrapper)
+    # To be called after printing on a window.
+    def wrefresh
+      FFI::NCurses.wrefresh(@pointer)
+    end
+    # destroy the window and the panel. 
+    # This is important. It should be placed in the ensure block of caller application, so it happens.
+    def destroy
+      FFI::NCurses.del_panel(@panel) if @panel
+      FFI::NCurses.delwin(@pointer)   if @pointer
+      @panel = @pointer = nil # prevent call twice
+    end
+    # route other methods to ffi. {{{
+    # This should preferable NOT be used. Better to use the direct call itself.
+    # It attempts to route other calls to FFI::NCurses by trying to add w to the name and passing the pointer.
+    # I would like to remove this at some time.
+    def method_missing(name, *args)
+      name = name.to_s
+      if (name[0,2] == "mv")
+        test_name = name.dup
+        test_name[2,0] = "w" # insert "w" after"mv"
+        if (FFI::NCurses.respond_to?(test_name))
+          return FFI::NCurses.send(test_name, @pointer, *args)
+        end
+      end
+      test_name = "w" + name
+      if (FFI::NCurses.respond_to?(test_name))
+        return FFI::NCurses.send(test_name, @pointer, *args)
+      end
+      FFI::NCurses.send(name, @pointer, *args)
+    end # }}}
+    # make a box around the window. Just a wrapper
+    def box
+      FFI::NCurses.box(@pointer, 0, 0)
+    end
+    # print a centered title on top of window
+    # This should be called after box, or else box will erase the title
+    # @param str [String] title to print
+    # @param color [Integer] color_pair 
+    # @param att [Integer] attribute constant
+    def title str, color=0, att=BOLD
+      strl = str.length
+      col = (@width - strl)/2
+      printstring(0,col, str, color, att)
+    end
+
+  end # window 
+end # module

data/lib/umbra.rb

@@ -0,0 +1,47 @@
+require "umbra/version"
+#require 'ffi-ncurses'
+require "umbra/window"
+require "umbra/form"
+
+module Umbra
+  def alert str, config={}
+    require 'umbra/dialog'
+    #title = config[:title] || "Alert"
+    #cp    = config[:color_pair] || create_color_pair( COLOR_BLUE, COLOR_WHITE )
+    #attr  = config[:attrib]     || NORMAL
+
+    config[:text]              ||= str
+    config[:title]             ||= "Alert"
+    config[:window_color_pair] ||=  create_color_pair( COLOR_BLUE, COLOR_WHITE )
+    config[:window_attr]       ||= NORMAL
+    config[:buttons]           ||= ["Ok"]
+    
+    #m = Dialog.new text: str, title: title, window_color_pair: cp, window_attr: attr
+    m = Dialog.new config
+    m.run
+  end
+  # confirmation dialog which prompts message with Ok and Cancel and returns true or false.
+  def confirm str, config={}
+    require 'umbra/dialog'
+
+    config[:text]              ||= str
+    config[:title]             ||= "Confirm"
+    config[:window_color_pair] ||=  create_color_pair( COLOR_BLUE, COLOR_WHITE )
+    config[:window_attr]       ||= NORMAL
+    config[:buttons]           ||= ["Ok", "Cancel"]
+    
+    m = Dialog.new config
+    ret = m.run
+    return ret == 0
+  end
+
+  # view an array in a popup window
+  def view array, config={}
+    require 'umbra/pad'
+    title = config[:title] || "Viewer"
+    cp    = config[:color_pair] || create_color_pair( COLOR_BLUE, COLOR_WHITE )
+    attr  = config[:attrib]     || NORMAL
+    m = Pad.new list: array, height: FFI::NCurses.LINES-2, width: FFI::NCurses.COLS-10, title: title, color_pair: cp, attrib: attr
+    m.run
+  end
+end

data/umbra.gemspec

@@ -0,0 +1,27 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "umbra/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ncumbra"
+  spec.version       = Umbra::VERSION
+  spec.authors       = ["kepler"]
+  spec.email         = ["githubkepler.50s@gishpuppy.com"]
+
+  spec.summary       = %q{tiny ncurses library for creating simple apps}
+  spec.description   = %q{minimal, provides forms and a few basic widgets}
+  spec.homepage      = "https://github.com/mare-imbrium/umbra"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "ffi-ncurses", ">= 0.4.0", ">= 0.4.0"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: ncumbra
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kepler
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: ffi-ncurses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: minimal, provides forms and a few basic widgets
+email:
+- githubkepler.50s@gishpuppy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- README.md.bak
+- Rakefile
+- bin/console
+- bin/setup
+- examples/ex1.rb
+- examples/ex2.rb
+- examples/ex21.rb
+- examples/ex3.rb
+- examples/ex4.rb
+- examples/ex5.rb
+- examples/exbox.rb
+- examples/exm1.rb
+- examples/keys.rb
+- examples/tt.rb
+- lib/umbra.rb
+- lib/umbra/box.rb
+- lib/umbra/button.rb
+- lib/umbra/buttongroup.rb
+- lib/umbra/checkbox.rb
+- lib/umbra/dialog.rb
+- lib/umbra/eventhandler.rb
+- lib/umbra/field.rb
+- lib/umbra/form.rb
+- lib/umbra/keymappinghandler.rb
+- lib/umbra/label.rb
+- lib/umbra/labeledfield.rb
+- lib/umbra/listbox.rb
+- lib/umbra/menu.rb
+- lib/umbra/messagebox.rb
+- lib/umbra/pad.rb
+- lib/umbra/radiobutton.rb
+- lib/umbra/textbox.rb
+- lib/umbra/togglebutton.rb
+- lib/umbra/version.rb
+- lib/umbra/widget.rb
+- lib/umbra/window.rb
+- umbra.gemspec
+homepage: https://github.com/mare-imbrium/umbra
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: tiny ncurses library for creating simple apps
+test_files: []