reflexion 0.5.3 → 0.7.0

data/test/test_link_constraint.rb

@@ -0,0 +1,237 @@
+require_relative 'helper'
+
+
+class TestLinkConstraint < Test::Unit::TestCase
+
+  include HasWindow
+
+  def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
+    Reflex::View.new(
+      frame: [x, y, w, h],
+      shape: Reflex::RectShape.new(density: 1),
+      **options, &block)
+  end
+
+  def point(...)
+    Reflex::Point.new(...)
+  end
+
+  def setup_views(win = window)
+    v1 = view 100, 100, dynamic: true
+    v2 = view 200, 100, static:  true
+    win&.add v1
+    win&.add v2
+    [v1, v2, win, win&.root]
+  end
+
+  def test_initial_state()
+    v1, v2, = setup_views
+
+    assert_equal v1,                v1.link(v2)              .pins[0].view
+    assert_equal v2,                v1.link(v2)              .pins[1].view
+    assert_nil                      v1.link(v2)              .axis
+    assert_equal_point point(1, 0), v1.link(v2, axis: [1, 0]).axis
+    assert_equal 100,               v1.link(v2)              .distance
+    assert_equal 1,                 v1.link(v2, distance: 1) .distance
+    assert_equal 2,                 v1.link(v2, dist:     2) .distance
+    assert_nil                      v1.link(v2)              .range
+    assert_equal 3..3,              v1.link(v2, range: 3)    .range
+    assert_equal 4..5,              v1.link(v2, range: 4..5) .range
+    assert_nil                      v1.link(v2)              .motor
+    assert_equal 6,                 v1.link(v2, motor: 6)    .motor
+    assert_nil                      v1.link(v2)              .force
+    assert_equal 8,                 v1.link(v2, force: 8)    .force
+    assert_nil                      v1.link(v2)              .spring
+    assert_equal 7,                 v1.link(v2, spring: 7)   .spring
+    assert_in_delta 0.7,            v1.link(v2)              .damping
+    assert_in_delta 0.1,            v1.link(v2, damping: 0.1).damping
+    assert_false                    v1.link(v2)              .collide?
+    assert_true                     v1.link(v2)              .active?
+    assert_false                    v1.link(v2)              .removed?
+  end
+
+  def test_link_to_view()
+    v1, v2, _, root = setup_views
+    root.gravity(-900, 0)
+
+    c = v1.link v2, dist: 50
+    assert_equal v2, c.pins[1].view
+
+    60.times {root.update_world}
+    assert_equal_point point(150, 100), v1.pos
+    assert_in_delta    50,              c.current_distance, 0.01
+  end
+
+  def test_link_to_world()
+    v1, _, _, root = setup_views
+    root.gravity(-900, 0)
+
+    c = v1.pin.link [200, 125], dist: 50
+    assert_nil c.pins[1].view
+
+    60.times {root.update_world}
+    assert_equal_point point(125, 100), v1.pos
+    assert_in_delta    50,              c.current_distance, 0.01
+  end
+
+  def test_distance()
+    v1, v2, = setup_views
+
+    c = v1.link v2, dist: 80, spring: 4
+    assert_equal 80, c.distance
+    assert_equal 80, c.dist
+
+    c.dist = 90
+    assert_equal 90, c.distance
+  end
+
+  def test_range()
+    v1, v2, _, root = setup_views
+    root.gravity 0, 900
+
+    c = v1.link v2, distance: 100, range: 0..120, spring: 1, damping: 0
+    60.times {root.update_world}
+    assert_operator c.current_distance, :<=, 121
+
+    c.range = nil
+    assert_nil c.range
+
+    assert_raise(ArgumentError) {c.range = 'invalid'}
+  end
+
+  def test_motor()
+    v1, v2, = setup_views
+
+    c = v1.link v2, motor: 10
+    assert_equal 10, c.motor
+
+    c.motor = nil
+    assert_nil c.motor
+  end
+
+  def test_force()
+    v1, v2, = setup_views
+
+    c = v1.link v2, motor: 10, force: 500
+    assert_equal 500, c.force
+
+    c.force = nil
+    assert_nil        c.force
+
+    c.force = 100
+    assert_equal 100, c.force
+
+    assert_raise(ArgumentError) {c.force = -1}
+  end
+
+  def test_axis_to_view()
+    v1, v2, _, root = setup_views
+    root.gravity 900, 900
+
+    c = v1.link v2, axis: [1, 0]
+    assert_equal_point point(1, 0), c.axis
+    assert_equal       v2,          c.pins[1].view
+
+    root.update_world
+    assert_operator    v1.linear_velocity.x, :>, 0
+    assert_in_delta 0, v1.linear_velocity.y # locked to the axis
+  end
+
+  def test_axis_to_world()
+    v1, _, _, root = setup_views
+    root.gravity 900, 900
+
+    c = v1.pin.link axis: [1, 0]
+    assert_nil c.pins[1].view
+
+    root.update_world
+    assert_operator    v1.linear_velocity.x, :>, 0
+    assert_in_delta 0, v1.linear_velocity.y
+  end
+
+  def test_axis_locks_rotation()
+    v1, v2, _, root = setup_views
+
+    v1.link v2, axis: [1, 0]
+
+    v1.angular_velocity = 90
+    3.times {root.update_world}
+    assert_in_delta 0, v1.angular_velocity # prismatic locks relative rotation
+  end
+
+  def test_axis_change()
+    v1, v2, _, root = setup_views
+    root.gravity 900, 900
+
+    c = v1.link v2, axis: [1, 0]
+    root.update_world
+    assert_operator    v1.linear_velocity.x, :>, 0
+    assert_in_delta 0, v1.linear_velocity.y
+
+    c.axis = [0, 1]
+    assert_equal_point point(0, 1), c.axis
+
+    root.update_world
+    assert_operator v1.linear_velocity.y, :>, 0
+  end
+
+  def test_axis_morphs_between_distance_and_rail()
+    v1, v2, = setup_views
+
+    c = v1.link v2
+    assert_nil c.axis # a distance joint has no axis
+
+    c.axis = [1, 0]
+    assert_equal_point point(1, 0), c.axis # now a rail
+
+    c.axis = nil
+    assert_nil c.axis # back to a distance joint
+  end
+
+  def test_axis_distance()
+    v1, v2, _, root = setup_views
+
+    c = v1.link v2, axis: [1, 0], distance: 30, spring: 4, damping: 1
+    assert_equal 30, c.distance
+
+    60.times {root.update_world}
+    assert_in_delta 30, c.current_distance, 1 # the spring drives to the rest
+  end
+
+  def test_axis_distance_is_rest_not_translation()
+    v1, v2, _, root = setup_views
+    root.gravity 900, 0
+
+    c = v1.link v2, axis: [1, 0]
+    3.times {root.update_world}
+    assert_operator c.current_distance.abs, :>, 0 # slides along the axis
+    assert_in_delta 0, c.distance                 # but the rest stays put
+  end
+
+  def test_axis_range()
+    v1, v2, _, root = setup_views
+    root.gravity 0, 900
+
+    c = v1.pin(25, 25).link v2.pin(25, 25), axis: [0, 1], range: 100..200
+    assert_equal 100..200, c.range
+
+    60.times {root.update_world}
+    assert_equal_point point(200, 300), v1.pos
+  end
+
+  def test_axis_motor()
+    v1, v2, _, root = setup_views
+    root.gravity(-900, 0)
+
+    c = v1.link v2, axis: [1, 0], motor: 100
+    assert_equal 100, c.motor
+
+    3.times {root.update_world}
+    assert_operator    v1.linear_velocity.x, :>, 1
+    assert_in_delta 0, v1.linear_velocity.y
+
+    c.motor = nil
+    assert_nil c.motor
+  end
+
+end# TestLinkConstraint

