termgui 0.0.4 → 0.0.5

data/test/editor/editor_base_test.rb

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

data/test/element_bounds_test.rb

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

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

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

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