georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/simple_features/polygon.rb

@@ -1,31 +1,30 @@
 require 'geo_ruby/simple_features/geometry'
 
 module GeoRuby
-
   module SimpleFeatures
-
     # Represents a polygon as an array of linear rings (see LinearRing).
-    # No check is performed regarding the validity of the geometries forming the polygon.
+    # No check is performed regarding the validity of the geometries
+    # forming the polygon.
     class Polygon < Geometry
-      #the list of rings forming the polygon
+      # the list of rings forming the polygon
       attr_reader :rings
 
-      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
-        super(srid,with_z,with_m)
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        super(srid, with_z, with_m)
         @rings = []
       end
 
-      #Delegate the unknown methods to the rings array
-      def method_missing(method_name,*args,&b)
-        @rings.send(method_name,*args,&b)
+      # Delegate the unknown methods to the rings array
+      def method_missing(method_name, *args, &b)
+        @rings.send(method_name, *args, &b)
       end
 
-      #Bounding box in 2D/3D. Returns an array of 2 points
+      # Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
-        unless with_z
+        if !with_z
           @rings[0].bounding_box
         else
-          result = @rings[0].bounding_box #valid for x and y
+          result = @rings[0].bounding_box # valid for x and y
           max_z, min_z = result[1].z, result[0].z
           1.upto(size - 1) do |index|
             bbox = @rings[index].bounding_box
@@ -47,47 +46,50 @@ module GeoRuby
             max_m = lrmr[1] if lrmr[1] > max_m
             min_m = lrmr[0] if lrmr[0] < min_m
           end
-          [min_m,max_m]
+          [min_m, max_m]
         else
-          [0,0]
+          [0, 0]
         end
       end
 
-      #tests for other equality. The SRID is not taken into account.
+      # tests for other equality. The SRID is not taken into account.
       def ==(other_polygon)
-        if other_polygon.class != self.class or
-            length != other_polygon.length
+        if other_polygon.class != self.class ||
+           length != other_polygon.length
           false
         else
-          index=0
-          while index<length
+          index = 0
+          while index < length
             return false if self[index] != other_polygon[index]
-            index+=1
+            index += 1
           end
           true
         end
       end
 
-      #binary representation of a polygon, without the headers neccessary for a valid WKB string
-      def binary_representation(allow_z=true,allow_m=true)
-        rep = [length].pack("V")
-        each {|linear_ring| rep << linear_ring.binary_representation(allow_z,allow_m)}
+      # Binary representation of a polygon.
+      # Without the headers neccessary for a valid WKB string
+      def binary_representation(allow_z = true, allow_m = true)
+        rep = [length].pack('V')
+        each { |linear_ring| rep << linear_ring.binary_representation(allow_z, allow_m) }
         rep
       end
 
-      #WKB geometry type
+      # WKB geometry type
       def binary_geometry_type
         3
       end
 
-      #Text representation of a polygon
-      def text_representation(allow_z=true,allow_m=true)
-        @rings.collect{|line_string| "(" + line_string.text_representation(allow_z,allow_m) + ")" }.join(",")
+      # Text representation of a polygon
+      def text_representation(allow_z = true, allow_m = true)
+        @rings.map do |line_string|
+          '(' + line_string.text_representation(allow_z, allow_m) + ')'
+        end.join(',')
       end
 
-      #WKT geometry type
+      # WKT geometry type
       def text_geometry_type
-        "POLYGON"
+        'POLYGON'
       end
 
       # Contains a point?
@@ -95,38 +97,39 @@ module GeoRuby
         !@rings.select { |lr| lr.contains_point? point }.empty?
       end
 
-      #georss simple representation : outputs only the outer ring
+      # georss simple representation : outputs only the outer ring
       def georss_simple_representation(options)
-        georss_ns = options[:georss_ns] || "georss"
+        georss_ns = options[:georss_ns] || 'georss'
         geom_attr = options[:geom_attr]
         "<#{georss_ns}:polygon#{geom_attr}>" + self[0].georss_poslist + "</#{georss_ns}:polygon>\n"
       end
 
-      #georss w3c representation : outputs the first point of the outer ring
+      # georss w3c representation : outputs the first point of the outer ring
       def georss_w3cgeo_representation(options)
-        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        w3cgeo_ns = options[:w3cgeo_ns] || 'geo'
 
         "<#{w3cgeo_ns}:lat>#{self[0][0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0][0].x}</#{w3cgeo_ns}:long>\n"
       end
