reflexion 0.5.2 → 0.6.0

data/test/test_menu.rb

@@ -0,0 +1,207 @@
+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, :command]
+    assert_equal 'c',         m.shortcut_key
+    assert_equal [:command],  m.shortcut_modifiers
+  end
+
+  def test_shortcut_key_keeps_modifiers()
+    m = menu
+    m.shortcut = [:c, :command, :shift]
+    assert_equal  'c',                   m.shortcut_key
+    assert_equal %i[command shift].sort, m.shortcut_modifiers.sort
+    m.shortcut_key = :v
+    assert_equal     'v',                m.shortcut_key
+    assert_equal %i[command shift].sort, m.shortcut_modifiers.sort
+  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

@@ -15,8 +15,10 @@ class TestPointer < Test::Unit::TestCase
   DOWN        = Reflex::Pointer::DOWN
   UP          = Reflex::Pointer::UP
   MOVE        = Reflex::Pointer::MOVE
-  STAY        = Reflex::Pointer::STAY
   CANCEL      = Reflex::Pointer::CANCEL
+  ENTER       = Reflex::Pointer::ENTER
+  LEAVE       = Reflex::Pointer::LEAVE
+  STAY        = Reflex::Pointer::STAY
 
   T = true
   F = false
@@ -44,7 +46,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 +101,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 +141,12 @@ class TestPointer < Test::Unit::TestCase
     assert_equal 2, pointer(position: [1, 2]).y
   end
 
+  def test_modifiers()
+    p = pointer modifiers: Reflex::MOD_SHIFT | Reflex::MOD_NUMPAD
+    assert_equal [:shift, :numpad], p.modifiers
+    assert_equal [:shift],          p.modifiers(locks: false)
+  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

data/test/test_pointer_event.rb

@@ -50,7 +50,7 @@ class TestPointerEvent < Test::Unit::TestCase
     assert_equal [2, 3],   e.pos     .to_a
     assert_equal 2,        e.x
     assert_equal 3,        e.y
-    assert_equal 4,        e.modifiers
+    assert_equal [:shift], e.modifiers
     assert_equal 5,        e.click_count
     assert_equal true,     e.drag?
     assert_equal 6,        e.time

data/test/test_snap_constraint.rb

