reflexion 0.5.2 → 0.6.0

data/test/test_application.rb

@@ -11,6 +11,17 @@ class TestApplication < Test::Unit::TestCase
     assert_equal 'AppName', @@app.name
   end
 
+  def test_menu()
+    m          = Reflex::Menu.new
+    assert_nil      @@app.menu
+    @@app.menu = m
+    assert_equal m, @@app.menu
+    @@app.menu = nil
+    assert_nil      @@app.menu
+
+    assert_raise(TypeError) {@@app.menu = 1}
+  end
+
   def test_inspect()
     assert_match %r|#<Reflex::Application:0x\w{16}>|, @@app.inspect
   end

data/test/test_chase_constraint.rb

@@ -0,0 +1,124 @@
+require_relative 'helper'
+
+
+class TestChaseConstraint < 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.chase(v2)              .pins[0].view
+    assert_nil           v1.chase(v2)              .pins[1].view
+    assert_equal v2,     v1.chase(v2)              .target.view
+    assert_nil           v1.chase(v2)              .force
+    assert_equal 1,      v1.chase(v2, force: 1)    .force
+    assert_equal 5,      v1.chase(v2)              .spring
+    assert_equal 2,      v1.chase(v2, spring: 2)   .spring
+    assert_in_delta 0.7, v1.chase(v2)              .damping
+    assert_in_delta 0.1, v1.chase(v2, damping: 0.1).damping
+    assert_false         v1.chase(v2)              .collide?
+    assert_true          v1.chase(v2)              .active?
+    assert_false         v1.chase(v2)              .removed?
+  end
+
+  def test_chase_view()
+    v1, v2, _, root = setup_views
+
+    c = v1.chase v2
+    assert_equal v2, c.target.view
+
+    root.update_world
+    assert_operator v1.linear_velocity.x, :>, 0
+  end
+
+  def test_chase_world_point()
+    v1, _, _, root = setup_views
+
+    c = v1.chase            [300, 300]
+    assert_nil                          c.target.view
+    assert_equal_point point(300, 300), c.target.pos
+
+    root.update_world
+    assert_operator v1.linear_velocity.x, :>, 0
+    assert_operator v1.linear_velocity.y, :>, 0
+  end
+
+  def test_grabbing_corner_creates_torque()
+    v1, _, _, root = setup_views
+
+    c = v1.pin(0, 0).chase [300, 100], spring: 8
+    assert_equal_point point(0, 0), c.pins[0].pos
+
+    3.times {root.update_world}
+    assert_operator v1.angular_velocity.abs, :>, 1
+  end
+
+  def test_chase_to_itself_error()
+    v1, v2, = setup_views
+
+    assert_raise(ArgumentError) {v1.chase v1}
+    assert_raise(ArgumentError) {v1.chase(v2).target = v1}
+  end
+
+  def test_target()
+    v1, v2, = setup_views
+
+    c = v1.chase [300, 300]
+    assert_nil                          c.target.view
+    assert_equal_point point(300, 300), c.target.pos
+
+    c.target =   v2
+    assert_equal v2,                    c.target.view
+    assert_nil                          c.target.pos
+
+    c.target = v2.pin(0, 0)
+    assert_equal v2,                    c.target.view
+    assert_equal_point point(0, 0),     c.target.pos
+
+    c.target = [v2, 5, 5]
+    assert_equal v2,                    c.target.view
+    assert_equal_point point(5, 5),     c.target.pos
+
+    c.target = nil
+    assert_nil                          c.target.view
+    assert_nil                          c.target.pos
+  end
+
+  def test_force()
+    v1, = setup_views
+
+    c = v1.chase [300, 100], 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
+
+end# TestChaseConstraint

data/test/test_clipboard.rb

