termgui 0.0.4

data/test/element_bounds_test.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element'
+require_relative '../src/util'
+require_relative '../src/style'
+require_relative '../src/screen'
+require_relative '../src/log'
+
+class ElementBoundsTest < Test::Unit::TestCase
+  def test_abs
+    child2 = Element.new(x: 2, y: 1)
+    child1 = Element.new(x: 4, y: 3, children: [child2])
+
+    assert_equal 2, child2.x
+    assert_equal 1, child2.y
+    assert_equal 4, child1.x
+    assert_equal 3, child1.y
+
+    assert_equal 6, child2.abs_x
+    assert_equal 4, child2.abs_y
+    assert_equal 4, child1.abs_x
+    assert_equal 3, child1.abs_y
+  end
+
+  def test_abs_percent
+    e = Element.new(x: 1, y: 2, width: 16, height: 12)
+    e1 = Element.new(x: 0.3, y: 0.2, width: 0.6, height: 0.6)
+    e.append_child(e1)
+    assert_equal 9, e1.abs_width
+    assert_equal 7, e1.abs_height
+    assert_equal 4, e1.abs_y
+    assert_equal 5, e1.abs_x
+  end
+
+  def test_render_offset
+    screen = Screen.new_for_testing(width: 12, height: 7, silent: true)
+    screen.append_child Element.new(x: 7, y: 3, width: 7, height: 12, text: 'hello', ch: '·', style: { border: Border.new, padding: Bounds.new(top: 1, left: 2) })
+    screen.clear
+    screen.render
+
+    assert_equal(
+      '            \n' \
+      '            \n' \
+      '            \n' \
+      '       ┌────\n' \
+      '       │····\n' \
+      '       │··he\n' \
+      '       │····\n', screen.renderer.print
+    )
+
+    screen.offset.left = 5
+    screen.clear
+    screen.render
+    assert_equal(
+      '            \n' \
+      '            \n' \
+      '            \n' \
+      '  ┌───────┐ \n' \
+      '  │·······│ \n' \
+      '  │··hello│ \n' \
+      '  │·······│ \n', screen.renderer.print
+    )
+
+    screen.offset.top = 2
+    screen.clear
+    screen.render
+    assert_equal(
+      '            \n' \
+      '  ┌───────┐ \n' \
+      '  │·······│ \n' \
+      '  │··hello│ \n' \
+      '  │·······│ \n' \
+      '  │·······│ \n' \
+      '  │·······│ \n', screen.renderer.print
+    )
+  end
+end

data/test/element_box_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element_box'
+require_relative '../src/screen'
+require_relative '../src/element'
+
+class ElementBoxTest < Test::Unit::TestCase
+end

data/test/element_render_test.rb

