rays 0.1.21 → 0.1.22

data/test/test_point.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestPoint < Test::Unit::TestCase
 
-  def point (*args)
-    Rays::Point.new *args
+  def point(*args)
+    Rays::Point.new(*args)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal point(0, 0, 0), point()
     assert_equal point(1, 1, 0), point(1)
     assert_equal point(1, 2, 0), point(1, 2)
@@ -18,7 +18,7 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(ArgumentError) {point(1, 2, 3, 4)}
   end
 
-  def test_dup ()
+  def test_dup()
     o   = point
     assert_equal point(0, 0, 0), o
     o.x = 1
@@ -30,14 +30,14 @@ class TestPoint < Test::Unit::TestCase
     assert_equal point(1, 0, 0), o
   end
 
-  def test_get_xyz ()
+  def test_get_xyz()
     o = point 1, 2, 3
     assert_equal 1, o.x
     assert_equal 2, o.y
     assert_equal 3, o.z
   end
 
-  def test_set_xyz ()
+  def test_set_xyz()
     o = point
     o.x = 1
     assert_equal [1, 0, 0], o.to_a(3)
@@ -47,7 +47,7 @@ class TestPoint < Test::Unit::TestCase
     assert_equal [1, 2, 3], o.to_a(3)
   end
 
-  def test_move_to ()
+  def test_move_to()
     o = point 1, 2, 3
     assert_equal point(4, 2, 3), o.move_to(  4)
     assert_equal point(4, 5, 3), o.move_to(  4,   5)
@@ -67,7 +67,7 @@ class TestPoint < Test::Unit::TestCase
     assert_equal point(4, 5, 6), o1
   end
 
-  def test_move_by ()
+  def test_move_by()
     o = point 1, 2, 3
     assert_equal point( 5,  2,  3), o.move_by(  4)
     assert_equal point( 5,  7,  3), o.move_by(  4,   5)
@@ -90,13 +90,13 @@ class TestPoint < Test::Unit::TestCase
     assert_equal point(5,  7,  9), o1
   end
 
-  def test_length ()
+  def test_length()
     assert_in_delta 0,            point(0).length
     assert_in_delta 1,            point(1, 0, 0).length
     assert_in_delta Math.sqrt(2), point(1, 1, 0).length
   end
 
-  def test_normalize ()
+  def test_normalize()
     assert_in_delta 1, point( 1,   0,    0)   .normalize.length
     assert_in_delta 1, point( 1,   1,    0)   .normalize.length
     assert_in_delta 1, point( 1,   1,    1)   .normalize.length
@@ -105,12 +105,12 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(Rucy::NativeError) {point(0).normalize}
   end
 
-  def test_normal ()
+  def test_normal()
     assert_equal point(1, 2, 3).normalize, point(1, 2, 3).normal
     assert_raise(Rucy::NativeError) {point(0).normal}
   end
 
-  def test_to_a ()
+  def test_to_a()
     o = point 1, 2, 3
     assert_equal [1, 2],    o.to_a
     assert_equal [1],       o.to_a(1)
@@ -121,7 +121,7 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(ArgumentError) {o.to_a(4)}
   end
 
-  def test_index ()
+  def test_index()
     o = point 1, 2, 3
     assert_equal 1, o[0]
     assert_equal 2, o[1]
@@ -130,7 +130,7 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(IndexError) {point[3]}
   end
 
-  def test_index_assign ()
+  def test_index_assign()
     o = point 1, 2, 3
     o[0] = 4
     assert_equal [4, 2, 3], o.to_a(3)
@@ -142,7 +142,7 @@ class TestPoint < Test::Unit::TestCase
     assert_raise(IndexError) {point[ 3] = 7}
   end
 
-  def test_compare ()
+  def test_compare()
     o = point 1, 2, 3
     assert     o == point(1, 2, 3)
     assert_not o != point(1, 2, 3)
@@ -156,11 +156,11 @@ class TestPoint < Test::Unit::TestCase
     assert o > point(1, 2, 2)
   end
 