@@ -0,0 +1,54 @@
+require_relative 'helper'
+
+
+class TestClipboard < Test::Unit::TestCase
+
+  def setup()
+    @saved_text = Reflex::Clipboard.text
+  end
+
+  def teardown()
+    if @saved_text
+      Reflex::Clipboard.text = @saved_text
+    else
+      Reflex::Clipboard.clear
+    end
+  end
+
+  def test_initialize()
+    assert_raise(Reflex::ReflexError) {Reflex::Clipboard.new}
+  end
+
+  def test_text()
+    Reflex::Clipboard.text = 'ABC'
+    assert_equal 'ABC', Reflex::Clipboard.text
+  end
+
+  def test_text_utf8()
+    Reflex::Clipboard.text = 'あいう'
+    assert_equal 'あいう',        Reflex::Clipboard.text
+    assert_equal Encoding::UTF_8, Reflex::Clipboard.text.encoding
+  end
+
+  def test_text_multiline()
+    Reflex::Clipboard.text = "A\nB\nC"
+    assert_equal "A\nB\nC", Reflex::Clipboard.text
+  end
+
+  def test_universal_accessor()
+    Reflex::Clipboard.text 'ABC'
+    assert_equal 'ABC', Reflex::Clipboard.text
+  end
+
+  def test_clear()
+    Reflex::Clipboard.text = 'ABC'
+    Reflex::Clipboard.clear
+    assert_nil Reflex::Clipboard.text
+  end unless linux?
+
+  def test_empty_text()
+    Reflex::Clipboard.text = ''
+    assert_equal '', Reflex::Clipboard.text
+  end unless linux?
+
+end# TestClipboard

data/test/test_constraint.rb