@@ -0,0 +1,124 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element'
+require_relative '../src/util'
+require_relative '../src/style'
+require_relative '../src/screen'
+require_relative '../src/log'
+
+class ElementRenderTest < Test::Unit::TestCase
+  def test_render
+    child2 = Element.new(x: 2, y: 1, width: 2, height: 1, ch: '2')
+    child1 = Element.new(x: 4, y: 3, width: 10, height: 8, ch: '1', children: [child2])
+    node = Element.new(children: [child1])
+    screen = Screen.new_for_testing(width: 16, height: 11)
+    node.render screen
+    s3 =
+      '                \\n' \
+      '                \\n' \
+      '                \\n' \
+      '    1111111111  \\n' \
+      '    1122111111  \\n' \
+      '    1111111111  \\n' \
+      '    1111111111  \\n' \
+      '    1111111111  \\n' \
+      '    1111111111  \\n' \
+      '    1111111111  \\n' \
+      '    1111111111  \\n' \
+      ''
+    assert_equal s3, screen.renderer.print
+  end
+
+  def test_render_text1
+    screen = Screen.new_for_testing(width: 12, height: 7)
+    e = Element.new(x: 1, y: 2, width: 6, height: 3, text: 'hello', ch: '·')
+    screen.append_child(e)
+    screen.render
+    assert_equal(
+      '            \\n' \
+      '            \\n' \
+      ' hello·     \\n' \
+      ' ······     \\n' \
+      ' ······     \\n' \
+      '            \\n' \
+      '            \\n' \
+    '', screen.print
+    )
+  end
+
+  def test_render_text2
+    screen = Screen.new_for_testing(width: 12, height: 7)
+    e = Element.new(x: 1, y: 2, width: 9, height: 3, text: 'hello', ch: '·', style: { padding: Bounds.new(top: 1, left: 2) })
+    screen.append_child(e)
+    screen.render
+    assert_equal(
+      '            \\n' \
+      '            \\n' \
+      ' ·········  \\n' \
+      ' ··hello··  \\n' \
+      ' ·········  \\n' \
+      '            \\n' \
+      '            \\n' \
+    '', screen.print
+    )
+  end
+
+  def test_render_border
+    screen = Screen.new_for_testing(width: 12, height: 9)
+    e = Element.new(x: 1, y: 2, width: 6, height: 3, text: 'hello', ch: '·')
+    e.style.border = Border.new
+    screen.append_child(e)
+    screen.render
+    assert_equal(
+      '            \n' \
+'            \n' \
+' ┌──────┐   \n' \
+' │hello·│   \n' \
+' │······│   \n' \
+' │······│   \n' \
+' └──────┘   \n' \
+'            \n' \
+'            \n' \
+      '', screen.print
+    )
+  end
+
+  def test_render_text_nl
+    screen = Screen.new_for_testing(width: 12, height: 7)
+    e = Element.new(x: 1, y: 2, width: 6, height: 3, text: 'hello\nworld', ch: '·')
+    e.style.border = Border.new
+    screen.append_child(e)
+    screen.render
+    assert_equal(
+      '            \n' \
+      '            \n' \
+      ' ┌──────┐   \n' \
+      ' │hello·│   \n' \
+      ' │world·│   \n' \
+      ' │······│   \n' \
+      ' └──────┘   \n' \
+      '', screen.print
+    )
+  end
+
+  def test_render_text_wrap
+    screen = Screen.new_for_testing(width: 16, height: 9)
+    e = Element.new(x: 1, y: 1, width: 12, height: 5, text: 'as df rf ty gh fg sdf ed', ch: '·')
+    e.style.border = Border.new
+    e.style.wrap = true
+    screen.append_child(e)
+    screen.render
+    assert_equal(
+      '                \n' \
+      ' ┌────────────┐ \n' \
+      ' │as df rf ty·│ \n' \
+      ' │gh fg sdf ed│ \n' \
+      ' │············│ \n' \
+      ' │············│ \n' \
+      ' │············│ \n' \
+      ' └────────────┘ \n' \
+      '                \n' \
+      '', screen.print
+    )
+  end
+end

data/test/element_style_test.rb