-  def test_negate ()
+  def test_negate()
     assert_equal point(-1, 2, -3), -point(1, -2, 3)
   end
 
-  def test_arithmetic_operations ()
+  def test_arithmetic_operations()
     assert_equal point(11, 22, 33), point(10, 20, 30) + point(1, 2, 3)
     assert_equal point( 9, 18, 27), point(10, 20, 30) - point(1, 2, 3)
     assert_equal point(10, 40, 90), point(10, 20, 30) * point(1, 2, 3)
@@ -175,15 +175,15 @@ class TestPoint < Test::Unit::TestCase
     assert_equal point( 5, 10, 15), point(10, 20, 30) / 2
   end
 
-  def test_inspect ()
+  def test_inspect()
     assert_equal "#<Rays::Point 1.0, 2.0, 3.0>", point(1, 2, 3).inspect
   end
 
-  def test_dot ()
+  def test_dot()
     assert_equal 1*4 + 2*5 + 3*6, Rays::Point::dot(point(1, 2, 3), point(4, 5, 6))
   end
 
-  def test_cross ()
+  def test_cross()
     assert_equal point(0, 0, 1), Rays::Point::cross(point(1, 0, 0), point(0, 1, 0))
   end
 

data/test/test_polygon.rb

@@ -7,42 +7,42 @@ require_relative 'helper'
 class TestPolygon < Test::Unit::TestCase
 
   class Rays::Polygon
-    def dump ()
+    def dump()
       map {|l| l.map &:to_a}
     end
   end
 
-  def polygon (*args)
-    Rays::Polygon.new *args
+  def polygon(*args, **kwargs)
+    Rays::Polygon.new(*args, **kwargs)
   end
 
-  def line (*args)
-    Rays::Polygon::Line.new *args
+  def line(*args)
+    Rays::Polygon::Line.new(*args)
   end
 
-  def polyline (*args)
-    Rays::Polyline.new *args
+  def polyline(*args)
+    Rays::Polyline.new(*args)
   end
 
-  def point (*args)
-    Rays::Point.new *args
+  def point(*args)
+    Rays::Point.new(*args)
   end
 
-  def bounds (*args)
-    Rays::Bounds.new *args
+  def bounds(*args)
+    Rays::Bounds.new(*args)
   end
 
-  def rect (*args)
-    Rays::Polygon.rect *args
+  def rect(*args)
+    Rays::Polygon.rect(*args)
   end
 
-  def assert_equal_polygon (poly1, poly2)
-    assert_equal *[poly1, poly2].map {|poly|
+  def assert_equal_polygon(poly1, poly2)
+    assert_equal(*[poly1, poly2].map {|poly|
       poly.dump.map {|l| l.map {|p| p.map &:round}}.map(&:sort).sort.flatten
-    }
+    })
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal [[[1, 2], [3, 4]]], polygon(   1, 2,     3, 4,  loop: false).dump
     assert_equal [[[5, 6], [7, 8]]], polygon(  [5, 6],   [7, 8], loop: false).dump
     assert_equal [[[1, 1], [2, 2]]], polygon(     [1],      [2], loop: false).dump
@@ -63,7 +63,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: false)}
   end
 
-  def test_expand ()
+  def test_expand()
     polygon([10,10], [20,10], [30,20],          loop: false).expand(1).tap {|o|
       assert_equal 1, o   .size
       assert_equal 6, o[0].size
@@ -74,7 +74,7 @@ class TestPolygon < Test::Unit::TestCase
     }
   end
 
-  def test_transform_with_matrix ()
+  def test_transform_with_matrix()
     m = Rays::Matrix.translate 10, 10
     assert_equal_polygon rect(20, 20, 50, 50), rect(10, 10, 50, 50).transform(m)
 
@@ -85,7 +85,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal_polygon rect(-10, 0, 10, 10), rect(0, 0, 10, 10).transform(m)
   end
 
-  def test_transform_block ()
+  def test_transform_block()
     o = rect(0, 0, 100, 100) - rect(10, 10, 50, 50)
     assert_equal 2, o.size
 