data/test/test_menu.rb

@@ -0,0 +1,237 @@
+require_relative 'helper'
+
+
+class TestMenu < Test::Unit::TestCase
+
+  def menu(*args, &block)
+    Reflex::Menu.new(*args, &block)
+  end
+
+  def test_initialize()
+    assert_equal '',     menu.label
+    assert_equal 'File', menu(:File).label
+  end
+
+  def test_add_child()
+    menu.tap do |m|
+      m.add menu(:A)
+      m.add menu(:B)
+      m.add menu(:C), index: 1
+      assert_equal 3,         m.size
+      assert_equal %w[A C B], m.map(&:label)
+    end
+
+    menu.tap do |m|
+      m.add menu(:A)
+      m.add menu(:B), index: 0
+      m.add menu(:C), index: m.size
+      assert_equal %w[B A C], m.map(&:label)
+    end
+
+    menu.tap do |m|
+      m.add menu(:A)
+      m.add menu(:B), index: 99
+      m.add menu(:C), index: -1
+      m.add menu(:D), index: nil
+      assert_equal %w[A B C D], m.map(&:label)
+    end
+  end
+
+  def test_add_twice_to_same_parent()
+    m = menu
+    c = m.add menu
+    m.add c
+    assert_equal 1, m.size
+  end
+
+  def test_add_child_having_other_parent_raises()
+    a, b = menu, menu
+    c    = a.add menu
+    assert_raise(ArgumentError, Reflex::ReflexError) {b.add c}
+  end
+
+  def test_add_nil_raises()
+    assert_raise(TypeError, ArgumentError) {menu.add nil}
+  end
+
+  def test_remove()
+    m = menu
+    a = m.add menu(:A)
+    m.add menu(:B)
+    m.remove a
+    assert_equal %w[B], m.map(&:label)
+  end
+
+  def test_clear_children()
+    m = menu
+    m.add menu(:A)
+    m.clear_children
+    assert_true m.empty?
+  end
+
+  def test_find_children()
+    root = menu
+    root.add(menu(:A)).name = :x
+    root.add(menu(:B)).name = :x
+    root.add(menu(:C)).name = :y
+    assert_equal 2, root.find_children(:x).size
+  end
+
+  def test_find_children_recursive()
+    root = menu
+    file = root.add menu(:File)
+    file.add(menu :Open).name = :x
+    assert_equal 1, root.find_children(:x)       .size
+    assert_equal 0, root.find_children(:x, false).size
+  end
+
+  def test_label()
+    m       = menu
+    m.label = :Open
+    assert_equal 'Open', m.label
+  end
+
+  def test_label_changes_separator()
+    m       = menu :File
+    assert_false m.separator?
+    m.label = '-'
+    assert_true  m.separator?
+    m.label = :Edit
+    assert_false m.separator?
+  end
+
+  def test_enable_and_disable()
+    m = menu
+    assert_true  m.enabled?
+    m.enable false
+    assert_false m.enabled?
+    m.enable
+    assert_true  m.enabled?
+    m.disable
+    assert_false m.enabled?
+  end
+
+  def test_check_and_uncheck()
+    m = menu
+    assert_false m.checked?
+    m.check true
+    assert_true  m.checked?
+    m.uncheck
+    assert_false m.checked?
+    m.check
+    assert_true  m.checked?
+  end
+
+  def test_shortcut()
+    m = menu
+    m.shortcut_key = :s
+    assert_equal :s, m.shortcut_key
+    assert_equal [], m.shortcut_modifiers
+
+    m.shortcut = [:c, :control]
+    assert_equal :c,          m.shortcut_key
+    assert_equal [:control],  m.shortcut_modifiers
+  end
+
+  def test_shortcut_key_symbol_roundtrip()
+    m = menu
+    # non-character keys are representable now (were impossible as strings)
+    m.shortcut_key = :f1
+    assert_equal :f1, m.shortcut_key
+    m.shortcut_key = :left
+    assert_equal :left, m.shortcut_key
+
+    # a KeyCode constant is also accepted directly
+    m.shortcut_key = Reflex::KEY_A
+    assert_equal :a, m.shortcut_key
+
+    # nil clears it
+    m.shortcut_key = nil
+    assert_nil m.shortcut_key
+  end
+
+  def test_shortcut_key_unknown_symbol_raises()
+    assert_raise(ArgumentError) {menu.shortcut_key = :nonexistent}
+  end
+
+  def test_shortcut_key_keeps_modifiers()
+    m = menu
+    m.shortcut = [:c, :control, :shift]
+    assert_equal :c,                     m.shortcut_key
+    assert_equal %i[control shift].sort, m.shortcut_modifiers.sort
+    m.shortcut_key = :v
+    assert_equal :v,                     m.shortcut_key
+    assert_equal %i[control shift].sort, m.shortcut_modifiers.sort
+  end
+
+  def test_shortcut_modifiers_unsupported_on_platform_raise()
+    if osx?
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:win]}
+    elsif win32?
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:command]}
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:win]}
+    end
+  end
+
+  def test_image()
+    m, img  = menu, Reflex::Image.new(8, 8)
+    assert_nil        m.image
+    m.image = img
+    assert_equal img, m.image
+    m.image = nil
+    assert_nil        m.image
+
+    assert_raise(TypeError) {m.image = 1}
+  end
+
+  def test_separator()
+    assert_false menu(:File).separator?
+    assert_true  menu('-').separator?
+    assert_true  menu('---').separator?
+    assert_false menu('').separator?
+  end
+
+  def test_parent()
+    m = menu
+    c = m.add menu
+    assert_equal m, c.parent
+    assert_nil      m.parent
+    m.remove c
+    assert_nil      c.parent
+  end
+
+  def test_children()
+    m = menu
+    c = m.add menu
+    assert_equal [c], m.children
+    assert_equal  c,  m.first
+  end
+
+  def test_each_without_block()
+    m = menu
+    m.add menu(:A)
+    assert_kind_of Enumerator, m.each
+    assert_equal %w[A], m.each.map(&:label)
+  end
+
+  def test_nested()
+    root = menu
+    file = root.add menu(:File)
+    file.add menu(:Open)
+    assert_equal 'Open', root.first.first.label
+  end
+
+  def test_event_hooks()
+    m     = menu
+    fired = []
+    %i[click show hide open_submenu close_submenu].each {|ev| m.on(ev) {|e| fired << ev}}
+    e     = Reflex::UpdateEvent.new 0, 0
+    m.on_click e
+    m.on_show e
+    m.on_hide e
+    m.on_open_submenu e
+    m.on_close_submenu e
+    assert_equal %i[click show hide open_submenu close_submenu], fired
+  end
+
+end# TestMenu

