termgui 0.0.4

data/src/widget/modal.rb

@@ -0,0 +1,69 @@
+# temporary modal window solution.
+# TODO: reimplement this using actual screen children elements and remove it for closing
+
+require_relative '../screen'
+require_relative '../util'
+require_relative '../element'
+require_relative '../style'
+require_relative '../log'
+require_relative '../widget/button'
+require_relative '../widget/col'
+require_relative '../widget/label'
+
+def open_modal(
+  screen: nil,
+  title: Label.new(text: 'Modal'),
+  content: Label.new(text: 'Content'),
+  on_close: nil
+)
+  modal = screen.query_one_by_attribute('modal-widget', true)
+  return if modal
+
+  screen.set_timeout(0.3) do
+    focused = screen.focus.focused
+    focusables = screen.focus.focusables
+    focusables.each { |e| e.set_attribute('focusable', false) }
+    title = title.is_a?(String) ? Label.new(text: title, style: { bold: true, fg: '#001119', underline: true }, x: 1, y: 1) : title
+    content = content.is_a?(String) ? Label.new(text: content, style: { wrap: true, fg: '#77aa33' }, x: 1, y: 3, height: 0.8, width: 0.9) : content
+    close = Button.new(text: 'close', y: 1, x: 0.9, action: proc {
+      modal.remove
+      screen.clear
+      screen.render
+      on_close&.call
+      focusables.each { |e| e.set_attribute('focusable', true) }
+      focused&.focus
+    })
+    modal = screen.append_child Element.new(
+      x: 0.2, y: 0.1,
+      height: 0.9,
+      width: 0.6,
+      attributes: { 'modal-widget': true },
+      padding: Bounds.new(top: 1, left: 2),
+      style: { bg: 'white', fg: 'blue', wrap: true, border: Border.new(bg: 'red', style: 'double') },
+      children: [
+        title,
+        close,
+        content
+      ]
+    )
+    close.focus
+    modal.render
+  end
+end
+
+def clode_modal(screen)
+  modals = screen.query_by_attribute('modal-widget', true)
+  # return unless modals.length>0
+  modals.each{|modal|modal.remove}
+  screen.render if modals.length>0
+end
+
+module TermGui
+  module Widget
+    class Modal
+      def self.open(**args)
+        open_modal(args)
+      end
+    end
+  end
+end

data/src/widget/row.rb

@@ -0,0 +1,26 @@
+require_relative '../element'
+module TermGui
+  module Widget
+    # Row container. A row child is rendered at the right of the previous child - all of them in one row.
+    # By default it will have width==0.999
+    class Row < Element
+      attr_accessor :gap
+      def initialize(**args)
+        super({ width: 0.9999999 }.merge(args))
+        @name = 'row'
+        @gap = args[:gap]||0
+      end
+
+      def layout
+        # init_x = abs_content_x
+        last_x = abs_content_x
+        @children.each do |c|
+          c.abs_x = last_x
+          last_x += c.abs_width + @gap
+        end
+      end
+    end
+  end
+end
+
+Row = TermGui::Widget::Row

data/src/widget/selectbox.rb