@@ -117,37 +117,37 @@ class TestPolygon < Test::Unit::TestCase
     }
   end
 
-  def test_intersects ()
+  def test_intersects()
     assert     rect(10, 10, 20, 20).intersects(rect 20, 20, 20, 20)
     assert_not rect(10, 10, 20, 20).intersects(rect 40, 40, 20, 20)
   end
 
-  def test_bounds ()
+  def test_bounds()
     assert_equal bounds(10, 20, 0, 20, 10, 0), polygon(10, 20, 30, 20, 20, 30).bounds
 
     assert     polygon(10, 20, 30, 20, 20, 30).bounds.valid?
     assert_not polygon()                      .bounds.valid?
   end
 
-  def test_loop ()
+  def test_loop()
     assert_equal true,  polygon(1, 2, 3, 4, 5, 6             ).first.loop?
     assert_equal true,  polygon(1, 2, 3, 4, 5, 6, loop: true ).first.loop?
     assert_equal false, polygon(1, 2, 3, 4, 5, 6, loop: false).first.loop?
   end
 
-  def test_size ()
+  def test_size()
     assert_equal 0, polygon(                             ).size
     assert_equal 1, polygon(1, 2, 3, 4,       loop: false).size
     assert_equal 1, polygon(1, 2, 3, 4, 5, 6, loop: false).size
     assert_equal 2, (rect(0, 0, 5, 5) | rect(10, 0, 5, 5)).size
   end
 
-  def test_empty? ()
+  def test_empty?()
     assert_equal true,  polygon(                ).empty?
     assert_equal false, polygon(1, 2, 3, 4, 5, 6).empty?
   end
 
-  def test_index ()
+  def test_index()
     o1 = rect  0, 0, 10, 10
     o2 = rect 20, 0, 10, 10
     o3 = rect 40, 0, 10, 10
@@ -159,7 +159,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_raise(IndexError) {o[-4]}
   end
 
-  def test_sub ()
+  def test_sub()
     rect10 = rect 0, 0, 10, 10
 
     o = rect10 - rect(5, 0, 10, 10)
@@ -177,7 +177,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal_polygon polygon(), rect10    - rect10
   end
 
-  def test_and ()
+  def test_and()
     rect10 = rect 0, 0, 10, 10
 
     o = rect10 & rect(5, 0, 10, 10)
@@ -195,7 +195,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal_polygon rect10,    rect10    & rect10
   end
 
-  def test_or ()
+  def test_or()
     rect10 = rect 0, 0, 10, 10
 
     o = rect10 | rect(5, 0, 10, 10)
@@ -213,7 +213,7 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal_polygon rect10, rect10    | rect10
   end
 
-  def test_xor ()
+  def test_xor()
     rect10 = rect 0, 0, 10, 10
 
     o = rect10 ^ rect(5, 0, 10, 10)

data/test/test_polygon_line.rb

@@ -7,28 +7,28 @@ require_relative 'helper'
 class TestPolygonLine < Test::Unit::TestCase
 
   class Rays::Polygon::Line
-    def dump ()
+    def dump()
       map &:to_a
     end
 
-    def loop_hole ()
+    def loop_hole()
       [loop?, hole?]
     end
   end
 
-  def line (*args)
-    Rays::Polygon::Line.new *args
+  def line(*args, **kwargs)
+    Rays::Polygon::Line.new(*args, **kwargs)
   end
 
-  def point (*args)
-    Rays::Point.new *args
+  def point(*args)
+    Rays::Point.new(*args)
   end
 
-  def rect (*args)
-    Rays::Polygon.rect *args
+  def rect(*args)
+    Rays::Polygon.rect(*args)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal [[1, 2], [3, 4], [5, 6]], line(   1, 2,     3, 4 ,    5, 6 ).dump
     assert_equal [[1, 2], [3, 4], [5, 6]], line(  [1, 2],   [3, 4],   [5, 6]).dump
     assert_equal [[1, 1], [2, 2], [3, 3]], line(     [1],      [2],      [3]).dump