data/test/test_pin.rb

@@ -0,0 +1,65 @@
+require_relative 'helper'
+
+
+class TestPin < Test::Unit::TestCase
+
+  def pin(...)
+    Reflex::Pin.new(...)
+  end
+
+  def view()
+    Reflex::View.new frame: [0, 0, 50, 50]
+  end
+
+  def point(*args)
+    Reflex::Point.new(*args)
+  end
+
+  def test_initialize()
+    v = view
+    assert_nil                pin                .view
+    assert_nil                pin                .pos
+    assert_nil                pin(         1)    .view
+    assert_equal point(1, 1), pin(         1)    .pos
+    assert_nil                pin(         2, 3) .view
+    assert_equal point(2, 3), pin(         2, 3) .pos
+    assert_equal v,           pin(v)             .view
+    assert_nil                pin(v)             .pos
+    assert_equal v,           pin(v,       4, 5) .view
+    assert_equal point(4, 5), pin(v,       4, 5) .pos
+    assert_equal v,           pin(v,      [6, 7]).view
+    assert_equal point(6, 7), pin(v,      [6, 7]).pos
+    assert_equal v,           pin(v, point(8, 9)).view
+    assert_equal point(8, 9), pin(v, point(8, 9)).pos
+  end
+
+  def test_dup()
+    v = view
+    assert_nil                pin         .dup.view
+    assert_nil                pin         .dup.pos
+    assert_nil                pin(   1, 2).dup.view
+    assert_equal point(1, 2), pin(   1, 2).dup.pos
+    assert_equal v,           pin(v, 3, 4).dup.view
+    assert_equal point(3, 4), pin(v, 3, 4).dup.pos
+  end
+
+  def test_pin()
+    v = view
+    assert_instance_of Reflex::Pin, v.pin
+
+    assert_equal v,           v.pin             .view
+    assert_nil                v.pin             .pos
+    assert_equal v,           v.pin(      1)    .view
+    assert_equal point(1, 1), v.pin(      1)    .pos
+    assert_equal v,           v.pin(      2, 3) .view
+    assert_equal point(2, 3), v.pin(      2, 3) .pos
+    assert_equal v,           v.pin(     [4, 5]).view
+    assert_equal point(4, 5), v.pin(     [4, 5]).pos
+    assert_equal v,           v.pin(point(6, 7)).view
+    assert_equal point(6, 7), v.pin(point(6, 7)).pos
+
+    assert_raise(TypeError) {v.pin view}
+    assert_raise(TypeError) {v.pin "invalid"}
+  end
+
+end# TestPin

