reflexion 0.1.19 → 0.1.23

data/test/test_has_frame.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestHasFrame < Test::Unit::TestCase
 
-  def view (*args)
-    Reflex::View.new *args
+  def view(*args)
+    Reflex::View.new(*args)
   end
 
-  def test_accessors ()
+  def test_accessors()
     v = view
     b = v.frame.dup
     assert_equal b, v.frame
@@ -28,18 +28,18 @@ class TestHasFrame < Test::Unit::TestCase
     assert_equal [15, 25, 30, 90, 190, 300], v.frame.to_a(3)
   end
 
-  def test_move ()
+  def test_move()
     v = view
-    v.move_to  10,  10; assert_equal [10, 10], v.pos.to_a
-    v.move_by  40,  40; assert_equal [50, 50], v.pos.to_a
-    v.move_by -10, -10; assert_equal [40, 40], v.pos.to_a
+    v.move_to( 10,  10); assert_equal [10, 10], v.pos.to_a
+    v.move_by( 40,  40); assert_equal [50, 50], v.pos.to_a
+    v.move_by(-10, -10); assert_equal [40, 40], v.pos.to_a
   end
 
-  def test_resize ()
+  def test_resize()
     v = view
-    v.resize_to  100,  100; assert_equal [100, 100], v.size.to_a
-    v.resize_by  400,  400; assert_equal [500, 500], v.size.to_a
-    v.resize_by -100, -100; assert_equal [400, 400], v.size.to_a
+    v.resize_to( 100,  100); assert_equal [100, 100], v.size.to_a
+    v.resize_by( 400,  400); assert_equal [500, 500], v.size.to_a
+    v.resize_by(-100, -100); assert_equal [400, 400], v.size.to_a
   end
 
 end# TestHasFrame

data/test/test_pointer.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+
+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
+
+  T = true
+  F = false
+
+  def pointer(
+    id: 0, type: TYPE_NONE, action: ACTION_NONE,
+    position: 0, modifiers: 0, click_count: 0, drag: false,
+    time: 0)
+
+    Reflex::Pointer.new(
+      id, type, action, position, modifiers, click_count, drag, time)
+  end
+
+  def test_initialize()
+    assert_nothing_raised {pointer}
+
+    p = pointer(
+      id: 1, type: TOUCH, action: DOWN,
+      position: [2, 3], modifiers: 4, click_count: 5, drag: true,
+      time: 6)
+
+    assert_equal    1,             p.id
+    assert_equal    [:touch],      p.type
+    assert_equal    :down,         p.action
+    assert_equal    [2, 3],        p.position.to_a
+    assert_equal    4,             p.modifiers
+    assert_equal    5,             p.click_count
+    assert_equal    true,          p.drag?
+    assert_equal    6,             p.time
+    assert_nil                     p.prev
+  end
+
+  def test_type()
+    def type(t)
+      pointer(type: t).tap do |o|
+        def o.test()
+          [type, mouse?, left?, right?, middle?, touch?, pen?]
+        end
+      end
+    end
+
+    o = type TYPE_NONE
+    assert_equal [[],              F, F, F, F, F, F], o.test
+
+    o = type MOUSE
+    assert_equal [[:mouse],        T, F, F, F, F, F], o.test
+
+    o = type LEFT
+    assert_equal [[:mouse_left],   F, T, F, F, F, F], o.test
+
+    o = type RIGHT
+    assert_equal [[:mouse_right],  F, F, T, F, F, F], o.test
+
+    o = type MIDDLE
+    assert_equal [[:mouse_middle], F, F, F, T, F, F], o.test
+
+    o = type TOUCH
+    assert_equal [[:touch],        F, F, F, F, T, F], o.test
+
+    o = type PEN
+    assert_equal [[:pen],          F, F, F, F, F, T], o.test
+
+    o = type LEFT | RIGHT
+    types = [:mouse_left, :mouse_right]
+    assert_equal [types, F, T, T, F, F, F], o.test
+
+    o = type LEFT | RIGHT | MIDDLE
+    types = [:mouse_left, :mouse_right, :mouse_middle]
+    assert_equal [types, F, T, T, T, F, F], o.test
+
+    o = type MOUSE | LEFT | RIGHT | MIDDLE | TOUCH | PEN
+    types = [:mouse, :mouse_left, :mouse_right, :mouse_middle, :touch, :pen]
+    assert_equal [types, T, T, T, T, T, T], o.test
+  end
+
+  def test_action()
+    def action(a)
+      pointer(action: a).tap do |o|
+        def o.test()
+          [action, down?, up?, move?, cancel?, stay?]
+        end
+      end
+    end
+
+    o = action ACTION_NONE
+    assert_equal [:none,   F, F, F, F, F], o.test
+
+    o = action DOWN
+    assert_equal [:down,   T, F, F, F, F], o.test
+
+    o = action UP
+    assert_equal [:up,     F, T, F, F, F], o.test
+
+    o = action MOVE
+    assert_equal [:move,   F, F, T, F, F], o.test
+
+    o = action CANCEL
+    assert_equal [:cancel, F, F, F, T, F], o.test
+
+    o = action STAY
+    assert_equal [:stay,   F, F, F, F, T], o.test
+  end
+
+  def test_position()
+    assert_equal [1, 1], pointer(position: 1     ).position.to_a
+    assert_equal [2, 3], pointer(position: [2, 3]).position.to_a
+  end
+
+  def test_xy()
+    assert_equal 1, pointer(position: [1, 2]).x
+    assert_equal 2, pointer(position: [1, 2]).y
+  end
+
+  def test_compare()
+    assert_equal pointer, pointer
+
+    assert_not_equal pointer, pointer(id:          1)
+    assert_not_equal pointer, pointer(type:        Reflex::Pointer::PEN)
+    assert_not_equal pointer, pointer(action:      Reflex::Pointer::UP)
+    assert_not_equal pointer, pointer(position:    2)
+    assert_not_equal pointer, pointer(modifiers:   3)
+    assert_not_equal pointer, pointer(click_count: 4)
+    assert_not_equal pointer, pointer(drag:        true)
+    assert_not_equal pointer, pointer(time:        5)
+  end
+
+end# TestPointer