@@ -0,0 +1,100 @@
+require_relative 'button'
+require_relative '../enterable'
+require_relative '../log'
+require_relative 'checkbox'
+
+module TermGui
+  module Widget
+    class SelectOption < CheckBox
+      def initialize(**args)
+        super
+        @name = 'select-option'
+        set_attribute('focusable', false)
+      end
+      # def default_style
+      #   Style.new(fg: 'white', bg: 'yellow')
+      # end
+    end
+
+    # One line text input box, analog to HTMLInputElement
+    class SelectBox < Button
+      include Enterable
+      def initialize(**args)
+        super
+        @name = 'select'
+        set_attribute('escape-on-blur', get_attribute('escape-on-blur') == nil ? true : get_attribute('escape-on-blur'))
+        set_attribute('action-on-focus', get_attribute('action-on-focus') == nil ? true : get_attribute('action-on-focus'))
+        @options = (args[:options] || [])
+        @option_elements = @options.map.with_index do |o, i|
+          SelectOption.new(
+            text: o[:text] || o[:value],
+            value: o[:selected] || false,
+            parent: self,
+            y: i + 1,
+            x: 0
+          )
+        end
+        render_options 0
+      end
+
+      def render_options(c = nil)
+        @current = c unless c == nil
+        @option_elements.each_with_index do |e, i|
+          e.style.bg = 'red' if i == @current
+          e.style.bg = 'black' if i != @current
+          e.render
+        end
+      end
+
+      def value
+        @option_elements.map.with_index { |e, i| e.value ? @options[i][:value] : nil }.reject { |v| v == nil }
+      end
+
+      def value=(v)
+        # todo
+        # throw 'todo'
+      end
+      def handle_key(event)
+        if !super(event)
+          if event.key == 'up'
+            render_options [@current - 1, 0].max
+            true
+          elsif event.key == 'down'
+            render_options [@current + 1, @option_elements.length - 1].min
+            true
+          elsif ['space'].include? event.key
+            @option_elements[@current].value = !@option_elements[@current].value
+            on_input value, event
+            true
+          else
+            false
+          end
+        else
+          true
+        end
+      end
+    end
+  end
+end
+
+SelectBox = TermGui::Widget::SelectBox
+
+# sb=nil
+# s = Screen.new(children: [
+#   Button.new(text: 'hello', x: 0.7, y: 0.6, action: proc {|e|
+#     e.target.text = sb.value.join(', ')
+#     e.target.render
+#   }),
+# (sb = SelectBox.new(x: 2, y: 1, width: 0.5, height: 0.5, options:
+# [
+#   {
+#     text: '1', value: 1, selected: true
+#   }, {
+#     text: '2', value: 2
+#   }, {
+#     text: '3', value: 3
+#   }
+# ]))
+# ])
+
+# s.start

data/src/widget/textarea.rb

@@ -0,0 +1,54 @@
+# require_relative 'button'
+# require_relative '../event'
+
+# module TermGui
+#   module Widget
+#     # One line text input box, analog to HTMLInputElement
+#     class TextArea < Button
+#       attr_accessor :value
+
+#       def initialize(**args)
+#         super
+#         @value = args[:value] || ''
+#         @key_listener = nil
+#         install(:input)
+#         install(:change)
+#         install(:escape)
+#         on(:action) do
+#           @key_listener = proc { |e| on_key e }
+#           root_screen.event.add_any_key_listener @key_listener
+#           on('change', args[:change]) if args[:change]
+#           on('input', args[:input]) if args[:input]
+#           on('escape', args[:escape]) if args[:escape]
+#         end
+#       end
+
+#       def on_key(event)
+#         if !get_attribute('focused')
+#           trigger('change', ChangeEvent.new(self, @value, event))
+#           root_screen.event.remove_any_key_listener @key_listener
+#         elsif event.key == 'escape'
+#           trigger('escape', EscapeEvent.new(self, event))
+#           root_screen.event.remove_any_key_listener @key_listener
+#         elsif event.key == 'backspace'
+#           on_input @value.slice(0, @value.length - 1), event
+#         elsif alphanumeric? event.key
+#           on_input @value + event.key, event
+#         end
+#       end
+
+#       protected
+
+#       def on_input(value, event = nil)
+#         @value = value
+#         self.text = @value
+#         update_width
+#         root_screen.clear
+#         root_screen.render
+#         trigger('input', ChangeEvent.new(self, @value, event))
+#       end
+#     end
+#   end
+# end
+
+# InputBox = TermGui::Widget::InputBox

data/src/xml/xml.rb