data/test/test_pointer.rb

@@ -3,20 +3,24 @@ require_relative 'helper'
 
 class TestPointer < Test::Unit::TestCase
 
-  TYPE_NONE = Reflex::Pointer::TYPE_NONE
-  MOUSE     = Reflex::Pointer::MOUSE
-  LEFT      = Reflex::Pointer::MOUSE_LEFT
-  RIGHT     = Reflex::Pointer::MOUSE_RIGHT
-  MIDDLE    = Reflex::Pointer::MOUSE_MIDDLE
-  TOUCH     = Reflex::Pointer::TOUCH
-  PEN       = Reflex::Pointer::PEN
-
-  ACTION_NONE = Reflex::Pointer::ACTION_NONE
-  DOWN        = Reflex::Pointer::DOWN
-  UP          = Reflex::Pointer::UP
-  MOVE        = Reflex::Pointer::MOVE
-  STAY        = Reflex::Pointer::STAY
-  CANCEL      = Reflex::Pointer::CANCEL
+  R = Reflex
+
+  TYPE_NONE = R::Pointer::TYPE_NONE
+  MOUSE     = R::Pointer::MOUSE
+  LEFT      = R::Pointer::MOUSE_LEFT
+  RIGHT     = R::Pointer::MOUSE_RIGHT
+  MIDDLE    = R::Pointer::MOUSE_MIDDLE
+  TOUCH     = R::Pointer::TOUCH
+  PEN       = R::Pointer::PEN
+
+  ACTION_NONE = R::Pointer::ACTION_NONE
+  DOWN        = R::Pointer::DOWN
+  UP          = R::Pointer::UP
+  MOVE        = R::Pointer::MOVE
+  CANCEL      = R::Pointer::CANCEL
+  ENTER       = R::Pointer::ENTER
+  LEAVE       = R::Pointer::LEAVE
+  STAY        = R::Pointer::STAY
 
   T = true
   F = false
