termgui 0.0.5 → 0.0.6

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

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