@@ -0,0 +1,85 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element'
+require_relative '../src/util'
+require_relative '../src/style'
+require_relative '../src/screen'
+require_relative '../src/log'
+
+class ElementStyleTest < Test::Unit::TestCase
+  def test_constructor_style
+    e = Element.new(
+      attributes: { focusable: true, focused: false },
+      style: {
+        focus: Style.new(bg: 'red')
+      }
+    )
+    assert_equal 'red', e.style.focus.bg
+    assert_equal true, e.get_attribute('focusable')
+    assert_equal true, e.get_attribute(:focusable)
+    assert_equal false, e.get_attribute(:focused)
+    assert_equal false, e.get_attribute('focused')
+    assert_equal nil, e.style.border
+    e.style.border = Border.new
+    assert_equal Border.new.style, e.style.border.style
+    # assert_equal ({ bg: nil,
+    #                 blink: nil,
+    #                 bold: nil,
+    #                 fg: nil,
+    #                 fraktur: nil,
+    #                 framed: nil,
+    #                 inverse: nil,
+    #                 style: 'single',
+    #                 underline: nil }), e.style.border.to_hash
+    # assert object_equal({ bg: nil,
+    #                       blink: nil,
+    #                       bold: nil,
+    #                       fg: nil,
+    #                       fraktur: nil,
+    #                       framed: nil,
+    #                       inverse: nil,
+    #                       style: 'single',
+    #                       underline: nil }, e.style.border.to_hash)
+
+    assert_equal(e.style.focus.bg, 'red')
+  end
+
+  # def test_style_no_focus_if_not_declared
+  #   e = Element.new
+  #   assert_equal nil, e.style.focus
+  #   assert_equal nil, e.style.border
+  # end
+
+  def test_style
+    s = Style.new(border: Border.new(style: 'classic', fg: 'red'), fg: 'blue', bg: 'bright_magenta')
+    assert_equal 'classic', s.border.style
+    assert_equal 'red', s.border.fg
+    assert_equal 'blue', s.fg
+
+    e = Element.new
+    e.style = { fg: 'black', bg: 'white' }
+    assert_equal 'black', e.style.fg
+    assert_equal 'white', e.style.bg
+
+    e.style = s
+    assert_equal 'classic', e.style.border.style
+    assert_equal 'red', e.style.border.fg
+    assert_equal 'blue', e.style.fg
+  end
+
+  def test_final_style
+    e = Element.new(
+      attributes: { focusable: true, focused: false },
+      style: {
+        bg: 'white',
+        focus: Style.new(bg: 'red')
+      }
+    )
+    assert_equal 'red', e.style.focus.bg
+    assert_equal 'white', e.final_style.bg
+    assert_equal false, e.get_attribute('focused')
+    e.set_attribute('focused', true)
+    assert_equal true, e.get_attribute('focused')
+    assert_equal 'red', e.final_style.bg
+  end
+end

data/test/element_test.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/element'
+require_relative '../src/util'
+require_relative '../src/style'
+require_relative '../src/screen'
+require_relative '../src/log'
+
+class ElementTest < Test::Unit::TestCase
+end

data/test/emitter_test.rb

@@ -0,0 +1,108 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/emitter'
+require_relative '../src/util'
+
+class EmitterTest < Test::Unit::TestCase
+  def test_event_emitter
+    event_emitter = Emitter.new
+    s = ''
+    ring_bell = lambda do |_object|
+      s = 'ring ring ring'
+    end
+    # create an event 'doorOpen'
+    event_emitter.install(:doorOpen)
+    # and subscribe code to event
+    event_emitter.subscribe(:doorOpen, ring_bell)
+    # to trigger event
+    event_emitter.emit(:doorOpen)
+    next_tick
+    assert_equal 'ring ring ring', s
+
+    s = ''
+    event_emitter.subscribe(:doorOpen, proc { |e| s = e[:msg] })
+    event_emitter.emit(:doorOpen, msg: 'hello')
+    next_tick
+    assert_equal 'hello', s
+  end
+
+  def test_state
+    e = Emitter.new
+    e.install(:play)
+    a = 0
+    b = 0
+    e.subscribe(:play, proc {
+      a += 1
+    })
+    e.emit(:play)
+    assert_equal 1, a
+    assert_equal 0, b
+    e.emitter_save('a')
+    e.emitter_reset
+    e.install(:play)
+    e.on(:play, proc { b += 1 })
+    e.emit(:play)
+    assert_equal 1, a
+    assert_equal 1, b
+    e.emitter_save('b')
+
+    e.emitter_load('a')
+    e.emit(:play)
+    assert_equal 2, a
+    assert_equal 1, b
+
+    e.emitter_load('b')
+    e.emit(:play)
+    assert_equal 2, a
+    assert_equal 2, b
+  end
+
+  def test_block
+    e = Emitter.new
+    e.install(:play)
+    a = 0
+    b = 0
+    e.subscribe(:play) { a += 1 }
+    e.on(:play) { b += 1 }
+    assert_equal 0, a
+    assert_equal 0, b
+    e.emit(:play)
+    assert_equal 1, a
+    assert_equal 1, b
+  end
+
+  def test_unsubscribe
+    e = Emitter.new
+    e.install(:play)
+    a = 0
+    b = 0
+    s1 = e.subscribe(:play) { a += 1 }
+    s2 = e.subscribe(:play) { b += 1 }
+    assert_equal 0, a
+    assert_equal 0, b
+    e.emit(:play)
+    assert_equal 1, a
+    assert_equal 1, b
+    e.unsubscribe(:play, s2)
+    e.emit(:play)
+    assert_equal 2, a
+    assert_equal 1, b
+  end
+
+  def test_once
+    e = Emitter.new
+    e.install(:play)
+    a = 0
+    b = 0
+    e.subscribe(:play) { a += 1 }
+    e.once(:play) { b += 1 }
+    assert_equal 0, a
+    assert_equal 0, b
+    e.emit(:play)
+    assert_equal 1, a
+    assert_equal 1, b
+    e.emit(:play)
+    assert_equal 2, a
+    assert_equal 1, b
+  end
+end