@@ -26,8 +30,7 @@ class TestPointer < Test::Unit::TestCase
     position: 0, modifiers: 0, click_count: 0, drag: false,
     time: 0)
 
-    Reflex::Pointer.new(
-      id, types, action, position, modifiers, click_count, drag, time)
+    R::Pointer.new(id, types, action, position, modifiers, click_count, drag, time)
   end
 
   def test_initialize()
@@ -44,7 +47,7 @@ class TestPointer < Test::Unit::TestCase
     assert_equal [2, 3],   p.position.to_a
     assert_equal 2,        p.x
     assert_equal 3,        p.y
-    assert_equal 4,        p.modifiers
+    assert_equal [:shift], p.modifiers
     assert_equal 5,        p.click_count
     assert_equal true,     p.drag?
     assert_equal 6,        p.time
@@ -99,28 +102,34 @@ class TestPointer < Test::Unit::TestCase
     def action(a)
       pointer(action: a).tap do |o|
         def o.test()
-          [action, down?, up?, move?, cancel?, stay?]
+          [action, down?, up?, move?, cancel?, enter?, leave?, stay?]
         end
       end
     end
 
     o = action ACTION_NONE
-    assert_equal [:none,   F, F, F, F, F], o.test
+    assert_equal [:none,   F, F, F, F, F, F, F], o.test
 
     o = action DOWN