-      #georss gml representation
+
+      # georss gml representation
       def georss_gml_representation(options)
-        georss_ns = options[:georss_ns] || "georss"
-        gml_ns = options[:gml_ns] || "gml"
+        georss_ns = options[:georss_ns] || 'georss'
+        gml_ns = options[:gml_ns] || 'gml'
 
         result = "<#{georss_ns}:where>\n<#{gml_ns}:Polygon>\n<#{gml_ns}:exterior>\n<#{gml_ns}:LinearRing>\n<#{gml_ns}:posList>\n" + self[0].georss_poslist + "\n</#{gml_ns}:posList>\n</#{gml_ns}:LinearRing>\n</#{gml_ns}:exterior>\n</#{gml_ns}:Polygon>\n</#{georss_ns}:where>\n"
       end
 
-      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
-      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
-      #it won't be used by GE anyway: clampToGround is the default)
+      # outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      # <tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      # it won't be used by GE anyway: clampToGround is the default)
       def kml_representation(options = {})
         result = "<Polygon#{options[:id_attr]}>\n"
         result += options[:geom_data] if options[:geom_data]
         rings.each_with_index do |ring, i|
           if i == 0
-            boundary = "outerBoundaryIs"
+            boundary = 'outerBoundaryIs'
           else
-            boundary = "innerBoundaryIs"
+            boundary = 'innerBoundaryIs'
           end
           result += "<#{boundary}><LinearRing><coordinates>\n"
           result += ring.kml_poslist(options)
@@ -136,36 +139,34 @@ module GeoRuby
       end
 
       def to_coordinates
-        rings.map{|lr| lr.to_coordinates}
+        rings.map(&:to_coordinates)
       end
 
-      def as_json(options = {})
-        {:type => 'Polygon', :coordinates => self.to_coordinates }
+      def as_json(_options = {})
+        { type: 'Polygon', coordinates: to_coordinates }
       end
 
-      #creates a new polygon. Accepts an array of linear strings as argument
-      def self.from_linear_rings(linear_rings,srid = DEFAULT_SRID,with_z=false,with_m=false)
-        polygon = new(srid,with_z,with_m)
+      # creates a new polygon. Accepts an array of linear strings as argument
+      def self.from_linear_rings(linear_rings, srid = DEFAULT_SRID, with_z = false, with_m = false)
+        polygon = new(srid, with_z, with_m)
         polygon.concat(linear_rings)
         polygon
       end
 
-      #creates a new polygon. Accepts a sequence of points as argument : ((x,y)....(x,y)),((x,y).....(x,y))
-      def self.from_coordinates(point_sequences,srid=DEFAULT_SRID,with_z=false,with_m=false)
-        polygon = new(srid,with_z,with_m)
-        polygon.concat( point_sequences.map {|points| LinearRing.from_coordinates(points,srid,with_z,with_m) } )
+      # creates a new polygon. Accepts a sequence of points as argument:
+      #  ((x,y)....(x,y)),((x,y).....(x,y))
+      def self.from_coordinates(point_sequences, srid = DEFAULT_SRID, z = false, m = false)
+        polygon = new(srid, z, m)
+        polygon.concat(point_sequences.map { |points| LinearRing.from_coordinates(points, srid, z, m) })
         polygon
       end
 
-      #creates a new polygon from a list of Points (pt1....ptn),(pti....ptj)
-      def self.from_points(point_sequences, srid=DEFAULT_SRID,with_z=false,with_m=false)
-        polygon = new(srid,with_z,with_m)
-        polygon.concat( point_sequences.map {|points| LinearRing.from_points(points,srid,with_z,with_m) } )
+      # creates a new polygon from a list of Points (pt1....ptn),(pti....ptj)
+      def self.from_points(point_sequences, srid = DEFAULT_SRID, z = false, m = false)
+        polygon = new(srid, z, m)
+        polygon.concat(point_sequences.map { |points| LinearRing.from_points(points, srid, z, m) })
         polygon
       end
-
     end
-
   end
-
 end

data/lib/geo_ruby/version.rb

@@ -1,3 +1,3 @@
 module GeoRuby
-  VERSION = '2.3.0'
+  VERSION = '2.5.1'
 end

data/spec/data/geojson/feature.json

@@ -0,0 +1,9 @@
+{
+  "type":"Feature",
+  "id":"Some.Nice.Id_777",
+  "properties":{"color": "red"},
+  "geometry":{
+    "type":"Point",
+    "coordinates":[97.03125, 39.7265625]
+  }
+}

data/spec/data/geojson/feature_collection.json

