reflexion 0.5.3 → 0.7.0

data/test/test_pointer_event.rb

@@ -3,16 +3,20 @@ require_relative 'helper'
 
 class TestPointerEvent < Test::Unit::TestCase
 
-  TYPE_NONE = Reflex::Pointer::TYPE_NONE
-  TOUCH     = Reflex::Pointer::TOUCH
-  PEN       = Reflex::Pointer::PEN
+  R = Reflex
 
-  ACTION_NONE = Reflex::Pointer::ACTION_NONE
-  DOWN        = Reflex::Pointer::DOWN
-  UP          = Reflex::Pointer::UP
+  TYPE_NONE = R::Pointer::TYPE_NONE
+  MOUSE     = R::Pointer::MOUSE
+  LEFT      = R::Pointer::MOUSE_LEFT
+  TOUCH     = R::Pointer::TOUCH
+  PEN       = R::Pointer::PEN
+
+  ACTION_NONE = R::Pointer::ACTION_NONE
+  DOWN        = R::Pointer::DOWN
+  UP          = R::Pointer::UP
 
   def event(*args, **kwargs)
-    Reflex::PointerEvent.new(*args, **kwargs)
+    R::PointerEvent.new(*args, **kwargs)
   end
 
   def pointer(
@@ -20,8 +24,7 @@ class TestPointerEvent < Test::Unit::TestCase
     position: 0, modifiers: 0, click_count: 0, drag: false,
     time: 0)
 
-    Reflex::Pointer.new(
-      id, type, action, position, modifiers, click_count, drag, time)
+    R::Pointer.new(id, type, action, position, modifiers, click_count, drag, time)
   end
 
   def test_initialize()
@@ -50,7 +53,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
@@ -89,4 +92,16 @@ class TestPointerEvent < Test::Unit::TestCase
     assert_nil       e[-4]
   end
 
+  def test_inspect()
+    assert_equal(
+      "#<Reflex::PointerEvent id:1 [:mouse, :mouse_left] :down (2.0, 3.0) mod:[:shift, :control] click:5 drag:true time:4.0>",
+      event(
+        pointer(
+          id: 1, type: MOUSE | LEFT, action: DOWN,
+          position: [2, 3], modifiers: 6, drag: true, click_count: 5,
+          time: 4),
+        pointer(id: 10, type: TOUCH, action: UP)
+      ).inspect)
+  end
+
 end# TestPointerEvent

data/test/test_reflex.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+
+class TestReflex < Test::Unit::TestCase
+
+  R = Reflex
+
+  def test_all_keys_have_symbol()
+    R::KEYS.each do |key|
+      assert_not_nil R.get_key_symbol!(key), "no symbol for keycode 0x%X" % key
+    end
+  end
+
+  def test_all_keys_are_on_this_platform()
+    R::KEYS.each do |key|
+      assert_operator key, :>=, 0, "keycode 0x%X is not on this platform" % key
+    end
+  end
+
+  def test_unsided_modifiers_have_symbol()
+    omit 'no command or option key here' unless Xot.osx? || Xot.win32?
+    assert_equal :command, R.get_key_symbol!(R::KEY_COMMAND)
+    assert_equal :option,  R.get_key_symbol!(R::KEY_OPTION)
+  end
+
+  def test_key_symbol_representative()
+    # Several keycodes share one symbol; the reverse lookup returns the
+    # first-defined keycode (KEY_SHIFT is listed before KEY_LSHIFT/KEY_RSHIFT).
+    assert_equal :shift, R.get_key_symbol!(R::KEY_SHIFT)
+    assert_equal :shift, R.get_key_symbol!(R::KEY_LSHIFT)
+    assert_equal :shift, R.get_key_symbol!(R::KEY_RSHIFT)
+
+    assert_equal R::KEY_SHIFT, R::KEYS.find {:shift == R.get_key_symbol!(_1)}
+  end
+
+end# TestReflex

data/test/test_screen.rb

@@ -3,12 +3,34 @@ require_relative 'helper'
 
 class TestScreen < Test::Unit::TestCase
 
+  include HasWindow
+
+  R = Reflex
+  S = R::Screen
+
   def screen()
-    Reflex::Window.new.screen
+    window.screen
   end
 
   def test_initialize()
-    assert_raise(Reflex::ReflexError) {Reflex::Screen.new}
+    assert_raise(R::ReflexError) {S.new}
+  end
+
+  def test_name()
+    S.all.each {assert_kind_of String, _1.name}
+  end
+
+  def test_pixel_density()
+    S.all.each {assert_operator _1.pixel_density, :>=, 1}
+  end
+
+  def test_all()
+    all = S.all
+    assert_true all.all? {_1.is_a? S}
+
+    omit 'no screen here' if all.empty?
+
+    assert_equal [0, 0], all.first.frame.position.to_a(2)
   end
 
 end# TestScreen