data/test/test_pointer_event.rb

@@ -6,125 +6,91 @@ require_relative 'helper'
 
 class TestPointerEvent < Test::Unit::TestCase
 
-  E = Reflex::PointerEvent
-  T = true
-  F = false
-
-  TYPE_NONE = E::TYPE_NONE
-  DOWN      = E::TYPE_DOWN
-  UP        = E::TYPE_UP
-  MOVE      = E::TYPE_MOVE
-
-  POINTER_NONE = E::POINTER_NONE
-  LEFT         = E::POINTER_MOUSE_LEFT
-  RIGHT        = E::POINTER_MOUSE_RIGHT
-  MIDDLE       = E::POINTER_MOUSE_MIDDLE
-  TOUCH        = E::POINTER_TOUCH
-  PEN          = E::POINTER_PEN
-
-  def event (
-    type = TYPE_NONE, pointer_type = POINTER_NONE,
-    modifiers = 0, count = 0, drag = false,
-    positions: [0])
-
-    Reflex::PointerEvent.new type, pointer_type, modifiers, count, drag, positions
-  end
-
-  def test_initialize ()
-    assert_nothing_raised       {event positions: 10.times.to_a}
-    assert_raise(ArgumentError) {event positions: 11.times.to_a}
-    assert_raise(ArgumentError) {event positions: []}
-  end
-
-  def test_type ()
-    def type (arg)
-      event(arg).tap do |o|
-        def o.test ()
-          [type, down?, up?, move?]
-        end
-      end
-    end
+  TYPE_NONE = Reflex::Pointer::TYPE_NONE
+  TOUCH     = Reflex::Pointer::TOUCH
+  PEN       = Reflex::Pointer::PEN
 
-    o = type TYPE_NONE
-    assert_equal [:none, F, F, F], o.test
+  ACTION_NONE = Reflex::Pointer::ACTION_NONE
+  DOWN        = Reflex::Pointer::DOWN
+  UP          = Reflex::Pointer::UP
 
-    o = type DOWN
-    assert_equal [:down, T, F, F], o.test
-
-    o = type UP
-    assert_equal [:up,   F, T, F], o.test
-
-    o = type MOVE
-    assert_equal [:move, F, F, T], o.test
+  def event(*args)
+    Reflex::PointerEvent.new(*args)
   end
 