@@ -74,7 +74,7 @@ class TestPolygonLine < Test::Unit::TestCase
     assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: false, hole: false)}
   end
 
-  def test_transform_with_materix ()
+  def test_transform_with_materix()
     m = Rays::Matrix.translate 100, 200
     line([10,10], [20,20], loop: false).transform(m).tap {|o|
       assert_equal [[110,210], [120,220]], o.dump
@@ -91,7 +91,7 @@ class TestPolygonLine < Test::Unit::TestCase
     }
   end
 
-  def test_transform_with_block ()
+  def test_transform_with_block()
     line([10,10], [20,20],          loop: false).transform {|points|
       points.map {|p| p + [10, 20]}
     }.tap {|o|
@@ -149,7 +149,7 @@ class TestPolygonLine < Test::Unit::TestCase
     }
   end
 
-  def test_hole ()
+  def test_hole()
     (rect(0, 0, 10, 10) - rect(1, 1, 2, 2)).tap {|o|
       assert_equal 1, o.select {|line| line.hole?}.size
     }
@@ -158,7 +158,7 @@ class TestPolygonLine < Test::Unit::TestCase
     }
   end
 
-  def test_inspect ()
+  def test_inspect()
     assert_equal(
       "#<Rays::Polygon::Line [1.0, 2.0], [3.0, 4.0], [5.0, 6.0], loop: true, hole: false>",
       line(1, 2, 3, 4, 5, 6).inspect)

data/test/test_polyline.rb

@@ -7,24 +7,24 @@ require_relative 'helper'
 class TestPolyline < Test::Unit::TestCase
 
   class Rays::Polyline
-    def dump ()
+    def dump()
       map &:to_a
     end
   end
 
-  def polyline (*args)
-    Rays::Polyline.new *args
+  def polyline(*args, **kwargs)
+    Rays::Polyline.new(*args, **kwargs)
   end
 
-  def point (*args)
-    Rays::Point.new *args
+  def point(*args)
+    Rays::Point.new(*args)
   end
 
-  def bounds (*args)
-    Rays::Bounds.new *args
+  def bounds(*args)
+    Rays::Bounds.new(*args)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal [[1, 2], [3, 4]], polyline(   1, 2,     3, 4 ).dump
     assert_equal [[1, 2], [3, 4]], polyline(  [1, 2],   [3, 4]).dump
     assert_equal [[1, 1], [2, 2]], polyline(     [1],      [2]).dump
@@ -52,7 +52,7 @@ class TestPolyline < Test::Unit::TestCase
     assert_nothing_raised       {polyline(1, 2, 3, 4, 5, 6, loop: false)}
   end
 
-  def test_expand ()
+  def test_expand()
     polyline([10,10], [20,20],                   loop: false).expand(1).tap {|o|
       assert_equal 1, o   .size
       assert_equal 4, o[0].size
@@ -68,33 +68,33 @@ class TestPolyline < Test::Unit::TestCase
     }
   end
 
-  def test_expand_with_cap ()
-    def pl; polyline [10,10], [20,20]; end
-    assert_nothing_raised       {pl.expand 1, Rays::CAP_ROUND}
-    assert_nothing_raised       {pl.expand 1, 'ROUND'}
-    assert_nothing_raised       {pl.expand 1, :ROUND}
-    assert_nothing_raised       {pl.expand 1, :round}
-    assert_nothing_raised       {pl.expand 1, 1}
-    assert_raise(ArgumentError) {pl.expand 1, -1}
-    assert_raise(ArgumentError) {pl.expand 1, 99}
-    assert_raise(ArgumentError) {pl.expand 1, 'hoge'}
-    assert_raise(ArgumentError) {pl.expand 1, :hoge}
+  def test_expand_with_cap()
+    pl = -> {polyline [10,10], [20,20]}
+    assert_nothing_raised       {pl[].expand 1, Rays::CAP_ROUND}
+    assert_nothing_raised       {pl[].expand 1, 'ROUND'}
+    assert_nothing_raised       {pl[].expand 1, :ROUND}
+    assert_nothing_raised       {pl[].expand 1, :round}
+    assert_nothing_raised       {pl[].expand 1, 1}
+    assert_raise(ArgumentError) {pl[].expand 1, -1}
+    assert_raise(ArgumentError) {pl[].expand 1, 99}
+    assert_raise(ArgumentError) {pl[].expand 1, 'hoge'}
+    assert_raise(ArgumentError) {pl[].expand 1, :hoge}
   end
 