data/test/event_test.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/event'
+
+class EventManagerTest < Test::Unit::TestCase
+  def test_add_key_listener
+    e = EventManager.new
+    s = 'n'
+    e.add_key_listener('q', proc do |ev|
+      s = ev.key
+    end)
+
+    e.handle_key(KeyEvent.new('q', 'q'))
+    assert_equal s, 'q', 'should notify'
+
+    e.handle_key(KeyEvent.new('x', 'x'))
+    assert_equal s, 'q', 'should not notify'
+  end
+end

data/test/focus_test.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/focus'
+require_relative '../src/node'
+require_relative '../src/event'
+
+class FocusTest < Test::Unit::TestCase
+  def test_next
+    c1 = Node.new(
+      name: 'child1',
+      attributes: { focusable: true }
+    )
+    c2 = Node.new(
+      name: 'child2',
+      attributes: { focusable: true }
+    )
+    root = Node.new(
+      text: 'parent',
+      children: [c1, c2]
+    )
+    assert_equal nil, c1.get_attribute(:focused)
+    focus = FocusManager.new(root: root, event: EventManager.new)
+    times = 0
+    focus.add_listener(:focus, proc { |e|
+      if times.zero?
+        assert_equal e[:focused], c2
+        assert_equal e[:previous], c1
+      end
+      times += 1
+    })
+    assert_equal true, c1.get_attribute(:focused)
+    focus.focus_next
+    assert_equal false, c1.get_attribute(:focused)
+    assert_equal true, c2.get_attribute(:focused)
+    assert_equal times, 1
+  end
+end

data/test/geometry_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/geometry'
+
+class GeometryTest < Test::Unit::TestCase
+  def test_bounds
+    o = Bounds.new(top: 2, left: 1, right: 3, bottom: 4)
+    assert_equal 2, o.top
+    o.top = 6
+    assert_equal 6, o.top
+  end
+end

data/test/input_test.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/input'
+
+class InputTest < Test::Unit::TestCase
+  def test_set_timeout
+    i = Input.new
+    t = nil
+    i.set_timeout(0.1, proc {
+      t = 'timeout'
+      i.stop
+    })
+    i.start
+    assert_equal t, 'timeout'
+  end
+
+  def test_set_timeout_block
+    i = Input.new
+    t = nil
+    i.set_timeout(0.1) do
+      t = 'timeout'
+      i.stop
+    end
+    i.start
+    assert_equal t, 'timeout'
+  end
+
+  def test_wait_for
+    i = Input.new
+    t = nil
+    y = nil
+    i.wait_for(proc { t == 1 }) do |timeout|
+      assert_equal false, timeout
+      assert_equal 1, t
+      y = 'works'
+      i.stop
+    end
+    i.set_timeout(0.2) do
+      t = 1
+    end
+    assert_equal nil, t
+    assert_equal nil, y
+    i.start
+    assert_equal y, 'works'
+    assert_equal 1, t
+  end
+end

