rgeo 0.4.0 → 0.5.0

data/test/wkrep/tc_wkb_parser.rb

@@ -4,162 +4,144 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
+require "test/unit"
+require "rgeo"
 
 module RGeo
-  module Tests  # :nodoc:
-    module WKRep  # :nodoc:
-
-      class TestWKBParser < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module WKRep # :nodoc:
+      class TestWKBParser < ::Test::Unit::TestCase # :nodoc:
         def test_point_2d_xdr_hex
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('00000000013ff00000000000004000000000000000')
+          obj_ = parser_.parse("00000000013ff00000000000004000000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(1, obj_.x)
           assert_equal(2, obj_.y)
         end
 
-
         def test_point_2d_xdr_binary
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse(['00000000013ff00000000000004000000000000000'].pack('H*'))
+          obj_ = parser_.parse(["00000000013ff00000000000004000000000000000"].pack("H*"))
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(1, obj_.x)
           assert_equal(2, obj_.y)
         end
 
-
         def test_point_2d_ndr
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('0101000000000000000000f03f0000000000000040')
+          obj_ = parser_.parse("0101000000000000000000f03f0000000000000040")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(1, obj_.x)
           assert_equal(2, obj_.y)
         end
 
-
         def test_point_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse('00800000013ff000000000000040000000000000004008000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
+          obj_ = parser_.parse("00800000013ff000000000000040000000000000004008000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
         end
 
-
         def test_point_with_ewkb_m
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_m_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse('00400000013ff000000000000040000000000000004008000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_m_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
+          obj_ = parser_.parse("00400000013ff000000000000040000000000000004008000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.m)
           assert_nil(obj_.z)
         end
 
-
         def test_point_with_ewkb_zm
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :has_m_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse('00c00000013ff0000000000000400000000000000040080000000000004010000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, has_m_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
+          obj_ = parser_.parse("00c00000013ff0000000000000400000000000000040080000000000004010000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_equal(4, obj_.m)
         end
 
-
         def test_point_with_wkb12_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse('00000003e93ff000000000000040000000000000004008000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
+          obj_ = parser_.parse("00000003e93ff000000000000040000000000000004008000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
         end
 
-
         def test_point_with_wkb12_m
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_m_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse('00000007d13ff000000000000040000000000000004008000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_m_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
+          obj_ = parser_.parse("00000007d13ff000000000000040000000000000004008000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.m)
           assert_nil(obj_.z)
         end
 
-
         def test_point_with_wkb12_zm
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :has_m_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse('0000000bb93ff0000000000000400000000000000040080000000000004010000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, has_m_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
+          obj_ = parser_.parse("0000000bb93ff0000000000000400000000000000040080000000000004010000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_equal(4, obj_.m)
         end
 
-
         def test_point_with_wkb12_z_without_wkb12_support
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_)
           assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse('00000003e93ff000000000000040000000000000004008000000000000')
+            parser_.parse("00000003e93ff000000000000040000000000000004008000000000000")
           end
         end
 
-
         def test_point_with_wkb12_z_without_enough_data
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
           assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse('00000003e93ff00000000000004000000000000000')
+            parser_.parse("00000003e93ff00000000000004000000000000000")
           end
         end
 
-
         def test_point_with_ewkb_z_and_srid
           factory_generator_ = ::Proc.new do |config_|
-            ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :srid => config_[:srid])
+            ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, srid: config_[:srid])
           end
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, :support_ewkb => true)
-          obj_ = parser_.parse('00a0000001000003e83ff000000000000040000000000000004008000000000000')
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, support_ewkb: true)
+          obj_ = parser_.parse("00a0000001000003e83ff000000000000040000000000000004008000000000000")
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
           assert_equal(1000, obj_.srid)
         end
 
-
         def test_linestring_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          obj_ = parser_.parse("0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(3, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
           assert_equal(6, obj_.point_n(2).y)
         end
 
-
         def test_linestring_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse('0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
+          obj_ = parser_.parse("0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
           assert_equal(6, obj_.point_n(1).z)
         end
 
-
         def test_linestring_with_ewkb_z_and_srid
           factory_generator_ = ::Proc.new do |config_|
-            ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :srid => config_[:srid])
+            ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true, srid: config_[:srid])
           end
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, :support_ewkb => true)
-          obj_ = parser_.parse('00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, support_ewkb: true)
+          obj_ = parser_.parse("00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
@@ -167,68 +149,61 @@ module RGeo
           assert_equal(1000, obj_.srid)
         end
 
-
         def test_linestring_with_wkb12_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse('00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_wkb12: true)
+          obj_ = parser_.parse("00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000")
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
           assert_equal(6, obj_.point_n(1).z)
         end
 
-
         def test_linestring_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000200000000')
+          obj_ = parser_.parse("000000000200000000")
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(0, obj_.num_points)
         end
 
-
         def test_polygon_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000')
+          obj_ = parser_.parse("000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000")
           assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
           assert_equal(4, obj_.exterior_ring.num_points)
           assert_equal(1, obj_.exterior_ring.point_n(0).x)
           assert_equal(5, obj_.exterior_ring.point_n(2).y)
         end
 
-
         def test_polygon_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000300000000')
+          obj_ = parser_.parse("000000000300000000")
           assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
           assert_equal(0, obj_.exterior_ring.num_points)
         end
 
-
         def test_multipoint_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000')
+          obj_ = parser_.parse("00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000")
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
           assert_equal(4, obj_[1].y)
         end
 
-
         def test_multipoint_mixed_byte_order
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000')
+          obj_ = parser_.parse("0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000")
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
           assert_equal(4, obj_[1].y)
         end
 
-
         def test_multipoint_with_ewkb_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse('00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000')
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
+          obj_ = parser_.parse("00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000")
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
@@ -238,53 +213,47 @@ module RGeo
           assert_nil(obj_[0].m)
         end
 
-
         def test_multipoint_ewkb_with_mixed_z
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
+          factory_ = ::RGeo::Cartesian.preferred_factory(has_z_coordinate: true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, support_ewkb: true)
           assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse('00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000')
+            parser_.parse("00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000")
           end
         end
 
-
         def test_multipoint_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000400000000')
+          obj_ = parser_.parse("000000000400000000")
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
 
-
         def test_multilinestring_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000')
+          obj_ = parser_.parse("0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000")
           assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].point_n(0).x)
           assert_equal(-4, obj_[1].point_n(1).y)
         end
 
-
         def test_multilinestring_wrong_element_type
           parser_ = ::RGeo::WKRep::WKBParser.new
           assert_raise(::RGeo::Error::ParseError) do
-            parser_.parse('0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000')
+            parser_.parse("0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000")
           end
         end
 
-
         def test_multilinestring_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000500000000')
+          obj_ = parser_.parse("000000000500000000")
           assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
 
-
         def test_multipolygon_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000')
+          obj_ = parser_.parse("000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000")
           assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(4, obj_[0].exterior_ring.num_points)
@@ -293,18 +262,16 @@ module RGeo
           assert_equal(0, obj_[1].exterior_ring.num_points)
         end
 
-
         def test_multipolygon_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000600000000')
+          obj_ = parser_.parse("000000000600000000")
           assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
 
-
         def test_collection_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000')
+          obj_ = parser_.parse("0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000")
           assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(::RGeo::Feature::LineString, obj_[0].geometry_type)
@@ -314,17 +281,13 @@ module RGeo
           assert_equal(-1, obj_[1].x)
         end
 
-
         def test_collection_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse('000000000700000000')
+          obj_ = parser_.parse("000000000700000000")
           assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
-
-
       end
-
     end
   end
 end

data/test/wkrep/tc_wkt_generator.rb

@@ -4,161 +4,137 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
+require "test/unit"
+require "rgeo"
 
 module RGeo
-  module Tests  # :nodoc:
-    module WKRep  # :nodoc:
-
-      class TestWKTGenerator < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module WKRep # :nodoc:
+      class TestWKTGenerator < ::Test::Unit::TestCase # :nodoc:
         def setup
-          @factory = ::RGeo::Cartesian.preferred_factory(:srid => 1000)
-          @factoryz = ::RGeo::Cartesian.preferred_factory(:srid => 1000, :has_z_coordinate => true)
-          @factorym = ::RGeo::Cartesian.preferred_factory(:srid => 1000, :has_m_coordinate => true)
-          @factoryzm = ::RGeo::Cartesian.preferred_factory(:srid => 1000, :has_z_coordinate => true, :has_m_coordinate => true)
+          @factory = ::RGeo::Cartesian.preferred_factory(srid: 1000)
+          @factoryz = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_z_coordinate: true)
+          @factorym = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_m_coordinate: true)
+          @factoryzm = ::RGeo::Cartesian.preferred_factory(srid: 1000, has_z_coordinate: true, has_m_coordinate: true)
         end
 
-
         def test_point_2d
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.point(1, 2)
-          assert_equal('Point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_z
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factoryz.point(1, 2, 3)
-          assert_equal('Point (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_z_wkt11strict
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt11_strict)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11_strict)
           obj_ = @factoryz.point(1, 2, 3)
-          assert_equal('Point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_m
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factorym.point(1, 2, 3)
-          assert_equal('Point (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_zm
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factoryzm.point(1, 2, 3, 4)
-          assert_equal('Point (1.0 2.0 3.0 4.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0 3.0 4.0)", generator_.generate(obj_))
         end
 
-
         def test_point_squarebrackets
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:square_brackets => true)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(square_brackets: true)
           obj_ = @factory.point(1, 2)
-          assert_equal('Point [1.0 2.0]', generator_.generate(obj_))
+          assert_equal("Point [1.0 2.0]", generator_.generate(obj_))
         end
 
-
         def test_point_uppercase
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:convert_case => :upper)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(convert_case: :upper)
           obj_ = @factory.point(1, 2)
-          assert_equal('POINT (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("POINT (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_lowercase
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:convert_case => :lower)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(convert_case: :lower)
           obj_ = @factory.point(1, 2)
-          assert_equal('point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_wkt12
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt12)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
           obj_ = @factory.point(1, 2)
-          assert_equal('Point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_wkt12_z
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt12)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
           obj_ = @factoryz.point(1, 2, 3)
-          assert_equal('Point Z (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("Point Z (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_wkt12_m
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt12)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
           obj_ = @factorym.point(1, 2, 3)
-          assert_equal('Point M (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("Point M (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_wkt12_zm
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt12)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
           obj_ = @factoryzm.point(1, 2, 3, 4)
-          assert_equal('Point ZM (1.0 2.0 3.0 4.0)', generator_.generate(obj_))
+          assert_equal("Point ZM (1.0 2.0 3.0 4.0)", generator_.generate(obj_))
         end
 
-
         def test_point_ewkt
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :ewkt)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt)
           obj_ = @factory.point(1, 2)
-          assert_equal('Point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_point_ewkt_z
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :ewkt)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt)
           obj_ = @factoryz.point(1, 2, 3)
-          assert_equal('Point (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_ewkt_m
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :ewkt)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt)
           obj_ = @factorym.point(1, 2, 3)
-          assert_equal('PointM (1.0 2.0 3.0)', generator_.generate(obj_))
+          assert_equal("PointM (1.0 2.0 3.0)", generator_.generate(obj_))
         end
 
-
         def test_point_ewkt_zm
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :ewkt)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt)
           obj_ = @factoryzm.point(1, 2, 3, 4)
-          assert_equal('Point (1.0 2.0 3.0 4.0)', generator_.generate(obj_))
+          assert_equal("Point (1.0 2.0 3.0 4.0)", generator_.generate(obj_))
         end
 
-
         def test_point_ewkt_with_srid
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :ewkt, :emit_ewkt_srid => true)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :ewkt, emit_ewkt_srid: true)
           obj_ = @factory.point(1, 2)