-    assert_equal [:down,   T, F, F, F, F], o.test
+    assert_equal [:down,   T, F, F, F, F, F, F], o.test
 
     o = action UP
-    assert_equal [:up,     F, T, F, F, F], o.test
+    assert_equal [:up,     F, T, F, F, F, F, F], o.test
 
     o = action MOVE
-    assert_equal [:move,   F, F, T, F, F], o.test
+    assert_equal [:move,   F, F, T, F, F, F, F], o.test
 
     o = action CANCEL
-    assert_equal [:cancel, F, F, F, T, F], o.test
+    assert_equal [:cancel, F, F, F, T, F, F, F], o.test
+
+    o = action ENTER
+    assert_equal [:enter,  F, F, F, F, T, F, F], o.test
+
+    o = action LEAVE
+    assert_equal [:leave,  F, F, F, F, F, T, F], o.test
 
     o = action STAY
-    assert_equal [:stay,   F, F, F, F, T], o.test
+    assert_equal [:stay,   F, F, F, F, F, F, T], o.test
   end
 
   def test_position()
@@ -133,6 +142,12 @@ class TestPointer < Test::Unit::TestCase
     assert_equal 2, pointer(position: [1, 2]).y
   end
 
+  def test_modifiers()
+    p = pointer modifiers: R::MOD_SHIFT | R::MOD_NUMPAD
+    assert_equal [:shift],          p.modifiers
+    assert_equal [:shift, :numpad], p.modifiers(all: true)
+  end
+
   def test_down()
     assert_equal 1, pointer(id: 1, action: DOWN).down.id # DOWN pointer's down() returns itself
     assert_nil      pointer(id: 2, action: UP)  .down
@@ -142,8 +157,8 @@ class TestPointer < Test::Unit::TestCase
     assert_equal pointer, pointer
 
     assert_not_equal pointer, pointer(id:          1)
-    assert_not_equal pointer, pointer(types:       Reflex::Pointer::PEN)
-    assert_not_equal pointer, pointer(action:      Reflex::Pointer::UP)
+    assert_not_equal pointer, pointer(types:       R::Pointer::PEN)
+    assert_not_equal pointer, pointer(action:      R::Pointer::UP)
     assert_not_equal pointer, pointer(position:    2)
     assert_not_equal pointer, pointer(modifiers:   3)
     assert_not_equal pointer, pointer(click_count: 4)
@@ -151,4 +166,13 @@ class TestPointer < Test::Unit::TestCase
     assert_not_equal pointer, pointer(time:        5)
   end
 
+  def test_inspect()
+    assert_equal(
+      '#<Reflex::Pointer id:1 [:mouse, :mouse_left] :up (2.0, 3.0) mod:[:shift, :control] click:5 drag:true time:4.0>',
+      pointer(
+        id: 1, types: MOUSE | LEFT, action: UP, position: [2, 3], modifiers: 6,
+        click_count: 5, drag: true, time: 4
+      ).inspect)
+  end
+
 end# TestPointer