data/test/key_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/key'
+
+class KeyTest < Test::Unit::TestCase
+  def test_char_to_name
+    assert_equal 'C-z', char_to_name('\x1A')
+  end
+
+  def test_name_to_char
+    assert_equal '\x1A', name_to_char('C-z')
+    assert_equal 'q', name_to_char('q')
+  end
+end

data/test/log_test.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/log'
+
+class Logger1
+  include Log
+  def initialize(file = 'log.txt')
+    @file = file
+  end
+end
+
+class LogTest < Test::Unit::TestCase
+  def test_log
+    `rm -rf tmp_test_log.txt`
+    l = Logger1.new 'tmp_test_log.txt'
+    l.log(a: [1, 2, { b: false, c: 'hello' }])
+    s = File.open('tmp_test_log.txt', 'r').read
+    assert_equal "------\n" + "[{:a=>[1, 2, {:b=>false, :c=>\"hello\"}]}]\n", s
+    `rm -rf tmp_test_log.txt`
+  end
+end

data/test/node_test.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+include Test::Unit::Assertions
+require_relative '../src/node'
+
+class NodeTest < Test::Unit::TestCase
+  def test_children
+    n = Node.new
+    assert_equal n.children, []
+    c = Node.new
+    n.append_child c
+    assert_equal n.children, [c]
+    assert_equal c.children, []
+  end
+
+  def test_visit_node
+    n = Node.new(
+      text: 'parent',
+      children: [
+        Node.new(name: 'child1'),
+        Node.new(name: 'child2', children: [
+                   Node.new(name: 'child2.1')
+                 ])
+      ]
+    )
+    assert_equal 'Node(name: node, children: [Node(name: child1, children: []), ' \
+                 'Node(name: child2, children: [Node(name: child2.1, children: [])])])',
+                 n.to_s
+    a = []
+    visit_node(n, proc { |child|
+      a.push child.name
+      false
+    })
+    assert_equal ['child1', 'child2.1', 'child2', 'node'], a
+  end
+
+  def test_query_by_attribute
+    n = Node.new(
+      text: 'parent',
+      attributes: {
+        foo: 'bar'
+      },
+      children: [
+        Node.new(
+          name: 'child1',
+          attributes: { a: 1.2 }
+        ),
+        Node.new(
+          name: 'child2',
+          attributes: { a: 1.2 },
+          children: [
+            Node.new(
+              name: 'child2.1',
+              attributes: { a: 1.2 }
+            )
+          ]
+        )
+      ]
+    )
+    result = n.query_by_attribute(:foo, 'bar')
+    assert_equal [n], result
+    assert_equal ['child1', 'child2.1', 'child2'], n.query_by_attribute(:a, 1.2).map(&:name)
+  end
+
+  def test_query_one_by_attribute
+    n = Node.new(
+      text: 'parent',
+      attributes: {
+      },
+      children: [
+        Node.new(
+          name: 'child1',
+          attributes: { a: 1.2 }
+        ),
+        Node.new(
+          name: 'child2',
+          attributes: { a: 1.2 },
+          children: [
+            Node.new(
+              name: 'child2.1',
+              attributes: { a: 1.2 }
+            )
+          ]
+        )
+      ]
+    )
+    result = n.query_one_by_attribute(:a, 1.2)
+    assert_equal 'child1', result.name
+  end
+
+  # def test_append_to
+  #   pend
+  # end
+
+  # def test_insert_children
+  #   pend
+  # end
+
+  # def test_remove
+  #   pend
+  # end
+
+  # def test_parent_prop
+  #   pend
+  # end
+end