-          assert_equal('SRID=1000;Point (1.0 2.0)', generator_.generate(obj_))
+          assert_equal("SRID=1000;Point (1.0 2.0)", generator_.generate(obj_))
         end
 
-
         def test_linestring_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(1, 2)
           p2_ = @factory.point(2, 2)
           p3_ = @factory.point(1, 1)
           obj_ = @factory.line_string([p1_, p2_, p3_])
-          assert_equal('LineString (1.0 2.0, 2.0 2.0, 1.0 1.0)', generator_.generate(obj_))
+          assert_equal("LineString (1.0 2.0, 2.0 2.0, 1.0 1.0)", generator_.generate(obj_))
         end
 
-
         def test_linestring_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.line_string([])
-          assert_equal('LineString EMPTY', generator_.generate(obj_))
+          assert_equal("LineString EMPTY", generator_.generate(obj_))
         end
 
-
         def test_polygon_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(0, 0)
@@ -167,10 +143,9 @@ module RGeo
           p4_ = @factory.point(0, 10)
           ext_ = @factory.line_string([p1_, p2_, p3_, p4_, p1_])
           obj_ = @factory.polygon(ext_)
-          assert_equal('Polygon ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0))', generator_.generate(obj_))
+          assert_equal("Polygon ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0))", generator_.generate(obj_))
         end
 