@@ -27,8 +27,7 @@
        "properties": {
          "prop0": "value0",
          "prop1": {"this": "that"}
-         }
        }
-     ]
-   }
-
+    }
+  ]
+}

data/spec/geo_ruby/{simple_features → ewk}/ewkb_parser_spec.rb

@@ -1,158 +1,157 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
+# rubocop:disable Metrics/LineLength
 describe GeoRuby::SimpleFeatures::EWKBParser do
 
   before(:each) do
-    @factory = GeoRuby::SimpleFeatures::GeometryFactory::new
-    @hex_ewkb_parser = GeoRuby::SimpleFeatures::HexEWKBParser::new(@factory)
+    @factory = GeoRuby::SimpleFeatures::GeometryFactory.new
+    @hex_ewkb_parser = GeoRuby::SimpleFeatures::HexEWKBParser.new(@factory)
   end
 
-  it "test_point2d" do
-    @hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC28406666666666A64640")
+  it 'test_point2d' do
+    @hex_ewkb_parser.parse('01010000207B000000CDCCCCCCCCCC28406666666666A64640')
     point = @factory.geometry
     expect(point).to be_instance_of GeoRuby::SimpleFeatures::Point
     expect(point).to eq(GeoRuby::SimpleFeatures::Point.from_x_y(12.4, 45.3, 123))
   end
 
-  it "test_point2d_BigEndian" do
-    @hex_ewkb_parser.parse("00000000014013A035BD512EC7404A3060C38F3669")
+  it 'test_point2d_BigEndian' do
+    @hex_ewkb_parser.parse('00000000014013A035BD512EC7404A3060C38F3669')
     point = @factory.geometry
     expect(point).to be_instance_of GeoRuby::SimpleFeatures::Point
     expect(point).to eq(GeoRuby::SimpleFeatures::Point.from_x_y(4.906455, 52.377953))
   end
 
-  it "test_point3dz" do
-    @hex_ewkb_parser.parse("01010000A07B000000CDCCCCCCCCCC28406666666666A646400000000000000CC0")
+  it 'test_point3dz' do
+    @hex_ewkb_parser.parse('01010000A07B000000CDCCCCCCCCCC28406666666666A646400000000000000CC0')
     point = @factory.geometry
     expect(point).to be_instance_of GeoRuby::SimpleFeatures::Point
     expect(point).to eq(GeoRuby::SimpleFeatures::Point.from_x_y_z(12.4, 45.3, -3.5, 123))
   end
 
-  it "test_point4d" do
-    @hex_ewkb_parser.parse("01010000E07B000000CDCCCCCCCCCC28406666666666A646400000000000000CC00000000000002E40")
+  it 'test_point4d' do
+    @hex_ewkb_parser.parse('01010000E07B000000CDCCCCCCCCCC28406666666666A646400000000000000CC00000000000002E40')
     point = @factory.geometry
     expect(point).to be_instance_of GeoRuby::SimpleFeatures::Point
     expect(point).to eq(GeoRuby::SimpleFeatures::Point.from_x_y_z_m(12.4, 45.3, -3.5, 15, 123))
   end
 
-  it "test_line_string" do
-    @hex_ewkb_parser.parse("01020000200001000002000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC4440")
+  it 'test_line_string' do
+    @hex_ewkb_parser.parse('01020000200001000002000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC4440')
     line_string = @factory.geometry
     expect(line_string).to be_instance_of GeoRuby::SimpleFeatures::LineString
-    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4,-45.3],[45.4,41.6]],256))
+    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4, -45.3], [45.4, 41.6]], 256))
 
-    @hex_ewkb_parser.parse("01020000A00001000002000000CDCCCCCCCCCC28406666666666A646C06666666666A641403333333333B34640CDCCCCCCCCCC44409A99999999992840")
+    @hex_ewkb_parser.parse('01020000A00001000002000000CDCCCCCCCCCC28406666666666A646C06666666666A641403333333333B34640CDCCCCCCCCCC44409A99999999992840')
     line_string = @factory.geometry
     expect(line_string).to be_instance_of GeoRuby::SimpleFeatures::LineString
-    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4,-45.3,35.3],[45.4,41.6,12.3]],256,true))
+    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4, -45.3, 35.3], [45.4, 41.6, 12.3]], 256, true))
 
