termgui 0.0.4 → 0.0.5

data/test/element_test.rb

@@ -1,10 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,48 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-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