-
         def test_polygon_with_hole
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(0, 0)
@@ -183,34 +158,30 @@ module RGeo
           ext_ = @factory.line_string([p1_, p2_, p3_, p4_, p1_])
           int_ = @factory.line_string([p5_, p6_, p7_, p5_])
           obj_ = @factory.polygon(ext_, [int_])
-          assert_equal('Polygon ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0))', generator_.generate(obj_))
+          assert_equal("Polygon ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0))", generator_.generate(obj_))
         end
 
-
         def test_polygon_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.polygon(@factory.line_string([]))
-          assert_equal('Polygon EMPTY', generator_.generate(obj_))
+          assert_equal("Polygon EMPTY", generator_.generate(obj_))
         end
 
-
         def test_multipoint_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(1, 2)
           p2_ = @factory.point(2, 2)
           p3_ = @factory.point(1, 1)
           obj_ = @factory.multi_point([p1_, p2_, p3_])
-          assert_equal('MultiPoint ((1.0 2.0), (2.0 2.0), (1.0 1.0))', generator_.generate(obj_))
+          assert_equal("MultiPoint ((1.0 2.0), (2.0 2.0), (1.0 1.0))", generator_.generate(obj_))
         end
 
-
         def test_multipoint_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.multi_point([])
-          assert_equal('MultiPoint EMPTY', generator_.generate(obj_))
+          assert_equal("MultiPoint EMPTY", generator_.generate(obj_))
         end
 
