ffi-geos 2.0.0 → 2.1.0

data/lib/ffi-geos/polygon.rb

@@ -34,7 +34,7 @@ module Geos
     end
 
     def dump_points(cur_path = [])
-      points = [ exterior_ring.dump_points ]
+      points = [exterior_ring.dump_points]
 
       interior_rings.each do |ring|
         points.push(ring.dump_points)
@@ -44,25 +44,25 @@ module Geos
     end
 
     def snap_to_grid!(*args)
-      if !self.empty?
+      unless empty?
         exterior_ring = self.exterior_ring.coord_seq.snap_to_grid!(*args)
 
-        if exterior_ring.length == 0
-          @ptr = Geos.create_empty_polygon(:srid => self.srid).ptr
+        if exterior_ring.empty?
+          @ptr = Geos.create_empty_polygon(srid: srid).ptr
         elsif exterior_ring.length < 4
-          raise Geos::InvalidGeometryError.new("snap_to_grid! produced an invalid number of points in exterior ring - found #{exterior_ring.length} - must be 0 or >= 4")
+          raise Geos::InvalidGeometryError, "snap_to_grid! produced an invalid number of points in exterior ring - found #{exterior_ring.length} - must be 0 or >= 4"
         else
           interior_rings = []
 
-          self.num_interior_rings.times { |i|
-            interior_ring = self.interior_ring_n(i).coord_seq.snap_to_grid!(*args)
+          num_interior_rings.times do |i|
+            interior_ring = interior_ring_n(i).coord_seq.snap_to_grid!(*args)
 
             interior_rings << interior_ring unless interior_ring.length < 4
-          }
+          end
 
           interior_rings.compact!
 
-          polygon = Geos.create_polygon(exterior_ring, interior_rings, :srid => self.srid)
+          polygon = Geos.create_polygon(exterior_ring, interior_rings, srid: srid)
           @ptr = polygon.ptr
         end
       end
@@ -71,33 +71,47 @@ module Geos
     end
 
     def snap_to_grid(*args)
-      ret = self.dup.snap_to_grid!(*args)
-      ret.srid = pick_srid_according_to_policy(self.srid)
+      ret = dup.snap_to_grid!(*args)
+      ret.srid = pick_srid_according_to_policy(srid)
       ret
     end
 
     %w{ max min }.each do |op|
       %w{ x y }.each do |dimension|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-          def #{dimension}_#{op}
-            unless self.empty?
-              self.envelope.exterior_ring.#{dimension}_#{op}
+        native_method = "GEOSGeom_get#{dimension.upcase}#{op[0].upcase}#{op[1..-1]}_r"
+
+        if FFIGeos.respond_to?(native_method)
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              return if empty?
+
+              double_ptr = FFI::MemoryPointer.new(:double)
+              FFIGeos.#{native_method}(Geos.current_handle_pointer, ptr, double_ptr)
+              double_ptr.read_double
             end
-          end
-        EOF
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless empty?
+                envelope.exterior_ring.#{dimension}_#{op}
+              end
+            end
+          RUBY
+        end
       end
 
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def z_#{op}
-          unless self.empty?
-            if self.has_z?
-              self.exterior_ring.z_#{op}
+          unless empty?
+            if has_z?
+              exterior_ring.z_#{op}
             else
               0
             end
           end
         end