-    @hex_ewkb_parser.parse("01020000E00001000002000000CDCCCCCCCCCC28406666666666A646C06666666666A64140CDCCCCCCCC8C46403333333333B34640CDCCCCCCCCCC44409A999999999928403D0AD7A3701D4440")
+    @hex_ewkb_parser.parse('01020000E00001000002000000CDCCCCCCCCCC28406666666666A646C06666666666A64140CDCCCCCCCC8C46403333333333B34640CDCCCCCCCCCC44409A999999999928403D0AD7A3701D4440')
     line_string = @factory.geometry
     expect(line_string).to be_instance_of GeoRuby::SimpleFeatures::LineString
-    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4,-45.3,35.3,45.1],[45.4,41.6,12.3,40.23]],256,true,true))
+    expect(line_string).to eq(GeoRuby::SimpleFeatures::LineString.from_coordinates([[12.4, -45.3, 35.3, 45.1], [45.4, 41.6, 12.3, 40.23]], 256, true, true))
   end
 
-  it "test_polygon" do
-    @hex_ewkb_parser.parse("0103000020000100000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F")
+  it 'test_polygon' do
+    @hex_ewkb_parser.parse('0103000020000100000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F')
     polygon = @factory.geometry
     expect(polygon).to be_instance_of GeoRuby::SimpleFeatures::Polygon
-    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]],256))
+    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0], [4, 0], [4, 4], [0, 4], [0, 0]], [[1, 1], [3, 1], [3, 3], [1, 3], [1, 1]]], 256))
 
-    @hex_ewkb_parser.parse("01030000A000010000020000000500000000000000000000000000000000000000000000000000004000000000000010400000000000000000000000000000004000000000000010400000000000001040000000000000004000000000000000000000000000001040000000000000004000000000000000000000000000000000000000000000004005000000000000000000F03F000000000000F03F00000000000000400000000000000840000000000000F03F0000000000000040000000000000084000000000000008400000000000000040000000000000F03F00000000000008400000000000000040000000000000F03F000000000000F03F0000000000000040")
+    @hex_ewkb_parser.parse('01030000A000010000020000000500000000000000000000000000000000000000000000000000004000000000000010400000000000000000000000000000004000000000000010400000000000001040000000000000004000000000000000000000000000001040000000000000004000000000000000000000000000000000000000000000004005000000000000000000F03F000000000000F03F00000000000000400000000000000840000000000000F03F0000000000000040000000000000084000000000000008400000000000000040000000000000F03F00000000000008400000000000000040000000000000F03F000000000000F03F0000000000000040')
     polygon = @factory.geometry
     expect(polygon).to be_instance_of GeoRuby::SimpleFeatures::Polygon
-    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0,2],[4,0,2],[4,4,2],[0,4,2],[0,0,2]],[[1,1,2],[3,1,2],[3,3,2],[1,3,2],[1,1,2]]],256,true))
+    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0, 2], [4, 0, 2], [4, 4, 2], [0, 4, 2], [0, 0, 2]], [[1, 1, 2], [3, 1, 2], [3, 3, 2], [1, 3, 2], [1, 1, 2]]], 256, true))
 
-    @hex_ewkb_parser.parse("010300006000010000020000000500000000000000000000000000000000000000000000000000004000000000000010400000000000000000000000000000004000000000000010400000000000001040000000000000004000000000000000000000000000001040000000000000004000000000000000000000000000000000000000000000004005000000000000000000F03F000000000000F03F00000000000000400000000000000840000000000000F03F0000000000000040000000000000084000000000000008400000000000000040000000000000F03F00000000000008400000000000000040000000000000F03F000000000000F03F0000000000000040")
+    @hex_ewkb_parser.parse('010300006000010000020000000500000000000000000000000000000000000000000000000000004000000000000010400000000000000000000000000000004000000000000010400000000000001040000000000000004000000000000000000000000000001040000000000000004000000000000000000000000000000000000000000000004005000000000000000000F03F000000000000F03F00000000000000400000000000000840000000000000F03F0000000000000040000000000000084000000000000008400000000000000040000000000000F03F00000000000008400000000000000040000000000000F03F000000000000F03F0000000000000040')
     polygon = @factory.geometry
     expect(polygon).to be_instance_of GeoRuby::SimpleFeatures::Polygon
-    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0,2],[4,0,2],[4,4,2],[0,4,2],[0,0,2]],[[1,1,2],[3,1,2],[3,3,2],[1,3,2],[1,1,2]]],256,false,true))
+    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0, 2], [4, 0, 2], [4, 4, 2], [0, 4, 2], [0, 0, 2]], [[1, 1, 2], [3, 1, 2], [3, 3, 2], [1, 3, 2], [1, 1, 2]]], 256, false, true))
 