data/test/test_snap_constraint.rb

@@ -0,0 +1,140 @@
+require_relative 'helper'
+
+
+class TestSnapConstraint < 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.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_text_event.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestTextEvent < Test::Unit::TestCase
+
+  PREEDIT, COMMIT = Reflex::TextEvent::PREEDIT, Reflex::TextEvent::COMMIT
+
+  def event(*args)
+    Reflex::TextEvent.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal :preedit, event(PREEDIT, 'あ', 1, 2).action
+    assert_equal 'あ',     event(PREEDIT, 'あ', 1, 2).text
+    assert_equal 1...3,    event(PREEDIT, 'あ', 1, 2).selection
+  end
+
+  def test_dup()
+    assert_equal :preedit, event(PREEDIT, 'あ', 1, 2).dup.action
+    assert_equal 'あ',     event(PREEDIT, 'あ', 1, 2).dup.text
+    assert_equal 1...3,    event(PREEDIT, 'あ', 1, 2).dup.selection
+
+    e1 = event PREEDIT, 'あ', 1, 2
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_preedit_commit()
+    assert_true  event(PREEDIT, 'あ', 1, 2).preedit?
+    assert_false event(PREEDIT, 'あ', 1, 2).commit?
+    assert_false event(COMMIT,  'あ', 1, 2).preedit?
+    assert_true  event(COMMIT,  'あ', 1, 2).commit?
+  end
+
+  def test_text()
+    assert_equal '',              event(PREEDIT, '',  1, 2).text
+    assert_equal '',              event(PREEDIT, nil, 1, 2).text
+    assert_equal Encoding::UTF_8, event(PREEDIT, 'あいう', 1, 2).text.encoding
+    assert_equal 3,               event(PREEDIT, 'あい😁', 1, 2).text.size
+  end
+
+  def test_selection()
+    assert_nil                      event(PREEDIT, 'あいうえ', -1, 0).selection
+    assert_equal 0...0,             event(PREEDIT, 'あいうえ',  0, 0).selection
+    assert_equal 1...1,             event(PREEDIT, 'あいうえ',  1, 0).selection
+    assert_equal 'いう', 'あいうえ'[event(PREEDIT, 'あいうえ',  1, 2).selection]
+  end
+
+end# TestTextEvent

data/test/test_view.rb

@@ -3,14 +3,12 @@ require_relative 'helper'
 
 class TestView < Test::Unit::TestCase
 
+  include HasWindow
+
   def view(*a, **k, &b)
     Reflex::View.new(*a, **k, &b)
   end
 
-  def window(*a, **k, &b)
-    Reflex::Window.new(*a, **k, &b)
-  end
-
   def style(*a, **k, &b)
     Reflex::Style.new(*a, **k, &b)
   end
@@ -85,12 +83,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 +166,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 +228,80 @@ class TestView < Test::Unit::TestCase
   end
 
   def test_add_remove_shape()
-    s = shape name: :S
-    s.density =  1
-    assert_equal 1, s.density
+    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
 
-    v = view
-    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
 
-    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
+  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
 
-    v.remove_shape s
-    assert_equal 0,     v.shapes.to_a.size
-    assert_not_includes v.find_shapes(selector name: :S), s
+    c = v1.link v2, name: :N1, tag: :T1
+    c.add_tag :T2
 
