reflexion 0.1.12 → 0.1.17

data/task/box2d.rake

@@ -1,25 +1,46 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
+task :box2d => 'box2d:update'
+
+
 namespace :box2d do
 
 
-  mod          = MODULE
-  box2d_srcdir = env :BOX2D, '~/lib/box2d/Box2D/Box2D'
-  srcdir       = mod.root_dir 'src/physics'
+  mod     = MODULE
+  tmp_dir = mod.root_dir 'tmp'
+
+  lib_git  = 'https://github.com/erincatto/Box2D'
+  lib_name = File.basename lib_git
+  lib_root = "#{tmp_dir}/#{lib_name}"
+  lib_path = "Box2D/Box2D"
+
+  copy_from    = "#{lib_root}/#{lib_path}"
+  copy_to_base = mod.root_dir 'src/physics'
+  copy_to      = "#{copy_to_base}/#{File.basename lib_path}"
+  copy_exts    = %w[h cpp]
 
 
-  task :update => srcdir do
-    sh %( rm -rf #{srcdir}/* )
-    sh %( cp -r #{box2d_srcdir} #{srcdir} )
+  task :update => [:clone, copy_to_base] do
+    sh %( rm -rf #{copy_to} )
+    sh %( cp -r #{copy_from} #{copy_to_base} )
+
+    Dir.glob "#{copy_to}/**/*" do |path|
+      ext = path[/\.[^.]+$/]
+      sh %( rm -f #{path} ) if ext && ext !~ /\.(#{copy_exts.join '|'})/i
+    end
+  end
 
-    Dir.glob "#{srcdir}/**/*" do |path|
-      ext = path[/\.(.+?)$/]
-      sh %( rm -f #{path} ) if ext && ext !~ /\.(h|cpp)/i
+  task :clone => tmp_dir do
+    Dir.chdir tmp_dir do
+      sh %( git clone #{lib_git} ) unless File.exist? lib_root
+      Dir.chdir lib_root do
+        sh %( git pull --rebase )
+      end
     end
   end
 
-  directory srcdir
+  directory tmp_dir, copy_to_base
 
 
 end# :box2d

data/test/test_capture_event.rb

@@ -6,18 +6,20 @@ require_relative 'helper'
 
 class TestCaptureEvent < Test::Unit::TestCase
 
-  def cap (*args)
-    Reflex::CaptureEvent.new *args.map {|arg| Reflex::CAPTURE_FLAG.symbols2bits *arg}
+  def event (*args)
+    Reflex::CaptureEvent.new *args.map {|arg|
+      Reflex::View.capture_flag.symbols2bits *arg
+    }
   end
 
   def test_begin ()
-    c = cap [:key, :pointer], []
+    c = event [:key, :pointer], []
     assert_equal [:key, :pointer], c.begin
     assert_equal true, c.begin?(:key)
     assert_equal true, c.begin?(:pointer)
     assert_equal true, c.begin?(:all)
 
-    c = cap [:key], []
+    c = event [:key], []
     assert_equal [:key], c.begin
     assert_equal true,  c.begin?(:key)
     assert_equal false, c.begin?(:pointer)
@@ -25,13 +27,13 @@ class TestCaptureEvent < Test::Unit::TestCase
   end
 
   def test_end ()
-    c = cap [], [:key, :pointer]
+    c = event [], [:key, :pointer]
     assert_equal [:key, :pointer], c.end
     assert_equal true, c.end?(:key)
     assert_equal true, c.end?(:pointer)
     assert_equal true, c.end?(:all)
 
-    c = cap [], [:key]
+    c = event [], [:key]
     assert_equal [:key], c.end
     assert_equal true,  c.end?(:key)
     assert_equal false, c.end?(:pointer)

data/test/test_pointer_event.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+
+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
+
+    o = type TYPE_NONE
+    assert_equal [:none, F, F, F], o.test
+
+    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
+  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
+
+    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
+  end
+
+  def test_size ()
+    assert_equal 1, event(positions: [0]   ).size
+    assert_equal 2, event(positions: [0, 1]).size
+  end
+
+  def test_xy ()
+    assert_equal 0, event(positions: [[0, 1], [2, 3]]).x
+    assert_equal 1, event(positions: [[0, 1], [2, 3]]).y
+  end
+
+  def test_position ()
+    assert_equal [0, 1], event(positions: [[0, 1], [2, 3]]).position.to_a
+  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)
+  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]}
+  end
+
+end# TestPointerEvent

data/test/test_selector.rb

@@ -21,7 +21,7 @@ class TestSelector < Test::Unit::TestCase
 
   def test_name ()
     s = sel
-    assert_equal '', s.name
+    assert_equal nil, s.name
     s.name = 'Test'
     assert_equal 'Test', s.name
   end

data/test/test_shape.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestShape < Test::Unit::TestCase
+
+  def shape (*args, &block)
+    Reflex::RectShape.new *args, &block
+  end
+
+  def test_density ()
+    s = shape
+    assert_equal 0, s.density
+    s.density = 1
+    assert_equal 1, s.density
+    s.density 2
+    assert_equal 2, s.density
+  end
+
+  def test_friction ()
+    s = shape
+    assert_equal 0, s.friction
+    s.friction = 1
+    assert_equal 1, s.friction
+    s.friction 2
+    assert_equal 2, s.friction
+  end
+
+  def test_restitution ()
+    s = shape
+    assert_equal 0, s.restitution
+    s.restitution = 1
+    assert_equal 1, s.restitution
+    s.restitution 2
+    assert_equal 2, s.restitution
+  end
+
+  def test_sensor ()
+    s = shape
+    assert_equal false, s.sensor?
+    s.sensor = true
+    assert_equal true, s.sensor?
+    s.sensor false
+    assert_equal false, s.sensor?
+  end
+
+  def test_category ()
+    s = shape
+    assert_equal 0b1,    s.category_bits
+    s.category_bits  =  0b1010
+    assert_equal 0b1010, s.category_bits
+    s.category_bits |=  0b100
+    assert_equal 0b1110, s.category_bits
+    s.category_bits &= ~0b10
+    assert_equal 0b1100, s.category_bits
+  end
+
+  def test_collision ()
+    s = shape
+    assert_equal 0xffff, s.collision_mask
+    s.collision_mask  =  0b1010
+    assert_equal 0b1010, s.collision_mask
+    s.collision_mask |=  0b100
+    assert_equal 0b1110, s.collision_mask
+    s.collision_mask &= ~0b10
+    assert_equal 0b1100, s.collision_mask
+  end
+
+end# TestShape

data/test/test_style.rb

@@ -10,8 +10,21 @@ class TestStyle < Test::Unit::TestCase
     Reflex::Style.new *args, &block
   end
 
+  def color (*args)
+    Reflex::Color.new *args
+  end
+
+  def setup ()
+    {
+      rgb100: color(1, 0, 0),
+      rgb010: color(0, 1, 0)
+    }.each do |name, col|
+      Rays::Color.set_palette_color name, col
+    end
+  end
+
   def test_initialize ()
-    assert_equal '',  style.name
+    assert_equal nil, style.name
     assert_equal 'A', style(name: :A).name
     assert_equal 'A', style{self.name = :A}.name
   end
@@ -23,16 +36,30 @@ class TestStyle < Test::Unit::TestCase
 
   def test_flow ()
     s = style
+    assert_equal [:none, :none], s.flow
 
+    s.flow =      :right
+    assert_equal [:right, :none], s.flow
+    s.flow =     [:right, :down]
     assert_equal [:right, :down], s.flow
-    s.flow = :up
-    assert_equal [:up, :none],   s.flow
-    s.flow = [:left, :down]
-    assert_equal [:left, :down], s.flow
-    s.flow = :none
-    assert_equal [:none, :none], s.flow
+    s.flow =      :left
+    assert_equal [:left,  :none], s.flow
+    s.flow =      :none
+    assert_equal [:none,  :none], s.flow
+
+    s.flow =      :right
+    assert_equal [:right, :none], s.flow
+    s.flow =      nil
+    assert_equal [:none,  :none], s.flow
+
     assert_raise(ArgumentError) {s.flow = []}
-    assert_raise(ArgumentError) {s.flow = [:down, :right, :none]}
+    assert_raise(ArgumentError) {s.flow = [:none,  :down]}
+    assert_raise(ArgumentError) {s.flow = [:right, :down, :none]}
+  end
+
+  def test_position ()
+    s = style
+    assert_equal [0, 0, 0, 0], s.position.map(&:value)
   end
 
   def test_margin_padding ()
@@ -63,9 +90,48 @@ class TestStyle < Test::Unit::TestCase
 =end
   end
 
-  def test_fill_stroke ()
-    assert_equal [0, 0, 0, 1], style.fill.to_a
-    assert_equal [0, 0, 0, 1], style.stroke.to_a
+  def test_foreground ()
+    s, white, transp = style, color(1, 1, 1, 1), color(0, 0, 0, 0)
+
+    assert_equal white,  s.foreground_fill
+    assert_equal transp, s.foreground_stroke
+
+    assert_equal [white,          transp], s.foreground
+    s.foreground = :rgb100
+    assert_equal [color(1, 0, 0), transp], s.foreground
+    s.foreground = nil
+    assert_equal [white,          transp], s.foreground
+
+    s.foreground  :rgb100
+    assert_equal [color(1, 0, 0), transp],         s.foreground
+    s.foreground  :rgb010,        nil
+    assert_equal [color(0, 1, 0), transp],         s.foreground
+    s.foreground  nil,            :rgb100
+    assert_equal [white,          color(1, 0, 0)], s.foreground
+    s.foreground  :rgb100,        :rgb010
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], s.foreground
+  end
+
+  def test_background ()
+    s, transp = style, color(0, 0, 0, 0)
+
+    assert_equal transp, s.background_fill
+    assert_equal transp, s.background_stroke
+
+    assert_equal [transp,         transp], s.background
+    s.background = :rgb100
+    assert_equal [color(1, 0, 0), transp], s.background
+    s.background = nil
+    assert_equal [transp,         transp], s.background
+
+    s.background  :rgb100
+    assert_equal [color(1, 0, 0), transp],         s.background
+    s.background  :rgb010,        nil
+    assert_equal [color(0, 1, 0), transp],         s.background
+    s.background  nil,            :rgb100
+    assert_equal [transp,         color(1, 0, 0)], s.background
+    s.background  :rgb100,        :rgb010
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], s.background
   end
 
   def test_image ()

data/test/test_style_length.rb

@@ -11,23 +11,52 @@ class TestStyleLength < Test::Unit::TestCase
   end
 
   def test_initialize ()
+    assert_equal nil, len.type
     assert_equal 0,   len.value
-    assert_equal nil, len.unit
-    assert_equal 100, len(100).value
-    assert_equal :px, len(100).unit
-    assert_equal 100, len(100, :px).value
-    assert_equal :px, len(100, :px).unit
-    assert_equal :%,  len(100, :%).unit
-    assert_equal 100, len('100px').value
-    assert_equal :px, len('100px').unit
-    assert_equal :%,  len('100%').unit
+
+    assert_equal nil, len(nil).type
+    assert_equal 0,   len(nil).value
+
+    assert_equal :px,   len(100).type
+    assert_equal 100,   len(100).value
+
+    assert_equal :px,   len('100px').type
+    assert_equal 100,   len('100px').value
+
+    assert_equal :%,    len('100%').type
+    assert_equal 100,   len('100%').value
+
+    assert_equal :fill, len('fill').type
+    assert_equal 1,     len('fill').value
+    assert_equal :fill, len('0.5 fill').type
+    assert_equal 0.5,   len('0.5 fill').value
+    assert_equal 0.5,   len('0.5fill').value
+    assert_equal :fill, len(:fill).type
+
+    assert_equal :fit,  len('fit').type
+    assert_equal 1,     len('fit').value
+    assert_equal :fit,  len(:fit).type
+
+    assert_raise(ArgumentError) {len ''}
+    assert_raise(ArgumentError) {len :px}
+    assert_raise(ArgumentError) {len :%}
+    assert_raise(ArgumentError) {len 'fill0.5'}
+    assert_raise(ArgumentError) {len 'fill 0.5'}
+    assert_raise(ArgumentError) {len '0.5fit'}
+    assert_raise(ArgumentError) {len '0.5 fit'}
+    assert_raise(ArgumentError) {len 'fit0.5'}
+    assert_raise(ArgumentError) {len 'fit 0.5'}
   end
 
   def test_to_s ()
-    assert_equal '100px',  len(100,   :px).to_s
-    assert_equal '100%',   len(100,   :%).to_s
-    assert_equal '100.5%', len(100.5, :%).to_s
-    assert_equal '',       len.to_s
+    assert_equal '',        len.to_s
+    assert_equal '',        len(nil).to_s
+    assert_equal '100px',   len('100px').to_s
+    assert_equal '100%',    len('100%').to_s
+    assert_equal '100.5%',  len('100.5%').to_s
+    assert_equal 'fill',    len('fill').to_s
+    assert_equal 'fit',     len('fit').to_s
+    assert_equal '0.5fill', len('0.5 fill').to_s
   end
 
   def test_inspect ()