@@ -0,0 +1,80 @@
+require 'rexml/document'
+require 'erb'
+require_relative '../element'
+require_relative '../screen'
+require_relative '../log'
+require_relative '../util'
+require_relative '../style'
+require_relative '../widget/col'
+require_relative '../widget/button'
+require_relative '../widget/label'
+
+def process_attrs(e, b, attrs = default_attrs)
+  a = {}
+  e.attributes.each_attribute do |attr|
+    value = attr.value
+    name =  attr.expanded_name
+    if attrs[:number].include? name
+      a[name.to_sym] = is_percent(value.to_f) ? value.to_f : value.to_i
+    elsif attrs[:code].include? name
+      a[name.to_sym] = eval(value, b)
+    elsif name == 'style'
+      a[name.to_sym] = Style.from_hash(eval(value))
+    else
+      a[name.to_sym] = value
+    end
+  end
+  a
+end
+
+def percent_bounds_hack(result, parent)
+  result.set_attribute('xml', true)
+  if parent && !parent.get_attribute('xml')
+    result.set_attribute('x', 0)
+    result.set_attribute('y', 0)
+    result.set_attribute('width', parent.width)
+    result.set_attribute('height', parent.height)
+  end
+end
+
+def process_node(node, parent = nil, bindings = nil, builders = default_builders, attrs = default_attrs)
+  if node.is_a?(REXML::Text)
+    parent.text += node.to_s.strip if parent
+  else
+    c = (builders[node.name.to_sym] || Element)
+    a = process_attrs(node, bindings, attrs).merge(parent: parent)
+    result = c.new(a.merge(builders[node.name.to_sym] ? {} : { name: node.name }))
+    percent_bounds_hack(result, parent)
+    node.each do |e|
+      c = process_node(e, result, bindings, builders, attrs)
+    end
+  end
+  result
+end
+
+def default_attrs
+  {
+    number: %w[width height x y],
+    code: ['action']
+  }
+end
+
+def default_builders
+  {
+    col: Col,
+    button: Button,
+    label: Label
+  }
+end
+
+def render_xml(xml: nil, parent: nil, binding: nil, custom_builders: {}, custom_attrs: {})
+  builders = default_builders.merge(custom_builders)
+  attrs = default_attrs.merge(custom_attrs)
+  doc = REXML::Document.new xml
+  process_node(doc, parent, binding, builders, attrs)
+end
+
+def render_erb(template: nil, parent: nil, binding: nil, erb_binding: binding, custom_builders: {}, custom_attrs: {})
+  xml = ERB.new(template).result(erb_binding).strip
+  render_xml(xml: xml, parent: parent, binding: binding, custom_builders: custom_builders, custom_attrs: custom_attrs)
+end

data/test/action_test.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element'
+require_relative '../src/screen'
+require_relative '../src/log'
+
+class ActionTest < Test::Unit::TestCase
+  def test_global_action
+    screen = Screen.new_for_testing width: 5, height: 6
+    s = ''
+    global = ''
+    e1 = screen.append_child Element.new(text: '1', attributes: { focusable: true })
+    screen.append_child Element.new(text: '2', attributes: { focusable: true, action: proc { |_e| s = 'e2' } })
+    e1.set_attribute('action', proc { s = 'e1' })
+    screen.action.on('action') do |e|
+      global = 'e' + e.target.text
+    end
+    screen.input.emit_key 'enter'
+    assert_equal '', s
+    assert_equal '', global
+    screen.focus.focus_next
+    assert_equal '', s
+    assert_equal '', global
+    screen.input.emit_key 'enter'
+    assert_equal 'e2', s
+    assert_equal 'e2', global
+    screen.focus.focus_next
+    assert_equal 'e2', s
+    assert_equal 'e2', global
+    screen.input.emit_key 'enter'
+    assert_equal 'e1', s
+    assert_equal 'e1', global
+  end
+end