@@ -0,0 +1,186 @@
+require_relative 'helper'
+
+
+class TestConstraint < Test::Unit::TestCase
+
+  R = Reflex
+
+  def window()
+    R::Window.new
+  end
+
+  def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
+    R::View.new(
+      frame: [x, y, w, h],
+      shape: R::RectShape.new(density: 1),
+      **options, &block)
+  end
+
+  def point(...)
+    R::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_activation()
+    v1, v2, = setup_views nil
+    w       = window
+
+    c = v1.link v2; assert_false c.active?
+    w.add    v1;    assert_false c.active?
+    w.add    v2;    assert_true  c.active?
+    w.remove v1;    assert_false c.active?
+    w.add    v1;    assert_true  c.active?
+    c = v1.link v2; assert_true  c.active?
+
+    assert_in_delta 100, c.current_distance
+  end
+
+  def test_pins()
+    v1, v2, = setup_views
+
+    c = v1.pin(10, 20).snap v2.pin(30, 40)
+    assert_equal       v1,            c.pins[0].view
+    assert_equal_point point(10, 20), c.pins[0].pos
+    assert_equal       v2,            c.pins[1].view
+    assert_equal_point point(30, 40), c.pins[1].pos
+    assert_equal       [v1, v2],      c.views
+    assert_equal       [v1, v2],      c.pins.map(&:view)
+  end
+
+  def test_resolved_positions()
+    v1, v2, = setup_views
+
+    assert_equal_point point( 25,   25), v1.pin        .snap(v2)        .pins[0].pos
+    assert_equal_point point(-75,   25), v1.pin        .snap(v2)        .pins[1].pos
+    assert_equal_point point( 10,   20), v1.pin(10, 20).snap(v2)        .pins[0].pos
+    assert_equal_point point(-90,   20), v1.pin(10, 20).snap(v2)        .pins[1].pos
+    assert_equal_point point( 130,  40), v1.pin        .snap(v2, 30, 40).pins[0].pos
+    assert_equal_point point( 30,   40), v1.pin        .snap(v2, 30, 40).pins[1].pos
+    assert_equal_point point( 50,   60), v1.pin(50, 60).snap(v2, 70, 80).pins[0].pos
+    assert_equal_point point( 70,   80), v1.pin(50, 60).snap(v2, 70, 80).pins[1].pos
+  end
+
+  def test_spring()
+    v1, v2, = setup_views
+
+    c = v1.link v2, spring: 4, damping: 0.5
+    assert_in_delta 4,                 c.spring
+    assert_in_delta 0.5,               c.damping
+
+    c.spring = nil; assert_nil         c.spring
+    c.spring = 8;   assert_in_delta 8, c.spring
+  end
+
+  def test_collide()
+    v1, v2, = setup_views
+
+    assert_false v1.snap(v2)                .collide?
+    assert_false v1.snap(v2, collide: false).collide?
+    assert_true  v1.snap(v2, collide: true) .collide?
+  end
+
+  def test_selector()
+    v1, v2, = setup_views
+
+    c = v1.link v2, name: :name1, tag: [:tag1, :tag2]
+    assert_equal 'name1',          c.name
+    assert_equal ['tag1', 'tag2'], c.tags.to_a
+    assert_true                    c.tag?(:tag1)
+    assert_true                    c.tag?('tag1')
+    assert_true                    c.tag?(:tag2)
+    assert_false                   c.tag?(:tag3)
+
+    c.name = :name2
+    assert_equal 'name2', c.name
+
+    assert_false                           c.tag?(:tag9)
+    c.add_tag                                     :tag9
+    assert_true                            c.tag?(:tag9)
+    assert_equal ['tag1', 'tag2', 'tag9'], c.tags.to_a
+    c.remove_tag                                  :tag9
+    assert_false                           c.tag?(:tag9)
+    assert_equal ['tag1', 'tag2'],         c.tags.to_a
+
+    c.clear_tags
+    assert_equal [], c.tags.to_a
+  end
+
+  def test_block()
+    v1, v2, = setup_views
+
+    c = v1.link v2 do
+      distance 80
+      spring   4
+    end
+    assert_equal    80, c.distance
+    assert_in_delta 4,  c.spring
+  end
+
+  def test_constraints()
+    v1, v2, = setup_views
+
+    c1 = v1.link v2
+    c2 = v1.snap v2
+    assert_equal [c1, c2], v1.constraints.to_a
+    assert_equal [c1, c2], v2.constraints.to_a
+    assert_equal [R::LinkConstraint, R::SnapConstraint], v1.constraints.map(&:class)
+  end
+
+  def test_remove()
+    v1, v2, _, parent = setup_views
+
+    c = v1.link v2
+    c.remove
+    assert_false     c.active?
+    assert_true      c.removed?
+    assert_equal [], v1.constraints.to_a
+    assert_equal [], v2.constraints.to_a
+
+    c.remove # idempotent
+
+    parent.remove v1
+    parent.add    v1
+    assert_false c.active? # never comes back
+
+    assert_nothing_raised do
+      c.spring   = 4
+      c.damping  = 0.5
+      c.distance = 50
+    end
+    assert_false c.active? # removed constraint is inert
+  end
+
+  def test_constrain_to_itself_error()
+    setup_views.tap do |v,|
+      assert_raise(ArgumentError) {v.snap  v}
+    end
+    setup_views.tap do |v,|
+      assert_raise(ArgumentError) {v.chase v}
+      assert_equal [], v.constraints.to_a # rejected self-constraint leaves no orphan
+    end
+  end
+
+  def test_world_mismatch_error()
+    win             = window
+    parent1, child1 = view(0, 0, 500, 500), view(100, 100, dynamic: true)
+    parent2, child2 = view(0, 0, 500, 500), view(100, 100, dynamic: true)
+    parent1.add child1
+    parent2.add child2
+    win.add parent1
+    win.add parent2
+    child1.meter2pixel # create parent1 world
+    child2.meter2pixel # create parent2 world
+
+    assert_raise(R::PhysicsError) {child1.snap child2}
+    assert_equal [], child1.constraints.to_a # rejected pins leave no trace
+    assert_equal [], child2.constraints.to_a
+  end
+
+end# TestConstraint

data/test/test_key_event.rb

@@ -43,4 +43,10 @@ class TestKeyEvent < Test::Unit::TestCase
     assert_nil event(DOWN, nil, 1, 2, 3).chars
   end
 
+  def test_modifiers()
+    e = event DOWN, 'a', 1, Reflex::MOD_CONTROL | Reflex::MOD_CAPS, 0
+    assert_equal [:control, :caps], e.modifiers
+    assert_equal [:control],        e.modifiers(locks: false)
+  end
+
 end# TestKeyEvent

data/test/test_link_constraint.rb

@@ -0,0 +1,239 @@
+require_relative 'helper'
+
+
+class TestLinkConstraint < 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.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