-    @hex_ewkb_parser.parse("01030000E0000100000200000005000000000000000000000000000000000000000000000000000040CDCCCCCCCC8C46C00000000000001040000000000000000000000000000000400000000000001440000000000000104000000000000010400000000000000040AE47E17A14AE1240000000000000000000000000000010400000000000000040713D0AD7A370F53F000000000000000000000000000000000000000000000040CDCCCCCCCC8C46C005000000000000000000F03F000000000000F03F00000000000000409A999999999928400000000000000840000000000000F03F00000000000000400000000000C05E400000000000000840000000000000084000000000000000406666666666662840000000000000F03F000000000000084000000000000000400000000000002840000000000000F03F000000000000F03F00000000000000409A99999999992840")
+    @hex_ewkb_parser.parse('01030000E0000100000200000005000000000000000000000000000000000000000000000000000040CDCCCCCCCC8C46C00000000000001040000000000000000000000000000000400000000000001440000000000000104000000000000010400000000000000040AE47E17A14AE1240000000000000000000000000000010400000000000000040713D0AD7A370F53F000000000000000000000000000000000000000000000040CDCCCCCCCC8C46C005000000000000000000F03F000000000000F03F00000000000000409A999999999928400000000000000840000000000000F03F00000000000000400000000000C05E400000000000000840000000000000084000000000000000406666666666662840000000000000F03F000000000000084000000000000000400000000000002840000000000000F03F000000000000F03F00000000000000409A99999999992840')
     polygon = @factory.geometry
     expect(polygon).to be_instance_of GeoRuby::SimpleFeatures::Polygon
-    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0,2,-45.1],[4,0,2,5],[4,4,2,4.67],[0,4,2,1.34],[0,0,2,-45.1]],[[1,1,2,12.3],[3,1,2,123],[3,3,2,12.2],[1,3,2,12],[1,1,2,12.3]]],256,true,true))
+    expect(polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0, 2, -45.1], [4, 0, 2, 5], [4, 4, 2, 4.67], [0, 4, 2, 1.34], [0, 0, 2, -45.1]], [[1, 1, 2, 12.3], [3, 1, 2, 123], [3, 3, 2, 12.2], [1, 3, 2, 12], [1, 1, 2, 12.3]]], 256, true, true))
   end
 
-  it "test_geometry_collection" do
-    @hex_ewkb_parser.parse("010700002000010000020000000101000000AE47E17A14AE12403333333333B34640010200000002000000CDCCCCCCCCCC16406666666666E628403333333333E350400000000000004B40")
+  it 'test_geometry_collection' do
+    @hex_ewkb_parser.parse('010700002000010000020000000101000000AE47E17A14AE12403333333333B34640010200000002000000CDCCCCCCCCCC16406666666666E628403333333333E350400000000000004B40')
     geometry_collection = @factory.geometry
     expect(geometry_collection).to be_instance_of GeoRuby::SimpleFeatures::GeometryCollection
 
-    expect(geometry_collection).to eq(GeoRuby::SimpleFeatures::GeometryCollection.from_geometries([GeoRuby::SimpleFeatures::Point.from_x_y(4.67,45.4,256),GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7,12.45],[67.55,54]],256)],256))
+    expect(geometry_collection).to eq(GeoRuby::SimpleFeatures::GeometryCollection.from_geometries([GeoRuby::SimpleFeatures::Point.from_x_y(4.67, 45.4, 256), GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7, 12.45], [67.55, 54]], 256)], 256))
     expect(geometry_collection[0].srid).to eql(256)
 
-    @hex_ewkb_parser.parse("01070000E0000100000200000001010000C0AE47E17A14AE12403333333333B34640F6285C8FC2D54640666666666666024001020000C002000000CDCCCCCCCCCC16406666666666E628403D0AD7A3703D124033333333339358403333333333E350400000000000004B4066666666666628403333333333330B40")
+    @hex_ewkb_parser.parse('01070000E0000100000200000001010000C0AE47E17A14AE12403333333333B34640F6285C8FC2D54640666666666666024001020000C002000000CDCCCCCCCCCC16406666666666E628403D0AD7A3703D124033333333339358403333333333E350400000000000004B4066666666666628403333333333330B40')
     geometry_collection = @factory.geometry
     expect(geometry_collection).to be_instance_of GeoRuby::SimpleFeatures::GeometryCollection