-  def test_pointer_type ()
-    def pointer_type (arg)
-      event(TYPE_NONE, arg).tap do |o|
-        def o.test ()
-          [pointer_type, left?, right?, middle?, touch?, pen?]
-        end
-      end
-    end
-
-    o = pointer_type POINTER_NONE
-    assert_equal [[],              F, F, F, F, F], o.test
-
-    o = pointer_type LEFT
-    assert_equal [[:mouse_left],   T, F, F, F, F], o.test
+  def pointer(
+    id: 0, type: TYPE_NONE, action: ACTION_NONE,
+    position: 0, modifiers: 0, click_count: 0, drag: false,
+    time: 0)
 
-    o = pointer_type RIGHT
-    assert_equal [[:mouse_right],  F, T, F, F, F], o.test
-
-    o = pointer_type MIDDLE
-    assert_equal [[:mouse_middle], F, F, T, F, F], o.test
-
-    o = pointer_type TOUCH
-    assert_equal [[:touch],        F, F, F, T, F], o.test
-
-    o = pointer_type PEN
-    assert_equal [[:pen],          F, F, F, F, T], o.test
-
-    o = pointer_type LEFT | RIGHT
-    types = [:mouse_left, :mouse_right]
-    assert_equal [types, T, T, F, F, F], o.test
-
-    o = pointer_type LEFT | RIGHT | MIDDLE
-    types = [:mouse_left, :mouse_right, :mouse_middle]
-    assert_equal [types, T, T, T, F, F], o.test
-
-    o = pointer_type LEFT | RIGHT | MIDDLE | TOUCH | PEN
-    types = [:mouse_left, :mouse_right, :mouse_middle, :touch, :pen]
-    assert_equal [types, T, T, T, T, T], o.test
+    Reflex::Pointer.new(
+      id, type, action, position, modifiers, click_count, drag, time)
   end
 
-  def test_size ()
-    assert_equal 1, event(positions: [0]   ).size
-    assert_equal 2, event(positions: [0, 1]).size
+  def test_initialize()
+    assert_nothing_raised       {event pointer}
+    assert_nothing_raised       {event pointer, pointer}
+    assert_raise(ArgumentError) {event}
+
+    p1 = pointer(
+      id: 1,  type: TOUCH, action: DOWN,
+      position: [2,  3],  modifiers: 4,  click_count: 5,  drag: true,
+      time: 6)
+    p2 = pointer(
+      id: 10, type: PEN,   action: UP,
+      position: [20, 30], modifiers: 40, click_count: 50, drag: false,
+      time: 60)
+    e = event p1, p2
+
+    assert_equal [p1, p2], e.pointers.to_a
+    assert_equal 2,        e.size
+    assert_equal false,    e.empty?
+    assert_equal false,    e.captured?
+
+    assert_equal 1,        p1.id
+    assert_equal [:touch], p1.type
+    assert_equal :down,    p1.action
+    assert_equal [2, 3],   p1.position.to_a
+    assert_equal [2, 3],   p1.pos     .to_a
+    assert_equal 2,        p1.x
+    assert_equal 3,        p1.y
+    assert_equal 4,        p1.modifiers
+    assert_equal 5,        p1.click_count
+    assert_equal true,     p1.drag?
+    assert_equal 6,        p1.time
   end
 
-  def test_xy ()
-    assert_equal 0, event(positions: [[0, 1], [2, 3]]).x
-    assert_equal 1, event(positions: [[0, 1], [2, 3]]).y
+  def test_dup()
+    e1 = event pointer
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_equal true,  e1.blocked?
+    assert_equal false, e2.blocked?
+    assert_equal true,  e3.blocked?
   end
 
-  def test_position ()
-    assert_equal [0, 1], event(positions: [[0, 1], [2, 3]]).position.to_a
+  def test_size()
+    assert_equal 1, event(pointer         ).size
+    assert_equal 2, event(pointer, pointer).size
   end
 
-  def test_positions ()
-    assert_equal [[0, 0]],         event(positions: [0]   ).positions.map(&:to_a)
-    assert_equal [[0, 0], [1, 1]], event(positions: [0, 1]).positions.map(&:to_a)
-
-    assert_equal [[0, 1]],         event(positions: [[0, 1]]        ).positions.map(&:to_a)
-    assert_equal [[0, 1], [2, 3]], event(positions: [[0, 1], [2, 3]]).positions.map(&:to_a)
+  def test_empty?()
+    assert_equal false, event(pointer).empty?
   end
 