-  def test_expand_with_join ()
-    def pl; polyline [10,10], [20,20]; end
-    assert_nothing_raised       {pl.expand 1, Rays::JOIN_ROUND}
-    assert_nothing_raised       {pl.expand 1, 'ROUND'}
-    assert_nothing_raised       {pl.expand 1, :ROUND}
-    assert_nothing_raised       {pl.expand 1, :round}
-    assert_nothing_raised       {pl.expand 1, 1}
-    assert_raise(ArgumentError) {pl.expand 1, 'hoge'}
-    assert_raise(ArgumentError) {pl.expand 1, :hoge}
-    assert_raise(ArgumentError) {pl.expand 1, -1}
-    assert_raise(ArgumentError) {pl.expand 1, 99}
+  def test_expand_with_join()
+    pl = -> {polyline [10,10], [20,20]}
+    assert_nothing_raised       {pl[].expand 1, Rays::JOIN_ROUND}
+    assert_nothing_raised       {pl[].expand 1, 'ROUND'}
+    assert_nothing_raised       {pl[].expand 1, :ROUND}
+    assert_nothing_raised       {pl[].expand 1, :round}
+    assert_nothing_raised       {pl[].expand 1, 1}
+    assert_raise(ArgumentError) {pl[].expand 1, 'hoge'}
+    assert_raise(ArgumentError) {pl[].expand 1, :hoge}
+    assert_raise(ArgumentError) {pl[].expand 1, -1}
+    assert_raise(ArgumentError) {pl[].expand 1, 99}
   end
 
-  def test_transform_with_materix ()
+  def test_transform_with_materix()
     m = Rays::Matrix.translate 100, 200
     polyline([10,10], [20,20]).transform(m).tap {|o|
       assert_equal [[110,210], [120,220]], o.dump
@@ -111,7 +111,7 @@ class TestPolyline < Test::Unit::TestCase
     }
   end
 
-  def test_transform_with_block ()
+  def test_transform_with_block()
     polyline([10,10], [20,20]                      ).transform {|points|
       points.map {|p| p + [10, 20]}
     }.tap {|o|
@@ -136,24 +136,24 @@ class TestPolyline < Test::Unit::TestCase
     }
   end
 
-  def test_bounds ()
+  def test_bounds()
     assert_equal bounds(10, 20, 0, 20, 10, 0), polyline(10, 20, 30, 20, 20, 30).bounds
 
     assert     polyline(10, 20, 30, 20, 20, 30).bounds.valid?
     assert_not polyline()                      .bounds.valid?
   end
 
-  def test_size ()
+  def test_size()
     assert_equal 2, polyline(1, 2, 3, 4,     ).size
     assert_equal 3, polyline(1, 2, 3, 4, 5, 6).size
   end
 
-  def test_empty? ()
+  def test_empty?()
     assert_equal true,  polyline(          ).empty?
     assert_equal false, polyline(1, 2, 3, 4).empty?
   end
 
-  def test_index ()
+  def test_index()
     o = polyline 1, 2, 3, 4, 5, 6
     assert_equal [1, 2], o[ 0].to_a
     assert_equal [3, 4], o[ 1].to_a
@@ -162,7 +162,7 @@ class TestPolyline < Test::Unit::TestCase
     assert_raise(IndexError) {o[-4]}
   end
 
-  def test_inspect ()
+  def test_inspect()
     assert_equal(
       "#<Rays::Polyline [1.0, 2.0], [3.0, 4.0], loop: false>",
       polyline(1, 2, 3, 4).inspect)