-
         def test_multilinestring_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(0, 0)
@@ -224,17 +195,15 @@ module RGeo
           ls2_ = @factory.line_string([p5_, p6_, p7_])
           ls3_ = @factory.line_string([])
           obj_ = @factory.multi_line_string([ls1_, ls2_, ls3_])
-          assert_equal('MultiLineString ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0), EMPTY)', generator_.generate(obj_))
+          assert_equal("MultiLineString ((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0), EMPTY)", generator_.generate(obj_))
         end
 
-
         def test_multilinestring_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.multi_line_string([])
-          assert_equal('MultiLineString EMPTY', generator_.generate(obj_))
+          assert_equal("MultiLineString EMPTY", generator_.generate(obj_))
         end
 
-
         def test_multipolygon_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(0, 0)
@@ -255,17 +224,15 @@ module RGeo
           poly2_ = @factory.polygon(@factory.line_string([]))
           poly3_ = @factory.polygon(ext3_)
           obj_ = @factory.multi_polygon([poly1_, poly2_, poly3_])
-          assert_equal('MultiPolygon (((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0)), EMPTY, ((20.0 20.0, 30.0 20.0, 30.0 30.0, 20.0 30.0, 20.0 20.0)))', generator_.generate(obj_))
+          assert_equal("MultiPolygon (((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0)), EMPTY, ((20.0 20.0, 30.0 20.0, 30.0 30.0, 20.0 30.0, 20.0 20.0)))", generator_.generate(obj_))
         end
 