-    v.add_shape s
-    assert_equal 1,     v.shapes.to_a.size
-    v.clear_shapes
-    assert_equal 0,     v.shapes.to_a.size
+    [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()
@@ -396,6 +484,45 @@ class TestView < Test::Unit::TestCase
     v.capture += [];                      assert_equal [],                      v.capture
   end
 
+  def test_accepts_text_input()
+    assert_false view                                             .accepts_text_input?
+    assert_true  view.tap {_1.text_input = true}                  .accepts_text_input?
+    assert_true  view.tap {_1.text_input = true;  _1.on(:text) {}}.accepts_text_input?
+    assert_false view.tap {_1.text_input = false}                 .accepts_text_input?
+    assert_false view.tap {_1.text_input = false; _1.on(:text) {}}.accepts_text_input?
+    assert_false view.tap {_1.text_input = nil}                   .accepts_text_input?
+    assert_true  view.tap {_1.text_input = nil;   _1.on(:text) {}}.accepts_text_input?
+
+    new_class = -> hook = nil {
+      Class.new(Reflex::View) {define_method(hook) {|*|} if hook}
+    }
+
+    assert_true  new_class.call(:on_text).new          .accepts_text_input?
+    assert_false new_class.call(:on_text).new.hide     .accepts_text_input?
+    assert_true  new_class.call(:on_text).new.hide.show.accepts_text_input?
+
+    %w[on_text on_text_preedit on_text_commit].each do |hook|
+      on_less = hook.sub 'on_', ''
+      assert_true new_class.call(hook).new        .accepts_text_input?, hook
+      assert_true view.tap {_1.on(on_less)  {|*|}}.accepts_text_input?, hook
+      assert_true view.tap {_1.before(hook) {|*|}}.accepts_text_input?, hook
+      assert_true view.tap {_1.after(hook)  {|*|}}.accepts_text_input?, hook
+    end
+  end
+
+  def test_text_input()
+    v            = view;  assert_nil   v.text_input
+    v.text_input = true;  assert_true  v.text_input
+    v.text_input = false; assert_false v.text_input
+    v.text_input = nil;   assert_nil   v.text_input
+  end
+
+  def test_text_input_bounds()
+    v = view
+    v.frame = [10, 20, 30, 40]
+    assert_equal Reflex::Bounds.new(0, 0, 30, 40), v.text_input_bounds
+  end
+
   def test_capturing()
     v, w = view, window
     w.add v

data/test/test_wheel_constraint.rb

@@ -0,0 +1,125 @@
+require_relative 'helper'
+
+
+class TestWheelConstraint < 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.wheel(v2)              .pins[0].view
+    assert_equal v2,                v1.wheel(v2)              .pins[1].view
+    assert_equal_point point(0, 1), v1.wheel(v2)              .axis
+    assert_equal_point point(1, 0), v1.wheel(v2, axis: [1, 0]).axis
+    assert_nil                      v1.wheel(v2)              .range
+    assert_equal 2..3,              v1.wheel(v2, range: 2..3) .range
+    assert_nil                      v1.wheel(v2)              .motor
+    assert_equal 4,                 v1.wheel(v2, motor: 4)    .motor
+    assert_nil                      v1.wheel(v2)              .force
+    assert_equal 6,                 v1.wheel(v2, force: 6)    .force
+    assert_nil                      v1.wheel(v2)              .spring
+    assert_equal 5,                 v1.wheel(v2, spring: 5)   .spring
+    assert_in_delta 0.7,            v1.wheel(v2)              .damping
+    assert_false                    v1.wheel(v2)              .collide?
+    assert_true                     v1.wheel(v2)              .active?
+    assert_false                    v1.wheel(v2)              .removed?
+  end
+
+  def test_rotation_is_free()
+    win     = window
+    wheeled = view 100, 100, dynamic: true
+    railed  = view 300, 100, dynamic: true
+    anchor  = view 200, 100, static:  true
+    [wheeled, railed, anchor].each {|v| win.add v}
+
+    wheeled.wheel anchor, axis: [1, 0] # a wheel leaves the rotation free
+    railed .link  anchor, axis: [1, 0] # a rail locks it
+
+    wheeled.angular_velocity = 90
+    railed .angular_velocity = 90
+    3.times {win.root.update_world}
+
+    assert_in_delta 0, railed.angular_velocity
+    assert_operator wheeled.angular_velocity.abs, :>, railed.angular_velocity.abs
+  end
+
+  def test_motor_spins_the_wheel()
+    v1, v2, _, root = setup_views
+
+    c = v1.wheel v2, axis: [1, 0], motor: 90
+    assert_equal 90, c.motor
+
+    root.update_world
+    assert_operator v1.angular_velocity, :>, 0
+
+    c.motor = nil
+    assert_nil c.motor
+  end
+
+  def test_force()
+    v1, v2, = setup_views
+
+    c = v1.wheel 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_slides_along_axis()
+    v1, v2, _, root = setup_views
+    root.gravity 900, 900
+
+    c = v1.wheel v2, axis: [1, 0]
+    assert_equal_point point(1, 0), c.axis
+
+    root.update_world
+    assert_operator    v1.linear_velocity.x, :>, 0 # suspension slides along the axis
+    assert_in_delta 0, v1.linear_velocity.y
+
+    c.axis = [0, 1]
+    assert_equal_point point(0, 1), c.axis
+  end
+
+  def test_range()
+    v1, v2, _, root = setup_views
+    root.gravity 0, 900
+
+    c = v1.pin(25, 25).wheel 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
+
+    c.range = nil
+    assert_nil c.range
+
+    assert_raise(ArgumentError) {c.range = 'invalid'}
+  end
+
+end# TestWheelConstraint