-    expect(geometry_collection).to eq(GeoRuby::SimpleFeatures::GeometryCollection.from_geometries([GeoRuby::SimpleFeatures::Point.from_x_y_z_m(4.67,45.4,45.67,2.3,256),GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7,12.45,4.56,98.3],[67.55,54,12.2,3.4]],256,true, true)],256,true, true))
+    expect(geometry_collection).to eq(GeoRuby::SimpleFeatures::GeometryCollection.from_geometries([GeoRuby::SimpleFeatures::Point.from_x_y_z_m(4.67, 45.4, 45.67, 2.3, 256), GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7, 12.45, 4.56, 98.3], [67.55, 54, 12.2, 3.4]], 256, true, true)], 256, true, true))
     expect(geometry_collection[0].srid).to eql(256)
   end
 
-  it "test_multi_point" do
-    @hex_ewkb_parser.parse("0104000020BC010000030000000101000000CDCCCCCCCCCC28403333333333D35EC0010100000066666666664650C09A99999999D95E4001010000001F97DD388EE35E400000000000C05E40")
+  it 'test_multi_point' do
+    @hex_ewkb_parser.parse('0104000020BC010000030000000101000000CDCCCCCCCCCC28403333333333D35EC0010100000066666666664650C09A99999999D95E4001010000001F97DD388EE35E400000000000C05E40')
     multi_point = @factory.geometry
     expect(multi_point).to be_instance_of GeoRuby::SimpleFeatures::MultiPoint
-    expect(multi_point).to eq(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]],444))
+    expect(multi_point).to eq(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[12.4, -123.3], [-65.1, 123.4], [123.55555555, 123]], 444))
     expect(multi_point.srid).to eql(444)
     expect(multi_point[0].srid).to eql(444)
 
-    @hex_ewkb_parser.parse("01040000A0BC010000030000000101000080CDCCCCCCCCCC28403333333333D35EC00000000000001240010100008066666666664650C09A99999999D95E40333333333333F33F01010000801F97DD388EE35E400000000000C05E406666666666660240")
+    @hex_ewkb_parser.parse('01040000A0BC010000030000000101000080CDCCCCCCCCCC28403333333333D35EC00000000000001240010100008066666666664650C09A99999999D95E40333333333333F33F01010000801F97DD388EE35E400000000000C05E406666666666660240')
     multi_point = @factory.geometry
     expect(multi_point).to be_instance_of GeoRuby::SimpleFeatures::MultiPoint
-    expect(multi_point).to eq(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[12.4,-123.3,4.5],[-65.1,123.4,1.2],[123.55555555,123,2.3]],444,true))
+    expect(multi_point).to eq(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[12.4, -123.3, 4.5], [-65.1, 123.4, 1.2], [123.55555555, 123, 2.3]], 444, true))
     expect(multi_point.srid).to eql(444)
     expect(multi_point[0].srid).to eql(444)
   end
 
-  it "test_multi_line_string" do
-    @hex_ewkb_parser.parse("01050000200001000002000000010200000002000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF010200000003000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF39B4C876BE8F46403333333333D35E40")
+  it 'test_multi_line_string' do
+    @hex_ewkb_parser.parse('01050000200001000002000000010200000002000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF010200000003000000000000000000F83F9A99999999994640E4BD6A65C20F4BC0FA7E6ABC749388BF39B4C876BE8F46403333333333D35E40')
     multi_line_string = @factory.geometry
     expect(multi_line_string).to be_instance_of GeoRuby::SimpleFeatures::MultiLineString
-    expect(multi_line_string).to eq(GeoRuby::SimpleFeatures::MultiLineString.from_line_strings([GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012]],256),GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5,45.2],[-54.12312,-0.012],[45.123,123.3]],256)],256))
+    expect(multi_line_string).to eq(GeoRuby::SimpleFeatures::MultiLineString.from_line_strings([GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5, 45.2], [-54.12312, -0.012]], 256), GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5, 45.2], [-54.12312, -0.012], [45.123, 123.3]], 256)], 256))
     expect(multi_line_string.srid).to eql(256)
     expect(multi_line_string[0].srid).to eql(256)
 