-
         def test_multipolygon_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.multi_polygon([])
-          assert_equal('MultiPolygon EMPTY', generator_.generate(obj_))
+          assert_equal("MultiPolygon EMPTY", generator_.generate(obj_))
         end
 
-
         def test_collection_basic
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           p1_ = @factory.point(0, 0)
@@ -288,12 +255,11 @@ module RGeo
           obj1_ = @factory.multi_polygon([poly1_, poly2_, poly3_])
           obj2_ = @factory.point(1, 2)
           obj_ = @factory.collection([obj1_, obj2_])
-          assert_equal('GeometryCollection (MultiPolygon (((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0)), EMPTY, ((20.0 20.0, 30.0 20.0, 30.0 30.0, 20.0 30.0, 20.0 20.0))), Point (1.0 2.0))', generator_.generate(obj_))
+          assert_equal("GeometryCollection (MultiPolygon (((0.0 0.0, 10.0 0.0, 10.0 10.0, 0.0 10.0, 0.0 0.0), (1.0 1.0, 2.0 2.0, 3.0 1.0, 1.0 1.0)), EMPTY, ((20.0 20.0, 30.0 20.0, 30.0 30.0, 20.0 30.0, 20.0 20.0))), Point (1.0 2.0))", generator_.generate(obj_))
         end
 
-
         def test_collection_wkt12_z
-          generator_ = ::RGeo::WKRep::WKTGenerator.new(:tag_format => :wkt12)
+          generator_ = ::RGeo::WKRep::WKTGenerator.new(tag_format: :wkt12)
           p1_ = @factoryz.point(0, 0)
           p2_ = @factoryz.point(10, 0)
           p3_ = @factoryz.point(10, 10)
@@ -314,19 +280,15 @@ module RGeo
           obj1_ = @factoryz.multi_polygon([poly1_, poly2_, poly3_])
           obj2_ = @factoryz.point(1, 2, 3)
           obj_ = @factoryz.collection([obj1_, obj2_])
-          assert_equal('GeometryCollection Z (MultiPolygon Z (((0.0 0.0 0.0, 10.0 0.0 0.0, 10.0 10.0 0.0, 0.0 10.0 0.0, 0.0 0.0 0.0), (1.0 1.0 0.0, 2.0 2.0 0.0, 3.0 1.0 0.0, 1.0 1.0 0.0)), EMPTY, ((20.0 20.0 0.0, 30.0 20.0 0.0, 30.0 30.0 0.0, 20.0 30.0 0.0, 20.0 20.0 0.0))), Point Z (1.0 2.0 3.0))', generator_.generate(obj_))
+          assert_equal("GeometryCollection Z (MultiPolygon Z (((0.0 0.0 0.0, 10.0 0.0 0.0, 10.0 10.0 0.0, 0.0 10.0 0.0, 0.0 0.0 0.0), (1.0 1.0 0.0, 2.0 2.0 0.0, 3.0 1.0 0.0, 1.0 1.0 0.0)), EMPTY, ((20.0 20.0 0.0, 30.0 20.0 0.0, 30.0 30.0 0.0, 20.0 30.0 0.0, 20.0 20.0 0.0))), Point Z (1.0 2.0 3.0))", generator_.generate(obj_))
         end
 
-
         def test_collection_empty
           generator_ = ::RGeo::WKRep::WKTGenerator.new
           obj_ = @factory.collection([])
-          assert_equal('GeometryCollection EMPTY', generator_.generate(obj_))
+          assert_equal("GeometryCollection EMPTY", generator_.generate(obj_))
         end
-
-
       end
-
     end
   end
 end