data/test/box_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/box'
+
+class BoxTest < Test::Unit::TestCase
+  def test_simple
+    b = draw_box(width: 8, height: 3)
+    assert_equal "box\n#{b.join('\n')}\nbox",
+                 "box\n" \
+                 '┌──────┐\\n' \
+                 '│      │\\n' \
+                 "└──────┘\n" \
+                 'box'
+  end
+end

data/test/css_test.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/util/css'
+
+class CssTest < Test::Unit::TestCase
+  def test_parse_rules
+    p = CSSParser.new
+    expected = '[{:selector=>"foo", :body=>"bg: red; padding-top: 3"}, {:selector=>".bar .primary", :body=>"border: double black"}, {:selector=>"; .sidebar .container", :body=>"padding: 1"}]'
+    actual = p.parse_rules('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}').to_s
+    assert_equal expected, actual
+  end
+
+  def test_parse_rules_properties
+    p = CSSParser.new
+    expected = '[{:selector=>"foo", :properties=>[{:name=>"bg", :value=>"red"}, {:name=>"padding-top", :value=>"3"}]}, {:selector=>".bar .primary", :properties=>[{:name=>"border", :value=>"double black"}]}, {:selector=>"; .sidebar .container", :properties=>[{:name=>"padding", :value=>"1"}]}]'
+    actual = p.parse_rules_properties(p.parse_rules('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}')).to_s
+    assert_equal expected, actual
+  end
+
+  def test_parse_rules_selectors
+    p = CSSParser.new
+    expected = '[{:selectors=>[[{:name=>"foo", :operator=>nil}]], :properies=>[{:name=>"bg", :value=>"red"}, {:name=>"padding-top", :value=>"3"}]}, {:selectors=>[[{:name=>".bar", :operator=>" "}, {:name=>".primary", :operator=>nil}]], :properies=>[{:name=>"border", :value=>"double black"}]}, {:selectors=>[[{:name=>";", :operator=>" "}, {:name=>".sidebar", :operator=>" "}, {:name=>".container", :operator=>nil}]], :properies=>[{:name=>"padding", :value=>"1"}]}]'
+    rules = p.parse_rules_properties(p.parse_rules('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}'))
+    actual = p.parse_rules_selectors(rules).to_s
+    assert_equal expected, actual
+  end
+
+  def test_parse
+    p = CSSParser.new
+    expected = '[{:selectors=>[[{:name=>"foo", :operator=>nil}]], :properies=>[{:name=>"bg", :value=>"red"}, {:name=>"padding-top", :value=>"3"}]}, {:selectors=>[[{:name=>".bar", :operator=>" "}, {:name=>".primary", :operator=>nil}]], :properies=>[{:name=>"border", :value=>"double black"}]}, {:selectors=>[[{:name=>";", :operator=>" "}, {:name=>".sidebar", :operator=>" "}, {:name=>".container", :operator=>nil}]], :properies=>[{:name=>"padding", :value=>"1"}]}]'
+    actual = p.parse('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}').to_s
+    assert_equal expected, actual
+  end
+
+  def test_parse_selector
+    expected = '[{:name=>"a", :operator=>">"}, {:name=>"b", :operator=>" "}, {:name=>"c", :operator=>">"}, {:name=>"d", :operator=>" "}, {:name=>"f", :operator=>nil}]'
+    assert_equal expected, CSSParser.new.parse_selector('a>  b c>d f').to_s
+  end
+end

data/test/editor/editor_base_test.rb