-    @hex_ewkb_parser.parse("0105000020000100000200000001020000C002000000000000000000F83F9A99999999994640CDCCCCCCCCCCF43F333333333333F33FE4BD6A65C20F4BC0FA7E6ABC749388BF333333333333F33F000000000000124001020000C003000000000000000000F83F9A99999999994640666666666666144000000000000012C0E4BD6A65C20F4BC0FA7E6ABC749388BF3333333333331BC03333333333330B4039B4C876BE8F46403333333333D35E40000000000000124033333333333315C0")
+    @hex_ewkb_parser.parse('0105000020000100000200000001020000C002000000000000000000F83F9A99999999994640CDCCCCCCCCCCF43F333333333333F33FE4BD6A65C20F4BC0FA7E6ABC749388BF333333333333F33F000000000000124001020000C003000000000000000000F83F9A99999999994640666666666666144000000000000012C0E4BD6A65C20F4BC0FA7E6ABC749388BF3333333333331BC03333333333330B4039B4C876BE8F46403333333333D35E40000000000000124033333333333315C0')
     multi_line_string = @factory.geometry
     expect(multi_line_string).to be_instance_of GeoRuby::SimpleFeatures::MultiLineString
-    expect(multi_line_string).to eq(GeoRuby::SimpleFeatures::MultiLineString.from_line_strings([GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5,45.2,1.3,1.2],[-54.12312,-0.012,1.2,4.5]],256,true,true),GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5,45.2,5.1,-4.5],[-54.12312,-0.012,-6.8,3.4],[45.123,123.3,4.5,-5.3]],256,true,true)],256,true,true))
+    expect(multi_line_string).to eq(GeoRuby::SimpleFeatures::MultiLineString.from_line_strings([GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5, 45.2, 1.3, 1.2], [-54.12312, -0.012, 1.2, 4.5]], 256, true, true), GeoRuby::SimpleFeatures::LineString.from_coordinates([[1.5, 45.2, 5.1, -4.5], [-54.12312, -0.012, -6.8, 3.4], [45.123, 123.3, 4.5, -5.3]], 256, true, true)], 256, true, true))
     expect(multi_line_string.srid).to eql(256)
     expect(multi_line_string[0].srid).to eql(256)
   end
 
-  it "test_multi_polygon" do
-    @hex_ewkb_parser.parse("0106000020000100000200000001030000000200000004000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC44406DE7FBA9F1D211403D2CD49AE61DF13FCDCCCCCCCCCC28406666666666A646C004000000333333333333034033333333333315409A999999999915408A8EE4F21FD2F63FEC51B81E85EB2C40F6285C8FC2F5F03F3333333333330340333333333333154001030000000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F")
+  it 'test_multi_polygon' do
+    @hex_ewkb_parser.parse('0106000020000100000200000001030000000200000004000000CDCCCCCCCCCC28406666666666A646C03333333333B34640CDCCCCCCCCCC44406DE7FBA9F1D211403D2CD49AE61DF13FCDCCCCCCCCCC28406666666666A646C004000000333333333333034033333333333315409A999999999915408A8EE4F21FD2F63FEC51B81E85EB2C40F6285C8FC2F5F03F3333333333330340333333333333154001030000000200000005000000000000000000000000000000000000000000000000001040000000000000000000000000000010400000000000001040000000000000000000000000000010400000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F')
     multi_polygon = @factory.geometry
     expect(multi_polygon).to be_instance_of GeoRuby::SimpleFeatures::MultiPolygon
-    expect(multi_polygon).to eq(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]],256),GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]],256)],256))
+    expect(multi_polygon).to eq(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[12.4, -45.3], [45.4, 41.6], [4.456, 1.0698], [12.4, -45.3]], [[2.4, 5.3], [5.4, 1.4263], [14.46, 1.06], [2.4, 5.3]]], 256), GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0], [4, 0], [4, 4], [0, 4], [0, 0]], [[1, 1], [3, 1], [3, 3], [1, 3], [1, 1]]], 256)], 256))
     expect(multi_polygon.srid).to eql(256)
     expect(multi_polygon[0].srid).to eql(256)
 