-  def test_at ()
-    assert_equal [0, 1], event(positions: [[0, 1], [2, 3]])[0].to_a
-    assert_equal [2, 3], event(positions: [[0, 1], [2, 3]])[1].to_a
-    assert_raise(IndexError) {event(positions: [[0, 1], [2, 3]])[-1]}
-    assert_raise(IndexError) {event(positions: [[0, 1], [2, 3]])[2]}
+  def test_get_at()
+    p1 = pointer position: 1
+    p2 = pointer position: 2
+    p3 = pointer position: 3
+    e  = event p1, p2, p3
+
+    assert_equal p1, e[0]
+    assert_equal p3, e[2]
+    assert_nil       e[3]
+    assert_equal p3, e[-1]
+    assert_equal p1, e[-3]
+    assert_nil       e[-4]
   end
 
 end# TestPointerEvent

data/test/test_reflex.rb

@@ -9,7 +9,7 @@ require_relative 'helper'
 
 class TestReflex < Test::Unit::TestCase
 
-  def test_init ()
+  def test_init()
     assert_raise(Rucy::NativeError) {Reflex.fin!}
     assert Reflex.init!
     assert_raise(Rucy::NativeError) {Reflex.init!}

data/test/test_selector.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestSelector < Test::Unit::TestCase
 
-  def sel (*args, &block)
-    Reflex::Selector.new *args, &block
+  def sel(*args, &block)
+    Reflex::Selector.new(*args, &block)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal 'A', sel(name: :A).name
     assert_equal 'B', sel(name: :A){set name: :B}.name
     assert_equal %w[T1],    sel(tag:    :T1      ).tags.to_a
@@ -19,14 +19,14 @@ class TestSelector < Test::Unit::TestCase
     assert_equal %w[T1 T2], sel(tags:  [:T1, :T2]).tags.to_a
   end
 
-  def test_name ()
+  def test_name()
     s = sel
     assert_equal nil, s.name
     s.name = 'Test'
     assert_equal 'Test', s.name
   end
 
-  def test_tags ()
+  def test_tags()
     s = sel
     assert_equal [], s.tags.to_a
     s.tag 'A'
@@ -40,13 +40,20 @@ class TestSelector < Test::Unit::TestCase
     assert_equal %w[a d], s.tags.map(&:downcase).to_a
   end
 
-  def test_clear_tags ()
+  def test_clear_tags()
     s = sel tag: [:T1, :T2]
     s.clear_tags
     assert_equal [], s.tags.to_a
   end
 
-  def test_contains ()
+  def test_empty()
+    assert_equal true,  sel                   .empty?
+    assert_equal false, sel(name: :A         ).empty?
+    assert_equal false, sel(          tag: :T).empty?
+    assert_equal false, sel(name: :A, tag: :T).empty?
+  end
+
+  def test_contains()
     assert_not sel.contains(sel name: :A, tag: :T)
     assert     sel(name: :A).contains(sel name: :A)
     assert_not sel(name: :A).contains(sel name: :B)
@@ -61,7 +68,7 @@ class TestSelector < Test::Unit::TestCase
     assert_not sel(tag: :T1).contains(sel name: :A, tag: :T1)
   end
 
-  def test_compare ()
+  def test_compare()
     assert_equal     sel(name: :A), sel(name: :A)
     assert_not_equal sel(name: :A), sel(name: :X)
     assert_equal     sel(tag: [:A, :B]), sel(tag: [:A, :B])

data/test/test_shape.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestShape < Test::Unit::TestCase
 
-  def shape (*args, &block)
-    Reflex::RectShape.new *args, &block
+  def shape(*args, &block)
+    Reflex::RectShape.new(*args, &block)
   end
 
-  def test_density ()
+  def test_density()
     s = shape
     assert_equal 0, s.density
     s.density = 1
@@ -19,7 +19,7 @@ class TestShape < Test::Unit::TestCase
     assert_equal 2, s.density
   end
 
-  def test_friction ()
+  def test_friction()
     s = shape
     assert_equal 0, s.friction
     s.friction = 1
@@ -28,7 +28,7 @@ class TestShape < Test::Unit::TestCase
     assert_equal 2, s.friction
   end
 
-  def test_restitution ()
+  def test_restitution()
     s = shape
     assert_equal 0, s.restitution
     s.restitution = 1