@@ -0,0 +1,201 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../../src/editor/editor_base'
+require_relative '../../src/log'
+require_relative '../../src/screen'
+require_relative '../../src/event'
+
+class EditorBaseTest < Test::Unit::TestCase
+  def test_arrows_enter_cursor_backspace
+    screen = Screen.new_for_testing(width: 24, height: 6)
+    ed = EditorBase.new(text: 'hello world\nhow are you?', screen: screen, cursor_x: 0, cursor_y: 0)
+    ed.enable
+    screen.set_timeout do
+      assert_equal 'hello world\nhow are you?', ed.text
+      assert_equal [0, 0], [ed.cursor_x, ed.cursor_y]
+
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world             \n' \
+        'how are you?            \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [0, 0], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('right'))
+      assert_equal [1, 0], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('enter'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'h                       \n' \
+        'ello world              \n' \
+        'how are you?            \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+
+      screen.event.handle_key(KeyEvent.new('backspace'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world             \n' \
+        'how are you?            \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [1, 0], [ed.cursor_x, ed.cursor_y]
+
+      6.times { screen.event.handle_key(KeyEvent.new('right')) }
+      screen.event.handle_key(KeyEvent.new('left'))
+      screen.event.handle_key(KeyEvent.new('down'))
+      assert_equal [6, 1], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('enter'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world             \n' \
+        'how ar                  \n' \
+        'e you?                  \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [0, 2], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('backspace'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world             \n' \
+        'how are you?            \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [6, 1], [ed.cursor_x, ed.cursor_y]
+
+      6.times { screen.event.handle_key(KeyEvent.new('left')) }
+      assert_equal [0, 1], [ed.cursor_x, ed.cursor_y]
+      screen.event.handle_key(KeyEvent.new('backspace'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello worldhow are you? \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [11, 0], [ed.cursor_x, ed.cursor_y]
+
+      3.times { screen.event.handle_key(KeyEvent.new('space')) }
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world   how are yo\n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [14, 0], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('X'))
+      screen.event.handle_key(KeyEvent.new('enter'))
+      screen.clear
+      ed.render
+      assert_equal(
+        'hello world   X         \n' \
+        'how are you?            \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [0, 1], [ed.cursor_x, ed.cursor_y]
+
+      screen.destroy
+    end
+    screen.start
+  end
+
+  def test_coords
+    screen = Screen.new_for_testing(width: 24, height: 6)
+    ed = EditorBase.new(text: 'Welcome to this\nhumble editor', screen: screen, cursor_x: 0, cursor_y: 0, x: 5, y: 2)
+    ed.enable
+    screen.set_timeout do
+      screen.clear
+      ed.render
+      assert_equal(
+        '                        \n' \
+        '                        \n' \
+        '     Welcome to this    \n' \
+        '     humble editor      \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [0, 0], [ed.cursor_x, ed.cursor_y]
+      screen.event.handle_key(KeyEvent.new('down'))
+      assert_equal [0, 1], [ed.cursor_x, ed.cursor_y]
+      screen.event.handle_key(KeyEvent.new('right'))
+      assert_equal [1, 1], [ed.cursor_x, ed.cursor_y]
+      screen.event.handle_key(KeyEvent.new('enter'))
+      screen.clear
+      ed.render
+      assert_equal(
+        '                        \n' \
+        '                        \n' \
+        '     Welcome to this    \n' \
+        '     h                  \n' \
+        '     umble editor       \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [0, 2], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('backspace'))
+      assert_equal [1, 1], [ed.cursor_x, ed.cursor_y]
+      screen.clear
+      ed.render
+      assert_equal(
+        '                        \n' \
+        '                        \n' \
+        '     Welcome to this    \n' \
+        '     humble editor      \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [1, 1], [ed.cursor_x, ed.cursor_y]
+
+      screen.event.handle_key(KeyEvent.new('A'))
+      screen.clear
+      ed.render
+      assert_equal(
+        '                        \n' \
+        '                        \n' \
+        '     Welcome to this    \n' \
+        '     hAumble editor     \n' \
+        '                        \n' \
+        '                        \n', screen.renderer.print
+      )
+      assert_equal [2, 1], [ed.cursor_x, ed.cursor_y]
+
+      # screen.renderer.print_dev_stdout
+
+      screen.destroy
+    end
+    screen.start
+  end
+end