-    @hex_ewkb_parser.parse("0106000020000100000200000001030000400200000004000000CDCCCCCCCCCC28406666666666A646C0333333333333F33F3333333333B34640CDCCCCCCCCCC4440333333333333F33F6DE7FBA9F1D211403D2CD49AE61DF13F333333333333F33FCDCCCCCCCCCC28406666666666A646C0333333333333F33F0400000033333333333303403333333333331540333333333333F33F9A999999999915408A8EE4F21FD2F63F333333333333F33FEC51B81E85EB2C40F6285C8FC2F5F03F333333333333F33F33333333333303403333333333331540333333333333F33F0103000040020000000500000000000000000000000000000000000000333333333333F33F00000000000010400000000000000000333333333333F33F00000000000010400000000000001040666666666666024000000000000000000000000000001040333333333333F33F00000000000000000000000000000000333333333333F33F05000000000000000000F03F000000000000F03F9A999999999901400000000000000840000000000000F03F6666666666660A40000000000000084000000000000008409A9999999999F13F000000000000F03F00000000000008403333333333330340000000000000F03F000000000000F03F9A99999999990140")
+    @hex_ewkb_parser.parse('0106000020000100000200000001030000400200000004000000CDCCCCCCCCCC28406666666666A646C0333333333333F33F3333333333B34640CDCCCCCCCCCC4440333333333333F33F6DE7FBA9F1D211403D2CD49AE61DF13F333333333333F33FCDCCCCCCCCCC28406666666666A646C0333333333333F33F0400000033333333333303403333333333331540333333333333F33F9A999999999915408A8EE4F21FD2F63F333333333333F33FEC51B81E85EB2C40F6285C8FC2F5F03F333333333333F33F33333333333303403333333333331540333333333333F33F0103000040020000000500000000000000000000000000000000000000333333333333F33F00000000000010400000000000000000333333333333F33F00000000000010400000000000001040666666666666024000000000000000000000000000001040333333333333F33F00000000000000000000000000000000333333333333F33F05000000000000000000F03F000000000000F03F9A999999999901400000000000000840000000000000F03F6666666666660A40000000000000084000000000000008409A9999999999F13F000000000000F03F00000000000008403333333333330340000000000000F03F000000000000F03F9A99999999990140')
     multi_polygon = @factory.geometry
     expect(multi_polygon).to be_instance_of GeoRuby::SimpleFeatures::MultiPolygon
-    expect(multi_polygon).to eq(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[12.4,-45.3,1.2],[45.4,41.6,1.2],[4.456,1.0698,1.2],[12.4,-45.3,1.2]],[[2.4,5.3,1.2],[5.4,1.4263,1.2],[14.46,1.06,1.2],[2.4,5.3,1.2]]],256,false,true),GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0,1.2],[4,0,1.2],[4,4,2.3],[0,4,1.2],[0,0,1.2]],[[1,1,2.2],[3,1,3.3],[3,3,1.1],[1,3,2.4],[1,1,2.2]]],256,false,true)],256,false,true))
+    expect(multi_polygon).to eq(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[12.4, -45.3, 1.2], [45.4, 41.6, 1.2], [4.456, 1.0698, 1.2], [12.4, -45.3, 1.2]], [[2.4, 5.3, 1.2], [5.4, 1.4263, 1.2], [14.46, 1.06, 1.2], [2.4, 5.3, 1.2]]], 256, false, true), GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0, 0, 1.2], [4, 0, 1.2], [4, 4, 2.3], [0, 4, 1.2], [0, 0, 1.2]], [[1, 1, 2.2], [3, 1, 3.3], [3, 3, 1.1], [1, 3, 2.4], [1, 1, 2.2]]], 256, false, true)], 256, false, true))
     expect(multi_polygon.srid).to eql(256)
     expect(multi_polygon[0].srid).to eql(256)
   end
 
-
-  it "test_failure_trailing_data" do
-    #added A345 at the end
-    expect {@hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC28406666666666A64640A345")}.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
+  it 'test_failure_trailing_data' do
+    # added A345 at the end
+    expect { @hex_ewkb_parser.parse('01010000207B000000CDCCCCCCCCCC28406666666666A64640A345') }.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
   end
 
-  it "test_failure_unknown_geometry_type" do
-    expect {@hex_ewkb_parser.parse("01090000207B000000CDCCCCCCCCCC28406666666666A64640")}.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
+  it 'test_failure_unknown_geometry_type' do
+    expect { @hex_ewkb_parser.parse('01090000207B000000CDCCCCCCCCCC28406666666666A64640') }.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
   end
 
-  it "test_failure_m" do
-    expect {@hex_ewkb_parser.parse("01010000607B000000CDCCCCCCCCCC28406666666666A64640")}.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
+  it 'test_failure_m' do
+    expect { @hex_ewkb_parser.parse('01010000607B000000CDCCCCCCCCCC28406666666666A64640') }.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
   end
 
-  it "test_failure_truncated_data" do
-    expect {@hex_ewkb_parser.parse("01010000207B000000CDCCCCCCCCCC2840666666")}.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
+  it 'test_failure_truncated_data' do
+    expect { @hex_ewkb_parser.parse('01010000207B000000CDCCCCCCCCCC2840666666') }.to raise_error(GeoRuby::SimpleFeatures::EWKBFormatError)
   end
 
 end