@@ -37,7 +37,7 @@ class TestShape < Test::Unit::TestCase
     assert_equal 2, s.restitution
   end
 
-  def test_sensor ()
+  def test_sensor()
     s = shape
     assert_equal false, s.sensor?
     s.sensor = true
@@ -46,7 +46,7 @@ class TestShape < Test::Unit::TestCase
     assert_equal false, s.sensor?
   end
 
-  def test_category ()
+  def test_category()
     s = shape
     assert_equal 0b1,    s.category_bits
     s.category_bits  =  0b1010
@@ -57,7 +57,7 @@ class TestShape < Test::Unit::TestCase
     assert_equal 0b1100, s.category_bits
   end
 
-  def test_collision ()
+  def test_collision()
     s = shape
     assert_equal 0xffff, s.collision_mask
     s.collision_mask  =  0b1010

data/test/test_style.rb

@@ -6,15 +6,15 @@ require_relative 'helper'
 
 class TestStyle < Test::Unit::TestCase
 
-  def style (*args, &block)
-    Reflex::Style.new *args, &block
+  def style(*args, &block)
+    Reflex::Style.new(*args, &block)
   end
 
-  def color (*args)
-    Reflex::Color.new *args
+  def color(*args)
+    Reflex::Color.new(*args)
   end
 
-  def setup ()
+  def setup()
     {
       rgb100: color(1, 0, 0),
       rgb010: color(0, 1, 0)
@@ -23,18 +23,18 @@ class TestStyle < Test::Unit::TestCase
     end
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal nil, style.name
     assert_equal 'A', style(name: :A).name
     assert_equal 'A', style{self.name = :A}.name
   end
 
-  def test_selector ()
+  def test_selector()
     assert_equal 'A', style(name: :A).selector.name
     assert_equal %w[T], style(tag: :T).selector.tags.to_a
   end
 
-  def test_flow ()
+  def test_flow()
     s = style
     assert_equal [:none, :none], s.flow
 
@@ -57,12 +57,12 @@ class TestStyle < Test::Unit::TestCase
     assert_raise(ArgumentError) {s.flow = [:right, :down, :none]}
   end
 
-  def test_position ()
+  def test_position()
     s = style
     assert_equal [0, 0, 0, 0], s.position.map(&:value)
   end
 
-  def test_margin_padding ()
+  def test_margin_padding()
     s = style
 
     assert_equal [0, 0, 0, 0], s.margin.to_a.map(&:value)
@@ -90,7 +90,7 @@ class TestStyle < Test::Unit::TestCase
 =end
   end
 
-  def test_foreground ()
+  def test_foreground()
     s, white, transp = style, color(1, 1, 1, 1), color(0, 0, 0, 0)
 
     assert_equal white,  s.foreground_fill
@@ -112,7 +112,7 @@ class TestStyle < Test::Unit::TestCase
     assert_equal [color(1, 0, 0), color(0, 1, 0)], s.foreground
   end
 
-  def test_background ()
+  def test_background()
     s, transp = style, color(0, 0, 0, 0)
 
     assert_equal transp, s.background_fill
@@ -134,7 +134,7 @@ class TestStyle < Test::Unit::TestCase
     assert_equal [color(1, 0, 0), color(0, 1, 0)], s.background
   end
 
-  def test_image ()
+  def test_image()
     assert_equal nil, style.image
   end
 

data/test/test_style_length.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestStyleLength < Test::Unit::TestCase
 
-  def len (*args, &block)
-    Reflex::StyleLength.new *args, &block
+  def len(*args, &block)
+    Reflex::StyleLength.new(*args, &block)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal nil, len.type
     assert_equal 0,   len.value
 
@@ -48,7 +48,7 @@ class TestStyleLength < Test::Unit::TestCase
     assert_raise(ArgumentError) {len 'fit 0.5'}
   end
 
-  def test_to_s ()
+  def test_to_s()
     assert_equal '',        len.to_s
     assert_equal '',        len(nil).to_s
     assert_equal '100px',   len('100px').to_s
@@ -59,7 +59,7 @@ class TestStyleLength < Test::Unit::TestCase
     assert_equal '0.5fill', len('0.5 fill').to_s
   end
 
-  def test_inspect ()
+  def test_inspect()
     assert_nothing_raised {len.inspect}
   end