termgui 0.0.5 → 0.0.6

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

data/test/performance/performance1.rb

@@ -0,0 +1,48 @@
+# warning: execute this in a real terminal (not in vscode's) because of performance
+
+require_relative '../../src/widget/button'
+require_relative '../../src/screen'
+require_relative '../../src/util'
+
+def test(timeout: 3, box_count: 80, interval: 0.01, render_count: 1, screen_width: 120, screen_height: 32, text_length: 5, no_buffer: false)
+  t0 = Time.now
+  i = 0
+  s = Screen.new(width: screen_width, height: screen_height)
+  s.renderer.no_buffer = no_buffer
+  s.set_timeout(timeout) do
+    config = {
+      timeout: timeout, box_count: box_count, interval: interval, render_count: render_count, screen_width:
+      screen_width, screen_height: screen_height, text_length: text_length, no_buffer: no_buffer
+    }
+    s.clear
+    s.destroy
+    print_string "\r
+Iteration ##{i} \r
+Time: #{Time.now - t0} \r
+Config: #{config} \r"
+  end
+
+  draw = proc {
+    box_count.times do |j|
+      s.append_child Button.new(x: random_int(2, s.width - 20),
+      y: random_int(1, s.height - 4), text: "button#{j}",
+      style: { bg: random_color, fg: random_color, border: { style: 'single', fg: random_color } })
+    end
+  }
+  step = proc {
+    i += 1
+    s.empty
+    s.clear
+    draw.call
+    l = s.append_child Label.new(text: "iteration ##{i} **")
+    render_count.times { s.render }
+    s.set_timeout(interval) do
+      step.call
+    end
+  }
+  step.call
+  s.start
+end
+
+test(render_count: 10, no_buffer: true)
+# test(screen_width: nil, screen_height: nil)

data/test/renderer_test.rb

@@ -0,0 +1,74 @@
+require_relative '../src/renderer'
+require_relative '../src/util'
+require 'test/unit'
+include Test::Unit::Assertions
+
+class RendererTest < Test::Unit::TestCase
+  def test_rect_stub
+    assert_include "\e[2;2Hllllllll" \
+                   "\e[3;2Hllllllll" \
+                   "\e[4;2Hllllllll" \
+                   "\e[5;2Hllllllll" \
+                   "\e[6;2Hllllllll", `ruby test/renderer_test_rect.rb`
+  end
+
+  def test_rect
+    r = Renderer.new
+    s = r.rect x: 2, y: 1, width: 3, height: 2, ch: 'x'
+    assert_equal  "\e[2;2Hxxx\e[3;2Hxxx", s
+  end
+
+  def test_print
+    r2 = Renderer.new 10, 7
+    r2.rect x: 2, y: 1, width: 3, height: 2, ch: 'x'
+    assert_equal                  '          \\n' \
+                 '  xxx     \\n' \
+                 '  xxx     \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n', r2.print
+
+    r2.rect x: 4, y: 2, width: 2, height: 3, ch: 'y'
+    assert_equal                 '          \\n' \
+                 '  xxx     \\n' \
+                 '  xxyy    \\n' \
+                 '    yy    \\n' \
+                 '    yy    \\n' \
+                 '          \\n' \
+                 '          \\n', r2.print
+    r2.clear
+    assert_equal '          \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n' \
+                 '          \\n', r2.print
+  end
+
+  def test_circle
+    s = Screen.new_for_testing(width: 30, height: 20)
+    s.circle(x: 10, y: 10, radius: 6, stroke: Style.new(bg: 'green', fg: 'red'), stroke_ch: 'x', fill: Style.new(bg: 'blue'), fill_ch: 'o')
+    assert_equal'                              \n' \
+                '                              \n' \
+                '                              \n' \
+                '                              \n' \
+                '        xxxxx                 \n' \
+                '       xooooox                \n' \
+                '      xooooooox               \n' \
+                '     xooooooooox              \n' \
+                '    xooooooooooox             \n' \
+                '    xooooooooooox             \n' \
+                '    xooooooooooox             \n' \
+                '    xooooooooooox             \n' \
+                '    xooooooooooox             \n' \
+                '     xooooooooox              \n' \
+                '      xooooooox               \n' \
+                '       xooooox                \n' \
+                '        xxxxx                 \n' \
+                '                              \n' \
+                '                              \n' \
+                '                              \n', s.print
+  end
+end