@@ -0,0 +1,142 @@
+require_relative 'helper'
+
+
+class TestSnapConstraint < Test::Unit::TestCase
+
+  def window()
+    Reflex::Window.new
+  end
+
+  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.snap(v2)              .pins[0].view
+    assert_equal v2,     v1.snap(v2)              .pins[1].view
+    assert_nil           v1.snap(v2)              .angle
+    assert_equal 1..1,   v1.snap(v2, angle: 1)    .angle
+    assert_equal 2..3,   v1.snap(v2, angle: 2..3) .angle
+    assert_nil           v1.snap(v2)              .motor
+    assert_equal 4,      v1.snap(v2, motor: 4)    .motor
+    assert_nil           v1.snap(v2)              .force
+    assert_equal 6,      v1.snap(v2, force: 6)    .force
+    assert_nil           v1.snap(v2)              .spring
+    assert_equal 5,      v1.snap(v2, spring: 5)   .spring
+    assert_in_delta 0.7, v1.snap(v2)              .damping
+    assert_in_delta 0.1, v1.snap(v2, damping: 0.1).damping
+    assert_false         v1.snap(v2)              .collide?
+    assert_true          v1.snap(v2)              .active?
+    assert_false         v1.snap(v2)              .removed?
+  end
+
+  def test_snap_keeps_positions()
+    v1, v2, _, root = setup_views
+    v1.angle = 45
+
+    v1.snap v2 # nothing moves
+
+    10.times {root.update_world}
+    assert_equal_point point(0), v1.linear_velocity
+  end
+
+  def test_snap_pulls_together()
+    v1, v2, _, root = setup_views
+
+    v1.pin(25, 25).snap v2.pin(25, 25), angle: 0, spring: 4
+
+    root.update_world
+    assert_operator v1.linear_velocity.x, :>, 0
+  end
+
+  def test_snap_to_world()
+    v1, _, _, root = setup_views
+    root.gravity 0, 900
+
+    c = v1.snap
+    assert_nil c.pins[1].view
+
+    60.times {root.update_world}
+    assert_in_delta 100, v1.frame.y, 0.01 # hangs against gravity
+  end
+
+  def test_weld_fixes_angle()
+    v1, v2, _, root = setup_views
+
+    v1.snap v2, angle: 0 # welds and fixes the angle
+    v1.angular_velocity = 90
+
+    10.times {root.update_world}
+    assert_in_delta 0, v1.angular_velocity
+  end
+
+  def test_angle()
+    v1, v2, = setup_views
+
+    c = v1.snap v2, angle: -30..90
+    assert_equal(-30..90, c.angle)
+
+    c.angle = 0
+    assert_equal 0..0, c.angle
+
+    c.angle = nil
+    assert_nil c.angle
+
+    assert_raise(ArgumentError) {c.angle = 'invalid'}
+  end
+
+  def test_motor()
+    v1, v2, _, root = setup_views
+
+    c = v1.snap v2, motor: 90
+    assert_equal 90, c.motor
+
+    3.times {root.update_world}
+    assert_in_delta 90, v1.angular_velocity
+
+    c.motor = nil
+    assert_nil c.motor
+  end
+
+  def test_force()
+    v1, v2, = setup_views
+
+    c = v1.snap v2, motor: 90, 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_force_limits_the_motor()
+    v1, v2, _, root = setup_views
+
+    v1.snap v2, motor: 90, force: 0 # a powerless motor can not spin
+
+    3.times {root.update_world}
+    assert_in_delta 0, v1.angular_velocity
+  end
+
+end# TestSnapConstraint

data/test/test_view.rb

@@ -85,12 +85,36 @@ class TestView < Test::Unit::TestCase
   end
 
   def test_add_child()
+    view.tap do |v|
+      v.add view(name: :a)
+      v.add view(name: :b)
+      v.add view(name: :c), index: 1
+      assert_equal %w[a c b], v.children.map(&:name)
+    end
+
+    view.tap do |v|
+      v.add view(name: :a)
+      v.add view(name: :b), index: 0
+      v.add view(name: :c), index: v.children.to_a.size
+      assert_equal %w[b a c], v.children.map(&:name)
+    end
+
+    view.tap do |v|
+      v.add view(name: :a)
+      v.add view(name: :b), index: 99
+      v.add view(name: :c), index: -1
+      v.add view(name: :d), index: nil
+      assert_equal %w[a b c d], v.children.map(&:name)
+    end
+
+    view.tap do |v|
+      assert_nothing_raised       {v.add_child view}
+      assert_raise(ArgumentError) {v.add_child v}
+    end
+
     assert_raise(ArgumentError) {view.add_child}
-    assert_raise(TypeError) {view.add_child nil}
-    assert_raise(TypeError) {view.add_child 1}
-    v = view
-    assert_raise(ArgumentError) {v.add_child v}
-    assert_nothing_raised {v.add_child view}
+    assert_raise(TypeError)     {view.add_child nil}
+    assert_raise(TypeError)     {view.add_child 1}
   end
 
   def test_remove_child()
@@ -144,6 +168,18 @@ class TestView < Test::Unit::TestCase
     assert_not_includes v.find_styles(selector name: :N), s
   end
 
+  def test_find_styles()
+    v, s = view, style(name: :N1, tag: :T1)
+    s.add_tag :T2
+    v.add_style s
+
+    assert_includes v.find_styles(:N1),                       s
+    assert_includes v.find_styles(selector tag:   :T1),       s
+    assert_includes v.find_styles(selector tags: [:T1, :T2]), s
+    assert_empty    v.find_styles(selector tags: [:T1, :X])
+    assert_empty    v.find_styles(selector tag:   :X)
+  end
+
   def test_shape()
     s = shape
     assert_equal 0, s.density