-      EOF
+      RUBY
     end
 
     %w{
@@ -110,21 +124,21 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{m}!(*args)
-          self.exterior_ring.coord_seq.#{m}!(*args)
-          self.interior_rings.each do |ring|
+          exterior_ring.coord_seq.#{m}!(*args)
+          interior_rings.each do |ring|
             ring.coord_seq.#{m}!(*args)
           end
           self
         end
 
         def #{m}(*args)
-          ret = self.dup.#{m}!(*args)
-          ret.srid = pick_srid_according_to_policy(self.srid)
+          ret = dup.#{m}!(*args)
+          ret.srid = pick_srid_according_to_policy(srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end

data/lib/ffi-geos/strtree.rb

@@ -37,9 +37,7 @@ module Geos
         end
       end
 
-      if capacity <= 0
-        raise ArgumentError, 'STRtree capacity must be greater than 0'
-      end
+      raise ArgumentError, 'STRtree capacity must be greater than 0' if capacity <= 0
 
       ptr = FFIGeos.GEOSSTRtree_create_r(Geos.current_handle_pointer, capacity)
 
@@ -99,7 +97,7 @@ module Geos
     def remove(geom, item)
       check_geometry(geom)
 
-      key = if storage = @storage.detect { |k, v| v[:item] == item }
+      key = if storage = @storage.detect { |_k, v| v[:item] == item }
         storage[0]
       end
 
@@ -180,7 +178,7 @@ module Geos
 
         return nil if @storage.empty?
 
-        callback = proc { |item, _item2, distance_ptr|
+        callback = proc { |item, _item_2, distance_ptr|
           key = item.read_int
           geom_from_storage = @storage[key][:geometry]
 

data/lib/ffi-geos/tools.rb

@@ -47,7 +47,7 @@ module Geos
         when GEOS_GEOMETRYCOLLECTION
           GeometryCollection
         else
-          raise Geos::InvalidGeometryTypeError.new
+          raise Geos::InvalidGeometryTypeError
       end
 
       klass.new(geom_ptr, options).tap do |ret|

data/lib/ffi-geos/utils.rb

@@ -43,9 +43,7 @@ module Geos
           raise ArgumentError, "Wrong number of arguments (#{args.length} for 1-3)"
         end
 
-        if cs.length != 1
-          raise ArgumentError, 'IllegalArgumentException: Point coordinate list must contain a single element'
-        end
+        raise ArgumentError, 'IllegalArgumentException: Point coordinate list must contain a single element' if cs.length != 1
 
         cs_dup = cs.dup
         cs_dup.ptr.autorelease = false
@@ -56,9 +54,7 @@ module Geos
       def create_line_string(cs, options = {})
         cs = cs_from_cs_or_geom(cs)
 
-        if cs.length <= 1 && cs.length != 0
-          raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements'
-        end
+        raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements' if cs.length <= 1 && !cs.empty?
 
         cs_dup = cs.dup
         cs_dup.ptr.autorelease = false
@@ -69,9 +65,7 @@ module Geos
       def create_linear_ring(cs, options = {})
         cs = cs_from_cs_or_geom(cs)
 
-        if cs.length <= 1 && cs.length != 0
-          raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements'
-        end
+        raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements' if cs.length <= 1 && !cs.empty?
 
         cs.ptr.autorelease = false
 
@@ -154,9 +148,7 @@ module Geos
         options = extract_options!(args)
 
         geoms = Array(args).flatten.tap do |i|
-          if i.detect { |g| !g.is_a?(klass) }
-            raise TypeError, "Expected geoms Array to contain #{klass} objects"
-          end
+          raise TypeError, "Expected geoms Array to contain #{klass} objects" if i.detect { |g| !g.is_a?(klass) }
         end
 
         geoms_dups = geoms.map(&:dup)

data/lib/ffi-geos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geos
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.1.0'
 end

data/lib/ffi-geos/wkb_writer.rb

@@ -57,9 +57,8 @@ module Geos
     end
 
     def output_dimensions=(dim)
-      if dim < 2 || dim > 3
-        raise ArgumentError, 'Output dimensions must be either 2 or 3'
-      end
+      raise ArgumentError, 'Output dimensions must be either 2 or 3' if dim < 2 || dim > 3
+
       FFIGeos.GEOSWKBWriter_setOutputDimension_r(Geos.current_handle_pointer, ptr, dim)
     end
 

data/lib/ffi-geos/wkt_writer.rb

@@ -29,7 +29,7 @@ module Geos
     end
 
     def set_options(options) #:nodoc:
-      [ :trim, :old_3d, :rounding_precision, :output_dimensions ].each do |k|
+      [:trim, :old_3d, :rounding_precision, :output_dimensions].each do |k|
         send("#{k}=", options[k]) if respond_to?("#{k}=") && options.key?(k)
       end
     end
@@ -67,9 +67,7 @@ module Geos
       # Available in GEOS 3.3+.
       def rounding_precision=(r)
         r = r.to_i
-        if r > 255
-          raise ArgumentError, 'Rounding precision cannot be greater than 255'
-        end
+        raise ArgumentError, 'Rounding precision cannot be greater than 255' if r > 255
 
         @rounding_precision = r
         FFIGeos.GEOSWKTWriter_setRoundingPrecision_r(Geos.current_handle_pointer, ptr, @rounding_precision)
@@ -88,9 +86,8 @@ module Geos
       # Available in GEOS 3.3+.
       def output_dimensions=(dim)
         dim = dim.to_i
-        if dim < 2 || dim > 3
-          raise ArgumentError, 'Output dimensions must be either 2 or 3'
-        end
+        raise ArgumentError, 'Output dimensions must be either 2 or 3' if dim < 2 || dim > 3
+
         FFIGeos.GEOSWKTWriter_setOutputDimension_r(Geos.current_handle_pointer, ptr, dim)
       end
     end

data/sonar-project.properties

@@ -0,0 +1,16 @@
+sonar.projectKey=dark-panda_ffi-geos
+sonar.organization=dark-panda
+
+# This is the name and version displayed in the SonarCloud UI.
+#sonar.projectName=ffi-geos
+#sonar.projectVersion=1.0
+
+# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
+sonar.sources=lib, test
+
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8
+
+# Additional reports
+sonar.ruby.rubocop.reportPaths=rubocop-report.json
+sonar.ruby.coverage.reportPaths=coverage/.resultset.json

data/test/coordinate_sequence_tests.rb

@@ -43,6 +43,28 @@ class CoordinateSequenceTests < Minitest::Test
     assert_equal(2, @cs.dimensions)
   end
 
+  def test_counter_clockwise
+    skip unless ENV['FORCE_TESTS'] || Geos::CoordinateSequence.method_defined?(:counter_clockwise?)
+
+    cs = Geos::CoordinateSequence.new([
+      [0, 0],
+      [1, 0],
+      [1, 1],
+      [0, 0]
+    ])
+
+    assert(cs.counter_clockwise?)
+
+    cs = Geos::CoordinateSequence.new([
+      [0, 0],
+      [1, 1],
+      [1, 0],
+      [0, 0]
+    ])
+
+    refute(cs.counter_clockwise?)
+  end
+
   def test_check_bounds
     assert_raises(Geos::IndexBoundsError) { @cs.set_x(10, 0.1) }
     assert_raises(Geos::IndexBoundsError) { @cs.set_x(-1, 0.1) }
@@ -105,11 +127,11 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_read_from_array
     cs = Geos::CoordinateSequence.new([
-      [ 0, 0 ],
-      [ 1, 1 ],
-      [ 2, 2 ],
-      [ 3, 3 ],
-      [ 4, 4 ]
+      [0, 0],
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 4]
     ])
 
     assert_equal(2, cs.dimensions)
@@ -117,30 +139,30 @@ class CoordinateSequenceTests < Minitest::Test
 
     assert_raises(Geos::CoordinateSequence::ParseError) do
       cs = Geos::CoordinateSequence.new([
-        [ 1, 2 ],
-        [ 1, 2, 3 ]
+        [1, 2],
+        [1, 2, 3]
       ])
     end
 
     assert_raises(Geos::CoordinateSequence::ParseError) do
       cs = Geos::CoordinateSequence.new([
-        [ 1, 2, 3, 4 ]
+        [1, 2, 3, 4]
       ])
     end
   end
 
   def test_to_point
-    cs = Geos::CoordinateSequence.new([ 5, 7 ])
+    cs = Geos::CoordinateSequence.new([5, 7])
     assert_equal('POINT (5 7)', write(cs.to_point, trim: true))
   end
 
   def test_to_to_linear_ring
     cs = Geos::CoordinateSequence.new([
-      [ 0, 0 ],
-      [ 0, 5 ],
-      [ 5, 5 ],
-      [ 5, 0 ],
-      [ 0, 0 ]
+      [0, 0],
+      [0, 5],
+      [5, 5],
+      [5, 0],
+      [0, 0]
     ])
 
     assert_equal('LINEARRING (0 0, 0 5, 5 5, 5 0, 0 0)', write(cs.to_linear_ring, trim: true))
@@ -150,7 +172,7 @@ class CoordinateSequenceTests < Minitest::Test
     cs = Geos::CoordinateSequence.new
     assert_geom_empty(cs)
 
-    cs = Geos::CoordinateSequence.new([ 4, 1 ])
+    cs = Geos::CoordinateSequence.new([4, 1])
     refute_geom_empty(cs)
   end
 
@@ -162,10 +184,10 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_to_line_string
     cs = Geos::CoordinateSequence.new([
-      [ 0, 0 ],
-      [ 0, 5 ],
-      [ 5, 5 ],
-      [ 5, 0 ]
+      [0, 0],
+      [0, 5],
+      [5, 5],
+      [5, 0]
     ])
 
     assert_equal('LINESTRING (0 0, 0 5, 5 5, 5 0)', write(cs.to_line_string, trim: true))
@@ -179,11 +201,11 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_to_polygon
     cs = Geos::CoordinateSequence.new([
-      [ 0, 0 ],
-      [ 0, 5 ],
-      [ 5, 5 ],
-      [ 5, 0 ],
-      [ 0, 0 ]
+      [0, 0],
+      [0, 5],
+      [5, 5],
+      [5, 0],
+      [0, 0]
     ])
 
     assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(cs.to_polygon, trim: true))
@@ -282,8 +304,8 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_array_like_access
     cs = Geos::CoordinateSequence.new([
-      [ 0, 1 ],
-      [ 2, 3 ]
+      [0, 1],
+      [2, 3]
     ])
 
     assert_equal(0, cs[0][0])
@@ -292,7 +314,7 @@ class CoordinateSequenceTests < Minitest::Test
     assert_equal(3, cs[1][1])
 
     cs = Geos::CoordinateSequence.new([
-      [ 4, 5, 6 ]
+      [4, 5, 6]
     ])
 
     assert_equal(4, cs[0][0])
@@ -302,9 +324,9 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_slice
     cs = Geos::CoordinateSequence.new([
-      [ 0, 1 ],
-      [ 2, 3 ],
-      [ 4, 5 ]
+      [0, 1],
+      [2, 3],
+      [4, 5]
     ])
 
     assert_equal([[0, 1], [2, 3]], cs.slice(0..1))
@@ -313,21 +335,21 @@ class CoordinateSequenceTests < Minitest::Test
   end
 
   def test_proxy_clone
-    cs = Geos::CoordinateSequence.new([ 10, 20 ])
-    cs2 = cs.clone
+    cs = Geos::CoordinateSequence.new([10, 20])
+    cs_2 = cs.clone
 
     cs.x[0] = 100
 
     assert_equal(100, cs.x[0])
-    assert_equal(10, cs2.x[0])
+    assert_equal(10, cs_2.x[0])
 
-    refute_equal(cs.x, cs2.x)
-    refute_equal(cs.y, cs2.y)
+    refute_equal(cs.x, cs_2.x)
+    refute_equal(cs.y, cs_2.y)
   end
 
   def test_has_z
-    assert_geom_has_z(Geos::CoordinateSequence.new([ 0, 1, 2 ]))
-    refute_geom_has_z(Geos::CoordinateSequence.new([ 0, 1 ]))
+    assert_geom_has_z(Geos::CoordinateSequence.new([0, 1, 2]))
+    refute_geom_has_z(Geos::CoordinateSequence.new([0, 1]))
     refute_geom_has_z(Geos::CoordinateSequence.new(1, 2))
     assert_geom_has_z(Geos::CoordinateSequence.new(1, 3))
     assert_geom_has_z(read('POINT (0 0 0)').coord_seq)
@@ -335,38 +357,38 @@ class CoordinateSequenceTests < Minitest::Test
   end
 
   def test_x_max
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
     assert_equal(10, cs.x_max)
   end
 
   def test_x_min
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
     assert_equal(-10, cs.x_min)
   end
 
   def test_y_max
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
     assert_equal(20, cs.y_max)
   end
 
   def test_y_min
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
     assert_equal(-15, cs.y_min)
   end
 
   def test_z_max
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
-    assert(cs.z_max.nan?, " Expected NaN")
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
+    assert(cs.z_max.nan?, ' Expected NaN')
 
-    cs = Geos::CoordinateSequence.new([ -10, -15, -20 ], [ 0, 5, 10 ], [ 10, 20, 30 ])
+    cs = Geos::CoordinateSequence.new([-10, -15, -20], [0, 5, 10], [10, 20, 30])
     assert_equal(30, cs.z_max)
   end
 
   def test_z_min
-    cs = Geos::CoordinateSequence.new([ -10, -15 ], [ 0, 5 ], [ 10, 20 ])
-    assert(cs.z_min.nan?, " Expected NaN")
+    cs = Geos::CoordinateSequence.new([-10, -15], [0, 5], [10, 20])
+    assert(cs.z_min.nan?, ' Expected NaN')
 
-    cs = Geos::CoordinateSequence.new([ -10, -15, -20 ], [ 0, 5, 10 ], [ 10, 20, 30 ])
+    cs = Geos::CoordinateSequence.new([-10, -15, -20], [0, 5, 10], [10, 20, 30])
     assert_equal(-20, cs.z_min)
   end
 
@@ -384,9 +406,9 @@ class CoordinateSequenceTests < Minitest::Test
     ]
 
     coordinates = [
-      [ -10.123456789, -15.123456789 ],
-      [ 0.123456789, 5.123456789 ],
-      [ 10.123456789, 20.123456789 ]
+      [-10.123456789, -15.123456789],
+      [0.123456789, 5.123456789],
+      [10.123456789, 20.123456789]
     ]
 
     9.times do |i|
@@ -407,54 +429,54 @@ class CoordinateSequenceTests < Minitest::Test
 
   def test_snap_to_grid_with_hash
     cs = Geos::CoordinateSequence.new(
-      [ 10, 10 ],
-      [ 20, 20 ],
-      [ 30, 30 ]
+      [10, 10],
+      [20, 20],
+      [30, 30]
     )
-    cs.snap_to_grid!(:size_x => 1, :size_y => 1, :offset_x => 12.5, :offset_y => 12.5)
+    cs.snap_to_grid!(size_x: 1, size_y: 1, offset_x: 12.5, offset_y: 12.5)
 
     assert_equal([
-      [ 9.5, 9.5 ],
-      [ 20.5, 20.5 ],
-      [ 30.5, 30.5 ]
+      [9.5, 9.5],
+      [20.5, 20.5],
+      [30.5, 30.5]
     ], cs.to_a)
   end
 
   def test_snap_to_grid_with_geometry_origin
     cs = Geos::CoordinateSequence.new(
-      [ 10, 10 ],
-      [ 20, 20 ],
-      [ 30, 30 ]
+      [10, 10],
+      [20, 20],
+      [30, 30]
     )
-    cs.snap_to_grid!(:size => 1, :offset => read('LINESTRING (0 0, 25 25)'))
+    cs.snap_to_grid!(size: 1, offset: read('LINESTRING (0 0, 25 25)'))
 
     assert_equal([
-      [ 9.5, 9.5 ],
-      [ 20.5, 20.5 ],
-      [ 30.5, 30.5 ]
+      [9.5, 9.5],
+      [20.5, 20.5],
+      [30.5, 30.5]
     ], cs.to_a)
   end
 
   def test_snap_to_grid_with_z
     cs = Geos::CoordinateSequence.new(
-      [ 10, 10, 10 ],
-      [ 20, 20, 20 ],
-      [ 30, 30, 30 ]
+      [10, 10, 10],
+      [20, 20, 20],
+      [30, 30, 30]
     )
     cs.snap_to_grid!(
-      :size_x => 1,
-      :size_y => 1,
-      :size_z => 1,
+      size_x: 1,
+      size_y: 1,
+      size_z: 1,
 
-      :offset_x => 12.5,
-      :offset_y => 12.5,
-      :offset_z => 12.5
+      offset_x: 12.5,
+      offset_y: 12.5,
+      offset_z: 12.5
     )
 
     assert_equal([
-      [ 9.5, 9.5, 9.5 ],
-      [ 20.5, 20.5, 20.5 ],
-      [ 30.5, 30.5, 30.5 ]
+      [9.5, 9.5, 9.5],
+      [20.5, 20.5, 20.5],
+      [30.5, 30.5, 30.5]
     ], cs.to_a)
   end
 
@@ -486,10 +508,10 @@ class CoordinateSequenceTests < Minitest::Test
     assert_equal(expected, cs.to_a)
 
     cs = Geos::CoordinateSequence.new(coords)
-    cs2 = cs.snap_to_grid
+    cs_2 = cs.snap_to_grid
 
     assert_equal(coords, cs.to_a)
-    assert_equal(expected, cs2.to_a)
+    assert_equal(expected, cs_2.to_a)
   end
 
   undef :affine_tester
@@ -502,83 +524,83 @@ class CoordinateSequenceTests < Minitest::Test
     end
 
     cs = Geos::CoordinateSequence.new(coords)
-    cs2 = cs.send(method, *args)
+    cs_2 = cs.send(method, *args)
 
     expected.length.times do |i|
       assert_in_delta(coords[i], cs.get_ordinate(0, i), TOLERANCE)
-      assert_in_delta(expected[i], cs2.get_ordinate(0, i), TOLERANCE)
+      assert_in_delta(expected[i], cs_2.get_ordinate(0, i), TOLERANCE)
     end
   end
 
   def test_rotate
-    affine_tester(:rotate, [ 29.0, 11.0 ], [ 1, 1 ], Math::PI / 2, [ 10.0, 20.0 ])
-    affine_tester(:rotate, [ -2.0, 0.0 ], [ 1, 1 ], -Math::PI / 2, [ -1.0, 2.0 ])
-    affine_tester(:rotate, [ 19.0, 1.0 ], [ 1, 1 ], Math::PI / 2, read('POINT(10 10)'))
-    affine_tester(:rotate, [ -0.5, 0.5 ], [ 1, 1 ], Math::PI / 2, read('LINESTRING(0 0, 1 0)'))
+    affine_tester(:rotate, [29.0, 11.0], [1, 1], Math::PI / 2, [10.0, 20.0])
+    affine_tester(:rotate, [-2.0, 0.0], [1, 1], -Math::PI / 2, [-1.0, 2.0])
+    affine_tester(:rotate, [19.0, 1.0], [1, 1], Math::PI / 2, read('POINT(10 10)'))
+    affine_tester(:rotate, [-0.5, 0.5], [1, 1], Math::PI / 2, read('LINESTRING(0 0, 1 0)'))
   end
 
   def test_rotate_x
-    affine_tester(:rotate_x, [ 1, -1, -1 ], [ 1, 1, 1 ], Math::PI)
-    affine_tester(:rotate_x, [ 1, -1, 1 ], [ 1, 1, 1 ], Math::PI / 2)
-    affine_tester(:rotate_x, [ 1, 1, -1 ], [ 1, 1, 1 ], Math::PI + Math::PI / 2)
-    affine_tester(:rotate_x, [ 1, 1, 1 ], [ 1, 1, 1 ], Math::PI * 2)
+    affine_tester(:rotate_x, [1, -1, -1], [1, 1, 1], Math::PI)
+    affine_tester(:rotate_x, [1, -1, 1], [1, 1, 1], Math::PI / 2)
+    affine_tester(:rotate_x, [1, 1, -1], [1, 1, 1], Math::PI + Math::PI / 2)
+    affine_tester(:rotate_x, [1, 1, 1], [1, 1, 1], Math::PI * 2)
   end
 
   def test_rotate_y
-    affine_tester(:rotate_y, [ -1, 1, -1 ], [ 1, 1, 1 ], Math::PI)
-    affine_tester(:rotate_y, [ 1, 1, -1 ], [ 1, 1, 1 ], Math::PI / 2)
-    affine_tester(:rotate_y, [ -1, 1, 1 ], [ 1, 1, 1 ], Math::PI + Math::PI / 2)
-    affine_tester(:rotate_y, [ 1, 1, 1 ], [ 1, 1, 1 ], Math::PI * 2)
+    affine_tester(:rotate_y, [-1, 1, -1], [1, 1, 1], Math::PI)
+    affine_tester(:rotate_y, [1, 1, -1], [1, 1, 1], Math::PI / 2)
+    affine_tester(:rotate_y, [-1, 1, 1], [1, 1, 1], Math::PI + Math::PI / 2)
+    affine_tester(:rotate_y, [1, 1, 1], [1, 1, 1], Math::PI * 2)
   end
 
   def test_rotate_z
-    affine_tester(:rotate_z, [ -1, -1 ], [ 1, 1 ], Math::PI)
-    affine_tester(:rotate_z, [ -1, 1 ], [ 1, 1 ], Math::PI / 2)
-    affine_tester(:rotate_z, [ 1, -1 ], [ 1, 1 ], Math::PI + Math::PI / 2)
-    affine_tester(:rotate_z, [ 1, 1 ], [ 1, 1 ], Math::PI * 2)
+    affine_tester(:rotate_z, [-1, -1], [1, 1], Math::PI)
+    affine_tester(:rotate_z, [-1, 1], [1, 1], Math::PI / 2)
+    affine_tester(:rotate_z, [1, -1], [1, 1], Math::PI + Math::PI / 2)
+    affine_tester(:rotate_z, [1, 1], [1, 1], Math::PI * 2)
   end
 
   def test_scale
-    affine_tester(:scale, [ 5, 5 ], [ 1, 1 ], 5, 5)
-    affine_tester(:scale, [ 3, 2 ], [ 1, 1 ], 3, 2)
-    affine_tester(:scale, [ 40, 40, 40 ], [ 10, 20, -5 ], 4, 2, -8)
+    affine_tester(:scale, [5, 5], [1, 1], 5, 5)
+    affine_tester(:scale, [3, 2], [1, 1], 3, 2)
+    affine_tester(:scale, [40, 40, 40], [10, 20, -5], 4, 2, -8)
   end
 
   def test_scale_hash
-    affine_tester(:scale, [ 5, 5 ], [ 1, 1 ], :x => 5, :y => 5)
-    affine_tester(:scale, [ 3, 2 ], [ 1, 1 ], :x => 3, :y => 2)
-    affine_tester(:scale, [ 40, 40, 40 ], [ 10, 20, -5 ], :x => 4, :y => 2, :z => -8)
+    affine_tester(:scale, [5, 5], [1, 1], x: 5, y: 5)
+    affine_tester(:scale, [3, 2], [1, 1], x: 3, y: 2)
+    affine_tester(:scale, [40, 40, 40], [10, 20, -5], x: 4, y: 2, z: -8)
   end
 
   def test_trans_scale
-    affine_tester(:trans_scale, [ 2, 2 ], [ 1, 1 ], 1, 1, 1, 1)
-    affine_tester(:trans_scale, [ 3, 3 ], [ 2, 2 ], 1, 1, 1, 1)
-    affine_tester(:trans_scale, [ 0, 0 ], [ 1, 1 ], -1, -1, -1, -1)
-    affine_tester(:trans_scale, [ 1, 2 ], [ 1, 1 ], 0, 1, 1, 1)
-    affine_tester(:trans_scale, [ 2, 1 ], [ 1, 1 ], 1, 0, 1, 1)
-    affine_tester(:trans_scale, [ 0, 2 ], [ 1, 1 ], 1, 1, 0, 1)
-    affine_tester(:trans_scale, [ 2, 0 ], [ 1, 1 ], 1, 1, 1, 0)
-    affine_tester(:trans_scale, [ 3, 2 ], [ 1, 1 ], 2, 1, 1, 1)
-    affine_tester(:trans_scale, [ 2, 3 ], [ 1, 1 ], 1, 2, 1, 1)
-    affine_tester(:trans_scale, [ 4, 2 ], [ 1, 1 ], 1, 1, 2, 1)
-    affine_tester(:trans_scale, [ 2, 4 ], [ 1, 1 ], 1, 1, 1, 2)
-    affine_tester(:trans_scale, [ 15, 28 ], [ 1, 1 ], 2, 3, 5, 7)
-    affine_tester(:trans_scale, [ 15, 28, 1 ], [ 1, 1, 1 ], 2, 3, 5, 7)
+    affine_tester(:trans_scale, [2, 2], [1, 1], 1, 1, 1, 1)
+    affine_tester(:trans_scale, [3, 3], [2, 2], 1, 1, 1, 1)
+    affine_tester(:trans_scale, [0, 0], [1, 1], -1, -1, -1, -1)
+    affine_tester(:trans_scale, [1, 2], [1, 1], 0, 1, 1, 1)
+    affine_tester(:trans_scale, [2, 1], [1, 1], 1, 0, 1, 1)
+    affine_tester(:trans_scale, [0, 2], [1, 1], 1, 1, 0, 1)
+    affine_tester(:trans_scale, [2, 0], [1, 1], 1, 1, 1, 0)
+    affine_tester(:trans_scale, [3, 2], [1, 1], 2, 1, 1, 1)
+    affine_tester(:trans_scale, [2, 3], [1, 1], 1, 2, 1, 1)
+    affine_tester(:trans_scale, [4, 2], [1, 1], 1, 1, 2, 1)
+    affine_tester(:trans_scale, [2, 4], [1, 1], 1, 1, 1, 2)
+    affine_tester(:trans_scale, [15, 28], [1, 1], 2, 3, 5, 7)
+    affine_tester(:trans_scale, [15, 28, 1], [1, 1, 1], 2, 3, 5, 7)
   end
 
   def test_trans_scale_hash
-    affine_tester(:trans_scale, [ 2, 2 ], [ 1, 1 ], :delta_x => 1, :delta_y => 1, :x_factor => 1, :y_factor => 1)
-    affine_tester(:trans_scale, [ 15, 28, 1 ], [ 1, 1, 1 ], :delta_x => 2, :delta_y => 3, :x_factor => 5, :y_factor => 7)
-    affine_tester(:trans_scale, [ 3, 1, 1 ], [ 1, 1, 1 ], :delta_x => 2, :z_factor => 2)
+    affine_tester(:trans_scale, [2, 2], [1, 1], delta_x: 1, delta_y: 1, x_factor: 1, y_factor: 1)
+    affine_tester(:trans_scale, [15, 28, 1], [1, 1, 1], delta_x: 2, delta_y: 3, x_factor: 5, y_factor: 7)
+    affine_tester(:trans_scale, [3, 1, 1], [1, 1, 1], delta_x: 2, z_factor: 2)
   end
 
   def test_translate
-    affine_tester(:translate, [ 5, 12 ], [ 0, 0 ], 5, 12)
-    affine_tester(:translate, [ -3, -7, 3 ], [ 0, 0, 0 ], -3, -7, 3)
+    affine_tester(:translate, [5, 12], [0, 0], 5, 12)
+    affine_tester(:translate, [-3, -7, 3], [0, 0, 0], -3, -7, 3)
   end
 
   def test_translate_hash
-    affine_tester(:translate, [ 5, 12 ], [ 0, 0 ], :x => 5, :y => 12)
-    affine_tester(:translate, [ -3, -7, 3 ], [ 0, 0, 0 ], :x => -3, :y => -7, :z => 3)
+    affine_tester(:translate, [5, 12], [0, 0], x: 5, y: 12)
+    affine_tester(:translate, [-3, -7, 3], [0, 0, 0], x: -3, y: -7, z: 3)
   end
 end