@@ -194,26 +230,80 @@ class TestView < Test::Unit::TestCase
   end
 
   def test_add_remove_shape()
-    s = shape name: :S
-    s.density =  1
-    assert_equal 1, s.density
-
-    v = view
-    assert_equal 0,     v.shapes.to_a.size
-
+    view.tap do |v|
+      s = shape name: :S
+      s.density =  1
+      assert_equal 1, s.density
+
+      assert_equal 0,     v.shapes.to_a.size
+
+      v.add_shape s
+      assert_equal 1,     v.shapes.to_a.size
+      assert_includes     v.find_shapes(selector name: :S), s
+      assert_equal 1,     v.find_shapes(selector name: :S).first.density
+
+      v.remove_shape s
+      assert_equal 0,     v.shapes.to_a.size
+      assert_not_includes v.find_shapes(selector name: :S), s
+
+      v.add_shape s
+      assert_equal 1,     v.shapes.to_a.size
+      v.clear_shapes
+      assert_equal 0,     v.shapes.to_a.size
+    end
+
+    view.tap do |v|
+      v.add_shape shape(name: :a)
+      v.add_shape shape(name: :b)
+      v.add_shape shape(name: :c), index: 1
+      assert_equal %w[a c b], v.shapes.map(&:name)
+    end
+
+    view.tap do |v|
+      v.add_shape shape(name: :a)
+      v.add_shape shape(name: :b), index: 0
+      v.add_shape shape(name: :c), index: v.shapes.to_a.size
+      assert_equal %w[b a c], v.shapes.map(&:name)
+    end
+
+    view.tap do |v|
+      v.add_shape shape(name: :a)
+      v.add_shape shape(name: :b), index: 99
+      v.add_shape shape(name: :c), index: -1
+      v.add_shape shape(name: :d), index: nil
+      assert_equal %w[a b c d], v.shapes.map(&:name)
+    end
+  end
+
+  def test_find_shapes()
+    v, s = view, shape(name: :N1, tag: :T1)
+    s.add_tag :T2
     v.add_shape s
-    assert_equal 1,     v.shapes.to_a.size
-    assert_includes     v.find_shapes(selector name: :S), s
-    assert_equal 1,     v.find_shapes(selector name: :S).first.density
-
-    v.remove_shape s
-    assert_equal 0,     v.shapes.to_a.size
-    assert_not_includes v.find_shapes(selector name: :S), s
 
-    v.add_shape s
-    assert_equal 1,     v.shapes.to_a.size
-    v.clear_shapes
-    assert_equal 0,     v.shapes.to_a.size
+    assert_includes v.find_shapes(:N1),                       s
+    assert_includes v.find_shapes(selector tag:   :T1),       s
+    assert_includes v.find_shapes(selector tags: [:T1, :T2]), s
+    assert_empty    v.find_shapes(selector tags: [:T1, :X])
+    assert_empty    v.find_shapes(selector tag:   :X)
+  end
+
+  def test_find_constraints()
+    win = window
+    v1 = view frame: [100, 100, 50, 50], shape: shape(density: 1), dynamic: true
+    v2 = view frame: [200, 100, 50, 50], shape: shape(density: 1), static:  true
+    win.add v1
+    win.add v2
+
+    c = v1.link v2, name: :N1, tag: :T1
+    c.add_tag :T2
+
+    [v1, v2].each do |v|
+      assert_includes v.find_constraints(:N1),                       c
+      assert_includes v.find_constraints(selector tag:   :T1),       c
+      assert_includes v.find_constraints(selector tags: [:T1, :T2]), c
+      assert_empty    v.find_constraints(selector tags: [:T2, :X])
+      assert_empty    v.find_constraints(selector tags: [:X])
+    end
   end
 
   def test_name()